@tickernelz/paperclip-pro-plugin-daytona 2026.925.0

package/dist/file-sync.test.js

@@ -0,0 +1,974 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+import zlib from "node:zlib";
+import { Transform } from "node:stream";
+import { afterEach, describe, expect, it } from "vitest";
+// The plugin module imports `@daytonaio/sdk` as a value, but the sync tests never
+// touch a real Daytona client — every sandbox call goes through a local mock. Stub
+// the SDK so the import resolves without the excluded provider package.
+import { vi } from "vitest";
+vi.mock("@daytonaio/sdk", () => ({
+    Daytona: class MockDaytona {
+    },
+    DaytonaNotFoundError: class MockDaytonaNotFoundError extends Error {
+    },
+    DaytonaTimeoutError: class MockDaytonaTimeoutError extends Error {
+    },
+}));
+import { performSyncIn } from "./file-sync.js";
+import { __setDaytonaPluginContextForTest } from "./plugin.js";
+// Build a mock Daytona sandbox for the inbound directory path. `executeCommand`
+// records every command and returns exit 0, except that any command whose text
+// matches `failCommandMatch` returns exit 1 (to simulate an extract failure).
+// `uploadFiles` records each upload destination so a test can read the reserved
+// scratch tar path the runtime chose.
+function createMockSandbox(input) {
+    return {
+        process: {
+            executeCommand: async (command) => {
+                input.commands.push({ command });
+                if (input.failCommandMatch && input.failCommandMatch.test(command)) {
+                    return { exitCode: 1, result: "simulated extract failure" };
+                }
+                return { exitCode: 0, result: "" };
+            },
+        },
+        fs: {
+            uploadFiles: async (uploads) => {
+                for (const upload of uploads)
+                    input.uploadedDestinations.push(upload.destination);
+            },
+        },
+    };
+}
+describe("daytona file-sync inbound scratch cleanup", () => {
+    const cleanupDirs = [];
+    afterEach(async () => {
+        while (cleanupDirs.length > 0) {
+            const dir = cleanupDirs.pop();
+            if (!dir)
+                continue;
+            await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+        }
+    });
+    it("removes the reserved scratch tar when a directory extraction fails", async () => {
+        const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-scratch-"));
+        cleanupDirs.push(rootDir);
+        const sourceDir = path.join(rootDir, "referenced-project");
+        await fs.mkdir(sourceDir, { recursive: true });
+        await fs.writeFile(path.join(sourceDir, "README.md"), "referenced project\n", "utf8");
+        const remoteDir = "/workspace";
+        const targetPath = "/workspace/.paperclip-runtime/test-adapter/project-abc";
+        const uploadedDestinations = [];
+        const commands = [];
+        // Fail the extract round trip (the only command that runs `tar -xf`).
+        const sandbox = createMockSandbox({
+            failCommandMatch: /tar -xf/,
+            uploadedDestinations,
+            commands,
+        });
+        const operations = [{
+                operationId: "sync-op-1",
+                files: [{ sourcePath: sourceDir, targetPath, kind: "directory" }],
+            }];
+        await expect(performSyncIn({
+            // The mock stands in for the Daytona SDK Sandbox; only the two methods the
+            // inbound directory path calls are needed.
+            sandbox: sandbox,
+            operations,
+            remoteDir,
+            timeoutSeconds: 30,
+        })).rejects.toThrow(/syncIn extract/);
+        // The runtime uploaded exactly one reserved scratch tar under the workspace
+        // root. Its name carries the reserved `.paperclip-upload-` prefix.
+        expect(uploadedDestinations).toHaveLength(1);
+        const scratchTar = uploadedDestinations[0];
+        expect(scratchTar).toContain(".paperclip-upload-");
+        expect(scratchTar.startsWith(`${remoteDir}/`)).toBe(true);
+        // The failure path swept the scratch tar: a standalone `rm -f` of the exact
+        // scratch path ran after the failed extract. The extract command itself also
+        // contains an `rm -f`, so the cleanup is the `rm -f` command that does NOT run
+        // `tar -xf`.
+        const cleanupCommands = commands.filter((entry) => entry.command.includes(scratchTar) &&
+            entry.command.includes("rm -f") &&
+            !entry.command.includes("tar -xf"));
+        expect(cleanupCommands.length).toBeGreaterThan(0);
+    });
+    it("does not sweep scratch on the happy path (extract removes it)", async () => {
+        const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-scratch-"));
+        cleanupDirs.push(rootDir);
+        const sourceDir = path.join(rootDir, "referenced-project");
+        await fs.mkdir(sourceDir, { recursive: true });
+        await fs.writeFile(path.join(sourceDir, "README.md"), "referenced project\n", "utf8");
+        const remoteDir = "/workspace";
+        const targetPath = "/workspace/.paperclip-runtime/test-adapter/project-abc";
+        const uploadedDestinations = [];
+        const commands = [];
+        // No failure: every command succeeds, so the extract's own `rm -f` clears the
+        // scratch and no extra cleanup round trip runs.
+        const sandbox = createMockSandbox({ uploadedDestinations, commands });
+        const operations = [{
+                operationId: "sync-op-1",
+                files: [{ sourcePath: sourceDir, targetPath, kind: "directory" }],
+            }];
+        await performSyncIn({
+            sandbox: sandbox,
+            operations,
+            remoteDir,
+            timeoutSeconds: 30,
+        });
+        const scratchTar = uploadedDestinations[0];
+        // The standalone cleanup command (a `rm -f` without `tar -xf`) never runs on the
+        // happy path — only the extract command, which ends with its own `rm -f`.
+        const standaloneRemoves = commands.filter((entry) => entry.command.includes(scratchTar) &&
+            entry.command.includes("rm -f") &&
+            !entry.command.includes("tar -xf"));
+        expect(standaloneRemoves).toHaveLength(0);
+    });
+    it("writes an inbound file mapping to a sandbox path outside the workspace root", async () => {
+        const hostDir = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-outside-root-"));
+        cleanupDirs.push(hostDir);
+        const sourcePath = path.join(hostDir, "source.txt");
+        await fs.writeFile(sourcePath, "payload");
+        // A target outside the workspace remote dir. The inbound direction writes
+        // host data into the sandbox, and the sandbox already has read/write
+        // authority over its own filesystem, so the provider no longer confines
+        // the target to the remote dir.
+        const remoteDir = "/workspace";
+        const targetPath = "/etc/paperclip-outside-root.txt";
+        const uploadedDestinations = [];
+        const commands = [];
+        const sandbox = createMockSandbox({ uploadedDestinations, commands });
+        const operations = [{
+                operationId: "sync-op-outside-root",
+                files: [{ sourcePath, targetPath, kind: "file" }],
+            }];
+        const result = await performSyncIn({ sandbox: sandbox, operations, remoteDir, timeoutSeconds: 30 });
+        expect(result.operations[0].filesTransferred).toBe(1);
+        const promoteCommand = commands.map((entry) => entry.command).find((command) => command.includes("mv -f"));
+        expect(promoteCommand).toBeDefined();
+        expect(promoteCommand).toContain(targetPath);
+    });
+});
+// ---------------------------------------------------------------
+// zstd-3 transport compression on the inbound file-mapping path
+// ---------------------------------------------------------------
+const ZSTD_MIN_SOURCE_BYTES_FOR_TEST = 8 * 1024 * 1024;
+// A real `zstd` binary is required to run the tests that execute a real
+// promotion script (the sandbox stand-in below shells out to THIS host). The
+// package never depends on a `zstd` binary on the production host — only the
+// sandbox side does, per the design — but the test double needs one to prove
+// the decompression contract for real rather than only recording commands.
+// Skip cleanly, like the existing `describeLinux`/`describeLive` gates in this
+// package, when the test host has none.
+const hasZstdBinary = spawnSync("zstd", ["--version"]).status === 0;
+const describeWithZstd = hasZstdBinary ? describe : describe.skip;
+function sha256OfFile(filePath) {
+    return fs.readFile(filePath).then((buf) => crypto.createHash("sha256").update(buf).digest("hex"));
+}
+async function writeCompressibleFile(filePath, sizeBytes) {
+    // Low-entropy repeated content compresses well past the 10% saving bar.
+    const chunk = Buffer.from("paperclip-zstd-transport-compression-fixture-".repeat(64));
+    const parts = [];
+    for (let written = 0; written < sizeBytes; written += chunk.length)
+        parts.push(chunk);
+    await fs.writeFile(filePath, Buffer.concat(parts).subarray(0, sizeBytes));
+}
+async function writeIncompressibleFile(filePath, sizeBytes) {
+    await fs.writeFile(filePath, crypto.randomBytes(sizeBytes));
+}
+/**
+ * A lightweight recording sandbox double for the fallback-condition tests: it
+ * never runs a real shell, only records commands and reports a canned exit
+ * code, and simulates the zstd availability probe via `probeReportsZstd`.
+ * Host-side compression (`node:zlib`) still runs for real in the code under
+ * test — only the SANDBOX side is faked here — so these tests genuinely
+ * exercise the host compression/ratio decision.
+ */
+function createRecordingSandbox(input) {
+    return {
+        process: {
+            executeCommand: async (command) => {
+                input.commands.push({ command });
+                if (command.includes("mkdir -p")) {
+                    return { exitCode: 0, result: input.probeReportsZstd ? "PAPERCLIP_ZSTD_AVAILABLE\n" : "" };
+                }
+                return { exitCode: 0, result: "" };
+            },
+        },
+        fs: {
+            uploadFiles: async (uploads) => {
+                for (const upload of uploads) {
+                    input.uploadedSources.push(upload.source);
+                    input.uploadedDestinations.push(upload.destination);
+                }
+            },
+            setFilePermissions: async () => undefined,
+        },
+    };
+}
+/**
+ * A real POSIX-shell-backed sandbox double: `executeCommand` runs the exact
+ * command string on THIS host via `/bin/sh -c`, and `uploadFiles`/
+ * `setFilePermissions` apply real bytes/modes onto a real directory standing
+ * in for the sandbox root. This proves the decompression/promotion script
+ * for real, instead of only recording which commands the code would send.
+ */
+function createRealExecSandbox(input) {
+    const commands = [];
+    return {
+        commands,
+        sandbox: {
+            process: {
+                executeCommand: async (command) => {
+                    commands.push({ command });
+                    const result = spawnSync("/bin/sh", ["-c", command], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, env: input?.commandEnv });
+                    return { exitCode: result.status ?? 1, result: (result.stdout ?? "") + (result.stderr ?? "") };
+                },
+            },
+            fs: {
+                uploadFiles: async (uploads) => {
+                    if (input?.uploadOverride && (await input.uploadOverride(uploads)))
+                        return;
+                    for (const upload of uploads)
+                        await fs.copyFile(upload.source, upload.destination);
+                },
+                setFilePermissions: async (target, options) => {
+                    await fs.chmod(target, parseInt(options.mode, 8));
+                },
+            },
+        },
+    };
+}
+// Daytona uses GNU tar. macOS contributors can install gnu-tar; the usual
+// Linux CI path runs this directly without extra dependencies.
+const gnuTar = ["gtar", "tar"].map((candidate) => {
+    const resolved = spawnSync("/bin/sh", ["-c", 'command -v "$1"', "sh", candidate], { encoding: "utf8" }).stdout.trim();
+    return resolved && spawnSync(resolved, ["--version"], { encoding: "utf8" }).stdout?.includes("GNU tar") ? resolved : null;
+}).find(Boolean);
+it.skipIf(!gnuTar)("extracts interleaved read-only skill directories with GNU tar and preserves their modes", async () => {
+    const root = await fs.mkdtemp("/tmp/paperclip-daytona-readonly-");
+    const source = path.join(root, "source");
+    const remoteDir = path.join(root, "remote");
+    const target = path.join(remoteDir, "skill");
+    const bin = path.join(root, "bin");
+    await fs.mkdir(path.join(source, "references", "agents"), { recursive: true });
+    await fs.mkdir(remoteDir);
+    await fs.mkdir(bin);
+    await fs.symlink(gnuTar, path.join(bin, "tar"));
+    await fs.writeFile(path.join(source, "references", "overview.md"), "overview", { mode: 0o444 });
+    await fs.writeFile(path.join(source, "references", "agents", "qa.md"), "QA instructions", { mode: 0o444 });
+    for (const dir of ["references/agents", "references"])
+        await fs.chmod(path.join(source, dir), 0o555);
+    try {
+        const { sandbox } = createRealExecSandbox({
+            commandEnv: { ...process.env, PATH: `${bin}:${process.env.PATH}` },
+            uploadOverride: async (uploads) => {
+                for (const upload of uploads) {
+                    // BSD tar can list a child directory before its parent's files, then
+                    // visit that child later. GNU tar must not finalize its 0555 mode early.
+                    const archive = spawnSync(gnuTar, ["-c", "--owner=12345", "--group=12345", "--no-xattrs", "--no-recursion", "-f", upload.destination, "-C", source,
+                        "references", "references/agents", "references/overview.md", "references/agents/qa.md"], { encoding: "utf8", env: { ...process.env, COPYFILE_DISABLE: "1" } });
+                    expect(archive.status, archive.stderr).toBe(0);
+                }
+                return true;
+            },
+        });
+        await performSyncIn({ sandbox: sandbox, remoteDir, timeoutSeconds: 30,
+            operations: [{ operationId: "readonly-skill", files: [{ sourcePath: source, targetPath: target, kind: "directory", mode: 0o555 }] }] });
+        // A resumed sandbox already contains the previous read-only skill bundle.
+        await fs.writeFile(path.join(target, "unrelated.txt"), "keep me");
+        await performSyncIn({ sandbox: sandbox, remoteDir, timeoutSeconds: 30,
+            operations: [{ operationId: "readonly-skill-resume", files: [{ sourcePath: source, targetPath: target, kind: "directory", mode: 0o555 }] }] });
+        expect(await fs.readFile(path.join(target, "unrelated.txt"), "utf8")).toBe("keep me");
+        expect(await fs.readFile(path.join(target, "references", "agents", "qa.md"), "utf8")).toBe("QA instructions");
+        expect((await fs.stat(path.join(target, "references", "agents"))).mode & 0o777).toBe(0o555);
+        expect((await fs.stat(path.join(target, "references", "agents", "qa.md"))).mode & 0o777).toBe(0o444);
+        // Never treat a corrupted read-only bundle as a cache hit, even if its
+        // file size, permissions and timestamp still match the source archive.
+        const qa = path.join(target, "references", "agents", "qa.md");
+        const before = await fs.stat(qa);
+        await fs.chmod(qa, 0o644);
+        await fs.writeFile(qa, "XX instructions");
+        await fs.chmod(qa, 0o444);
+        await fs.utimes(qa, before.atime, before.mtime);
+        await expect(performSyncIn({ sandbox: sandbox, remoteDir, timeoutSeconds: 30,
+            operations: [{ operationId: "corrupt-skill-resume", files: [{ sourcePath: source, targetPath: target, kind: "directory", mode: 0o555 }] }] })).rejects.toThrow("syncIn extract");
+        expect(await fs.readFile(qa, "utf8")).toBe("XX instructions");
+        expect((await fs.readdir(remoteDir)).filter((name) => name.startsWith(".paperclip-upload"))).toEqual([]);
+    }
+    finally {
+        for (const base of [source, target]) {
+            for (const dir of ["references/agents", "references"])
+                await fs.chmod(path.join(base, dir), 0o700).catch(() => undefined);
+        }
+        await fs.rm(root, { recursive: true, force: true });
+    }
+}, 30_000);
+it.skipIf(!gnuTar)("uploads gzip directory archives and preserves content, executable modes, and symlinks", async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-gzip-dir-"));
+    const source = path.join(root, "source");
+    const remoteDir = path.join(root, "remote");
+    const target = path.join(remoteDir, "target");
+    const bin = path.join(root, "bin");
+    await fs.mkdir(path.join(source, "bin"), { recursive: true });
+    await fs.mkdir(remoteDir);
+    await fs.mkdir(bin);
+    await fs.symlink(gnuTar, path.join(bin, "tar"));
+    await fs.writeFile(path.join(source, "bin", "tool.sh"), "#!/bin/sh\necho ok\n", { mode: 0o755 });
+    await fs.symlink("bin/tool.sh", path.join(source, "tool-link"));
+    try {
+        let uploadedArchiveBytes;
+        const { sandbox } = createRealExecSandbox({
+            commandEnv: { ...process.env, PATH: `${bin}:${process.env.PATH}` },
+            uploadOverride: async (uploads) => {
+                uploadedArchiveBytes = await fs.readFile(uploads[0].source);
+                for (const upload of uploads)
+                    await fs.copyFile(upload.source, upload.destination);
+                return true;
+            },
+        });
+        await performSyncIn({
+            sandbox: sandbox,
+            remoteDir,
+            timeoutSeconds: 30,
+            operations: [{
+                    operationId: "gzip-directory",
+                    files: [{ sourcePath: source, targetPath: target, kind: "directory" }],
+                }],
+        });
+        expect(uploadedArchiveBytes).toBeDefined();
+        expect(uploadedArchiveBytes.subarray(0, 2)).toEqual(Buffer.from([0x1f, 0x8b]));
+        expect(await fs.readFile(path.join(target, "bin", "tool.sh"), "utf8")).toBe("#!/bin/sh\necho ok\n");
+        expect((await fs.stat(path.join(target, "bin", "tool.sh"))).mode & 0o777).toBe(0o755);
+        expect(await fs.readlink(path.join(target, "tool-link"))).toBe("bin/tool.sh");
+    }
+    finally {
+        await fs.rm(root, { recursive: true, force: true });
+    }
+}, 30_000);
+it.skipIf(!gnuTar)("uploads and extracts a gzip empty directory archive", async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-gzip-empty-"));
+    const source = path.join(root, "source");
+    const remoteDir = path.join(root, "remote");
+    const target = path.join(remoteDir, "target");
+    const bin = path.join(root, "bin");
+    await fs.mkdir(source);
+    await fs.mkdir(remoteDir);
+    await fs.mkdir(bin);
+    await fs.symlink(gnuTar, path.join(bin, "tar"));
+    try {
+        let uploadedArchiveBytes;
+        const { sandbox } = createRealExecSandbox({
+            commandEnv: { ...process.env, PATH: `${bin}:${process.env.PATH}` },
+            uploadOverride: async (uploads) => {
+                uploadedArchiveBytes = await fs.readFile(uploads[0].source);
+                for (const upload of uploads)
+                    await fs.copyFile(upload.source, upload.destination);
+                return true;
+            },
+        });
+        await performSyncIn({
+            sandbox: sandbox,
+            remoteDir,
+            timeoutSeconds: 30,
+            operations: [{
+                    operationId: "gzip-empty-directory",
+                    files: [{ sourcePath: source, targetPath: target, kind: "directory" }],
+                }],
+        });
+        expect(uploadedArchiveBytes).toBeDefined();
+        expect(uploadedArchiveBytes.subarray(0, 2)).toEqual(Buffer.from([0x1f, 0x8b]));
+        expect(await fs.readdir(target)).toEqual([]);
+    }
+    finally {
+        await fs.rm(root, { recursive: true, force: true });
+    }
+}, 30_000);
+describe("daytona file-sync inbound zstd transport compression", () => {
+    const cleanupDirs = [];
+    afterEach(async () => {
+        while (cleanupDirs.length > 0) {
+            const dir = cleanupDirs.pop();
+            if (!dir)
+                continue;
+            await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+        }
+    });
+    const mkTempDir = async (prefix) => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+        cleanupDirs.push(dir);
+        return dir;
+    };
+    describeWithZstd("compressed path (real promotion script, real zstd)", () => {
+        it("compresses on the host and decompresses in-sandbox to a byte-identical file", async () => {
+            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "workspace-upload.tar");
+            await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            const targetPath = path.posix.join(remoteDir, "workspace-upload.tar");
+            const { sandbox, commands } = createRealExecSandbox();
+            const operations = [{
+                    operationId: "sync-op-1",
+                    files: [{ sourcePath, targetPath, kind: "file" }],
+                }];
+            const result = await performSyncIn({ sandbox: sandbox, operations, remoteDir, timeoutSeconds: 30 });
+            expect(result.operations[0].filesTransferred).toBe(1);
+            expect(result.operations[0].bytesTransferred).toBe(ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            // The promote script actually ran a real `zstd -d -o` — proves decompression
+            // happened, not just that the code called `uploadFiles`.
+            expect(commands.some((entry) => entry.command.includes("zstd -d -o"))).toBe(true);
+            expect(await sha256OfFile(targetPath)).toBe(await sha256OfFile(sourcePath));
+            // Cleanup on success: no reserved scratch (raw or `.zst`) remains.
+            const remaining = await fs.readdir(remoteDir);
+            expect(remaining.filter((name) => name.includes(".paperclip-upload"))).toHaveLength(0);
+        });
+        it("removes the private compressed host temp directory after a successful sync", async () => {
+            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "workspace-upload.tar");
+            await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            const targetPath = path.posix.join(remoteDir, "target.bin");
+            let capturedHostTempDir = "";
+            const { sandbox } = createRealExecSandbox({
+                uploadOverride: async (uploads) => {
+                    const zstdUpload = uploads.find((upload) => upload.destination.endsWith(".zst"));
+                    if (zstdUpload)
+                        capturedHostTempDir = path.dirname(zstdUpload.source);
+                    for (const upload of uploads)
+                        await fs.copyFile(upload.source, upload.destination);
+                    return true;
+                },
+            });
+            const operations = [{
+                    operationId: "sync-op-1",
+                    files: [{ sourcePath, targetPath, kind: "file" }],
+                }];
+            await performSyncIn({ sandbox: sandbox, operations, remoteDir, timeoutSeconds: 30 });
+            expect(capturedHostTempDir).toContain("paperclip-daytona-zstd-");
+            // The private host temp directory (not just the file inside it) is gone
+            // after a successful sync.
+            await expect(fs.stat(capturedHostTempDir)).rejects.toThrow();
+        });
+        it("reports the sync as successful when the post-promotion `.zst` cleanup fails, and warns with a leftover count but no path", async () => {
+            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "workspace-upload.tar");
+            await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            const targetPath = path.posix.join(remoteDir, "target.bin");
+            // Put a stand-in `rm` first on PATH. It always exits 1. So BOTH the
+            // promote script's OWN `.zst` cleanup and the later bounded sweep's
+            // separate `rm -f` fail, the same way a persistent cleanup error would.
+            // The other commands (`mv`, `zstd`, `chmod`) still resolve to the real
+            // binaries later on PATH.
+            const fakeBinDir = await mkTempDir("paperclip-daytona-zstd-fakebin-");
+            const fakeRmPath = path.join(fakeBinDir, "rm");
+            await fs.writeFile(fakeRmPath, "#!/bin/sh\nexit 1\n");
+            await fs.chmod(fakeRmPath, 0o755);
+            const originalPath = process.env.PATH;
+            process.env.PATH = `${fakeBinDir}${path.delimiter}${originalPath}`;
+            const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+            try {
+                const { sandbox } = createRealExecSandbox();
+                const operations = [{
+                        operationId: "sync-op-1",
+                        files: [{ sourcePath, targetPath, kind: "file" }],
+                    }];
+                // Every target file is already installed by the time the `.zst`
+                // cleanup runs, so a failing cleanup must never turn into a sync
+                // failure.
+                await performSyncIn({ sandbox: sandbox, operations, remoteDir, timeoutSeconds: 30 });
+                expect(await sha256OfFile(targetPath)).toBe(await sha256OfFile(sourcePath));
+                // The forced `rm` failure left the `.zst` scratch behind — proof the
+                // fake `rm` actually ran and failed, not that cleanup was skipped.
+                const remaining = await fs.readdir(remoteDir);
+                const zstdName = remaining.find((name) => name.endsWith(".zst"));
+                expect(zstdName).toBeDefined();
+                // A leftover that survives both the inline cleanup and the bounded
+                // sweep is observable: exactly one warning, carrying a count, never
+                // the scratch pathname itself.
+                expect(warnSpy).toHaveBeenCalledTimes(1);
+                const warning = warnSpy.mock.calls[0]?.[0];
+                expect(warning).toContain("1 post-promotion scratch file");
+                expect(warning).not.toContain(zstdName);
+            }
+            finally {
+                process.env.PATH = originalPath;
+                warnSpy.mockRestore();
+            }
+        });
+        it("recovers a transient post-promotion `.zst` cleanup failure with the bounded sweep, without warning", async () => {
+            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "workspace-upload.tar");
+            await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            const targetPath = path.posix.join(remoteDir, "target.bin");
+            // A stand-in `rm` that fails only its first call — the promote script's
+            // own inline `.zst` cleanup. It defers to the real `rm` for every later
+            // call. This simulates a transient cleanup failure: the bounded sweep's
+            // own, separate `rm -f` is the second call, and it succeeds.
+            const fakeBinDir = await mkTempDir("paperclip-daytona-zstd-fakebin-");
+            const counterFile = path.join(fakeBinDir, "rm-call-count");
+            const fakeRmPath = path.join(fakeBinDir, "rm");
+            await fs.writeFile(fakeRmPath, [
+                "#!/bin/sh",
+                "n=0",
+                `[ -f "${counterFile}" ] && n=$(cat "${counterFile}")`,
+                "n=$((n + 1))",
+                `printf '%s' "$n" > "${counterFile}"`,
+                '[ "$n" -eq 1 ] && exit 1',
+                'exec /bin/rm "$@"',
+                "",
+            ].join("\n"));
+            await fs.chmod(fakeRmPath, 0o755);
+            const originalPath = process.env.PATH;
+            process.env.PATH = `${fakeBinDir}${path.delimiter}${originalPath}`;
+            const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+            try {
+                const { sandbox } = createRealExecSandbox();
+                const operations = [{
+                        operationId: "sync-op-1",
+                        files: [{ sourcePath, targetPath, kind: "file" }],
+                    }];
+                await performSyncIn({ sandbox: sandbox, operations, remoteDir, timeoutSeconds: 30 });
+                expect(await sha256OfFile(targetPath)).toBe(await sha256OfFile(sourcePath));
+                expect(await fs.readFile(counterFile, "utf8")).toBe("2"); // proves the sweep actually ran a second `rm`
+                // The sweep's separate, later `rm -f` succeeded where the inline
+                // cleanup failed — no `.zst` scratch remains, so there is nothing to
+                // warn about.
+                const remaining = await fs.readdir(remoteDir);
+                expect(remaining.some((name) => name.endsWith(".zst"))).toBe(false);
+                expect(warnSpy).not.toHaveBeenCalled();
+            }
+            finally {
+                process.env.PATH = originalPath;
+                warnSpy.mockRestore();
+            }
+        });
+        it("never promotes a partial file when decompression fails, and sweeps all reserved scratch", async () => {
+            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "workspace-upload.tar");
+            await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            const targetPath = path.posix.join(remoteDir, "target.bin");
+            const { sandbox } = createRealExecSandbox({
+                // Simulate the `.zst` upload landing corrupted: the in-sandbox
+                // `zstd -d -c` step will fail for real on this invalid input.
+                uploadOverride: async (uploads) => {
+                    for (const upload of uploads) {
+                        if (upload.destination.endsWith(".zst")) {
+                            await fs.writeFile(upload.destination, Buffer.from("not a valid zstd frame at all"));
+                        }
+                        else {
+                            await fs.copyFile(upload.source, upload.destination);
+                        }
+                    }
+                    return true;
+                },
+            });
+            const operations = [{
+                    operationId: "sync-op-1",
+                    files: [{ sourcePath, targetPath, kind: "file" }],
+                }];
+            await expect(performSyncIn({ sandbox: sandbox, operations, remoteDir, timeoutSeconds: 30 })).rejects.toThrow(/syncIn rename/);
+            await expect(fs.stat(targetPath)).rejects.toThrow(); // never promoted
+            const remaining = await fs.readdir(remoteDir);
+            expect(remaining.filter((name) => name.includes(".paperclip-upload"))).toHaveLength(0); // scratch swept
+        });
+        it("applies mapping.mode via chmod before promotion, when set", async () => {
+            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourceNoMode = path.join(hostDir, "no-mode.tar");
+            const sourceWithMode = path.join(hostDir, "with-mode.tar");
+            await writeCompressibleFile(sourceNoMode, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            await writeCompressibleFile(sourceWithMode, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 2048);
+            const targetNoMode = path.posix.join(remoteDir, "no-mode.bin");
+            const targetWithMode = path.posix.join(remoteDir, "with-mode.bin");
+            // `zstd -d -o` copies the mode of its INPUT (the uploaded `.zst`
+            // scratch) onto its output. Widen every `.zst` scratch to 0644 here,
+            // standing in for a Daytona upload that does not preserve a host-side
+            // 0600 origin. A pass on the no-mode assertion below then proves the
+            // promote script's OWN `chmod` forces 0600 — not that the scratch
+            // happened to arrive owner-only already.
+            const { sandbox } = createRealExecSandbox({
+                uploadOverride: async (uploads) => {
+                    for (const upload of uploads) {
+                        await fs.copyFile(upload.source, upload.destination);
+                        if (upload.destination.endsWith(".zst"))
+                            await fs.chmod(upload.destination, 0o644);
+                    }
+                    return true;
+                },
+            });
+            const operations = [{
+                    operationId: "sync-op-1",
+                    files: [
+                        { sourcePath: sourceNoMode, targetPath: targetNoMode, kind: "file" },
+                        { sourcePath: sourceWithMode, targetPath: targetWithMode, kind: "file", mode: 0o640 },
+                    ],
+                }];
+            await performSyncIn({ sandbox: sandbox, operations, remoteDir, timeoutSeconds: 30 });
+            // A mapping with no `mode` lands owner-only (0600): the promote script
+            // always runs `chmod` on the decompressed file right after
+            // `zstd -d -o`, and uses 0600 when the mapping sets no `mode` — even
+            // though its `.zst` scratch arrived at 0644 above. A mapping with an
+            // explicit `mode` gets that mode instead.
+            expect((await fs.stat(targetNoMode)).mode & 0o777).toBe(0o600);
+            expect((await fs.stat(targetWithMode)).mode & 0o777).toBe(0o640);
+        });
+        it("runs two concurrent compressed sync operations without cross-talk", async () => {
+            const remoteDirA = await mkTempDir("paperclip-daytona-zstd-remote-a-");
+            const remoteDirB = await mkTempDir("paperclip-daytona-zstd-remote-b-");
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourceA = path.join(hostDir, "a.tar");
+            const sourceB = path.join(hostDir, "b.tar");
+            await writeCompressibleFile(sourceA, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 2048);
+            await writeCompressibleFile(sourceB, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 4096);
+            await fs.appendFile(sourceA, "AAAA-marker-a");
+            await fs.appendFile(sourceB, "BBBB-marker-b");
+            const targetA = path.posix.join(remoteDirA, "target.bin");
+            const targetB = path.posix.join(remoteDirB, "target.bin");
+            const { sandbox: sandboxA } = createRealExecSandbox();
+            const { sandbox: sandboxB } = createRealExecSandbox();
+            await Promise.all([
+                performSyncIn({
+                    sandbox: sandboxA,
+                    operations: [{ operationId: "a", files: [{ sourcePath: sourceA, targetPath: targetA, kind: "file" }] }],
+                    remoteDir: remoteDirA,
+                    timeoutSeconds: 30,
+                }),
+                performSyncIn({
+                    sandbox: sandboxB,
+                    operations: [{ operationId: "b", files: [{ sourcePath: sourceB, targetPath: targetB, kind: "file" }] }],
+                    remoteDir: remoteDirB,
+                    timeoutSeconds: 30,
+                }),
+            ]);
+            expect(await sha256OfFile(targetA)).toBe(await sha256OfFile(sourceA));
+            expect(await sha256OfFile(targetB)).toBe(await sha256OfFile(sourceB));
+        });
+        it("emits exactly the five compression/decompress span attributes, with closed-set/numeric values", async () => {
+            const spans = [];
+            const tracer = {
+                startSpan(_name, options) {
+                    const span = { attributes: { ...(options?.attributes ?? {}) } };
+                    spans.push(span);
+                    return {
+                        setAttribute(key, value) {
+                            span.attributes[key] = value;
+                        },
+                        setStatus() { },
+                        end() { },
+                    };
+                },
+            };
+            const restore = __setDaytonaPluginContextForTest({ tracer });
+            let targetPath = "";
+            let remoteDir = "";
+            try {
+                remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
+                const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+                const sourcePath = path.join(hostDir, "workspace-upload.tar");
+                await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+                targetPath = path.posix.join(remoteDir, "target.bin");
+                const { sandbox } = createRealExecSandbox();
+                await performSyncIn({
+                    sandbox: sandbox,
+                    operations: [{ operationId: "op-1", files: [{ sourcePath, targetPath, kind: "file" }] }],
+                    remoteDir,
+                    timeoutSeconds: 30,
+                });
+            }
+            finally {
+                restore();
+            }
+            const allAttrs = {};
+            for (const span of spans)
+                Object.assign(allAttrs, span.attributes);
+            const compressionKeys = Object.keys(allAttrs).filter((key) => key.includes(".transfer.compression.") || key.includes(".transfer.decompress."));
+            expect(new Set(compressionKeys)).toEqual(new Set([
+                "paperclip.sandbox.startup.transfer.compression.codec",
+                "paperclip.sandbox.startup.transfer.compression.wall_ms",
+                "paperclip.sandbox.startup.transfer.compression.bytes_in",
+                "paperclip.sandbox.startup.transfer.compression.bytes_out",
+                "paperclip.sandbox.startup.transfer.decompress.wall_ms",
+            ]));
+            expect(allAttrs["paperclip.sandbox.startup.transfer.compression.codec"]).toBe("zstd");
+            for (const key of [
+                "paperclip.sandbox.startup.transfer.compression.wall_ms",
+                "paperclip.sandbox.startup.transfer.compression.bytes_in",
+                "paperclip.sandbox.startup.transfer.compression.bytes_out",
+                "paperclip.sandbox.startup.transfer.decompress.wall_ms",
+            ]) {
+                expect(Number.isFinite(allAttrs[key])).toBe(true);
+            }
+        });
+    });
+    describe("raw-path fallback conditions (no real sandbox exec needed)", () => {
+        it("falls back to the raw path when the sandbox reports no zstd binary", async () => {
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "big.tar");
+            await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            const uploadedSources = [];
+            const uploadedDestinations = [];
+            const sandbox = createRecordingSandbox({
+                probeReportsZstd: false,
+                uploadedSources,
+                uploadedDestinations,
+                commands: [],
+            });
+            const operations = [{
+                    operationId: "op-1",
+                    files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
+                }];
+            await performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 });
+            expect(uploadedSources).toEqual([sourcePath]); // raw source uploaded directly
+            expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
+        });
+        it("falls back to the raw path when the source is below ZSTD_MIN_SOURCE_BYTES", async () => {
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "small.tar");
+            await fs.writeFile(sourcePath, "well below the 8 MiB compression floor\n");
+            const uploadedSources = [];
+            const uploadedDestinations = [];
+            const sandbox = createRecordingSandbox({
+                probeReportsZstd: true,
+                uploadedSources,
+                uploadedDestinations,
+                commands: [],
+            });
+            const operations = [{
+                    operationId: "op-1",
+                    files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
+                }];
+            await performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 });
+            expect(uploadedSources).toEqual([sourcePath]);
+            expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
+        });
+        it("falls back to the raw path when the saving ratio is below ZSTD_MIN_SAVING_RATIO", async () => {
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "incompressible.tar");
+            await writeIncompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            const uploadedSources = [];
+            const uploadedDestinations = [];
+            const sandbox = createRecordingSandbox({
+                probeReportsZstd: true,
+                uploadedSources,
+                uploadedDestinations,
+                commands: [],
+            });
+            const operations = [{
+                    operationId: "op-1",
+                    files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
+                }];
+            await performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 });
+            expect(uploadedSources).toEqual([sourcePath]); // host discarded the compressed candidate
+            expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
+        });
+        it("falls back to the raw path when zlib.createZstdCompress is not a function (feature-detect)", async () => {
+            // `createZstdCompress` is a non-writable (but configurable) property on
+            // `node:zlib` — simulate an older Node runtime without zstd support by
+            // redefining it, not assigning it.
+            const original = zlib.createZstdCompress;
+            Object.defineProperty(zlib, "createZstdCompress", { value: undefined, configurable: true, writable: true });
+            try {
+                const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+                const sourcePath = path.join(hostDir, "big.tar");
+                await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+                const uploadedSources = [];
+                const uploadedDestinations = [];
+                const sandbox = createRecordingSandbox({
+                    probeReportsZstd: true,
+                    uploadedSources,
+                    uploadedDestinations,
+                    commands: [],
+                });
+                const operations = [{
+                        operationId: "op-1",
+                        files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
+                    }];
+                await performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 });
+                expect(uploadedSources).toEqual([sourcePath]);
+                expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
+            }
+            finally {
+                Object.defineProperty(zlib, "createZstdCompress", { value: original, configurable: true, writable: true });
+            }
+        });
+        it("falls back to the raw path when host compression throws, and leaves no host temp file", async () => {
+            const original = zlib.createZstdCompress;
+            const throwingCompressor = () => new Transform({
+                transform(_chunk, _encoding, callback) {
+                    callback(new Error("simulated host compression failure"));
+                },
+            });
+            Object.defineProperty(zlib, "createZstdCompress", {
+                value: throwingCompressor,
+                configurable: true,
+                writable: true,
+            });
+            try {
+                const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+                const sourcePath = path.join(hostDir, "big.tar");
+                await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+                const uploadedSources = [];
+                const uploadedDestinations = [];
+                const sandbox = createRecordingSandbox({
+                    probeReportsZstd: true,
+                    uploadedSources,
+                    uploadedDestinations,
+                    commands: [],
+                });
+                const operations = [{
+                        operationId: "op-1",
+                        files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
+                    }];
+                const before = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+                await performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 });
+                expect(uploadedSources).toEqual([sourcePath]);
+                expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
+                const after = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+                expect(after).toEqual(before); // no leftover host temp file
+            }
+            finally {
+                Object.defineProperty(zlib, "createZstdCompress", { value: original, configurable: true, writable: true });
+            }
+        });
+        it("removes the private host temp directory when the post-compression size stat throws", async () => {
+            const realStat = fs.stat.bind(fs);
+            const statSpy = vi.spyOn(fs, "stat").mockImplementation(async (targetPath, ...rest) => {
+                if (typeof targetPath === "string" && path.basename(targetPath) === "artifact.zst") {
+                    throw new Error("simulated post-compression stat failure");
+                }
+                return realStat(targetPath, ...rest);
+            });
+            try {
+                const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+                const sourcePath = path.join(hostDir, "big.tar");
+                await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+                const uploadedSources = [];
+                const uploadedDestinations = [];
+                const sandbox = createRecordingSandbox({
+                    probeReportsZstd: true,
+                    uploadedSources,
+                    uploadedDestinations,
+                    commands: [],
+                });
+                const operations = [{
+                        operationId: "op-1",
+                        files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
+                    }];
+                const before = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+                await performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 });
+                // The post-compression stat failed, so the candidate falls back to the raw path.
+                expect(uploadedSources).toEqual([sourcePath]);
+                expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
+                const after = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+                expect(after).toEqual(before); // the stat failure did not leak the private host temp directory
+            }
+            finally {
+                statSpy.mockRestore();
+            }
+        });
+        it("removes the host compressed temp file and sweeps sandbox scratch when the upload itself is rejected (cancellation)", async () => {
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "big.tar");
+            await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            const commands = [];
+            const sandbox = {
+                process: {
+                    executeCommand: async (command) => {
+                        commands.push({ command });
+                        return { exitCode: 0, result: command.includes("mkdir -p") ? "PAPERCLIP_ZSTD_AVAILABLE\n" : "" };
+                    },
+                },
+                fs: {
+                    uploadFiles: async () => {
+                        throw new Error("simulated cancellation");
+                    },
+                    setFilePermissions: async () => undefined,
+                },
+            };
+            const before = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+            const operations = [{
+                    operationId: "op-1",
+                    files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
+                }];
+            await expect(performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 })).rejects.toThrow(/simulated cancellation/);
+            const after = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+            expect(after).toEqual(before); // no leftover host temp file
+            const rmCommands = commands.filter((entry) => entry.command.includes("rm -f"));
+            expect(rmCommands.length).toBeGreaterThan(0); // both reserved scratch names swept
+        });
+        it("stages the compressed artifact in a private 0700 directory with a 0600 file, and removes the directory when the upload fails", async () => {
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "big.tar");
+            await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            let capturedDir = "";
+            let capturedDirMode = -1;
+            let capturedFileMode = -1;
+            const sandbox = {
+                process: {
+                    executeCommand: async (command) => ({
+                        exitCode: 0,
+                        result: command.includes("mkdir -p") ? "PAPERCLIP_ZSTD_AVAILABLE\n" : "",
+                    }),
+                },
+                fs: {
+                    uploadFiles: async (uploads) => {
+                        const zstdUpload = uploads.find((upload) => upload.destination.endsWith(".zst"));
+                        if (!zstdUpload)
+                            throw new Error("test setup: expected a compressed upload");
+                        // Read the modes BEFORE throwing: the directory and its file still
+                        // exist at this point, on the way to the (simulated) failed upload.
+                        capturedDir = path.dirname(zstdUpload.source);
+                        capturedDirMode = (await fs.stat(capturedDir)).mode & 0o777;
+                        capturedFileMode = (await fs.stat(zstdUpload.source)).mode & 0o777;
+                        throw new Error("simulated upload failure");
+                    },
+                    setFilePermissions: async () => undefined,
+                },
+            };
+            const operations = [{
+                    operationId: "op-1",
+                    files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
+                }];
+            await expect(performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 })).rejects.toThrow(/simulated upload failure/);
+            expect(capturedDirMode).toBe(0o700);
+            expect(capturedFileMode).toBe(0o600);
+            // The private directory (not only the file) is removed after the upload fails.
+            await expect(fs.stat(capturedDir)).rejects.toThrow();
+        });
+        it("passes the caller's timeoutSeconds unchanged through every round trip on the compressed path", async () => {
+            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const sourcePath = path.join(hostDir, "big.tar");
+            await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
+            const seenTimeouts = [];
+            const sandbox = {
+                process: {
+                    executeCommand: async (command, _cwd, _env, timeoutSeconds) => {
+                        seenTimeouts.push(timeoutSeconds);
+                        return { exitCode: 0, result: command.includes("mkdir -p") ? "PAPERCLIP_ZSTD_AVAILABLE\n" : "" };
+                    },
+                },
+                fs: {
+                    uploadFiles: async (_uploads, timeoutSeconds) => {
+                        seenTimeouts.push(timeoutSeconds);
+                    },
+                    setFilePermissions: async () => undefined,
+                },
+            };
+            const operations = [{
+                    operationId: "op-1",
+                    files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
+                }];
+            await performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 123 });
+            expect(seenTimeouts.length).toBeGreaterThanOrEqual(3); // mkdir and probe, transfer, promote
+            expect(seenTimeouts.every((timeout) => timeout === 123)).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=file-sync.test.js.map