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"); }); });