freestyle-sync 0.1.7 → 0.1.9

package/README.md

@@ -1,11 +1,19 @@
 # Freestyle Sync
 
-Sync your current directory, it's dependencies, and your agent context into a VM. VM snapshots ensure only changes are uploaded.
+Sync your current directory, it's dependencies, and your agent context into a remote runtime. Freestyle VMs support snapshots so only changes are uploaded on later runs.
 
 ```
 npx freestyle-sync
 ```
 
+Freestyle VMs are the default provider. You can sync into a local Apple container on macOS with the Apple `container` CLI installed:
+
+```sh
+npx freestyle-sync --provider apple-container --apple-container-image ubuntu:24.04
+```
+
+Use `--vm-id <container-name-or-id>` to reuse an existing Apple container. Snapshot caching is only available with the Freestyle provider.
+
 Use the SDK when embedding sync inside another CLI/app (no required `freestyle-sync.config.ts` or cache file):
 
 ```ts
@@ -29,7 +37,7 @@ const result = await sync({
     },
 });
 
-console.log("synced VM", result.vmId);
+console.log("synced runtime", result.vmId);
 ```
 
 freestyle-sync creates `freestyle-sync.config.mjs` on first run and installs the config dependencies into your project as dev dependencies. Remove the generated config or dependencies if you want to reset it later.

package/dist/src/main.js

@@ -22,8 +22,9 @@ const execFileAsync = promisify(execFile);
 const CLI_NAME = "freestyle-sync";
 const CACHE_VERSION = 1;
 const PLUGIN_PREFERENCES_VERSION = 1;
-const ARCHIVE_CHUNK_CHARS = 1024 * 1024;
+const ARCHIVE_CHUNK_BYTES = 512 * 1024;
 const MS_PER_SECOND = 1000;
+const DEFAULT_APPLE_CONTAINER_IMAGE = "ubuntu:24.04";
 const DEFAULT_FREESTYLE_API_URL = "https://api.freestyle.sh";
 const DEFAULT_STACK_API_URL = "https://api.stack-auth.com";
 const DEFAULT_STACK_PROJECT_ID = "0edf478c-f123-46fb-818f-34c0024a9f35";
@@ -138,9 +139,10 @@ export async function sync(sdkOptions) {
         progress.step("Reading sync cache");
         const cache = currentCache;
         if (!options.vmId && !cache.snapshotId) {
-            console.warn(`${CLI_NAME} --skip-sync: no cached snapshot found. A new empty VM will be created. Run without --skip-sync first to create a snapshot.`);
+            console.warn(`${CLI_NAME} --skip-sync: no cached snapshot found. A new empty runtime will be created. Run without --skip-sync first to create a snapshot.`);
         }
-        const source = options.vmId ? `existing VM ${options.vmId}` : cache.snapshotId ? `snapshot ${cache.snapshotId}` : "a new VM";
+        const provider = resolveVmProvider(options.provider);
+        const source = options.vmId ? `existing ${provider.runtimeLabel} ${options.vmId}` : cache.snapshotId ? `snapshot ${cache.snapshotId}` : `a new ${provider.runtimeLabel}`;
         console.log(`Skipping sync: creating VM from ${source}`);
         console.log(`Remote project: ${options.remoteProjectDir}`);
         if (options.dryRun) {
@@ -149,26 +151,26 @@ export async function sync(sdkOptions) {
                 snapshotId: currentCache.snapshotId,
             };
         }
-        progress.step("Preparing Freestyle VM");
-        const { vm, vmId } = await getOrCreateVm(options, cache.snapshotId);
+        progress.step(`Preparing ${provider.displayName}`);
+        const { vm, vmId, provider: runtimeProvider } = await getOrCreateVm(options, cache.snapshotId);
         resultVmId = vmId;
-        console.log(`Using VM: ${vmId}`);
+        console.log(`Using ${runtimeProvider.runtimeLabel}: ${vmId}`);
         progress.step(`Running post-sync plugins for ${vmId}`);
         const contextCandidates = await discoverPluginContextCandidates(options);
         const postSyncMessages = await runAfterSyncPlugins(vm, vmId, options, contextCandidates);
         console.log("");
-        console.log(`VM ready: ${vmId}`);
+        console.log(`${capitalize(runtimeProvider.runtimeLabel)} ready: ${vmId}`);
         console.log(`Project: ${options.remoteProjectDir}`);
         if (cache.snapshotId) {
             console.log(`Snapshot cache: ${cache.snapshotId}`);
         }
         for (const message of postSyncMessages)
             console.log(message);
-        console.log(`SSH: npx freestyle vm ssh ${vmId}`);
+        console.log(`${capitalize(runtimeProvider.runtimeLabel)} access: ${runtimeProvider.connectionHint(vmId)}`);
         if (options.autoSsh) {
             const connected = await runConnectPlugins(vm, vmId, options, contextCandidates);
             if (!connected)
-                await sshIntoVm(vmId);
+                await connectToVm(runtimeProvider, vmId);
         }
         return {
             vmId,
@@ -198,10 +200,11 @@ export async function sync(sdkOptions) {
             snapshotId: currentCache.snapshotId,
         };
     }
-    progress.step("Preparing Freestyle VM");
-    const { vm, vmId } = await getOrCreateVm(options, cache.snapshotId);
+    const provider = resolveVmProvider(options.provider);
+    progress.step(`Preparing ${provider.displayName}`);
+    const { vm, vmId, provider: runtimeProvider } = await getOrCreateVm(options, cache.snapshotId);
     resultVmId = vmId;
-    console.log(`Uploading to VM: ${vmId}`);
+    console.log(`Uploading to ${runtimeProvider.runtimeLabel}: ${vmId}`);
     progress.step(`Uploading project changes to ${vmId}`);
     await ensureRemoteBase(vm, options.remoteProjectDir);
     const projectResult = await syncProject(vm, vmId, options, projectChanges);
@@ -223,6 +226,7 @@ export async function sync(sdkOptions) {
         version: CACHE_VERSION,
         projectRoot: options.projectRoot,
         remoteProjectDir: options.remoteProjectDir,
+        provider: options.provider,
         vmId,
         snapshotId: snapshotOverride ? snapshotOverride.snapshotId : cache.snapshotId,
         projectFiles: projectCurrent,
@@ -236,12 +240,13 @@ export async function sync(sdkOptions) {
     progress.step("Saving local sync cache");
     await saveCache(buildSyncCache());
     let snapshotPromise = null;
-    if (options.snapshot) {
+    const createSnapshot = vm.snapshot;
+    if (options.snapshot && createSnapshot) {
         progress.step(`Creating snapshot cache for ${vmId} in background`);
         snapshotPromise = (async () => {
             await runBeforeSnapshotPlugins(vm, vmId, options);
             try {
-                const snapshot = await vm.snapshot({ name: `${CLI_NAME}-${path.basename(options.projectRoot)}-${Date.now()}` });
+                const snapshot = await createSnapshot({ name: `${CLI_NAME}-${path.basename(options.projectRoot)}-${Date.now()}` });
                 return snapshot.snapshotId;
             }
             catch (error) {
@@ -250,6 +255,9 @@ export async function sync(sdkOptions) {
             }
         })();
     }
+    else if (options.snapshot) {
+        progress.step(`Skipping snapshot cache for ${runtimeProvider.displayName}`);
+    }
     else {
         progress.step("Skipping snapshot cache");
     }
@@ -257,7 +265,7 @@ export async function sync(sdkOptions) {
     const postSyncMessages = await runAfterSyncPlugins(vm, vmId, options, contextCandidates);
     progress.finish();
     console.log("");
-    console.log(`${success(symbol("✓", "*"))} ${bold(`VM ready: ${vmId}`)}`);
+    console.log(`${success(symbol("✓", "*"))} ${bold(`${capitalize(runtimeProvider.runtimeLabel)} ready: ${vmId}`)}`);
     console.log(`${dim("Remote project:")} ${options.remoteProjectDir}`);
     console.log(`${dim("Project files:")} ${projectResult.uploaded} uploaded, ${projectResult.removed} removed, ${projectResult.unchanged} unchanged`);
     console.log(`${dim("Context files:")} ${contextResult.uploaded} uploaded, ${contextResult.unchanged} unchanged`);
@@ -269,11 +277,11 @@ export async function sync(sdkOptions) {
     }
     for (const message of postSyncMessages)
         console.log(message);
-    console.log(`${accent(symbol("➜", ">"))} ${bold(`SSH: npx freestyle vm ssh ${vmId}`)}`);
+    console.log(`${accent(symbol("➜", ">"))} ${bold(`${capitalize(runtimeProvider.runtimeLabel)} access: ${runtimeProvider.connectionHint(vmId)}`)}`);
     if (options.autoSsh) {
         const connected = await runConnectPlugins(vm, vmId, options, contextCandidates);
         if (!connected)
-            await sshIntoVm(vmId);
+            await connectToVm(runtimeProvider, vmId);
     }
     if (snapshotPromise) {
         const newSnapshotId = await snapshotPromise;
@@ -516,9 +524,15 @@ async function parseArgs(args) {
         else if (arg === "--no-ssh") {
             options.autoSsh = false;
         }
+        else if (arg === "--provider" || arg === "--vm-provider") {
+            options.provider = parseVmProvider(readOptionValue(args, ++index, arg));
+        }
         else if (arg === "--vm-id") {
             options.vmId = readOptionValue(args, ++index, arg);
         }
+        else if (arg === "--apple-container-image" || arg === "--container-image") {
+            options.appleContainerImage = readOptionValue(args, ++index, arg);
+        }
         else if (arg === "--name") {
             options.name = readOptionValue(args, ++index, arg);
         }
@@ -565,7 +579,9 @@ function defaultCliOptions() {
         projectRoot: process.cwd(),
         cachePath: "",
         remoteProjectDir: "",
+        provider: "freestyle",
         name: "",
+        appleContainerImage: DEFAULT_APPLE_CONTAINER_IMAGE,
         yes: false,
         dryRun: false,
         disablePlugins: [],
@@ -599,14 +615,17 @@ async function finalizeCliOptions(options) {
     };
 }
 function printHelp() {
-    console.log(`${CLI_NAME} uploads the current project into a Freestyle VM.
+    console.log(`${CLI_NAME} uploads the current project into a remote runtime.
 
 Usage:
     ${CLI_NAME} [project-dir] [options]
 
 Options:
-	--vm-id <id>             Sync into an existing Freestyle VM.
-    --name <name>            Name for a newly created VM. Defaults to ${CLI_NAME}-<project>.
+    --provider <name>        Runtime provider: freestyle or apple-container. Defaults to freestyle.
+	--vm-id <id>             Sync into an existing provider runtime.
+    --apple-container-image <image>
+                             Apple Containers image. Defaults to ${DEFAULT_APPLE_CONTAINER_IMAGE}.
+    --name <name>            Name for a newly created runtime. Defaults to ${CLI_NAME}-<project>.
     --remote-dir <path>      Remote project directory. Defaults to the local absolute path.
     --cache <path>           Snapshot/hash cache path. Defaults to .freestyle-sync/cache.json.
 	--include-env <name>     Always copy an environment variable. Repeatable.
@@ -616,16 +635,16 @@ Options:
     --list-plugins           Show configured plugins and whether they are enabled.
 	--install                Run detected dependency install command after sync.
     --no-ssh                 Do not automatically open VS Code/Cursor or SSH after sync.
-	--idle-timeout <seconds> Set VM idle timeout when creating/starting.
+    --idle-timeout <seconds> Set runtime idle timeout when supported.
     --no-auth                Disable auth plugins for this run.
     --no-agent-context       Disable agent context plugins for this run.
 	--no-git-dir             Exclude the local .git directory from project sync.
     --all-copilot-workspaces Include Copilot chat state for every VS Code workspace.
     --no-snapshot, --skip-snapshot
-                             Do not snapshot the VM after sync.
-    --skip-sync              Create a VM from the last cached snapshot without syncing current
-                             files. Requires a prior sync with snapshotting enabled, or --vm-id.
-	--dry-run                Show what would sync without creating or changing a VM.
+                             Do not snapshot the runtime after sync.
+    --skip-sync              Create a runtime from the last cached snapshot without syncing current
+                             files. Requires a provider that supports snapshots, or --vm-id.
+	--dry-run                Show what would sync without creating or changing a runtime.
     -y, --yes                Deprecated; accepted for compatibility.
 	-h, --help               Show this help.
 `);
@@ -640,9 +659,11 @@ function readOptionValue(args, index, option) {
 async function readCache(cachePath, options) {
     try {
         const parsed = JSON.parse(await readFile(cachePath, "utf8"));
-        if (parsed.version === CACHE_VERSION && parsed.projectRoot === options.projectRoot && parsed.remoteProjectDir === options.remoteProjectDir) {
+        const provider = parsed.provider ?? "freestyle";
+        if (parsed.version === CACHE_VERSION && parsed.projectRoot === options.projectRoot && parsed.remoteProjectDir === options.remoteProjectDir && provider === options.provider) {
             return {
                 ...parsed,
+                provider,
                 projectFiles: parsed.projectFiles ?? {},
                 contextFiles: parsed.contextFiles ?? {},
                 snapshotProjectFiles: parsed.snapshotProjectFiles,
@@ -659,6 +680,7 @@ async function readCache(cachePath, options) {
         version: CACHE_VERSION,
         projectRoot: options.projectRoot,
         remoteProjectDir: options.remoteProjectDir,
+        provider: options.provider,
         projectFiles: {},
         contextFiles: {},
     };
@@ -669,6 +691,7 @@ function normalizeCache(cache, options) {
         version: CACHE_VERSION,
         projectRoot: options.projectRoot,
         remoteProjectDir: options.remoteProjectDir,
+        provider: options.provider,
         projectFiles: cache.projectFiles ?? {},
         contextFiles: cache.contextFiles ?? {},
         snapshotProjectFiles: cache.snapshotProjectFiles ?? {},
@@ -962,9 +985,11 @@ async function writePluginPreferences(preferencesPath, preferences) {
     await writeFile(preferencesPath, `${JSON.stringify({ ...preferences, updatedAt: new Date().toISOString() }, null, 2)}\n`, "utf8");
 }
 function printPlan(options, projectChanges, contextChanges, envExports, cache) {
-    const source = options.vmId ? `existing VM ${options.vmId}` : cache.snapshotId ? `snapshot ${cache.snapshotId}` : "a new VM";
+    const provider = resolveVmProvider(options.provider);
+    const source = options.vmId ? `existing ${provider.runtimeLabel} ${options.vmId}` : cache.snapshotId ? `snapshot ${cache.snapshotId}` : `a new ${provider.runtimeLabel}`;
     console.log("");
     console.log(`${bold("Sync plan")}`);
+    console.log(`${dim("  Provider:")} ${provider.displayName}`);
     console.log(`${dim("  Source:")} ${source}`);
     console.log(`${dim("  Local:")} ${options.projectRoot}`);
     console.log(`${dim("  Remote:")} ${options.remoteProjectDir}`);
@@ -1200,20 +1225,161 @@ async function runFreestyleLogin(extraArgs = []) {
         });
     });
 }
+function parseVmProvider(value) {
+    if (value === "freestyle" || value === "apple-container")
+        return value;
+    throw new Error(`unknown provider: ${value}. Expected freestyle or apple-container.`);
+}
+function resolveVmProvider(provider) {
+    if (provider === "apple-container")
+        return appleContainerProvider;
+    return freestyleVmProvider;
+}
+const freestyleVmProvider = {
+    name: "freestyle",
+    displayName: "Freestyle VM",
+    runtimeLabel: "VM",
+    async prepare(options, snapshotId) {
+        const freestyle = await getFreestyleClient();
+        if (options.vmId) {
+            const { vm } = await freestyle.vms.get({ vmId: options.vmId });
+            await vm.start(options.idleTimeoutSeconds ? { idleTimeoutSeconds: options.idleTimeoutSeconds } : undefined);
+            return { vm: vm, vmId: options.vmId };
+        }
+        console.log(snapshotId ? `Creating VM from snapshot ${snapshotId}...` : "Creating Freestyle VM...");
+        const result = await freestyle.vms.create({
+            name: options.name,
+            snapshotId: snapshotId ?? undefined,
+            idleTimeoutSeconds: options.idleTimeoutSeconds,
+        });
+        return { vm: result.vm, vmId: result.vmId };
+    },
+    connectionHint(vmId) {
+        return `npx freestyle vm ssh ${vmId}`;
+    },
+    async connect(vmId) {
+        console.log(`Connecting to VM ${vmId}...`);
+        await spawnInherited("npx", ["freestyle", "vm", "ssh", vmId], "ssh exited with status");
+    },
+};
+const appleContainerProvider = {
+    name: "apple-container",
+    displayName: "Apple container",
+    runtimeLabel: "container",
+    async prepare(options) {
+        if (options.vmId) {
+            await startAppleContainer(options.vmId);
+            return { vm: new AppleContainerVm(options.vmId), vmId: options.vmId };
+        }
+        console.log(`Creating Apple container ${options.name} from ${options.appleContainerImage}...`);
+        const result = await execFileAsync("container", ["run", "--detach", "--name", options.name, options.appleContainerImage, "sleep", "infinity"]);
+        const vmId = result.stdout.trim() || options.name;
+        return { vm: new AppleContainerVm(vmId), vmId };
+    },
+    connectionHint(vmId) {
+        return `container exec --interactive --tty ${vmId} sh -l`;
+    },
+    async connect(vmId) {
+        console.log(`Connecting to container ${vmId}...`);
+        await spawnInherited("container", ["exec", "--interactive", "--tty", vmId, "sh", "-l"], "container shell exited with status");
+    },
+};
 async function getOrCreateVm(options, snapshotId) {
-    const freestyle = await getFreestyleClient();
-    if (options.vmId) {
-        const { vm } = await freestyle.vms.get({ vmId: options.vmId });
-        await vm.start(options.idleTimeoutSeconds ? { idleTimeoutSeconds: options.idleTimeoutSeconds } : undefined);
-        return { vm, vmId: options.vmId };
-    }
-    console.log(snapshotId ? `Creating VM from snapshot ${snapshotId}...` : "Creating Freestyle VM...");
-    const result = await freestyle.vms.create({
-        name: options.name,
-        snapshotId: snapshotId ?? undefined,
-        idleTimeoutSeconds: options.idleTimeoutSeconds,
+    const provider = resolveVmProvider(options.provider);
+    if (snapshotId && provider.name !== "freestyle") {
+        console.warn(`${provider.displayName} does not support Freestyle snapshots. Creating a fresh ${provider.runtimeLabel}.`);
+    }
+    const runtime = await provider.prepare(options, provider.name === "freestyle" ? snapshotId : undefined);
+    return { ...runtime, provider };
+}
+async function startAppleContainer(containerId) {
+    const result = await execFileResult("container", ["start", containerId]);
+    if (result.statusCode !== 0 && !/already running/i.test(result.stderr || result.stdout || "")) {
+        throw new Error(`failed to start Apple container ${containerId}: ${result.stderr || result.stdout || `exit ${result.statusCode}`}`);
+    }
+}
+class AppleContainerVm {
+    containerId;
+    fs = {
+        writeFile: (remotePath, content) => this.writeFile(remotePath, content),
+        writeTextFile: (remotePath, content) => this.writeFile(remotePath, Buffer.from(content)),
+    };
+    constructor(containerId) {
+        this.containerId = containerId;
+    }
+    exec(args) {
+        return execFileResult("container", ["exec", this.containerId, "sh", "-lc", args.command], { timeoutMs: args.timeoutMs });
+    }
+    async writeFile(remotePath, content) {
+        const directory = path.posix.dirname(remotePath);
+        await checkedContainerExec(this.containerId, `mkdir -p ${shellQuote(directory)} && cat > ${shellQuote(remotePath)}`, content);
+    }
+}
+async function checkedContainerExec(containerId, command, input) {
+    const result = await execFileResult("container", ["exec", "--interactive", containerId, "sh", "-lc", command], { input });
+    if (result.statusCode && result.statusCode !== 0) {
+        throw new Error(`container command failed (${result.statusCode}): ${command}\n${result.stderr || result.stdout || ""}`);
+    }
+}
+async function execFileResult(file, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(file, args, { stdio: [options.input ? "pipe" : "ignore", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        let settled = false;
+        let timedOut = false;
+        const timer = options.timeoutMs
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+            }, options.timeoutMs)
+            : undefined;
+        child.stdout?.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+        child.stderr?.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            reject(error);
+        });
+        child.on("exit", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resolve({
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8"),
+                statusCode: timedOut ? 124 : code ?? 1,
+            });
+        });
+        if (options.input) {
+            child.stdin?.end(options.input);
+        }
     });
-    return { vm: result.vm, vmId: result.vmId };
+}
+async function spawnInherited(file, args, errorPrefix) {
+    const exitCode = await new Promise((resolve, reject) => {
+        const child = spawn(file, args, { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("exit", (code) => resolve(code));
+    });
+    if (exitCode && exitCode !== 0) {
+        throw new Error(`${errorPrefix} ${exitCode}`);
+    }
+}
+async function connectToVm(provider, vmId) {
+    if (!provider.connect) {
+        console.log(`Connect with: ${provider.connectionHint(vmId)}`);
+        return;
+    }
+    await provider.connect(vmId);
+}
+function capitalize(value) {
+    return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
 }
 async function ensureRemoteBase(vm, remoteProjectDir) {
     await checkedExec(vm, `mkdir -p ${shellQuote(remoteProjectDir)} /root/.freestyle-sync`);
@@ -1392,20 +1558,20 @@ async function createTar(args) {
     });
 }
 async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, label) {
-    const archive = await readFile(archivePath);
-    const encoded = archive.toString("base64");
-    const chunkCount = Math.max(1, Math.ceil(encoded.length / ARCHIVE_CHUNK_CHARS));
+    const archiveSize = (await stat(archivePath)).size;
+    const archiveHash = await hashFile(archivePath);
+    const chunkCount = Math.max(1, Math.ceil(archiveSize / ARCHIVE_CHUNK_BYTES));
     const chunkDir = `/tmp/freestyle-sync-${label}-${Date.now()}.chunks`;
-    console.log(`VM ${vmId}: streaming ${formatBytes(archive.length)} ${label} archive in ${chunkCount} chunk${chunkCount === 1 ? "" : "s"}...`);
+    console.log(`VM ${vmId}: streaming ${formatBytes(archiveSize)} ${label} archive in ${chunkCount} chunk${chunkCount === 1 ? "" : "s"}...`);
     await checkedExec(vm, `rm -rf ${shellQuote(chunkDir)} && mkdir -p ${shellQuote(chunkDir)}`);
     const width = String(chunkCount - 1).length;
     const canRenderInlineProgress = process.stdout.isTTY;
     const logEvery = Math.max(1, Math.ceil(chunkCount / 4));
-    for (let index = 0; index < chunkCount; index += 1) {
-        const start = index * ARCHIVE_CHUNK_CHARS;
-        const chunk = encoded.slice(start, start + ARCHIVE_CHUNK_CHARS);
-        const chunkName = `${String(index).padStart(width, "0")}.b64`;
-        await vm.fs.writeTextFile(`${chunkDir}/${chunkName}`, chunk);
+    let index = 0;
+    for await (const chunk of createReadStream(archivePath, { highWaterMark: ARCHIVE_CHUNK_BYTES })) {
+        const chunkName = `${String(index).padStart(width, "0")}.chunk.b64`;
+        const content = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        await vm.fs.writeTextFile(`${chunkDir}/${chunkName}`, content.toString("base64"));
         const uploadedChunks = index + 1;
         if (chunkCount > 1) {
             const progressMessage = `VM ${vmId}: uploaded ${uploadedChunks}/${chunkCount} ${label} archive chunks`;
@@ -1419,8 +1585,27 @@ async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, l
                 console.log(progressMessage);
             }
         }
-    }
-    await checkedExec(vm, `cat ${shellQuote(chunkDir)}/*.b64 | base64 -d > ${shellQuote(remoteArchivePath)} && rm -rf ${shellQuote(chunkDir)}`);
+        index += 1;
+    }
+    await checkedExec(vm, archiveSize === 0
+        ? `: > ${shellQuote(remoteArchivePath)} && rm -rf ${shellQuote(chunkDir)}`
+        : [
+            "set -e",
+            `rm -f ${shellQuote(remoteArchivePath)}`,
+            `for chunk in ${shellQuote(chunkDir)}/*.chunk.b64; do`,
+            `    base64 -d "$chunk" >> ${shellQuote(remoteArchivePath)}`,
+            "done",
+            `actual_size=$(wc -c < ${shellQuote(remoteArchivePath)} | tr -d '[:space:]')`,
+            `actual_hash=$(sha256sum ${shellQuote(remoteArchivePath)} | awk '{print $1}')`,
+            `if [ "$actual_size" != ${shellQuote(String(archiveSize))} ] || [ "$actual_hash" != ${shellQuote(archiveHash)} ]; then`,
+            `    rm -f ${shellQuote(remoteArchivePath)}`,
+            `    rm -rf ${shellQuote(chunkDir)}`,
+            `    echo ${shellQuote(`archive integrity check failed for ${label}: expected ${archiveSize} bytes/${archiveHash}`)} >&2`,
+            `    echo "got $actual_size bytes/$actual_hash" >&2`,
+            "    exit 1",
+            "fi",
+            `rm -rf ${shellQuote(chunkDir)}`,
+        ].join("\n"));
 }
 async function mkdirRemote(vm, directories) {
     for (const chunk of chunkArray(directories, 50)) {
@@ -1487,17 +1672,6 @@ async function runConnectPlugins(vm, vmId, options, contextCandidates) {
     }
     return false;
 }
-async function sshIntoVm(vmId) {
-    console.log(`Connecting to VM ${vmId}...`);
-    const exitCode = await new Promise((resolve, reject) => {
-        const child = spawn("npx", ["freestyle", "vm", "ssh", vmId], { stdio: "inherit" });
-        child.on("error", reject);
-        child.on("exit", (code) => resolve(code));
-    });
-    if (exitCode && exitCode !== 0) {
-        throw new Error(`ssh exited with status ${exitCode}`);
-    }
-}
 async function hashFile(filePath) {
     const hash = createHash("sha256");
     await new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freestyle-sync",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "main": "dist/src/main.js",
   "exports": {
@@ -22,7 +22,8 @@
     "build": "rm -rf dist plugins/*/dist && tsc -p tsconfig.json && node scripts/prepare-plugin-packages.mjs",
     "check": "tsc --noEmit -p tsconfig.json",
     "prepack": "npm run build",
-    "publish": "npm run check && npm run build && npm run publish:workspaces && npm publish",
+    "publish": "npm run check && npm run build && npm run publish:workspaces && npm run publish:root",
+    "publish:root": "node scripts/publish-root.mjs",
     "publish:workspaces": "node scripts/publish-workspaces.mjs",
     "start": "node src/main.ts"
   },