freestyle-sync 0.1.2 → 0.1.3

package/README.md

@@ -1,11 +1,12 @@
 # Freestyle Sync
 
-Sync your current directory, it's dependencies, and your agent context into a VM.
+Sync your current directory, it's dependencies, and your agent context into a VM. VM snapshots ensure only changes are uploaded.
 
 ```
 npx freestyle-sync
 ```
 
+Configure complex sync behavior using plugins.
 ```ts
 import { defineConfig } from "freestyle-sync";
 import { claudeAgentPlugin } from "@freestyle-sync/agent-claude";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freestyle-sync",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "main": "src/main.ts",
   "exports": {

package/plugins/agent-copilot/src/index.ts

@@ -33,11 +33,13 @@ export function copilotAgentPlugin() {
             return [];
         },
         async beforeOpenRemoteEditor({ vm, vmId, scheme, remoteWorkspaceUri, contextCandidates, utils }) {
+            if (!isSupportedEditorScheme(scheme)) return [];
             const result = await preseedLocalCopilotForRemoteUri(vm, vmId, contextCandidates, scheme, remoteWorkspaceUri, utils);
             if (result.status === "copied") return [`Prepared Copilot sidebar state for ${scheme === "cursor" ? "Cursor" : "VS Code"}.`];
             return [];
         },
         async afterOpenRemoteEditor({ vm, vmId, scheme, remoteWorkspaceUri, contextCandidates, utils }) {
+            if (!isSupportedEditorScheme(scheme)) return [];
             const result = await syncLocalCopilotForRemoteUri(vm, vmId, contextCandidates, remoteWorkspaceUri, utils);
             if (result.status === "copied") return [`Copied Copilot sidebar state to opened ${scheme === "cursor" ? "Cursor" : "VS Code"} workspace.`];
             if (result.status === "pending") return ["Copilot sidebar state: opened the editor, but the workspace storage bucket was not created yet. Reload the window after it finishes connecting, then rerun vmpush if needed."];
@@ -166,7 +168,7 @@ async function syncLocalCopilotForRemoteUri(vm: RemoteVm, vmId: string, contextC
     return { status: "pending", count: 0 };
 }
 
-async function preseedLocalCopilotForRemoteUri(vm: RemoteVm, vmId: string, contextCandidates: ContextCandidate[], scheme: "vscode" | "cursor", remoteWorkspaceUri: string, utils: PushvmPluginUtils): Promise<CopyResult> {
+async function preseedLocalCopilotForRemoteUri(vm: RemoteVm, vmId: string, contextCandidates: ContextCandidate[], scheme: string, remoteWorkspaceUri: string, utils: PushvmPluginUtils): Promise<CopyResult> {
     const sourceCopilotDir = selectedCurrentCopilotSource(contextCandidates);
     if (!sourceCopilotDir || !(await exists(sourceCopilotDir))) return { status: "skipped", count: 0 };
 
@@ -455,17 +457,25 @@ async function ensureWorkspaceStateDb(stateDb: string) {
     await execFileAsync("sqlite3", [stateDb, "CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB);"]);
 }
 
-function codeUserRootsForScheme(home: string, scheme: "vscode" | "cursor") {
-    if (scheme === "cursor") {
-        return [
-            path.join(home, "Library", "Application Support", "Cursor", "User"),
-            path.join(home, ".config", "Cursor", "User"),
-        ];
+function codeUserRootsForScheme(home: string, scheme: string) {
+    switch (scheme) {
+        case "cursor":
+            return [
+                path.join(home, "Library", "Application Support", "Cursor", "User"),
+                path.join(home, ".config", "Cursor", "User"),
+            ];
+        case "vscode":
+            return [
+                path.join(home, "Library", "Application Support", "Code", "User"),
+                path.join(home, ".config", "Code", "User"),
+            ];
+        default:
+            return [];
     }
-    return [
-        path.join(home, "Library", "Application Support", "Code", "User"),
-        path.join(home, ".config", "Code", "User"),
-    ];
+}
+
+function isSupportedEditorScheme(scheme: string): scheme is "vscode" | "cursor" {
+    return scheme === "vscode" || scheme === "cursor";
 }
 
 function codeUserRoots(home: string) {

package/src/main.ts

@@ -17,6 +17,9 @@ const execFileAsync = promisify(execFile);
 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 = {
@@ -79,14 +82,33 @@ type SyncResult = {
 class Progress {
     private current = 0;
     private readonly total: number;
+    private currentStepStartedAt = 0;
+    private currentStepMessage?: string;
 
     constructor(total: number) {
         this.total = total;
     }
 
     step(message: string) {
+        if (this.currentStepMessage) {
+            this.printCompletion();
+        }
         this.current += 1;
-        console.log(`[${this.current}/${this.total}] ${message}`);
+        this.currentStepMessage = message;
+        this.currentStepStartedAt = Date.now();
+        console.log(`${accent(symbol("➜", ">"))} ${bold(`[${this.current}/${this.total}]`)} ${message}`);
+    }
+
+    finish() {
+        if (!this.currentStepMessage) return;
+        this.printCompletion();
+        this.currentStepMessage = undefined;
+    }
+
+    private 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))}`);
     }
 }
 
@@ -99,6 +121,7 @@ if (isDirectCliExecution()) {
 
 async function main() {
     const options = await parseArgs(process.argv.slice(2));
+    printHeading("vmpush");
     config = await loadConfig(options.projectRoot);
     plugins = config.plugins;
     const pluginPreferences = await updatePluginPreferences(options);
@@ -107,12 +130,53 @@ async function main() {
         printPlugins(pluginPreferences, options);
         return;
     }
-    const progress = new Progress(options.dryRun ? 2 : options.install ? 12 : 11);
 
     if (options.dryRun) {
         console.log("vmpush dry run");
     }
 
+    if (options.skipSync) {
+        const progress = new Progress(3);
+        progress.step("Reading sync cache");
+        const cache = await readCache(options.cachePath, options);
+
+        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.");
+        }
+
+        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;
+        }
+
+        progress.step("Preparing Freestyle VM");
+        const { vm, vmId } = await getOrCreateVm(options, cache.snapshotId);
+        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);
+        console.log(`SSH: npx freestyle vm ssh ${vmId}`);
+        if (options.autoSsh) {
+            const connected = await runConnectPlugins(vm, vmId, options, contextCandidates);
+            if (!connected) await sshIntoVm(vmId);
+        }
+        return;
+    }
+
+    const progress = new Progress(options.dryRun ? 2 : options.install ? 12 : 11);
+
     progress.step("Scanning project files");
     const cache = await readCache(options.cachePath, options);
     const base = cacheBaseForSync(options, cache);
@@ -132,6 +196,7 @@ async function main() {
     printPlan(options, projectChanges, contextChanges, envExports, cache);
 
     if (options.dryRun) {
+        progress.finish();
         return;
     }
 
@@ -162,59 +227,69 @@ async function main() {
         await runInstall(vm, options.projectRoot, options.remoteProjectDir);
     }
 
-    let snapshotId = cache.snapshotId;
-    let snapshotProjectFiles = cache.snapshotProjectFiles;
-    let snapshotContextFiles = cache.snapshotContextFiles;
-    let snapshotEnvHash = cache.snapshotEnvHash;
-    if (options.snapshot) {
-        progress.step(`Creating snapshot cache for ${vmId}`);
-        await runBeforeSnapshotPlugins(vm, vmId, options);
-        try {
-            const snapshot = await vm.snapshot({ name: `vmpush-${path.basename(options.projectRoot)}-${Date.now()}` });
-            snapshotId = snapshot.snapshotId;
-            snapshotProjectFiles = projectCurrent;
-            snapshotContextFiles = contextCurrent;
-            snapshotEnvHash = envHash;
-        } catch (error) {
-            console.warn(`Snapshot cache skipped: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    } else {
-        progress.step("Skipping snapshot cache");
-    }
-
-    progress.step("Saving local sync cache");
-    await writeCache(options.cachePath, {
+    const buildSyncCache = (snapshotOverride?: { snapshotId: string }): CacheFile => ({
         version: CACHE_VERSION,
         projectRoot: options.projectRoot,
         remoteProjectDir: options.remoteProjectDir,
         vmId,
-        snapshotId,
+        snapshotId: snapshotOverride ? snapshotOverride.snapshotId : cache.snapshotId,
         projectFiles: projectCurrent,
         contextFiles: contextCurrent,
-        snapshotProjectFiles,
-        snapshotContextFiles,
+        snapshotProjectFiles: snapshotOverride ? projectCurrent : cache.snapshotProjectFiles,
+        snapshotContextFiles: snapshotOverride ? contextCurrent : cache.snapshotContextFiles,
         envHash,
-        snapshotEnvHash,
+        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;
+    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()}` });
+                return snapshot.snapshotId;
+            } catch (error) {
+                console.warn(`Snapshot cache skipped: ${error instanceof Error ? error.message : String(error)}`);
+                return null;
+            }
+        })();
+    } 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(`VM ready: ${vmId}`);
-    console.log(`Project: ${options.remoteProjectDir}`);
-    console.log(`Project files: ${projectResult.uploaded} uploaded, ${projectResult.removed} removed, ${projectResult.unchanged} unchanged`);
-    console.log(`Context files: ${contextResult.uploaded} uploaded, ${contextResult.unchanged} unchanged`);
-    if (snapshotId) {
-        console.log(`Snapshot cache: ${snapshotId}`);
+    console.log(`${success(symbol("✓", "*"))} ${bold(`VM 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`);
+    if (snapshotPromise) {
+        console.log(`${dim("Snapshot cache:")} creating in background`);
+    } else if (cache.snapshotId) {
+        console.log(`${dim("Snapshot cache:")} ${cache.snapshotId}`);
     }
     for (const message of postSyncMessages) console.log(message);
-    console.log(`SSH: npx freestyle vm ssh ${vmId}`);
+    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 (snapshotPromise) {
+        const newSnapshotId = await snapshotPromise;
+        if (newSnapshotId) {
+            await writeCache(options.cachePath, buildSyncCache({ snapshotId: newSnapshotId }));
+            console.log(`Snapshot cache saved: ${newSnapshotId}`);
+        }
+    }
 }
 
 function isDirectCliExecution() {
@@ -298,6 +373,7 @@ async function parseArgs(args: string[]): Promise<CliOptions> {
         includeGitDir: true,
         includeAllCopilotWorkspaces: false,
         snapshot: true,
+        skipSync: false,
         install: false,
         autoSsh: true,
         envKeys: [],
@@ -331,6 +407,8 @@ async function parseArgs(args: string[]): Promise<CliOptions> {
             options.includeAllCopilotWorkspaces = true;
         } else if (arg === "--no-snapshot" || arg === "--skip-snapshot") {
             options.snapshot = false;
+        } else if (arg === "--skip-sync") {
+            options.skipSync = true;
         } else if (arg === "--install") {
             options.install = true;
         } else if (arg === "--no-ssh") {
@@ -400,6 +478,8 @@ Options:
     --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.
     -y, --yes                Deprecated; accepted for compatibility.
 	-h, --help               Show this help.
@@ -750,20 +830,62 @@ function printPlan(
     cache: CacheFile,
 ) {
     const source = options.vmId ? `existing VM ${options.vmId}` : cache.snapshotId ? `snapshot ${cache.snapshotId}` : "a new VM";
-    console.log(`Syncing ${options.projectRoot} to ${source}`);
-    console.log(`Remote project: ${options.remoteProjectDir}`);
-    console.log(`Project files: ${projectChanges.changed.length} changed, ${projectChanges.removed.length} removed, ${projectChanges.unchanged} unchanged`);
-    console.log(`Context files: ${contextChanges.changed.length} changed, ${contextChanges.removed.length} removed, ${contextChanges.unchanged} unchanged`);
-    console.log(`Estimated upload: ${formatBytes(totalEntrySize(projectChanges.changed))} project, ${formatBytes(totalEntrySize(contextChanges.changed))} context`);
+    console.log("");
+    console.log(`${bold("Sync plan")}`);
+    console.log(`${dim("  Source:")} ${source}`);
+    console.log(`${dim("  Local:")} ${options.projectRoot}`);
+    console.log(`${dim("  Remote:")} ${options.remoteProjectDir}`);
+    console.log(`${dim("  Project files:")} ${projectChanges.changed.length} changed, ${projectChanges.removed.length} removed, ${projectChanges.unchanged} unchanged`);
+    console.log(`${dim("  Context files:")} ${contextChanges.changed.length} changed, ${contextChanges.removed.length} removed, ${contextChanges.unchanged} unchanged`);
+    console.log(`${dim("  Estimated upload:")} ${formatBytes(totalEntrySize(projectChanges.changed))} project, ${formatBytes(totalEntrySize(contextChanges.changed))} context`);
     if (Object.keys(envExports).length > 0) {
-        console.log(`Environment exports: ${Object.keys(envExports).length}`);
+        console.log(`${dim("  Environment exports:")} ${Object.keys(envExports).length}`);
     }
+    console.log("");
 }
 
 function totalEntrySize(entries: LocalEntry[]) {
     return entries.reduce((total, entry) => total + entry.size, 0);
 }
 
+function printHeading(name: string) {
+    console.log(`${bold(name)} ${dim(`${symbol("→", "-")} Freestyle sync`)}`);
+    console.log("");
+}
+
+function formatDuration(milliseconds: number) {
+    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) {
+    return USE_UNICODE_OUTPUT ? unicode : ascii;
+}
+
+function accent(text: string) {
+    return color(36, text);
+}
+
+function success(text: string) {
+    return color(32, text);
+}
+
+function dim(text: string) {
+    return color(2, text);
+}
+
+function bold(text: string) {
+    return color(1, text);
+}
+
+function color(code: number, text: string) {
+    if (!USE_STYLED_OUTPUT) return text;
+    return `\u001b[${code}m${text}\u001b[0m`;
+}
+
 async function getOrCreateVm(options: CliOptions, snapshotId?: string) {
     if (options.vmId) {
         const { vm } = await freestyle.vms.get({ vmId: options.vmId });
@@ -1049,7 +1171,7 @@ async function runBeforeOpenRemoteEditorPlugins(
     vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
     vmId: string,
     options: CliOptions,
-    scheme: "vscode" | "cursor",
+    scheme: string,
     remoteWorkspaceUri: string,
     contextCandidates: ContextCandidate[],
 ) {
@@ -1073,7 +1195,7 @@ async function runAfterOpenRemoteEditorPlugins(
     vm: Awaited<ReturnType<typeof getOrCreateVm>>["vm"],
     vmId: string,
     options: CliOptions,
-    scheme: "vscode" | "cursor",
+    scheme: string,
     remoteWorkspaceUri: string,
     contextCandidates: ContextCandidate[],
 ) {

package/src/plugin-api.ts

@@ -16,6 +16,7 @@ export type CliOptions = {
     includeGitDir: boolean;
     includeAllCopilotWorkspaces: boolean;
     snapshot: boolean;
+    skipSync: boolean;
     install: boolean;
     autoSsh: boolean;
     envKeys: string[];
@@ -68,15 +69,17 @@ export type RemoteHookContext = PushvmPluginContext & {
     vmId: string;
 };
 
+export type EditorScheme = string;
+
 export type EditorHookContext = RemoteHookContext & {
-    scheme: "vscode" | "cursor";
+    scheme: EditorScheme;
     remoteWorkspaceUri: string;
 };
 
 export type ConnectHookContext = RemoteHookContext & {
     contextCandidates: ContextCandidate[];
-    runBeforeOpenRemoteEditor(args: { scheme: "vscode" | "cursor"; remoteWorkspaceUri: string }): Promise<string[]>;
-    runAfterOpenRemoteEditor(args: { scheme: "vscode" | "cursor"; remoteWorkspaceUri: string }): Promise<string[]>;
+    runBeforeOpenRemoteEditor(args: { scheme: EditorScheme; remoteWorkspaceUri: string }): Promise<string[]>;
+    runAfterOpenRemoteEditor(args: { scheme: EditorScheme; remoteWorkspaceUri: string }): Promise<string[]>;
 };
 
 export type PushvmPlugin = {