freestyle-sync 0.1.8 → 0.1.10

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.
@@ -71,4 +79,26 @@ export default defineConfig({
         shellHistoryPlugin(),
     ],
 });
-```
+```
+
+Project sync can exclude folders and include additional local paths. Include paths may point outside the project directory; they are copied into the remote project at the configured relative target.
+
+```js
+export default defineConfig({
+    sync: {
+        exclude: ["dist", ".turbo"],
+        include: [
+            { source: "../shared-config", target: "shared-config" },
+        ],
+    },
+    plugins: [
+        nodeNpmPlugin(),
+    ],
+});
+```
+
+`nodeNpmPlugin()` excludes `node_modules` from upload by default and installs dependencies on the remote runtime using the project lockfile: `pnpm install --frozen-lockfile`, Yarn `--frozen-lockfile`/`--immutable`, or `npm ci`. To keep the previous behavior of syncing `node_modules` and only repairing native/workspace packages remotely, use:
+
+```js
+nodeNpmPlugin({ syncNodeModules: true })
+```

package/dist/src/main.js

@@ -10,7 +10,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import "dotenv/config";
 import { createHash } from "node:crypto";
 import { createReadStream, realpathSync } from "node:fs";
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { chmod, copyFile, lstat, mkdir, mkdtemp, readFile, readlink, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -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_BYTES = 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,
@@ -180,7 +182,8 @@ export async function sync(sdkOptions) {
     progress.step("Scanning project files");
     const cache = currentCache;
     const base = cacheBaseForSync(options, cache);
-    const projectEntries = await scanProject(options.projectRoot, options.includeGitDir);
+    const projectSyncConfig = await resolveProjectSyncConfig(options);
+    const projectEntries = await scanProject(options.projectRoot, options.includeGitDir, projectSyncConfig);
     const projectCurrent = digestMap(projectEntries);
     const projectChanges = diffEntries(projectEntries, base.projectFiles);
     progress.step("Detecting auth and agent context");
@@ -198,10 +201,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 +227,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 +241,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 +256,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 +266,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 +278,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 +525,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 +580,9 @@ function defaultCliOptions() {
         projectRoot: process.cwd(),
         cachePath: "",
         remoteProjectDir: "",
+        provider: "freestyle",
         name: "",
+        appleContainerImage: DEFAULT_APPLE_CONTAINER_IMAGE,
         yes: false,
         dryRun: false,
         disablePlugins: [],
@@ -599,14 +616,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 +636,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 +660,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 +681,7 @@ async function readCache(cachePath, options) {
         version: CACHE_VERSION,
         projectRoot: options.projectRoot,
         remoteProjectDir: options.remoteProjectDir,
+        provider: options.provider,
         projectFiles: {},
         contextFiles: {},
     };
@@ -669,6 +692,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 ?? {},
@@ -696,23 +720,92 @@ async function writeCache(cachePath, cache) {
     await mkdir(path.dirname(cachePath), { recursive: true });
     await writeFile(cachePath, `${JSON.stringify(cache, null, 2)}\n`, "utf8");
 }
-async function scanProject(projectRoot, includeGitDir) {
-    const entries = [];
-    await walk(projectRoot, "", entries, {
+async function resolveProjectSyncConfig(options) {
+    const configs = [];
+    if (config.sync)
+        configs.push(config.sync);
+    for (const plugin of plugins) {
+        const pluginConfig = await plugin.configureProjectSync?.({ options, utils: pluginUtils });
+        if (pluginConfig)
+            configs.push(pluginConfig);
+    }
+    return {
+        exclude: configs.flatMap((projectConfig) => projectConfig.exclude ?? []).map(normalizeProjectPattern),
+        include: configs.flatMap((projectConfig) => normalizeProjectIncludes(options.projectRoot, projectConfig.include ?? [])),
+    };
+}
+function normalizeProjectIncludes(projectRoot, includes) {
+    return includes.map((include) => {
+        const source = typeof include === "string" ? include : include.source;
+        const target = typeof include === "string" ? undefined : include.target;
+        const resolvedSource = path.resolve(projectRoot, source);
+        return {
+            source: resolvedSource,
+            target: normalizeProjectPattern(target ?? path.basename(resolvedSource)),
+        };
+    });
+}
+function normalizeProjectPattern(value) {
+    const normalized = path.posix.normalize(value.replace(/\\/g, "/")).replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!normalized || normalized === ".") {
+        throw new Error("project sync paths must not be empty");
+    }
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new Error(`project sync paths must stay inside the remote project: ${value}`);
+    }
+    return normalized;
+}
+async function scanProject(projectRoot, includeGitDir, syncConfig) {
+    const entriesByPath = new Map();
+    const rootEntries = [];
+    await walk(projectRoot, "", rootEntries, {
         skipDirectory(relativePath, name) {
             if (!includeGitDir && relativePath === ".git")
                 return true;
-            return false;
+            return shouldSkipProjectDirectory(relativePath, name, syncConfig.exclude);
         },
     });
-    return entries.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+    upsertProjectEntries(entriesByPath, rootEntries);
+    for (const include of syncConfig.include) {
+        upsertProjectEntries(entriesByPath, await scanProjectInclude(include, syncConfig.exclude));
+    }
+    return Array.from(entriesByPath.values()).sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function scanProjectInclude(include, exclude) {
+    const stats = await lstat(include.source).catch((error) => {
+        throw new Error(`project sync include does not exist: ${include.source} (${error instanceof Error ? error.message : String(error)})`);
+    });
+    if (stats.isFile() || stats.isSymbolicLink()) {
+        return [await digestEntry(include.source, include.target)];
+    }
+    if (!stats.isDirectory()) {
+        return [];
+    }
+    const entries = [];
+    await walk(include.source, "", entries, {
+        mapRelativePath(relativePath) {
+            return `${include.target}/${relativePath}`;
+        },
+        skipDirectory(relativePath, name) {
+            return shouldSkipProjectDirectory(relativePath, name, exclude);
+        },
+    });
+    return entries;
+}
+function upsertProjectEntries(entriesByPath, entries) {
+    for (const entry of entries)
+        entriesByPath.set(entry.relativePath, entry);
+}
+function shouldSkipProjectDirectory(relativePath, name, exclude) {
+    return exclude.some((excludedPath) => relativePath === excludedPath || name === excludedPath);
 }
 async function walk(root, relativePath, entries, options) {
     const absolutePath = path.join(root, relativePath);
     const dir = await import("node:fs/promises").then((fs) => fs.readdir(absolutePath, { withFileTypes: true }));
     for (const dirent of dir) {
         const childRelativePath = relativePath ? path.join(relativePath, dirent.name) : dirent.name;
-        const normalizedRelativePath = toPosix(childRelativePath);
+        const localRelativePath = toPosix(childRelativePath);
+        const normalizedRelativePath = options.mapRelativePath?.(localRelativePath) ?? localRelativePath;
         const childAbsolutePath = path.join(root, childRelativePath);
         if (dirent.isDirectory()) {
             if (options.skipDirectory(normalizedRelativePath, dirent.name)) {
@@ -962,9 +1055,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 +1295,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);
+        }
+    });
+}
+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));
     });
-    return { vm: result.vm, vmId: result.vmId };
+    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`);
@@ -1221,7 +1457,7 @@ async function ensureRemoteBase(vm, remoteProjectDir) {
 async function syncProject(vm, vmId, options, changes) {
     if (changes.changed.length > 0) {
         console.log(`VM ${vmId}: uploading ${changes.changed.length} changed project files...`);
-        const archive = await createProjectArchive(options.projectRoot, changes.changed);
+        const archive = await createProjectArchive(changes.changed);
         try {
             await uploadArchiveInChunks(vm, vmId, archive, "/tmp/freestyle-sync-project.tgz", "project");
             await checkedExec(vm, `mkdir -p ${shellQuote(options.remoteProjectDir)} && tar --no-same-owner --no-same-permissions -xzf /tmp/freestyle-sync-project.tgz -C ${shellQuote(options.remoteProjectDir)} && rm -f /tmp/freestyle-sync-project.tgz`);
@@ -1346,11 +1582,11 @@ async function runInstall(vm, projectRoot, remoteProjectDir) {
 }
 async function detectInstallCommand(projectRoot) {
     if (await exists(path.join(projectRoot, "pnpm-lock.yaml")))
-        return "corepack enable && pnpm install";
+        return "corepack enable && pnpm install --frozen-lockfile";
     if (await exists(path.join(projectRoot, "yarn.lock")))
-        return "corepack enable && yarn install";
-    if (await exists(path.join(projectRoot, "package-lock.json")))
-        return "npm install";
+        return "corepack enable && yarn_version=$(yarn --version) && case \"$yarn_version\" in 1.*) yarn install --frozen-lockfile ;; *) yarn install --immutable ;; esac";
+    if (await exists(path.join(projectRoot, "package-lock.json")) || await exists(path.join(projectRoot, "npm-shrinkwrap.json")))
+        return "npm ci";
     if (await exists(path.join(projectRoot, "requirements.txt")))
         return "python3 -m pip install -r requirements.txt";
     if (await exists(path.join(projectRoot, "pyproject.toml")))
@@ -1361,12 +1597,23 @@ async function detectInstallCommand(projectRoot) {
         return "go mod download";
     return undefined;
 }
-async function createProjectArchive(projectRoot, entries) {
+async function createProjectArchive(entries) {
     const tempDir = await mkdtemp(path.join(tmpdir(), "freestyle-sync-"));
-    const listPath = path.join(tempDir, "files.list");
+    const stagingDir = path.join(tempDir, "staging");
     const archivePath = path.join(tempDir, "project.tgz");
-    await writeFile(listPath, Buffer.from(entries.map((entry) => entry.relativePath).join("\0") + "\0"));
-    await createTar(["--null", "--no-xattrs", "-T", listPath, "-czf", archivePath, "-C", projectRoot]);
+    await mkdir(stagingDir, { recursive: true });
+    for (const entry of entries) {
+        const destination = path.join(stagingDir, ...entry.relativePath.split("/"));
+        await mkdir(path.dirname(destination), { recursive: true });
+        if (entry.kind === "symlink") {
+            await symlink(await readlink(entry.absolutePath), destination);
+        }
+        else {
+            await copyFile(entry.absolutePath, destination);
+            await chmod(destination, entry.mode);
+        }
+    }
+    await createTar(["--no-xattrs", "-czf", archivePath, "-C", stagingDir, "."]);
     return archivePath;
 }
 async function createContextArchive(entries) {
@@ -1393,6 +1640,7 @@ async function createTar(args) {
 }
 async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, label) {
     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(archiveSize)} ${label} archive in ${chunkCount} chunk${chunkCount === 1 ? "" : "s"}...`);
@@ -1402,8 +1650,9 @@ async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, l
     const logEvery = Math.max(1, Math.ceil(chunkCount / 4));
     let index = 0;
     for await (const chunk of createReadStream(archivePath, { highWaterMark: ARCHIVE_CHUNK_BYTES })) {
-        const chunkName = `${String(index).padStart(width, "0")}.chunk`;
-        await vm.fs.writeFile(`${chunkDir}/${chunkName}`, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        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`;
@@ -1421,7 +1670,23 @@ async function uploadArchiveInChunks(vm, vmId, archivePath, remoteArchivePath, l
     }
     await checkedExec(vm, archiveSize === 0
         ? `: > ${shellQuote(remoteArchivePath)} && rm -rf ${shellQuote(chunkDir)}`
-        : `cat ${shellQuote(chunkDir)}/*.chunk > ${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)) {
@@ -1488,17 +1753,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.8",
+  "version": "0.1.10",
   "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"
   },