freestyle-sync 0.1.3 → 0.1.5

package/{src/main.ts → dist/src/main.js}

@@ -1,5 +1,13 @@
 #!/usr/bin/env node
-import "dotenv/config"
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+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";
@@ -9,20 +17,34 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { freestyle } from "freestyle";
-import type { CliOptions, ContextCandidate, PushvmConfig, PushvmPluginUtils, RemoteVm } from "./plugin-api.ts";
-export * from "./plugin-api.ts";
-
+export * from "./plugin-api.js";
 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 MS_PER_SECOND = 1000;
 const USE_UNICODE_OUTPUT = process.stdout.isTTY && (process.env.TERM !== "dumb" || Boolean(process.env.TERM_PROGRAM));
 const USE_STYLED_OUTPUT = process.stdout.isTTY && process.env.NO_COLOR !== "1";
-let config: PushvmConfig = { plugins: [] };
-let plugins = config.plugins;
-const pluginUtils: PushvmPluginUtils = {
+const DEFAULT_CONFIG_DEPENDENCIES = [
+    { name: "freestyle-sync", spec: "freestyle-sync@latest" },
+    { name: "@freestyle-sync/agent-claude", spec: "@freestyle-sync/agent-claude@latest" },
+    { name: "@freestyle-sync/agent-codex", spec: "@freestyle-sync/agent-codex@latest" },
+    { name: "@freestyle-sync/agent-copilot", spec: "@freestyle-sync/agent-copilot@latest" },
+    { name: "@freestyle-sync/auth-aws", spec: "@freestyle-sync/auth-aws@latest" },
+    { name: "@freestyle-sync/auth-azure", spec: "@freestyle-sync/auth-azure@latest" },
+    { name: "@freestyle-sync/auth-docker", spec: "@freestyle-sync/auth-docker@latest" },
+    { name: "@freestyle-sync/auth-env", spec: "@freestyle-sync/auth-env@latest" },
+    { name: "@freestyle-sync/auth-gcloud", spec: "@freestyle-sync/auth-gcloud@latest" },
+    { name: "@freestyle-sync/auth-git", spec: "@freestyle-sync/auth-git@latest" },
+    { name: "@freestyle-sync/auth-github-cli", spec: "@freestyle-sync/auth-github-cli@latest" },
+    { name: "@freestyle-sync/auth-npm", spec: "@freestyle-sync/auth-npm@latest" },
+    { name: "@freestyle-sync/auth-ssh", spec: "@freestyle-sync/auth-ssh@latest" },
+    { name: "@freestyle-sync/auth-yarn", spec: "@freestyle-sync/auth-yarn@latest" },
+    { name: "@freestyle-sync/node-npm", spec: "@freestyle-sync/node-npm@latest" },
+    { name: "@freestyle-sync/shell-history", spec: "@freestyle-sync/shell-history@latest" },
+];
+const pluginUtils = {
     checkedExec,
     createTar,
     uploadArchiveInChunks,
@@ -31,65 +53,17 @@ const pluginUtils: PushvmPluginUtils = {
     md5,
     delay,
 };
-
-type FileKind = "file" | "symlink";
-
-type FileDigest = {
-    hash: string;
-    kind: FileKind;
-    mode: number;
-    size: number;
-};
-
-type LocalEntry = FileDigest & {
-    absolutePath: string;
-    relativePath: string;
-};
-
-type CacheFile = {
-    version: number;
-    projectRoot: string;
-    remoteProjectDir: string;
-    vmId?: string;
-    snapshotId?: string;
-    projectFiles: Record<string, FileDigest>;
-    contextFiles: Record<string, FileDigest>;
-    snapshotProjectFiles?: Record<string, FileDigest>;
-    snapshotContextFiles?: Record<string, FileDigest>;
-    envHash?: string;
-    snapshotEnvHash?: string;
-    updatedAt?: string;
-};
-
-type PluginPreferences = {
-    version: number;
-    disabledPlugins: string[];
-    updatedAt?: string;
-};
-
-type ContextEntry = LocalEntry & {
-    remotePath: string;
-    label: string;
-    sensitive: boolean;
-};
-
-type SyncResult = {
-    uploaded: number;
-    removed: number;
-    unchanged: number;
-};
-
+let config = { plugins: [] };
+let plugins = config.plugins;
 class Progress {
-    private current = 0;
-    private readonly total: number;
-    private currentStepStartedAt = 0;
-    private currentStepMessage?: string;
-
-    constructor(total: number) {
+    current = 0;
+    total;
+    currentStepStartedAt = 0;
+    currentStepMessage;
+    constructor(total) {
         this.total = total;
     }
-
-    step(message: string) {
+    step(message) {
         if (this.currentStepMessage) {
             this.printCompletion();
         }
@@ -98,136 +72,149 @@ class Progress {
         this.currentStepStartedAt = Date.now();
         console.log(`${accent(symbol("➜", ">"))} ${bold(`[${this.current}/${this.total}]`)} ${message}`);
     }
-
     finish() {
-        if (!this.currentStepMessage) return;
+        if (!this.currentStepMessage)
+            return;
         this.printCompletion();
         this.currentStepMessage = undefined;
     }
-
-    private printCompletion() {
-        if (!this.currentStepMessage) return;
+    printCompletion() {
+        if (!this.currentStepMessage)
+            return;
         const elapsed = Date.now() - this.currentStepStartedAt;
         console.log(`${success(symbol("✔", "*"))} ${dim(`[${this.current}/${this.total}]`)} ${this.currentStepMessage} ${dim(formatDuration(elapsed))}`);
     }
 }
-
 if (isDirectCliExecution()) {
     main().catch((error) => {
-        console.error(`vmpush: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(`${CLI_NAME}: ${error instanceof Error ? error.message : String(error)}`);
         process.exitCode = 1;
     });
 }
-
 async function main() {
     const options = await parseArgs(process.argv.slice(2));
-    printHeading("vmpush");
-    config = await loadConfig(options.projectRoot);
+    const loadedConfig = await loadConfig(options.projectRoot);
+    await sync({
+        config: loadedConfig,
+        options,
+    });
+}
+export async function sync(sdkOptions) {
+    const options = await resolveCliOptions(sdkOptions.options);
+    printHeading(CLI_NAME);
+    config = sdkOptions.config;
     plugins = config.plugins;
-    const pluginPreferences = await updatePluginPreferences(options);
+    const pluginPreferences = await updatePluginPreferences(options, sdkOptions.pluginPreferences);
     plugins = activePlugins(pluginPreferences, options);
+    let currentCache = sdkOptions.cache ? normalizeCache(sdkOptions.cache, options) : await readCache(options.cachePath, options);
+    let resultVmId;
+    const saveCache = async (nextCache) => {
+        currentCache = nextCache;
+        if (sdkOptions.onCacheUpdate) {
+            await sdkOptions.onCacheUpdate(nextCache);
+            return;
+        }
+        if (!sdkOptions.cache) {
+            await writeCache(options.cachePath, nextCache);
+        }
+    };
     if (options.listPlugins) {
         printPlugins(pluginPreferences, options);
-        return;
+        return {
+            cache: currentCache,
+            snapshotId: currentCache.snapshotId,
+        };
     }
-
     if (options.dryRun) {
-        console.log("vmpush dry run");
+        console.log(`${CLI_NAME} dry run`);
     }
-
     if (options.skipSync) {
         const progress = new Progress(3);
         progress.step("Reading sync cache");
-        const cache = await readCache(options.cachePath, options);
-
+        const cache = currentCache;
         if (!options.vmId && !cache.snapshotId) {
-            console.warn("vmpush --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 VM 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";
         console.log(`Skipping sync: creating VM from ${source}`);
         console.log(`Remote project: ${options.remoteProjectDir}`);
-
         if (options.dryRun) {
-            return;
+            return {
+                cache: currentCache,
+                snapshotId: currentCache.snapshotId,
+            };
         }
-
         progress.step("Preparing Freestyle VM");
         const { vm, vmId } = await getOrCreateVm(options, cache.snapshotId);
+        resultVmId = vmId;
         console.log(`Using VM: ${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(`Project: ${options.remoteProjectDir}`);
         if (cache.snapshotId) {
             console.log(`Snapshot cache: ${cache.snapshotId}`);
         }
-        for (const message of postSyncMessages) console.log(message);
+        for (const message of postSyncMessages)
+            console.log(message);
         console.log(`SSH: npx freestyle vm ssh ${vmId}`);
         if (options.autoSsh) {
             const connected = await runConnectPlugins(vm, vmId, options, contextCandidates);
-            if (!connected) await sshIntoVm(vmId);
+            if (!connected)
+                await sshIntoVm(vmId);
         }
-        return;
+        return {
+            vmId,
+            cache: currentCache,
+            snapshotId: currentCache.snapshotId,
+        };
     }
-
     const progress = new Progress(options.dryRun ? 2 : options.install ? 12 : 11);
-
     progress.step("Scanning project files");
-    const cache = await readCache(options.cachePath, options);
+    const cache = currentCache;
     const base = cacheBaseForSync(options, cache);
     const projectEntries = await scanProject(options.projectRoot, options.includeGitDir);
     const projectCurrent = digestMap(projectEntries);
     const projectChanges = diffEntries(projectEntries, base.projectFiles);
-
     progress.step("Detecting auth and agent context");
     let envExports = collectPluginEnvironment(options);
     let contextCandidates = await discoverPluginContextCandidates(options);
     const envHash = hashString(renderEnvFile(envExports));
-
     const contextEntries = await scanContextCandidates(contextCandidates);
     const contextCurrent = digestMapByRemotePath(contextEntries);
     const contextChanges = diffContextEntries(contextEntries, base.contextFiles);
-
     printPlan(options, projectChanges, contextChanges, envExports, cache);
-
     if (options.dryRun) {
         progress.finish();
-        return;
+        return {
+            cache: currentCache,
+            snapshotId: currentCache.snapshotId,
+        };
     }
-
     progress.step("Preparing Freestyle VM");
     const { vm, vmId } = await getOrCreateVm(options, cache.snapshotId);
+    resultVmId = vmId;
     console.log(`Uploading to VM: ${vmId}`);
-
     progress.step(`Uploading project changes to ${vmId}`);
     await ensureRemoteBase(vm, options.remoteProjectDir);
     const projectResult = await syncProject(vm, vmId, options, projectChanges);
-
     progress.step(`Running remote fixups on ${vmId}`);
     await runRemoteFixups(vm, vmId, options);
-
     progress.step(`Uploading auth/context changes to ${vmId}`);
     const contextResult = await syncContext(vm, vmId, contextChanges);
     await runAfterContextSyncPlugins(vm, vmId, options, contextChanges.changed.map((entry) => entry.remotePath));
-
     progress.step(`Installing environment files on ${vmId}`);
     await installEnvironment(vm, envExports, envHash, base.envHash);
-
     progress.step(`Writing resume metadata on ${vmId}`);
     await writeRemoteResumeFiles(vm, options, vmId, envExports);
     await hardenRemoteRoot(vm);
-
     if (options.install) {
         progress.step(`Running install command on ${vmId}`);
         await runInstall(vm, options.projectRoot, options.remoteProjectDir);
     }
-
-    const buildSyncCache = (snapshotOverride?: { snapshotId: string }): CacheFile => ({
+    const buildSyncCache = (snapshotOverride) => ({
         version: CACHE_VERSION,
         projectRoot: options.projectRoot,
         remoteProjectDir: options.remoteProjectDir,
@@ -241,31 +228,29 @@ async function main() {
         snapshotEnvHash: snapshotOverride ? envHash : cache.snapshotEnvHash,
         updatedAt: new Date().toISOString(),
     });
-
     progress.step("Saving local sync cache");
-    await writeCache(options.cachePath, buildSyncCache());
-
-    let snapshotPromise: Promise<string | null> | null = null;
+    await saveCache(buildSyncCache());
+    let snapshotPromise = null;
     if (options.snapshot) {
         progress.step(`Creating snapshot cache for ${vmId} in background`);
         snapshotPromise = (async () => {
             await runBeforeSnapshotPlugins(vm, vmId, options);
             try {
-                const snapshot = await vm.snapshot({ name: `vmpush-${path.basename(options.projectRoot)}-${Date.now()}` });
+                const snapshot = await vm.snapshot({ name: `${CLI_NAME}-${path.basename(options.projectRoot)}-${Date.now()}` });
                 return snapshot.snapshotId;
-            } catch (error) {
+            }
+            catch (error) {
                 console.warn(`Snapshot cache skipped: ${error instanceof Error ? error.message : String(error)}`);
                 return null;
             }
         })();
-    } else {
+    }
+    else {
         progress.step("Skipping snapshot cache");
     }
-
     progress.step(`Running post-sync plugins for ${vmId}`);
     const postSyncMessages = await runAfterSyncPlugins(vm, vmId, options, contextCandidates);
     progress.finish();
-
     console.log("");
     console.log(`${success(symbol("✓", "*"))} ${bold(`VM ready: ${vmId}`)}`);
     console.log(`${dim("Remote project:")} ${options.remoteProjectDir}`);
@@ -273,49 +258,134 @@ async function main() {
     console.log(`${dim("Context files:")} ${contextResult.uploaded} uploaded, ${contextResult.unchanged} unchanged`);
     if (snapshotPromise) {
         console.log(`${dim("Snapshot cache:")} creating in background`);
-    } else if (cache.snapshotId) {
+    }
+    else if (cache.snapshotId) {
         console.log(`${dim("Snapshot cache:")} ${cache.snapshotId}`);
     }
-    for (const message of postSyncMessages) console.log(message);
+    for (const message of postSyncMessages)
+        console.log(message);
     console.log(`${accent(symbol("➜", ">"))} ${bold(`SSH: npx freestyle vm ssh ${vmId}`)}`);
     if (options.autoSsh) {
         const connected = await runConnectPlugins(vm, vmId, options, contextCandidates);
-        if (!connected) await sshIntoVm(vmId);
+        if (!connected)
+            await sshIntoVm(vmId);
     }
-
     if (snapshotPromise) {
         const newSnapshotId = await snapshotPromise;
         if (newSnapshotId) {
-            await writeCache(options.cachePath, buildSyncCache({ snapshotId: newSnapshotId }));
+            await saveCache(buildSyncCache({ snapshotId: newSnapshotId }));
             console.log(`Snapshot cache saved: ${newSnapshotId}`);
         }
     }
+    return {
+        vmId: resultVmId,
+        cache: currentCache,
+        snapshotId: currentCache.snapshotId,
+    };
 }
-
 function isDirectCliExecution() {
-    if (!process.argv[1]) return false;
+    if (!process.argv[1])
+        return false;
     try {
         return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
-    } catch {
+    }
+    catch {
         return path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
     }
 }
-
-async function loadConfig(projectRoot: string): Promise<PushvmConfig> {
-    const configPath = path.join(projectRoot, "freestyle-sync.config.ts");
-    if (!(await exists(configPath))) {
-        await writeFile(configPath, renderDefaultConfig(), "utf8");
-        console.log(`Created ${path.relative(process.cwd(), configPath) || path.basename(configPath)}`);
-    }
-
-    const imported = await import(pathToFileURL(configPath).href);
-    const loaded = imported.default as PushvmConfig | undefined;
+async function loadConfig(projectRoot) {
+    const configPath = await resolveConfigPath(projectRoot);
+    const imported = await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href));
+    const loaded = imported.default;
     if (!loaded || !Array.isArray(loaded.plugins)) {
         throw new Error(`${configPath} must export default defineConfig({ plugins: [...] })`);
     }
     return loaded;
 }
+async function resolveConfigPath(projectRoot) {
+    const jsConfigPath = path.join(projectRoot, "freestyle-sync.config.mjs");
+    const tsConfigPath = path.join(projectRoot, "freestyle-sync.config.ts");
+    if (await exists(jsConfigPath)) {
+        if (await migrateBundledDefaultConfig(jsConfigPath)) {
+            await ensureDefaultConfigDependencies(projectRoot);
+        }
+        else if (await isDefaultGeneratedConfig(jsConfigPath)) {
+            await ensureDefaultConfigDependencies(projectRoot);
+        }
+        return jsConfigPath;
+    }
+    if (await exists(tsConfigPath)) {
+        if (await migrateLegacyDefaultConfig(tsConfigPath, jsConfigPath)) {
+            await ensureDefaultConfigDependencies(projectRoot);
+            return jsConfigPath;
+        }
+        return tsConfigPath;
+    }
+    await writeFile(jsConfigPath, renderDefaultConfig(), "utf8");
+    console.log(`Created ${path.relative(process.cwd(), jsConfigPath) || path.basename(jsConfigPath)}`);
+    await ensureDefaultConfigDependencies(projectRoot);
+    return jsConfigPath;
+}
+async function isDefaultGeneratedConfig(configPath) {
+    const contents = await readFile(configPath, "utf8").catch(() => "");
+    return contents.trim() === renderDefaultConfig().trim();
+}
+async function migrateBundledDefaultConfig(configPath) {
+    const contents = await readFile(configPath, "utf8").catch(() => "");
+    if (contents.trim() !== renderBundledDefaultConfig().trim())
+        return false;
+    await writeFile(configPath, renderDefaultConfig(), "utf8");
+    console.log(`Updated ${path.relative(process.cwd(), configPath) || path.basename(configPath)} to install plugin packages`);
+    return true;
+}
+async function migrateLegacyDefaultConfig(tsConfigPath, jsConfigPath) {
+    const contents = await readFile(tsConfigPath, "utf8").catch(() => "");
+    if (contents.trim() !== renderLegacyDefaultConfig().trim())
+        return false;
+    await writeFile(jsConfigPath, renderDefaultConfig(), "utf8");
+    await rm(tsConfigPath);
+    console.log(`Updated ${path.relative(process.cwd(), jsConfigPath) || path.basename(jsConfigPath)} to install plugin packages`);
+    return true;
+}
+function renderLegacyDefaultConfig() {
+    return `import { claudeAgentPlugin } from "@freestyle-sync/agent-claude";
+import { codexAgentPlugin } from "@freestyle-sync/agent-codex";
+import { copilotAgentPlugin } from "@freestyle-sync/agent-copilot";
+import { awsAuthPlugin } from "@freestyle-sync/auth-aws";
+import { azureAuthPlugin } from "@freestyle-sync/auth-azure";
+import { dockerAuthPlugin } from "@freestyle-sync/auth-docker";
+import { envAuthPlugin } from "@freestyle-sync/auth-env";
+import { gcloudAuthPlugin } from "@freestyle-sync/auth-gcloud";
+import { gitAuthPlugin } from "@freestyle-sync/auth-git";
+import { githubCliAuthPlugin } from "@freestyle-sync/auth-github-cli";
+import { npmAuthPlugin } from "@freestyle-sync/auth-npm";
+import { sshAuthPlugin } from "@freestyle-sync/auth-ssh";
+import { yarnAuthPlugin } from "@freestyle-sync/auth-yarn";
+import { nodeNpmPlugin } from "@freestyle-sync/node-npm";
+import { shellHistoryPlugin } from "@freestyle-sync/shell-history";
+import { defineConfig } from "freestyle-sync";
 
+export default defineConfig({
+    plugins: [
+        envAuthPlugin(),
+        gitAuthPlugin(),
+        sshAuthPlugin(),
+        githubCliAuthPlugin(),
+        npmAuthPlugin(),
+        yarnAuthPlugin(),
+        dockerAuthPlugin(),
+        awsAuthPlugin(),
+        azureAuthPlugin(),
+        gcloudAuthPlugin(),
+        nodeNpmPlugin(),
+        claudeAgentPlugin(),
+        codexAgentPlugin(),
+        copilotAgentPlugin(),
+        shellHistoryPlugin(),
+    ],
+});
+`;
+}
 function renderDefaultConfig() {
     return `import { claudeAgentPlugin } from "@freestyle-sync/agent-claude";
 import { codexAgentPlugin } from "@freestyle-sync/agent-codex";
@@ -355,113 +425,183 @@ export default defineConfig({
 });
 `;
 }
-
-async function parseArgs(args: string[]): Promise<CliOptions> {
-    const options: CliOptions = {
-        projectRoot: process.cwd(),
-        cachePath: "",
-        remoteProjectDir: "",
-        name: "",
-        yes: false,
-        dryRun: false,
-        disablePlugins: [],
-        enablePlugins: [],
-        resetPluginPrefs: false,
-        listPlugins: false,
-        includeAuth: true,
-        includeAgentContext: true,
-        includeGitDir: true,
-        includeAllCopilotWorkspaces: false,
-        snapshot: true,
-        skipSync: false,
-        install: false,
-        autoSsh: true,
-        envKeys: [],
-    };
-
-    const positional: string[] = [];
+function renderBundledDefaultConfig() {
+    return `export default {
+    plugins: "default",
+};
+`;
+}
+async function ensureDefaultConfigDependencies(projectRoot) {
+    const missing = [];
+    for (const dependency of DEFAULT_CONFIG_DEPENDENCIES) {
+        if (!(await isDependencyInstalled(projectRoot, dependency.name))) {
+            missing.push(dependency.spec);
+        }
+    }
+    if (missing.length === 0)
+        return;
+    const { command, args } = await dependencyInstallCommand(projectRoot, missing);
+    console.log(`Installing freestyle-sync config dependencies with ${command}...`);
+    try {
+        await execFileAsync(command, args, { cwd: projectRoot });
+    }
+    catch (error) {
+        const details = error && typeof error === "object" && "stderr" in error ? String(error.stderr ?? "") : String(error);
+        throw new Error(`failed to install freestyle-sync config dependencies: ${details.trim() || String(error)}`);
+    }
+}
+async function isDependencyInstalled(projectRoot, name) {
+    return exists(path.join(projectRoot, "node_modules", ...name.split("/"), "package.json"));
+}
+async function dependencyInstallCommand(projectRoot, specs) {
+    if (await exists(path.join(projectRoot, "pnpm-lock.yaml")))
+        return { command: "pnpm", args: ["add", "-D", ...specs] };
+    if (await exists(path.join(projectRoot, "yarn.lock")))
+        return { command: "yarn", args: ["add", "-D", ...specs] };
+    return { command: "npm", args: ["install", "--save-dev", ...specs] };
+}
+async function parseArgs(args) {
+    const options = defaultCliOptions();
+    const positional = [];
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--help" || arg === "-h") {
             printHelp();
             process.exit(0);
-        } else if (arg === "--yes" || arg === "-y") {
+        }
+        else if (arg === "--yes" || arg === "-y") {
             options.yes = true;
-        } else if (arg === "--dry-run") {
+        }
+        else if (arg === "--dry-run") {
             options.dryRun = true;
-        } else if (arg === "--disable-plugin") {
+        }
+        else if (arg === "--disable-plugin") {
             options.disablePlugins.push(readOptionValue(args, ++index, arg));
-        } else if (arg === "--enable-plugin") {
+        }
+        else if (arg === "--enable-plugin") {
             options.enablePlugins.push(readOptionValue(args, ++index, arg));
-        } else if (arg === "--reset-plugin-prefs" || arg === "--reset-context-prefs") {
+        }
+        else if (arg === "--reset-plugin-prefs" || arg === "--reset-context-prefs") {
             options.resetPluginPrefs = true;
-        } else if (arg === "--list-plugins") {
+        }
+        else if (arg === "--list-plugins") {
             options.listPlugins = true;
-        } else if (arg === "--no-auth") {
+        }
+        else if (arg === "--no-auth") {
             options.includeAuth = false;
-        } else if (arg === "--no-agent-context") {
+        }
+        else if (arg === "--no-agent-context") {
             options.includeAgentContext = false;
-        } else if (arg === "--no-git-dir") {
+        }
+        else if (arg === "--no-git-dir") {
             options.includeGitDir = false;
-        } else if (arg === "--all-copilot-workspaces") {
+        }
+        else if (arg === "--all-copilot-workspaces") {
             options.includeAllCopilotWorkspaces = true;
-        } else if (arg === "--no-snapshot" || arg === "--skip-snapshot") {
+        }
+        else if (arg === "--no-snapshot" || arg === "--skip-snapshot") {
             options.snapshot = false;
-        } else if (arg === "--skip-sync") {
+        }
+        else if (arg === "--skip-sync") {
             options.skipSync = true;
-        } else if (arg === "--install") {
+        }
+        else if (arg === "--install") {
             options.install = true;
-        } else if (arg === "--no-ssh") {
+        }
+        else if (arg === "--no-ssh") {
             options.autoSsh = false;
-        } else if (arg === "--vm-id") {
+        }
+        else if (arg === "--vm-id") {
             options.vmId = readOptionValue(args, ++index, arg);
-        } else if (arg === "--name") {
+        }
+        else if (arg === "--name") {
             options.name = readOptionValue(args, ++index, arg);
-        } else if (arg === "--remote-dir") {
+        }
+        else if (arg === "--remote-dir") {
             options.remoteProjectDir = normalizeRemotePath(readOptionValue(args, ++index, arg));
-        } else if (arg === "--cache") {
+        }
+        else if (arg === "--cache") {
             options.cachePath = path.resolve(readOptionValue(args, ++index, arg));
-        } else if (arg === "--idle-timeout") {
+        }
+        else if (arg === "--idle-timeout") {
             options.idleTimeoutSeconds = Number(readOptionValue(args, ++index, arg));
             if (!Number.isInteger(options.idleTimeoutSeconds) || options.idleTimeoutSeconds < 1) {
                 throw new Error("--idle-timeout must be a positive integer");
             }
-        } else if (arg === "--include-env") {
+        }
+        else if (arg === "--include-env") {
             options.envKeys.push(readOptionValue(args, ++index, arg));
-        } else if (arg.startsWith("--")) {
+        }
+        else if (arg.startsWith("--")) {
             throw new Error(`unknown option: ${arg}`);
-        } else {
+        }
+        else {
             positional.push(arg);
         }
     }
-
     if (positional.length > 1) {
         throw new Error("expected at most one project path");
     }
-
     options.projectRoot = path.resolve(positional[0] ?? options.projectRoot);
+    return finalizeCliOptions(options);
+}
+async function resolveCliOptions(overrides) {
+    return finalizeCliOptions({
+        ...defaultCliOptions(),
+        ...overrides,
+        projectRoot: path.resolve(overrides?.projectRoot ?? process.cwd()),
+        disablePlugins: overrides?.disablePlugins ? [...overrides.disablePlugins] : [],
+        enablePlugins: overrides?.enablePlugins ? [...overrides.enablePlugins] : [],
+        envKeys: overrides?.envKeys ? [...overrides.envKeys] : [],
+    });
+}
+function defaultCliOptions() {
+    return {
+        projectRoot: process.cwd(),
+        cachePath: "",
+        remoteProjectDir: "",
+        name: "",
+        yes: false,
+        dryRun: false,
+        disablePlugins: [],
+        enablePlugins: [],
+        resetPluginPrefs: false,
+        listPlugins: false,
+        includeAuth: true,
+        includeAgentContext: true,
+        includeGitDir: true,
+        includeAllCopilotWorkspaces: false,
+        snapshot: true,
+        skipSync: false,
+        install: false,
+        autoSsh: true,
+        envKeys: [],
+    };
+}
+async function finalizeCliOptions(options) {
     const projectStats = await stat(options.projectRoot).catch(() => null);
     if (!projectStats?.isDirectory()) {
         throw new Error(`project path is not a directory: ${options.projectRoot}`);
     }
-
     const projectName = sanitizeName(path.basename(options.projectRoot));
-    options.name ||= `vmpush-${projectName}`;
-    options.remoteProjectDir ||= defaultRemoteProjectDir(options.projectRoot);
-    options.cachePath ||= path.join(options.projectRoot, ".freestyle-sync", "cache.json");
-
-    return options;
+    const remoteProjectDir = options.remoteProjectDir ? normalizeRemotePath(options.remoteProjectDir) : defaultRemoteProjectDir(options.projectRoot);
+    const cachePath = options.cachePath ? path.resolve(options.cachePath) : path.join(options.projectRoot, ".freestyle-sync", "cache.json");
+    return {
+        ...options,
+        name: options.name || `${CLI_NAME}-${projectName}`,
+        remoteProjectDir,
+        cachePath,
+    };
 }
-
 function printHelp() {
-    console.log(`vmpush uploads the current project into a Freestyle VM.
+    console.log(`${CLI_NAME} uploads the current project into a Freestyle VM.
 
 Usage:
-	vmpush [project-dir] [options]
+    ${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 vmpush-<project>.
+    --name <name>            Name for a newly created VM. 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.
@@ -485,18 +625,16 @@ Options:
 	-h, --help               Show this help.
 `);
 }
-
-function readOptionValue(args: string[], index: number, option: string) {
+function readOptionValue(args, index, option) {
     const value = args[index];
     if (!value || value.startsWith("--")) {
         throw new Error(`${option} requires a value`);
     }
     return value;
 }
-
-async function readCache(cachePath: string, options: CliOptions): Promise<CacheFile> {
+async function readCache(cachePath, options) {
     try {
-        const parsed = JSON.parse(await readFile(cachePath, "utf8")) as CacheFile;
+        const parsed = JSON.parse(await readFile(cachePath, "utf8"));
         if (parsed.version === CACHE_VERSION && parsed.projectRoot === options.projectRoot && parsed.remoteProjectDir === options.remoteProjectDir) {
             return {
                 ...parsed,
@@ -506,12 +644,12 @@ async function readCache(cachePath: string, options: CliOptions): Promise<CacheF
                 snapshotContextFiles: parsed.snapshotContextFiles,
             };
         }
-    } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
             console.warn(`Ignoring unreadable cache ${cachePath}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-
     return {
         version: CACHE_VERSION,
         projectRoot: options.projectRoot,
@@ -520,8 +658,19 @@ async function readCache(cachePath: string, options: CliOptions): Promise<CacheF
         contextFiles: {},
     };
 }
-
-function cacheBaseForSync(options: CliOptions, cache: CacheFile): { projectFiles: Record<string, FileDigest>; contextFiles: Record<string, FileDigest>; envHash?: string } {
+function normalizeCache(cache, options) {
+    return {
+        ...cache,
+        version: CACHE_VERSION,
+        projectRoot: options.projectRoot,
+        remoteProjectDir: options.remoteProjectDir,
+        projectFiles: cache.projectFiles ?? {},
+        contextFiles: cache.contextFiles ?? {},
+        snapshotProjectFiles: cache.snapshotProjectFiles ?? {},
+        snapshotContextFiles: cache.snapshotContextFiles ?? {},
+    };
+}
+function cacheBaseForSync(options, cache) {
     if (options.vmId && options.vmId === cache.vmId) {
         return {
             projectFiles: cache.projectFiles,
@@ -529,7 +678,6 @@ function cacheBaseForSync(options: CliOptions, cache: CacheFile): { projectFiles
             envHash: cache.envHash,
         };
     }
-
     if (!options.vmId && cache.snapshotId) {
         return {
             projectFiles: cache.snapshotProjectFiles ?? {},
@@ -537,40 +685,30 @@ function cacheBaseForSync(options: CliOptions, cache: CacheFile): { projectFiles
             envHash: cache.snapshotEnvHash,
         };
     }
-
     return { projectFiles: {}, contextFiles: {} };
 }
-
-async function writeCache(cachePath: string, cache: CacheFile) {
+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: string, includeGitDir: boolean): Promise<LocalEntry[]> {
-    const entries: LocalEntry[] = [];
+async function scanProject(projectRoot, includeGitDir) {
+    const entries = [];
     await walk(projectRoot, "", entries, {
         skipDirectory(relativePath, name) {
-            if (!includeGitDir && relativePath === ".git") return true;
+            if (!includeGitDir && relativePath === ".git")
+                return true;
             return false;
         },
     });
     return entries.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
-
-async function walk(
-    root: string,
-    relativePath: string,
-    entries: LocalEntry[],
-    options: { skipDirectory(relativePath: string, name: string): boolean },
-) {
+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 childAbsolutePath = path.join(root, childRelativePath);
-
         if (dirent.isDirectory()) {
             if (options.skipDirectory(normalizedRelativePath, dirent.name)) {
                 continue;
@@ -578,14 +716,12 @@ async function walk(
             await walk(root, childRelativePath, entries, options);
             continue;
         }
-
         if (dirent.isFile() || dirent.isSymbolicLink()) {
             entries.push(await digestEntry(childAbsolutePath, normalizedRelativePath));
         }
     }
 }
-
-async function digestEntry(absolutePath: string, relativePath: string): Promise<LocalEntry> {
+async function digestEntry(absolutePath, relativePath) {
     const stats = await import("node:fs/promises").then((fs) => fs.lstat(absolutePath));
     if (stats.isSymbolicLink()) {
         const target = await import("node:fs/promises").then((fs) => fs.readlink(absolutePath));
@@ -598,7 +734,6 @@ async function digestEntry(absolutePath: string, relativePath: string): Promise<
             hash: hashString(`symlink:${target}`),
         };
     }
-
     return {
         absolutePath,
         relativePath,
@@ -608,16 +743,13 @@ async function digestEntry(absolutePath: string, relativePath: string): Promise<
         hash: await hashFile(absolutePath),
     };
 }
-
-function digestMap(entries: LocalEntry[]): Record<string, FileDigest> {
+function digestMap(entries) {
     return Object.fromEntries(entries.map((entry) => [entry.relativePath, stripLocal(entry)]));
 }
-
-function digestMapByRemotePath(entries: ContextEntry[]): Record<string, FileDigest> {
+function digestMapByRemotePath(entries) {
     return Object.fromEntries(entries.map((entry) => [entry.remotePath, stripLocal(entry)]));
 }
-
-function stripLocal(entry: LocalEntry): FileDigest {
+function stripLocal(entry) {
     return {
         hash: entry.hash,
         kind: entry.kind,
@@ -625,58 +757,52 @@ function stripLocal(entry: LocalEntry): FileDigest {
         size: entry.size,
     };
 }
-
-function diffEntries(entries: LocalEntry[], previous: Record<string, FileDigest>) {
+function diffEntries(entries, previous) {
     const changed = entries.filter((entry) => previous[entry.relativePath]?.hash !== entry.hash);
     const currentKeys = new Set(entries.map((entry) => entry.relativePath));
     const removed = Object.keys(previous).filter((relativePath) => !currentKeys.has(relativePath));
     return { changed, removed, unchanged: entries.length - changed.length };
 }
-
-function diffContextEntries(entries: ContextEntry[], previous: Record<string, FileDigest>) {
+function diffContextEntries(entries, previous) {
     const changed = entries.filter((entry) => previous[entry.remotePath]?.hash !== entry.hash);
     const currentKeys = new Set(entries.map((entry) => entry.remotePath));
     const removed = Object.keys(previous).filter((remotePath) => !currentKeys.has(remotePath) && !isProtectedRemotePath(remotePath));
     return { changed, removed, unchanged: entries.length - changed.length };
 }
-
-function collectPluginEnvironment(options: CliOptions) {
-    const env: Record<string, string> = {};
+function collectPluginEnvironment(options) {
+    const env = {};
     for (const plugin of plugins) {
         Object.assign(env, plugin.collectEnvironment?.({ options, utils: pluginUtils }) ?? {});
     }
     return env;
 }
-
-async function discoverPluginContextCandidates(options: CliOptions) {
-    const candidates: ContextCandidate[] = [];
+async function discoverPluginContextCandidates(options) {
+    const candidates = [];
     for (const plugin of plugins) {
         const discovered = await plugin.discoverContextCandidates?.({ options, utils: pluginUtils });
-        if (discovered) candidates.push(...discovered);
+        if (discovered)
+            candidates.push(...discovered);
     }
     return dedupeContextCandidates(candidates);
 }
-
-function shouldSkipContextDirectory(relativePath: string, name: string) {
+function shouldSkipContextDirectory(relativePath, name) {
     return plugins.some((plugin) => plugin.shouldSkipContextDirectory?.(relativePath, name));
 }
-
-function isProtectedRemotePath(remotePath: string) {
+function isProtectedRemotePath(remotePath) {
     return plugins.some((plugin) => plugin.isProtectedRemotePath?.(remotePath));
 }
-
-function dedupeContextCandidates(candidates: ContextCandidate[]) {
-    const seen = new Set<string>();
+function dedupeContextCandidates(candidates) {
+    const seen = new Set();
     return candidates.filter((candidate) => {
         const key = `${candidate.source}\0${candidate.remoteRoot}`;
-        if (seen.has(key)) return false;
+        if (seen.has(key))
+            return false;
         seen.add(key);
         return true;
     });
 }
-
-async function scanContextCandidates(candidates: ContextCandidate[]): Promise<ContextEntry[]> {
-    const entries: ContextEntry[] = [];
+async function scanContextCandidates(candidates) {
+    const entries = [];
     for (const candidate of candidates) {
         const stats = await import("node:fs/promises").then((fs) => fs.lstat(candidate.source));
         if (stats.isFile()) {
@@ -687,17 +813,20 @@ async function scanContextCandidates(candidates: ContextCandidate[]): Promise<Co
                 label: candidate.label,
                 sensitive: candidate.sensitive,
             });
-        } else if (stats.isDirectory()) {
-            const candidateEntries: LocalEntry[] = [];
+        }
+        else if (stats.isDirectory()) {
+            const candidateEntries = [];
             await walk(candidate.source, "", candidateEntries, {
                 skipDirectory(relativePath, name) {
                     return shouldSkipContextDirectory(relativePath, name);
                 },
             });
             for (const local of candidateEntries) {
-                if (local.kind === "symlink") continue;
+                if (local.kind === "symlink")
+                    continue;
                 const remotePath = `${candidate.remoteRoot}/${local.relativePath}`;
-                if (isProtectedRemotePath(remotePath)) continue;
+                if (isProtectedRemotePath(remotePath))
+                    continue;
                 entries.push({
                     ...local,
                     remotePath,
@@ -709,24 +838,25 @@ async function scanContextCandidates(candidates: ContextCandidate[]): Promise<Co
     }
     return entries.sort((left, right) => left.remotePath.localeCompare(right.remotePath));
 }
-
-async function updatePluginPreferences(options: CliOptions): Promise<PluginPreferences> {
+async function updatePluginPreferences(options, providedPreferences) {
     const preferencesPath = getPluginPreferencesPath(options);
-    const preferences = options.resetPluginPrefs ? emptyPluginPreferences() : await readPluginPreferences(preferencesPath);
-    let changed = options.resetPluginPrefs;
-    const disabledPlugins = new Set<string>();
-
+    const usingProvidedPreferences = Boolean(providedPreferences);
+    const preferences = options.resetPluginPrefs
+        ? emptyPluginPreferences()
+        : normalizePluginPreferences(providedPreferences ?? await readPluginPreferences(preferencesPath));
+    let changed = options.resetPluginPrefs && !usingProvidedPreferences;
+    const disabledPlugins = new Set();
     for (const savedName of preferences.disabledPlugins) {
         const canonicalName = maybeResolvePluginSelector(savedName);
         disabledPlugins.add(canonicalName ?? savedName);
-        if (canonicalName && canonicalName !== savedName) changed = true;
+        if (canonicalName && canonicalName !== savedName)
+            changed = true;
     }
-
     for (const selector of options.enablePlugins) {
         const name = resolvePluginSelector(selector);
-        if (disabledPlugins.delete(name)) changed = true;
+        if (disabledPlugins.delete(name))
+            changed = true;
     }
-
     for (const selector of options.disablePlugins) {
         const name = resolvePluginSelector(selector);
         if (!disabledPlugins.has(name)) {
@@ -734,23 +864,24 @@ async function updatePluginPreferences(options: CliOptions): Promise<PluginPrefe
             changed = true;
         }
     }
-
     const next = { version: PLUGIN_PREFERENCES_VERSION, disabledPlugins: [...disabledPlugins].sort(), updatedAt: preferences.updatedAt };
-    if (changed) await writePluginPreferences(preferencesPath, next);
+    if (changed && !usingProvidedPreferences)
+        await writePluginPreferences(preferencesPath, next);
     return next;
 }
-
-function activePlugins(preferences: PluginPreferences, options: CliOptions) {
+function activePlugins(preferences, options) {
     const disabled = new Set(preferences.disabledPlugins);
     return config.plugins.filter((plugin) => {
-        if (disabled.has(plugin.name)) return false;
-        if (!options.includeAuth && plugin.name.startsWith("@freestyle-sync/auth-")) return false;
-        if (!options.includeAgentContext && plugin.name.startsWith("@freestyle-sync/agent-")) return false;
+        if (disabled.has(plugin.name))
+            return false;
+        if (!options.includeAuth && plugin.name.startsWith("@freestyle-sync/auth-"))
+            return false;
+        if (!options.includeAgentContext && plugin.name.startsWith("@freestyle-sync/agent-"))
+            return false;
         return true;
     });
 }
-
-function printPlugins(preferences: PluginPreferences, options: CliOptions) {
+function printPlugins(preferences, options) {
     const enabled = new Set(activePlugins(preferences, options).map((plugin) => plugin.name));
     console.log(`Plugin preferences: ${getPluginPreferencesPath(options)}`);
     for (const plugin of config.plugins) {
@@ -760,75 +891,72 @@ function printPlugins(preferences: PluginPreferences, options: CliOptions) {
         console.log(`${status.padEnd(19)} ${plugin.name}`);
     }
 }
-
-function resolvePluginSelector(selector: string) {
+function resolvePluginSelector(selector) {
     const match = maybeResolvePluginSelector(selector);
-    if (match) return match;
+    if (match)
+        return match;
     const matches = config.plugins.filter((plugin) => pluginSelectorAliases(plugin.name).includes(selector));
-    if (matches.length > 1) throw new Error(`ambiguous plugin selector ${selector}: ${matches.map((plugin) => plugin.name).join(", ")}`);
+    if (matches.length > 1)
+        throw new Error(`ambiguous plugin selector ${selector}: ${matches.map((plugin) => plugin.name).join(", ")}`);
     throw new Error(`unknown plugin ${selector}. Run --list-plugins to see configured plugins.`);
 }
-
-function maybeResolvePluginSelector(selector: string) {
+function maybeResolvePluginSelector(selector) {
     const matches = config.plugins.filter((plugin) => pluginSelectorAliases(plugin.name).includes(selector));
-    if (matches.length === 1) return matches[0].name;
-    if (matches.length > 1) throw new Error(`ambiguous plugin selector ${selector}: ${matches.map((plugin) => plugin.name).join(", ")}`);
+    if (matches.length === 1)
+        return matches[0].name;
+    if (matches.length > 1)
+        throw new Error(`ambiguous plugin selector ${selector}: ${matches.map((plugin) => plugin.name).join(", ")}`);
     return undefined;
 }
-
-function pluginSelectorAliases(name: string) {
+function pluginSelectorAliases(name) {
     const aliases = new Set([name]);
     const withoutScope = name.split("/").pop();
-    if (withoutScope) aliases.add(withoutScope);
+    if (withoutScope)
+        aliases.add(withoutScope);
     if (name.startsWith("@freestyle-sync/") && withoutScope) {
         aliases.add(`@freestyle/sync-plugin-${withoutScope}`);
         aliases.add(`@pushvm/plugin-${withoutScope}`);
         aliases.add(`sync-plugin-${withoutScope}`);
         aliases.add(`plugin-${withoutScope}`);
     }
-    if (withoutScope?.startsWith("sync-plugin-")) aliases.add(withoutScope.slice("sync-plugin-".length));
-    if (withoutScope?.startsWith("plugin-")) aliases.add(withoutScope.slice("plugin-".length));
+    if (withoutScope?.startsWith("sync-plugin-"))
+        aliases.add(withoutScope.slice("sync-plugin-".length));
+    if (withoutScope?.startsWith("plugin-"))
+        aliases.add(withoutScope.slice("plugin-".length));
     return [...aliases];
 }
-
-function emptyPluginPreferences(): PluginPreferences {
+function emptyPluginPreferences() {
     return { version: PLUGIN_PREFERENCES_VERSION, disabledPlugins: [] };
 }
-
-function getPluginPreferencesPath(options: CliOptions) {
+function normalizePluginPreferences(preferences) {
+    return {
+        version: PLUGIN_PREFERENCES_VERSION,
+        disabledPlugins: Array.isArray(preferences.disabledPlugins) ? preferences.disabledPlugins.filter((name) => typeof name === "string") : [],
+        updatedAt: preferences.updatedAt,
+    };
+}
+function getPluginPreferencesPath(options) {
     return path.join(path.dirname(options.cachePath), "plugin-preferences.json");
 }
-
-async function readPluginPreferences(preferencesPath: string): Promise<PluginPreferences> {
+async function readPluginPreferences(preferencesPath) {
     try {
-        const parsed = JSON.parse(await readFile(preferencesPath, "utf8")) as PluginPreferences;
+        const parsed = JSON.parse(await readFile(preferencesPath, "utf8"));
         if (parsed.version === PLUGIN_PREFERENCES_VERSION) {
-            return {
-                version: PLUGIN_PREFERENCES_VERSION,
-                disabledPlugins: Array.isArray(parsed.disabledPlugins) ? parsed.disabledPlugins.filter((name) => typeof name === "string") : [],
-                updatedAt: parsed.updatedAt,
-            };
+            return normalizePluginPreferences(parsed);
         }
-    } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
             console.warn(`Ignoring unreadable plugin preferences ${preferencesPath}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     return emptyPluginPreferences();
 }
-
-async function writePluginPreferences(preferencesPath: string, preferences: PluginPreferences) {
+async function writePluginPreferences(preferencesPath, preferences) {
     await mkdir(path.dirname(preferencesPath), { recursive: true });
     await writeFile(preferencesPath, `${JSON.stringify({ ...preferences, updatedAt: new Date().toISOString() }, null, 2)}\n`, "utf8");
 }
-
-function printPlan(
-    options: CliOptions,
-    projectChanges: ReturnType<typeof diffEntries>,
-    contextChanges: ReturnType<typeof diffContextEntries>,
-    envExports: Record<string, string>,
-    cache: CacheFile,
-) {
+function printPlan(options, projectChanges, contextChanges, envExports, cache) {
     const source = options.vmId ? `existing VM ${options.vmId}` : cache.snapshotId ? `snapshot ${cache.snapshotId}` : "a new VM";
     console.log("");
     console.log(`${bold("Sync plan")}`);
@@ -843,56 +971,46 @@ function printPlan(
     }
     console.log("");
 }
-
-function totalEntrySize(entries: LocalEntry[]) {
+function totalEntrySize(entries) {
     return entries.reduce((total, entry) => total + entry.size, 0);
 }
-
-function printHeading(name: string) {
+function printHeading(name) {
     console.log(`${bold(name)} ${dim(`${symbol("→", "-")} Freestyle sync`)}`);
     console.log("");
 }
-
-function formatDuration(milliseconds: number) {
+function formatDuration(milliseconds) {
     if (milliseconds < MS_PER_SECOND) {
         const rounded = Math.round(milliseconds);
         return `${rounded === 0 && milliseconds > 0 ? 1 : rounded}ms`;
     }
     return `${(milliseconds / MS_PER_SECOND).toFixed(1)}s`;
 }
-
-function symbol(unicode: string, ascii: string) {
+function symbol(unicode, ascii) {
     return USE_UNICODE_OUTPUT ? unicode : ascii;
 }
-
-function accent(text: string) {
+function accent(text) {
     return color(36, text);
 }
-
-function success(text: string) {
+function success(text) {
     return color(32, text);
 }
-
-function dim(text: string) {
+function dim(text) {
     return color(2, text);
 }
-
-function bold(text: string) {
+function bold(text) {
     return color(1, text);
 }
-
-function color(code: number, text: string) {
-    if (!USE_STYLED_OUTPUT) return text;
+function color(code, text) {
+    if (!USE_STYLED_OUTPUT)
+        return text;
     return `\u001b[${code}m${text}\u001b[0m`;
 }
-
-async function getOrCreateVm(options: CliOptions, snapshotId?: string) {
+async function getOrCreateVm(options, snapshotId) {
     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,
@@ -901,132 +1019,100 @@ async function getOrCreateVm(options: CliOptions, snapshotId?: string) {
     });
     return { vm: result.vm, vmId: result.vmId };
 }
-
-async function ensureRemoteBase(vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"], remoteProjectDir: string) {
+async function ensureRemoteBase(vm, remoteProjectDir) {
     await checkedExec(vm, `mkdir -p ${shellQuote(remoteProjectDir)} /root/.freestyle-sync`);
 }
-
-async function syncProject(
-    vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
-    vmId: string,
-    options: CliOptions,
-    changes: ReturnType<typeof diffEntries>,
-): Promise<SyncResult> {
+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);
         try {
-            await uploadArchiveInChunks(vm, vmId, archive, "/tmp/vmpush-project.tgz", "project");
-            await checkedExec(vm, `mkdir -p ${shellQuote(options.remoteProjectDir)} && tar --no-same-owner --no-same-permissions -xzf /tmp/vmpush-project.tgz -C ${shellQuote(options.remoteProjectDir)} && rm -f /tmp/vmpush-project.tgz`);
-        } finally {
+            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`);
+        }
+        finally {
             await rm(path.dirname(archive), { recursive: true, force: true });
         }
     }
-
     if (changes.removed.length > 0) {
         console.log(`VM ${vmId}: removing ${changes.removed.length} deleted project files...`);
         const removeList = Buffer.from(changes.removed.join("\0") + "\0");
-        await vm.fs.writeFile("/tmp/vmpush-remove-list", removeList);
-        await checkedExec(vm, `cd ${shellQuote(options.remoteProjectDir)} && xargs -0 rm -f -- < /tmp/vmpush-remove-list && rm -f /tmp/vmpush-remove-list`);
+        await vm.fs.writeFile("/tmp/freestyle-sync-remove-list", removeList);
+        await checkedExec(vm, `cd ${shellQuote(options.remoteProjectDir)} && xargs -0 rm -f -- < /tmp/freestyle-sync-remove-list && rm -f /tmp/freestyle-sync-remove-list`);
     }
-
     return {
         uploaded: changes.changed.length,
         removed: changes.removed.length,
         unchanged: changes.unchanged,
     };
 }
-
-async function runRemoteFixups(vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"], vmId: string, options: CliOptions) {
+async function runRemoteFixups(vm, vmId, options) {
     for (const plugin of plugins) {
-        if (!plugin.afterProjectSync) continue;
+        if (!plugin.afterProjectSync)
+            continue;
         try {
-            await plugin.afterProjectSync({ vm: vm as RemoteVm, vmId, options, utils: pluginUtils });
-        } catch (error) {
+            await plugin.afterProjectSync({ vm: vm, vmId, options, utils: pluginUtils });
+        }
+        catch (error) {
             console.warn(`Remote fixup ${plugin.name} skipped: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
 }
-
-async function runAfterContextSyncPlugins(
-    vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
-    vmId: string,
-    options: CliOptions,
-    changedRemotePaths: string[],
-) {
+async function runAfterContextSyncPlugins(vm, vmId, options, changedRemotePaths) {
     for (const plugin of plugins) {
-        if (!plugin.afterContextSync) continue;
-        await plugin.afterContextSync({ vm: vm as RemoteVm, vmId, options, utils: pluginUtils, changedRemotePaths });
+        if (!plugin.afterContextSync)
+            continue;
+        await plugin.afterContextSync({ vm: vm, vmId, options, utils: pluginUtils, changedRemotePaths });
     }
 }
-
-async function runAfterSyncPlugins(
-    vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
-    vmId: string,
-    options: CliOptions,
-    contextCandidates: ContextCandidate[],
-) {
-    const messages: string[] = [];
+async function runAfterSyncPlugins(vm, vmId, options, contextCandidates) {
+    const messages = [];
     for (const plugin of plugins) {
-        const result = await plugin.afterSync?.({ vm: vm as RemoteVm, vmId, options, utils: pluginUtils, contextCandidates });
-        if (result) messages.push(...result);
+        const result = await plugin.afterSync?.({ vm: vm, vmId, options, utils: pluginUtils, contextCandidates });
+        if (result)
+            messages.push(...result);
     }
     return messages;
 }
-
-async function runBeforeSnapshotPlugins(vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"], vmId: string, options: CliOptions) {
+async function runBeforeSnapshotPlugins(vm, vmId, options) {
     for (const plugin of plugins) {
-        if (!plugin.beforeSnapshot) continue;
+        if (!plugin.beforeSnapshot)
+            continue;
         try {
-            await plugin.beforeSnapshot({ vm: vm as RemoteVm, vmId, options, utils: pluginUtils });
-        } catch (error) {
+            await plugin.beforeSnapshot({ vm: vm, vmId, options, utils: pluginUtils });
+        }
+        catch (error) {
             console.warn(`Snapshot preparation ${plugin.name} skipped: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
 }
-
-async function syncContext(vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"], vmId: string, changes: ReturnType<typeof diffContextEntries>): Promise<SyncResult> {
+async function syncContext(vm, vmId, changes) {
     if (changes.removed.length > 0) {
         console.log(`VM ${vmId}: removing ${changes.removed.length} deleted auth/context files...`);
         await checkedExec(vm, changes.removed.map((remotePath) => `rm -f -- ${shellQuote(remotePath)}`).join("\n"));
     }
-
     if (changes.changed.length === 0) {
         return { uploaded: 0, removed: changes.removed.length, unchanged: changes.unchanged };
     }
-
     console.log(`VM ${vmId}: uploading ${changes.changed.length} changed auth/context files...`);
     const archive = await createContextArchive(changes.changed);
     try {
-        await uploadArchiveInChunks(vm, vmId, archive, "/tmp/vmpush-context.tgz", "context");
-        await checkedExec(vm, "tar --no-same-owner --no-same-permissions -xzf /tmp/vmpush-context.tgz -C / && rm -f /tmp/vmpush-context.tgz");
-    } finally {
+        await uploadArchiveInChunks(vm, vmId, archive, "/tmp/freestyle-sync-context.tgz", "context");
+        await checkedExec(vm, "tar --no-same-owner --no-same-permissions -xzf /tmp/freestyle-sync-context.tgz -C / && rm -f /tmp/freestyle-sync-context.tgz");
+    }
+    finally {
         await rm(path.dirname(archive), { recursive: true, force: true });
     }
     return { uploaded: changes.changed.length, removed: changes.removed.length, unchanged: changes.unchanged };
 }
-
-async function installEnvironment(
-    vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
-    envExports: Record<string, string>,
-    envHash: string,
-    previousHash?: string,
-) {
-    if (Object.keys(envExports).length === 0 || envHash === previousHash) return;
+async function installEnvironment(vm, envExports, envHash, previousHash) {
+    if (Object.keys(envExports).length === 0 || envHash === previousHash)
+        return;
     await checkedExec(vm, "mkdir -p /root/.freestyle-sync");
     await vm.fs.writeTextFile("/root/.freestyle-sync/env.sh", renderEnvFile(envExports));
-    await checkedExec(
-        vm,
-        "chmod 700 /root/.freestyle-sync && chmod 600 /root/.freestyle-sync/env.sh && grep -qxF 'test -f /root/.freestyle-sync/env.sh && . /root/.freestyle-sync/env.sh' /root/.profile || printf '\n%s\n' 'test -f /root/.freestyle-sync/env.sh && . /root/.freestyle-sync/env.sh' >> /root/.profile",
-    );
+    await checkedExec(vm, "chmod 700 /root/.freestyle-sync && chmod 600 /root/.freestyle-sync/env.sh && grep -qxF 'test -f /root/.freestyle-sync/env.sh && . /root/.freestyle-sync/env.sh' /root/.profile || printf '\n%s\n' 'test -f /root/.freestyle-sync/env.sh && . /root/.freestyle-sync/env.sh' >> /root/.profile");
 }
-
-async function writeRemoteResumeFiles(
-    vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
-    options: CliOptions,
-    vmId: string,
-    envExports: Record<string, string>,
-) {
+async function writeRemoteResumeFiles(vm, options, vmId, envExports) {
     const manifest = {
         vmId,
         project: options.remoteProjectDir,
@@ -1036,23 +1122,16 @@ async function writeRemoteResumeFiles(
     };
     await checkedExec(vm, `mkdir -p ${shellQuote(`${options.remoteProjectDir}/.freestyle-sync`)} /root/.freestyle-sync`);
     await vm.fs.writeTextFile(`${options.remoteProjectDir}/.freestyle-sync/remote.json`, `${JSON.stringify(manifest, null, 2)}\n`);
-    await vm.fs.writeTextFile(
-        "/root/.freestyle-sync/resume.sh",
-        `#!/usr/bin/env bash
+    await vm.fs.writeTextFile("/root/.freestyle-sync/resume.sh", `#!/usr/bin/env bash
 set -euo pipefail
 test -f /root/.freestyle-sync/env.sh && . /root/.freestyle-sync/env.sh
 cd ${shellQuote(options.remoteProjectDir)}
 exec "$SHELL" -l
-`,
-    );
+`);
     await vm.fs.writeTextFile("/root/.freestyle-sync/profile.sh", renderRemoteProfile(options.remoteProjectDir));
-    await checkedExec(
-        vm,
-        "chmod 700 /root/.freestyle-sync && chmod +x /root/.freestyle-sync/resume.sh && chmod 600 /root/.freestyle-sync/profile.sh && grep -qxF 'test -f /root/.freestyle-sync/profile.sh && . /root/.freestyle-sync/profile.sh' /root/.profile || printf '\n%s\n' 'test -f /root/.freestyle-sync/profile.sh && . /root/.freestyle-sync/profile.sh' >> /root/.profile",
-    );
+    await checkedExec(vm, "chmod 700 /root/.freestyle-sync && chmod +x /root/.freestyle-sync/resume.sh && chmod 600 /root/.freestyle-sync/profile.sh && grep -qxF 'test -f /root/.freestyle-sync/profile.sh && . /root/.freestyle-sync/profile.sh' /root/.profile || printf '\n%s\n' 'test -f /root/.freestyle-sync/profile.sh && . /root/.freestyle-sync/profile.sh' >> /root/.profile");
 }
-
-function renderRemoteProfile(remoteProjectDir: string) {
+function renderRemoteProfile(remoteProjectDir) {
     return `# Generated by freestyle-sync. Loaded by /root/.profile.
 test -f /root/.freestyle-sync/env.sh && . /root/.freestyle-sync/env.sh
 if [ -d ${shellQuote(remoteProjectDir)} ]; then
@@ -1060,8 +1139,7 @@ if [ -d ${shellQuote(remoteProjectDir)} ]; then
 fi
 `;
 }
-
-async function runInstall(vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"], projectRoot: string, remoteProjectDir: string) {
+async function runInstall(vm, projectRoot, remoteProjectDir) {
     const installCommand = await detectInstallCommand(projectRoot);
     if (!installCommand) {
         console.log("No dependency install command detected.");
@@ -1070,45 +1148,46 @@ async function runInstall(vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"], p
     console.log(`Running install: ${installCommand}`);
     await checkedExec(vm, `cd ${shellQuote(remoteProjectDir)} && ${installCommand}`, 20 * 60 * 1000);
 }
-
-async function detectInstallCommand(projectRoot: string) {
-    if (await exists(path.join(projectRoot, "pnpm-lock.yaml"))) return "corepack enable && pnpm install";
-    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";
-    if (await exists(path.join(projectRoot, "requirements.txt"))) return "python3 -m pip install -r requirements.txt";
-    if (await exists(path.join(projectRoot, "pyproject.toml"))) return "python3 -m pip install -e .";
-    if (await exists(path.join(projectRoot, "Cargo.toml"))) return "cargo fetch";
-    if (await exists(path.join(projectRoot, "go.mod"))) return "go mod download";
+async function detectInstallCommand(projectRoot) {
+    if (await exists(path.join(projectRoot, "pnpm-lock.yaml")))
+        return "corepack enable && pnpm install";
+    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";
+    if (await exists(path.join(projectRoot, "requirements.txt")))
+        return "python3 -m pip install -r requirements.txt";
+    if (await exists(path.join(projectRoot, "pyproject.toml")))
+        return "python3 -m pip install -e .";
+    if (await exists(path.join(projectRoot, "Cargo.toml")))
+        return "cargo fetch";
+    if (await exists(path.join(projectRoot, "go.mod")))
+        return "go mod download";
     return undefined;
 }
-
-async function createProjectArchive(projectRoot: string, entries: LocalEntry[]) {
-    const tempDir = await mkdtemp(path.join(tmpdir(), "vmpush-"));
+async function createProjectArchive(projectRoot, entries) {
+    const tempDir = await mkdtemp(path.join(tmpdir(), "freestyle-sync-"));
     const listPath = path.join(tempDir, "files.list");
     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]);
     return archivePath;
 }
-
-async function createContextArchive(entries: ContextEntry[]) {
-    const tempDir = await mkdtemp(path.join(tmpdir(), "vmpush-context-"));
+async function createContextArchive(entries) {
+    const tempDir = await mkdtemp(path.join(tmpdir(), "freestyle-sync-context-"));
     const stagingDir = path.join(tempDir, "staging");
     const archivePath = path.join(tempDir, "context.tgz");
     await mkdir(stagingDir, { recursive: true });
-
     for (const entry of entries) {
         const relativeRemotePath = entry.remotePath.replace(/^\/+/, "");
         const destination = path.join(stagingDir, ...relativeRemotePath.split("/"));
         await mkdir(path.dirname(destination), { recursive: true });
         await writeFile(destination, await readFile(entry.absolutePath));
     }
-
     await createTar(["--no-xattrs", "-czf", archivePath, "-C", stagingDir, "."]);
     return archivePath;
 }
-
-async function createTar(args: string[]) {
+async function createTar(args) {
     await execFileAsync("tar", args, {
         env: {
             ...process.env,
@@ -1116,69 +1195,57 @@ async function createTar(args: string[]) {
         },
     });
 }
-
-async function uploadArchiveInChunks(
-    vm: RemoteVm,
-    vmId: string,
-    archivePath: string,
-    remoteArchivePath: string,
-    label: string,
-) {
+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 chunkDir = `/tmp/vmpush-${label}-${Date.now()}.chunks`;
-
+    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"}...`);
     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);
-        if (chunkCount > 1 && ((index + 1) % 10 === 0 || index + 1 === chunkCount)) {
-            console.log(`VM ${vmId}: uploaded ${index + 1}/${chunkCount} ${label} archive chunks`);
+        const uploadedChunks = index + 1;
+        if (chunkCount > 1) {
+            const progressMessage = `VM ${vmId}: uploaded ${uploadedChunks}/${chunkCount} ${label} archive chunks`;
+            if (canRenderInlineProgress) {
+                process.stdout.write(`\r${progressMessage}`);
+                if (uploadedChunks === chunkCount) {
+                    process.stdout.write("\n");
+                }
+            }
+            else if (uploadedChunks === 1 || uploadedChunks % logEvery === 0 || uploadedChunks === chunkCount) {
+                console.log(progressMessage);
+            }
         }
     }
-
-    await checkedExec(
-        vm,
-        `cat ${shellQuote(chunkDir)}/*.b64 | base64 -d > ${shellQuote(remoteArchivePath)} && rm -rf ${shellQuote(chunkDir)}`,
-    );
+    await checkedExec(vm, `cat ${shellQuote(chunkDir)}/*.b64 | base64 -d > ${shellQuote(remoteArchivePath)} && rm -rf ${shellQuote(chunkDir)}`);
 }
-
-async function mkdirRemote(vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"], directories: string[]) {
+async function mkdirRemote(vm, directories) {
     for (const chunk of chunkArray(directories, 50)) {
         await checkedExec(vm, `mkdir -p ${chunk.map(shellQuote).join(" ")}`);
     }
 }
-
-async function hardenRemoteRoot(vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"]): Promise<void> {
+async function hardenRemoteRoot(vm) {
     await checkedExec(vm, "chown root:root /root && chmod 700 /root");
 }
-
-async function checkedExec(vm: RemoteVm, command: string, timeoutMs?: number) {
+async function checkedExec(vm, command, timeoutMs) {
     const result = await vm.exec({ command, timeoutMs });
     if (result.statusCode && result.statusCode !== 0) {
         throw new Error(`remote command failed (${result.statusCode}): ${command}\n${result.stderr ?? result.stdout ?? ""}`);
     }
     return result;
 }
-
-async function runBeforeOpenRemoteEditorPlugins(
-    vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
-    vmId: string,
-    options: CliOptions,
-    scheme: string,
-    remoteWorkspaceUri: string,
-    contextCandidates: ContextCandidate[],
-) {
-    const messages: string[] = [];
+async function runBeforeOpenRemoteEditorPlugins(vm, vmId, options, scheme, remoteWorkspaceUri, contextCandidates) {
+    const messages = [];
     for (const plugin of plugins) {
         const result = await plugin.beforeOpenRemoteEditor?.({
-            vm: vm as RemoteVm,
+            vm: vm,
             vmId,
             options,
             utils: pluginUtils,
@@ -1186,23 +1253,16 @@ async function runBeforeOpenRemoteEditorPlugins(
             remoteWorkspaceUri,
             contextCandidates,
         });
-        if (result) messages.push(...result);
+        if (result)
+            messages.push(...result);
     }
     return messages;
 }
-
-async function runAfterOpenRemoteEditorPlugins(
-    vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
-    vmId: string,
-    options: CliOptions,
-    scheme: string,
-    remoteWorkspaceUri: string,
-    contextCandidates: ContextCandidate[],
-) {
-    const messages: string[] = [];
+async function runAfterOpenRemoteEditorPlugins(vm, vmId, options, scheme, remoteWorkspaceUri, contextCandidates) {
+    const messages = [];
     for (const plugin of plugins) {
         const result = await plugin.afterOpenRemoteEditor?.({
-            vm: vm as RemoteVm,
+            vm: vm,
             vmId,
             options,
             utils: pluginUtils,
@@ -1210,20 +1270,15 @@ async function runAfterOpenRemoteEditorPlugins(
             remoteWorkspaceUri,
             contextCandidates,
         });
-        if (result) messages.push(...result);
+        if (result)
+            messages.push(...result);
     }
     return messages;
 }
-
-async function runConnectPlugins(
-    vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
-    vmId: string,
-    options: CliOptions,
-    contextCandidates: ContextCandidate[],
-) {
+async function runConnectPlugins(vm, vmId, options, contextCandidates) {
     for (const plugin of plugins) {
         const handled = await plugin.connect?.({
-            vm: vm as RemoteVm,
+            vm: vm,
             vmId,
             options,
             utils: pluginUtils,
@@ -1231,14 +1286,14 @@ async function runConnectPlugins(
             runBeforeOpenRemoteEditor: ({ scheme, remoteWorkspaceUri }) => runBeforeOpenRemoteEditorPlugins(vm, vmId, options, scheme, remoteWorkspaceUri, contextCandidates),
             runAfterOpenRemoteEditor: ({ scheme, remoteWorkspaceUri }) => runAfterOpenRemoteEditorPlugins(vm, vmId, options, scheme, remoteWorkspaceUri, contextCandidates),
         });
-        if (handled) return true;
+        if (handled)
+            return true;
     }
     return false;
 }
-
-async function sshIntoVm(vmId: string) {
+async function sshIntoVm(vmId) {
     console.log(`Connecting to VM ${vmId}...`);
-    const exitCode = await new Promise<number | null>((resolve, reject) => {
+    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));
@@ -1247,10 +1302,9 @@ async function sshIntoVm(vmId: string) {
         throw new Error(`ssh exited with status ${exitCode}`);
     }
 }
-
-async function hashFile(filePath: string): Promise<string> {
+async function hashFile(filePath) {
     const hash = createHash("sha256");
-    await new Promise<void>((resolve, reject) => {
+    await new Promise((resolve, reject) => {
         const stream = createReadStream(filePath);
         stream.on("data", (chunk) => hash.update(chunk));
         stream.on("error", reject);
@@ -1258,68 +1312,80 @@ async function hashFile(filePath: string): Promise<string> {
     });
     return hash.digest("hex");
 }
-
-function hashString(value: string): string {
+function hashString(value) {
     return createHash("sha256").update(value).digest("hex");
 }
-
-function md5(value: string): string {
+function md5(value) {
     return createHash("md5").update(value).digest("hex");
 }
-
-function renderEnvFile(envExports: Record<string, string>) {
-    const lines = ["# Generated by vmpush. Contains local auth tokens."];
+function renderEnvFile(envExports) {
+    const lines = [`# Generated by ${CLI_NAME}. Contains local auth tokens.`];
     for (const key of Object.keys(envExports).sort()) {
         lines.push(`export ${key}=${shellQuote(envExports[key])}`);
     }
     return `${lines.join("\n")}\n`;
 }
-
-function shellQuote(value: string): string {
+function shellQuote(value) {
     return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
-
-function normalizeRemotePath(value: string): string {
+function normalizeRemotePath(value) {
     const normalized = path.posix.normalize(value.replace(/\\/g, "/"));
     if (!normalized.startsWith("/")) {
         throw new Error("--remote-dir must be an absolute VM path");
     }
     return normalized;
 }
-
-function defaultRemoteProjectDir(projectRoot: string): string {
+function defaultRemoteProjectDir(projectRoot) {
     return normalizeRemotePath(toPosix(projectRoot));
 }
-
-function sanitizeName(value: string): string {
-    return value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+function sanitizeName(value) {
+    const lower = value.toLowerCase();
+    let normalized = "";
+    let lastWasDash = false;
+    for (const character of lower) {
+        const isAlpha = character >= "a" && character <= "z";
+        const isDigit = character >= "0" && character <= "9";
+        const isAllowedPunctuation = character === "." || character === "_" || character === "-";
+        if (isAlpha || isDigit || isAllowedPunctuation) {
+            normalized += character;
+            lastWasDash = false;
+            continue;
+        }
+        if (!lastWasDash) {
+            normalized += "-";
+            lastWasDash = true;
+        }
+    }
+    while (normalized.startsWith("-"))
+        normalized = normalized.slice(1);
+    while (normalized.endsWith("-"))
+        normalized = normalized.slice(0, -1);
+    return normalized || "project";
 }
-
-function toPosix(value: string) {
+function toPosix(value) {
     return value.split(path.sep).join(path.posix.sep);
 }
-
-function formatBytes(bytes: number) {
-    if (bytes < 1024) return `${bytes} B`;
-    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
     return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
 }
-
-async function delay(ms: number) {
+async function delay(ms) {
     await new Promise((resolve) => setTimeout(resolve, ms));
 }
-
-async function exists(filePath: string) {
+async function exists(filePath) {
     try {
         await stat(filePath);
         return true;
-    } catch {
+    }
+    catch {
         return false;
     }
 }
-
-function chunkArray<T>(items: T[], size: number): T[][] {
-    const chunks: T[][] = [];
+function chunkArray(items, size) {
+    const chunks = [];
     for (let index = 0; index < items.length; index += size) {
         chunks.push(items.slice(index, index + size));
     }