619 lines
25 KiB
TypeScript
619 lines
25 KiB
TypeScript
import { execFileSync, spawnSync } from "node:child_process";
|
|
import { createHash } from "node:crypto";
|
|
import { cp, mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import path from "node:path";
|
|
import { describe, expect, it } from "vitest";
|
|
import {
|
|
computeDaytonaImageContentId,
|
|
DAYTONA_IMAGE_CONTENT_SCHEMA,
|
|
DAYTONA_IMAGE_DOCKERFILE_PATH,
|
|
DAYTONA_IMAGE_INPUT_PATHS,
|
|
extractDaytonaBaseImages,
|
|
extractDaytonaDockerfileFrontendDigest,
|
|
} from "./daytona-image-content.js";
|
|
|
|
const repositoryRoot = path.resolve(import.meta.dirname, "../..");
|
|
|
|
describe("runner E2E Daytona image contract", () => {
|
|
it("accepts the frozen provider lock and rejects copied manifest drift offline", async () => {
|
|
const root = await mkdtemp(path.join(tmpdir(), "paperclip-provider-lock-contract-"));
|
|
try {
|
|
for (const relative of [
|
|
...DAYTONA_IMAGE_INPUT_PATHS.filter((entry) => entry.endsWith("package.json")),
|
|
".npmrc", "pnpm-workspace.yaml", "patches",
|
|
]) {
|
|
await mkdir(path.dirname(path.join(root, relative)), { recursive: true });
|
|
await cp(path.join(repositoryRoot, relative), path.join(root, relative), { recursive: true });
|
|
}
|
|
await cp(
|
|
path.join(repositoryRoot, "docker/daytona-runner/provider-dependencies.lock.yaml"),
|
|
path.join(root, "pnpm-lock.yaml"),
|
|
);
|
|
const validate = () => spawnSync("pnpm", [
|
|
"install", "--lockfile-only", "--ignore-scripts", "--frozen-lockfile", "--offline",
|
|
"--store-dir", path.join(root, "empty-store"),
|
|
"--filter", "@paperclipai/paperclip-runner...",
|
|
], { cwd: root, encoding: "utf8", stdio: "pipe", timeout: 30_000 });
|
|
const valid = validate();
|
|
expect(valid.error).toBeUndefined();
|
|
expect(valid.status, valid.stdout + valid.stderr).toBe(0);
|
|
|
|
// pnpm validates copied workspace manifests even outside the install filter.
|
|
const serverPath = path.join(root, "server/package.json");
|
|
const server = JSON.parse(await readFile(serverPath, "utf8"));
|
|
server.dependencies["paperclip-lock-drift-fixture"] = "0.0.0";
|
|
await writeFile(serverPath, JSON.stringify(server));
|
|
const drift = validate();
|
|
expect(drift.error).toBeUndefined();
|
|
expect(drift.status).toBe(1);
|
|
expect(drift.stdout).toContain("ERR_PNPM_OUTDATED_LOCKFILE");
|
|
} finally {
|
|
await rm(root, { recursive: true, force: true });
|
|
}
|
|
}, 60_000);
|
|
|
|
it("builds runnerd and the provider pack and verifies every required transport", async () => {
|
|
const [dockerfile, dockerignore, workflow] = await Promise.all([
|
|
readFile(
|
|
path.join(repositoryRoot, "docker/daytona-runner/Dockerfile"),
|
|
"utf8",
|
|
),
|
|
readFile(path.join(repositoryRoot, ".dockerignore"), "utf8"),
|
|
readFile(
|
|
path.join(
|
|
repositoryRoot,
|
|
".github/workflows/runner-full-stack-e2e.yml",
|
|
),
|
|
"utf8",
|
|
),
|
|
]);
|
|
const normalizedDockerfile = dockerfile.replace(/\\\r?\n\s*/g, " ");
|
|
expect(dockerfile).toContain("--bin paperclip-runnerd");
|
|
expect(dockerfile).toContain("assemble-provider-pack.mjs /provider-pack");
|
|
expect(normalizedDockerfile).not.toContain(
|
|
"COPY packages/paperclip-eval-kernel ./packages/paperclip-eval-kernel",
|
|
);
|
|
expect(normalizedDockerfile).not.toContain(
|
|
"COPY packages/paperclip-runner ./packages/paperclip-runner",
|
|
);
|
|
// Both provider builds consume the dedicated immutable resolution. Image
|
|
// creation must not refresh transitive packages from the registry.
|
|
expect(dockerfile).toContain("COPY packages ./packages");
|
|
expect(dockerfile).toContain(
|
|
"COPY docker/daytona-runner/provider-dependencies.lock.yaml ./pnpm-lock.yaml",
|
|
);
|
|
expect(dockerfile).not.toContain("--resolution-only");
|
|
expect(dockerfile).not.toContain("--no-frozen-lockfile");
|
|
expect(dockerfile).toContain("sha256sum -c /tmp/provider-lock.sha256");
|
|
expect(dockerfile).toContain(
|
|
"/opt/paperclip-runner/provider-pack/provider-pack.json",
|
|
);
|
|
expect(dockerfile).toContain(
|
|
"${PAPERCLIP_RUNNER_PROVIDER_PACK_ROOT}/node_modules/.bin",
|
|
);
|
|
for (const command of ["acpx", "claude-agent-acp", "codex-acp"]) {
|
|
expect(dockerfile).toContain(command);
|
|
}
|
|
for (const transport of ["dial_ws_loopback", "dial_wss", "listen_ws"]) {
|
|
expect(dockerfile).toContain(transport);
|
|
}
|
|
expect(dockerfile).toContain(
|
|
'metadata="$(paperclip-runnerd --build-metadata)"',
|
|
);
|
|
expect(dockerfile).toContain("provider-pack.json");
|
|
expect(dockerfile).toContain("io.paperclip.runner.content-id");
|
|
expect(dockerfile).toContain("org.opencontainers.image.revision");
|
|
expect(extractDaytonaDockerfileFrontendDigest(dockerfile)).toBe(
|
|
"sha256:a57df69d0ea827fb7266491f2813635de6f17269be881f696fbfdf2d83dda33e",
|
|
);
|
|
expect(extractDaytonaBaseImages(dockerfile)).toEqual([
|
|
"rust:1.97-bookworm@sha256:408fe88047cef61a2087653b0c5255fa51c0f2d6d94ddedd7a2562a9b91a46f6",
|
|
"node:24-bookworm@sha256:9137a20e25879e0b557227b57e3ee4e9af4bde29eb3db66134cd1723e84f830b",
|
|
"daytonaio/sandbox:0.8.0@sha256:eadf88e4391072b7ad4bed27d9cadfc9fe9d8ed375d9219d34c2ccb518f213e3",
|
|
]);
|
|
expect(dockerignore).toContain("**/node_modules");
|
|
expect(dockerignore).toContain("packages/paperclip-runner/dist");
|
|
expect(dockerignore).toContain("packages/paperclip-runner/runner/target");
|
|
for (const developmentOnlyInput of [
|
|
"packages/paperclip-runner/devtools",
|
|
"packages/paperclip-runner/docs",
|
|
"packages/paperclip-runner/examples",
|
|
"packages/paperclip-runner/test",
|
|
"packages/paperclip-runner/test-fixtures",
|
|
"packages/paperclip-runner/test-support",
|
|
"packages/paperclip-runner/**/*.md",
|
|
"packages/paperclip-runner/**/*.test.ts",
|
|
"packages/paperclip-runner/runner/crates/*/tests",
|
|
"packages/paperclip-runner/scripts/*-smoke.mjs",
|
|
]) {
|
|
expect(dockerignore).toContain(developmentOnlyInput);
|
|
}
|
|
expect(workflow).toContain("--platform linux/amd64");
|
|
expect(workflow).toContain(
|
|
"Compute Daytona image content ID with pinned bases",
|
|
);
|
|
expect(workflow).toContain(
|
|
"e2e-content-${{ needs.catalog.outputs.daytona_image_content_id }}",
|
|
);
|
|
expect(workflow).toContain(
|
|
'--build-arg "PAPERCLIP_RUNNER_CONTENT_ID=${IMAGE_CONTENT_ID}"',
|
|
);
|
|
expect(workflow).toContain(
|
|
"IMAGE_CACHE: ghcr.io/paperclipai/paperclip-daytona-runner:e2e-buildcache-amd64",
|
|
);
|
|
expect(workflow).toContain(
|
|
'--cache-from "type=registry,ref=${IMAGE_CACHE}"',
|
|
);
|
|
expect(workflow).toContain(
|
|
'--cache-to "type=registry,ref=${IMAGE_CACHE},mode=max"',
|
|
);
|
|
expect(workflow).toContain(
|
|
'if [ "$TARGET_REF" = "refs/heads/$DEFAULT_BRANCH" ]; then',
|
|
);
|
|
expect(workflow).not.toContain("e2e-git-${{ github.sha }}");
|
|
expect(workflow).toContain("cosign sign --yes");
|
|
expect(workflow).toContain("docker logout ghcr.io");
|
|
expect(workflow).toContain(`docker buildx imagetools inspect "$immutable"`);
|
|
expect(workflow).toContain(`--format '{{json .Image}}'`);
|
|
expect(workflow).not.toContain(`docker --config "$anonymous_config" pull`);
|
|
expect(workflow).not.toContain("docker image inspect");
|
|
expect(workflow).not.toContain("docker buildx prune --all --force");
|
|
expect(workflow).not.toContain("docker system prune --all --force");
|
|
expect(workflow).toContain('.architecture == "amd64"');
|
|
expect(workflow).toContain('.os == "linux"');
|
|
expect(workflow).toContain('.config.User == "daytona"');
|
|
expect(workflow).toContain("PAPERCLIP_RUNNER_PROVIDER_PACK_ROOT=");
|
|
expect(workflow).toContain(
|
|
"node packages/paperclip-runner/scripts/build-provider-pack.mjs packages/paperclip-runner/provider-pack",
|
|
);
|
|
expect(workflow).toContain(
|
|
"PAPERCLIP_RUNNER_REMOTE_PROVIDER_PACK_PATH: ${{ github.workspace }}/packages/paperclip-runner/provider-pack",
|
|
);
|
|
expect(workflow).toContain(
|
|
"PAPERCLIP_RUNNER_SOURCE_REVISION: ${{ needs.daytona_image.outputs.source_revision }}",
|
|
);
|
|
expect(workflow.indexOf("cosign verify")).toBeLessThan(
|
|
workflow.indexOf("docker logout ghcr.io"),
|
|
);
|
|
expect(workflow.indexOf("docker logout ghcr.io")).toBeLessThan(
|
|
workflow.indexOf(`--format '{{json .Image}}'`),
|
|
);
|
|
const providerInstall = dockerfile.indexOf(
|
|
"pnpm install --frozen-lockfile --filter '@paperclipai/paperclip-runner...'",
|
|
);
|
|
const runnerSourceCopy = dockerfile.indexOf("COPY packages ./packages");
|
|
const providerRevisionArg = dockerfile.indexOf(
|
|
"ARG PAPERCLIP_RUNNER_SOURCE_REVISION",
|
|
);
|
|
const cliInstall = dockerfile.indexOf("npm install -g");
|
|
const finalMetadataArgs = dockerfile.lastIndexOf(
|
|
"ARG PAPERCLIP_RUNNER_CONTENT_ID",
|
|
);
|
|
expect(providerInstall).toBeGreaterThan(0);
|
|
expect(runnerSourceCopy).toBeGreaterThan(0);
|
|
expect(runnerSourceCopy).toBeLessThan(providerInstall);
|
|
const lockVerification = dockerfile.indexOf(
|
|
"sha256sum -c /tmp/provider-lock.sha256",
|
|
);
|
|
expect(lockVerification).toBeGreaterThan(runnerSourceCopy);
|
|
expect(lockVerification).toBeLessThan(providerInstall);
|
|
expect(providerInstall).toBeLessThan(providerRevisionArg);
|
|
expect(cliInstall).toBeGreaterThan(0);
|
|
expect(cliInstall).toBeLessThan(finalMetadataArgs);
|
|
});
|
|
|
|
it("exports the canonical provider stage without a mutable base or recursive builder", async () => {
|
|
const dockerfile = await readFile(path.join(repositoryRoot, "docker/daytona-runner/Dockerfile"), "utf8");
|
|
const exportStage = dockerfile.split(/^FROM /m).find((stage) => stage.startsWith("scratch AS provider-pack-export\n"));
|
|
expect(exportStage).toMatch(/^COPY --from=provider-pack-build \/provider-pack \/provider-pack$/m);
|
|
expect(extractDaytonaBaseImages(dockerfile)).not.toContain("scratch");
|
|
expect(() => extractDaytonaBaseImages("FROM node:latest\nFROM scratch AS exported")).toThrow("immutable");
|
|
const builder = await readFile(path.join(repositoryRoot, "packages/paperclip-runner/scripts/build-provider-pack.mjs"), "utf8");
|
|
expect(builder).toContain('"--target", "provider-pack-export"');
|
|
expect(builder).toContain('"--platform", "linux/amd64"');
|
|
expect(builder).toContain("verifyProviderPack(exported");
|
|
expect(dockerfile).not.toContain("build-provider-pack.mjs /provider-pack");
|
|
for (const file of ["assemble-provider-pack.mjs", "provider-pack-integrity.mjs"]) {
|
|
expect(DAYTONA_IMAGE_INPUT_PATHS).toContain(`packages/paperclip-runner/scripts/${file}`);
|
|
}
|
|
});
|
|
|
|
it("builds both provider packs from the same verified dedicated lock before compiling", async () => {
|
|
const lockPath = "docker/daytona-runner/provider-dependencies.lock.yaml";
|
|
const lock = await readFile(path.join(repositoryRoot, lockPath));
|
|
const lockDigest = createHash("sha256").update(lock).digest("hex");
|
|
for (const [file, stageName] of [
|
|
["docker/daytona-runner/Dockerfile", "provider-pack-build"],
|
|
["Dockerfile", "cloud-provider-pack"],
|
|
] as const) {
|
|
const dockerfile = await readFile(path.join(repositoryRoot, file), "utf8");
|
|
const stage = dockerfile
|
|
.split(/^FROM /m)
|
|
.find((part) => part.split("\n", 1)[0]!.endsWith(` AS ${stageName}`));
|
|
expect(stage, file).toBeDefined();
|
|
const normalized = stage!.replace(/\\\r?\n\s*/g, " ");
|
|
const copy = normalized.indexOf(`COPY ${lockPath} ./pnpm-lock.yaml`);
|
|
const verify = normalized.indexOf("sha256sum -c /tmp/provider-lock.sha256");
|
|
const install = normalized.indexOf(
|
|
"pnpm install --frozen-lockfile --filter '@paperclipai/paperclip-runner...'",
|
|
);
|
|
const build = normalized.indexOf(
|
|
"pnpm --filter @paperclipai/paperclip-runner build:typescript",
|
|
);
|
|
const pack = normalized.indexOf(
|
|
"node packages/paperclip-runner/scripts/assemble-provider-pack.mjs /provider-pack",
|
|
);
|
|
expect(normalized).toContain(`ARG PAPERCLIP_RUNNER_LOCK_SHA256=${lockDigest}`);
|
|
expect(copy).toBeGreaterThan(0);
|
|
expect(verify).toBeGreaterThan(copy);
|
|
expect(install).toBeGreaterThan(verify);
|
|
expect(build).toBeGreaterThan(install);
|
|
expect(pack).toBeGreaterThan(build);
|
|
expect(normalized).not.toContain("--resolution-only");
|
|
expect(normalized).not.toContain("--no-frozen-lockfile");
|
|
expect(normalized).not.toMatch(/COPY --from=.*(?:node_modules|packages)/);
|
|
for (const input of [
|
|
"COPY packages ./packages",
|
|
"COPY server/package.json",
|
|
"COPY ui/package.json",
|
|
"COPY cli/package.json",
|
|
]) {
|
|
expect(normalized).toContain(input);
|
|
}
|
|
}
|
|
});
|
|
|
|
it("tracks dedicated transitive resolution and copied manifests but ignores CI root-lock churn", async () => {
|
|
const root = await mkdtemp(
|
|
path.join(tmpdir(), "paperclip-provider-lock-inputs-"),
|
|
);
|
|
const lockPath = "docker/daytona-runner/provider-dependencies.lock.yaml";
|
|
const manifestPath = "packages/adapters/codex-local/package.json";
|
|
// Select actual contract paths, so silently removing one breaks this test.
|
|
const inputPaths = DAYTONA_IMAGE_INPUT_PATHS.filter((entry) =>
|
|
[lockPath, manifestPath, "ui/package.json", "pnpm-lock.yaml"].includes(entry),
|
|
);
|
|
const options = {
|
|
repositoryRoot: root,
|
|
inputPaths,
|
|
baseImages: [`example.test/base:1@sha256:${"a".repeat(64)}`],
|
|
frontendDigest: `sha256:${"c".repeat(64)}`,
|
|
};
|
|
try {
|
|
for (const file of [lockPath, manifestPath, "ui/package.json"]) {
|
|
await mkdir(path.dirname(path.join(root, file)), { recursive: true });
|
|
}
|
|
const resolution =
|
|
"lockfileVersion: '9.0'\npackages:\n '@aws-sdk/client-s3@3.999.0':\n resolution: {integrity: sha512-reviewed}\n";
|
|
await writeFile(path.join(root, lockPath), resolution);
|
|
await writeFile(
|
|
path.join(root, manifestPath),
|
|
'{"dependencies":{"codex-acp":"1.6.2"}}',
|
|
);
|
|
await writeFile(
|
|
path.join(root, "ui/package.json"),
|
|
'{"dependencies":{"react":"19.2.8"}}',
|
|
);
|
|
await writeFile(path.join(root, "pnpm-lock.yaml"), "CI lock before refresh");
|
|
const original = await computeDaytonaImageContentId(options);
|
|
await writeFile(
|
|
path.join(root, "pnpm-lock.yaml"),
|
|
"CI lock after unrelated refresh",
|
|
);
|
|
expect(await computeDaytonaImageContentId(options)).toBe(original);
|
|
await writeFile(
|
|
path.join(root, lockPath),
|
|
resolution.replace("sha512-reviewed", "sha512-different"),
|
|
);
|
|
expect(await computeDaytonaImageContentId(options)).not.toBe(original);
|
|
await writeFile(path.join(root, lockPath), resolution);
|
|
for (const file of [manifestPath, "ui/package.json"]) {
|
|
const originalManifest = await readFile(path.join(root, file), "utf8");
|
|
await writeFile(
|
|
path.join(root, file),
|
|
originalManifest.replace(/1\.6\.2|19\.2\.8/, "99.0.0"),
|
|
);
|
|
expect(await computeDaytonaImageContentId(options)).not.toBe(original);
|
|
await writeFile(path.join(root, file), originalManifest);
|
|
}
|
|
} finally {
|
|
await rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("hashes the audited image dependency closure rather than the repository revision", async () => {
|
|
for (const requiredPath of [
|
|
".dockerignore",
|
|
"docker/daytona-runner/Dockerfile",
|
|
"docker/daytona-runner/provider-dependencies.lock.yaml",
|
|
"patches",
|
|
"packages/paperclip-eval-kernel/src",
|
|
"packages/paperclip-runner/package.json",
|
|
"packages/paperclip-runner/runner/crates",
|
|
"packages/paperclip-runner/src",
|
|
]) {
|
|
expect(DAYTONA_IMAGE_INPUT_PATHS).toContain(requiredPath);
|
|
}
|
|
expect(DAYTONA_IMAGE_CONTENT_SCHEMA).toBe(
|
|
"paperclip-daytona-runner-image-content/v6",
|
|
);
|
|
expect(DAYTONA_IMAGE_INPUT_PATHS).not.toContain("pnpm-lock.yaml");
|
|
// COPY packages ./packages includes every committed manifest, including
|
|
// nested adapter/plugin packages. A new package must update this contract.
|
|
const packageManifests = execFileSync(
|
|
"git",
|
|
["ls-files", "--", "packages/**/package.json"],
|
|
{ cwd: repositoryRoot, encoding: "utf8" },
|
|
)
|
|
.trim()
|
|
.split("\n");
|
|
expect(packageManifests.length).toBeGreaterThan(0);
|
|
for (const manifest of [
|
|
...packageManifests,
|
|
"server/package.json",
|
|
"ui/package.json",
|
|
"cli/package.json",
|
|
]) {
|
|
expect(DAYTONA_IMAGE_INPUT_PATHS).toContain(manifest);
|
|
}
|
|
expect(DAYTONA_IMAGE_INPUT_PATHS).not.toContain(
|
|
"packages/paperclip-eval-kernel",
|
|
);
|
|
expect(DAYTONA_IMAGE_INPUT_PATHS).not.toContain(
|
|
"packages/paperclip-runner",
|
|
);
|
|
expect(DAYTONA_IMAGE_DOCKERFILE_PATH).toBe(
|
|
"docker/daytona-runner/Dockerfile",
|
|
);
|
|
|
|
const contentId = await computeDaytonaImageContentId();
|
|
expect(contentId).toMatch(/^[0-9a-f]{64}$/);
|
|
});
|
|
|
|
it("changes for runtime source, package, lockfile, Dockerfile, frontend, base, or platform inputs", async () => {
|
|
const root = await mkdtemp(
|
|
path.join(tmpdir(), "paperclip-daytona-image-id-"),
|
|
);
|
|
const inputPaths = [
|
|
"docker/daytona-runner/Dockerfile",
|
|
"package.json",
|
|
"docker/daytona-runner/provider-dependencies.lock.yaml",
|
|
"packages/paperclip-runner/package.json",
|
|
"packages/paperclip-runner/src",
|
|
"packages/paperclip-runner/runner/crates",
|
|
] as const;
|
|
const options = {
|
|
repositoryRoot: root,
|
|
inputPaths,
|
|
baseImages: [`example.test/base:1@sha256:${"a".repeat(64)}`],
|
|
frontendDigest: `sha256:${"c".repeat(64)}`,
|
|
} as const;
|
|
try {
|
|
await mkdir(path.join(root, "docker/daytona-runner"), {
|
|
recursive: true,
|
|
});
|
|
await mkdir(path.join(root, "packages/paperclip-runner/src"), {
|
|
recursive: true,
|
|
});
|
|
await mkdir(
|
|
path.join(
|
|
root,
|
|
"packages/paperclip-runner/runner/crates/runner-core/src",
|
|
),
|
|
{ recursive: true },
|
|
);
|
|
await writeFile(
|
|
path.join(root, "docker/daytona-runner/Dockerfile"),
|
|
"FROM pinned\n",
|
|
);
|
|
await writeFile(path.join(root, "package.json"), '{"private":true}\n');
|
|
await writeFile(
|
|
path.join(root, "docker/daytona-runner/provider-dependencies.lock.yaml"),
|
|
"lockfileVersion: 9\n",
|
|
);
|
|
await writeFile(
|
|
path.join(root, "packages/paperclip-runner/package.json"),
|
|
'{"name":"@paperclipai/paperclip-runner"}\n',
|
|
);
|
|
await writeFile(
|
|
path.join(root, "packages/paperclip-runner/src/runner.ts"),
|
|
"version one\n",
|
|
);
|
|
await writeFile(
|
|
path.join(
|
|
root,
|
|
"packages/paperclip-runner/runner/crates/runner-core/src/lib.rs",
|
|
),
|
|
'pub const VERSION: &str = "one";\n',
|
|
);
|
|
const baseline = await computeDaytonaImageContentId(options);
|
|
expect(
|
|
await computeDaytonaImageContentId({
|
|
...options,
|
|
baseImages: [`example.test/base:1@sha256:${"b".repeat(64)}`],
|
|
}),
|
|
).not.toBe(baseline);
|
|
expect(
|
|
await computeDaytonaImageContentId({
|
|
...options,
|
|
baseImages: [`example.test/base:1@sha256:${"a".repeat(64)}`],
|
|
frontendDigest: `sha256:${"d".repeat(64)}`,
|
|
}),
|
|
).not.toBe(baseline);
|
|
|
|
await writeFile(
|
|
path.join(root, "unrelated.txt"),
|
|
"does not enter the image\n",
|
|
);
|
|
expect(await computeDaytonaImageContentId(options)).toBe(baseline);
|
|
|
|
await writeFile(
|
|
path.join(root, "pnpm-lock.yaml"),
|
|
"unrelated root resolution\n",
|
|
);
|
|
expect(await computeDaytonaImageContentId(options)).toBe(baseline);
|
|
|
|
for (const relativePath of [
|
|
"docker/daytona-runner/Dockerfile",
|
|
"package.json",
|
|
"docker/daytona-runner/provider-dependencies.lock.yaml",
|
|
"packages/paperclip-runner/package.json",
|
|
"packages/paperclip-runner/src/runner.ts",
|
|
"packages/paperclip-runner/runner/crates/runner-core/src/lib.rs",
|
|
]) {
|
|
const absolutePath = path.join(root, relativePath);
|
|
const original = await readFile(absolutePath, "utf8");
|
|
await writeFile(absolutePath, `${original}changed\n`);
|
|
expect(await computeDaytonaImageContentId(options)).not.toBe(baseline);
|
|
await writeFile(absolutePath, original);
|
|
}
|
|
expect(
|
|
await computeDaytonaImageContentId({
|
|
...options,
|
|
platform: "linux/arm64",
|
|
}),
|
|
).not.toBe(baseline);
|
|
} finally {
|
|
await rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("reuses the image for runner-only tests and documentation", async () => {
|
|
const root = await mkdtemp(
|
|
path.join(tmpdir(), "paperclip-daytona-runner-development-inputs-"),
|
|
);
|
|
const options = {
|
|
repositoryRoot: root,
|
|
inputPaths: ["packages/paperclip-runner"],
|
|
baseImages: [`example.test/base:1@sha256:${"a".repeat(64)}`],
|
|
frontendDigest: `sha256:${"c".repeat(64)}`,
|
|
} as const;
|
|
try {
|
|
const runnerRoot = path.join(root, "packages/paperclip-runner");
|
|
await mkdir(path.join(runnerRoot, "src/live"), { recursive: true });
|
|
await mkdir(path.join(runnerRoot, "docs"), { recursive: true });
|
|
await mkdir(path.join(runnerRoot, "spec"), { recursive: true });
|
|
await mkdir(path.join(runnerRoot, "scripts"), { recursive: true });
|
|
await mkdir(path.join(runnerRoot, "test-fixtures"), { recursive: true });
|
|
await mkdir(path.join(runnerRoot, "runner/crates/runner-core/src"), {
|
|
recursive: true,
|
|
});
|
|
await mkdir(path.join(runnerRoot, "runner/crates/runner-core/tests"), {
|
|
recursive: true,
|
|
});
|
|
await writeFile(
|
|
path.join(runnerRoot, "src/live/transport.ts"),
|
|
"export const runtime = 'one';\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "runner/crates/runner-core/src/lib.rs"),
|
|
'pub const RUNTIME: &str = "one";\n',
|
|
);
|
|
await writeFile(path.join(runnerRoot, "README.md"), "first readme\n");
|
|
await writeFile(
|
|
path.join(runnerRoot, "docs/local-runner.md"),
|
|
"first documentation\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "spec/architecture.md"),
|
|
"first architecture note\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "src/live/transport.test.ts"),
|
|
"first TypeScript test\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "test-fixtures/provider.json"),
|
|
'{"fixture":"one"}\n',
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "scripts/capability-clean-room-smoke.mjs"),
|
|
"first smoke probe\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "runner/crates/runner-core/tests/recovery.rs"),
|
|
"// first Rust integration test\n",
|
|
);
|
|
|
|
const baseline = await computeDaytonaImageContentId(options);
|
|
await mkdir(path.join(runnerRoot, "src/new-test-only-directory"));
|
|
await writeFile(
|
|
path.join(
|
|
runnerRoot,
|
|
"src/new-test-only-directory/transport-edge.test.ts",
|
|
),
|
|
"new TypeScript test\n",
|
|
);
|
|
await writeFile(path.join(runnerRoot, "README.md"), "second readme\n");
|
|
await writeFile(
|
|
path.join(runnerRoot, "docs/local-runner.md"),
|
|
"second documentation\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "spec/architecture.md"),
|
|
"second architecture note\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "src/live/transport.test.ts"),
|
|
"second TypeScript test\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "test-fixtures/provider.json"),
|
|
'{"fixture":"two"}\n',
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "scripts/capability-clean-room-smoke.mjs"),
|
|
"second smoke probe\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "runner/crates/runner-core/tests/recovery.rs"),
|
|
"// second Rust integration test\n",
|
|
);
|
|
expect(await computeDaytonaImageContentId(options)).toBe(baseline);
|
|
|
|
await writeFile(
|
|
path.join(runnerRoot, "src/live/transport.ts"),
|
|
"export const runtime = 'two';\n",
|
|
);
|
|
expect(await computeDaytonaImageContentId(options)).not.toBe(baseline);
|
|
|
|
await writeFile(
|
|
path.join(runnerRoot, "src/live/transport.ts"),
|
|
"export const runtime = 'one';\n",
|
|
);
|
|
await writeFile(
|
|
path.join(runnerRoot, "runner/crates/runner-core/src/lib.rs"),
|
|
'pub const RUNTIME: &str = "two";\n',
|
|
);
|
|
expect(await computeDaytonaImageContentId(options)).not.toBe(baseline);
|
|
} finally {
|
|
await rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("rejects mutable Docker base references", () => {
|
|
expect(() => extractDaytonaBaseImages("FROM node:24-bookworm\n")).toThrow(
|
|
"must use an immutable sha256 digest",
|
|
);
|
|
});
|
|
|
|
it("rejects a mutable or missing Dockerfile syntax frontend", async () => {
|
|
expect(() =>
|
|
extractDaytonaDockerfileFrontendDigest(
|
|
"# syntax=docker/dockerfile:1.7\nFROM scratch\n",
|
|
),
|
|
).toThrow("must pin its syntax frontend");
|
|
expect(() =>
|
|
extractDaytonaDockerfileFrontendDigest("FROM scratch\n"),
|
|
).toThrow("must pin its syntax frontend");
|
|
await expect(
|
|
computeDaytonaImageContentId({
|
|
inputPaths: [],
|
|
baseImages: [`example.test/base:1@sha256:${"a".repeat(64)}`],
|
|
frontendDigest: "sha256:mutable",
|
|
}),
|
|
).rejects.toThrow("must use an immutable sha256 digest");
|
|
});
|
|
});
|