freestyle-sync 0.1.2 → 0.1.4

package/{plugins/agent-copilot/src/index.ts → dist/plugins/agent-copilot/src/index.js}

@@ -4,18 +4,15 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { definePlugin, type ContextCandidate, type PushvmPluginUtils, type RemoteVm } from "../../../src/plugin-api.ts";
-
+import { definePlugin } from "../../../src/plugin-api.js";
 const execFileAsync = promisify(execFile);
-
-type CopyResult = { status: "copied"; count: number } | { status: "pending" | "skipped"; count: 0; reason?: string };
-
 export function copilotAgentPlugin() {
     return definePlugin({
         name: "@freestyle-sync/agent-copilot",
         async discoverContextCandidates({ options }) {
-            if (!options.includeAgentContext) return [];
-            const candidates: ContextCandidate[] = [];
+            if (!options.includeAgentContext)
+                return [];
+            const candidates = [];
             for (const codeRoot of codeUserRoots(homedir())) {
                 await addCopilotCandidates(candidates, codeRoot, options.projectRoot, options.includeAllCopilotWorkspaces);
             }
@@ -29,29 +26,31 @@ export function copilotAgentPlugin() {
             if (result.status === "copied") {
                 return [`Copilot sidebar state: copied to ${result.count} VS Code Remote workspace${result.count === 1 ? "" : "s"}`];
             }
-            if (result.status === "pending") return [`Copilot sidebar state: ${result.reason}`];
+            if (result.status === "pending")
+                return [`Copilot sidebar state: ${result.reason}`];
             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"}.`];
+            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."];
+            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."];
             return [];
         },
     });
 }
-
-async function installAgentCli(
-    vm: RemoteVm,
-    checkedExec: PushvmPluginUtils["checkedExec"],
-    binary: string,
-    packageName: string,
-) {
+async function installAgentCli(vm, checkedExec, binary, packageName) {
     await checkedExec(vm, `
 set -e
 export HOME="\${HOME:-/root}"
@@ -92,16 +91,14 @@ fi
 test -x /usr/local/bin/${binary}
 `, 600000);
 }
-
-async function addCopilotCandidates(candidates: ContextCandidate[], codeUserRoot: string, projectRoot: string, includeAllWorkspaces: boolean) {
-    if (!(await exists(codeUserRoot))) return;
-
+async function addCopilotCandidates(candidates, codeUserRoot, projectRoot, includeAllWorkspaces) {
+    if (!(await exists(codeUserRoot)))
+        return;
     const remoteUserRoot = remoteCodeRoot(codeUserRoot);
     const globalStorage = path.join(codeUserRoot, "globalStorage", "github.copilot-chat");
     if (await exists(globalStorage)) {
         addCandidate(candidates, globalStorage, `${remoteUserRoot}/globalStorage/github.copilot-chat`, "Copilot global chat state", "context:copilot-global");
     }
-
     const workspaceStorage = path.join(codeUserRoot, "workspaceStorage");
     const workspaceDirs = await listDirectories(workspaceStorage);
     for (const workspaceDir of workspaceDirs) {
@@ -115,13 +112,11 @@ async function addCopilotCandidates(candidates: ContextCandidate[], codeUserRoot
         }
     }
 }
-
-async function syncLocalCopilotForRemoteWorkspaces(vm: RemoteVm, vmId: string, remoteProjectDir: string, contextCandidates: ContextCandidate[], utils: PushvmPluginUtils): Promise<CopyResult> {
+async function syncLocalCopilotForRemoteWorkspaces(vm, vmId, remoteProjectDir, contextCandidates, utils) {
     const sourceCopilotDir = selectedCurrentCopilotSource(contextCandidates);
     if (!sourceCopilotDir || !(await exists(sourceCopilotDir))) {
         return { status: "skipped", count: 0, reason: "Copilot current workspace state is not selected." };
     }
-
     const destinations = await findRemoteWorkspaceCopilotDestinations(vmId, remoteProjectDir);
     if (destinations.length === 0) {
         return {
@@ -130,19 +125,17 @@ async function syncLocalCopilotForRemoteWorkspaces(vm: RemoteVm, vmId: string, r
             reason: "open this VM folder in VS Code once, then rerun vmpush to copy sidebar history.",
         };
     }
-
     await copyCopilotState(sourceCopilotDir, destinations);
     await copyCopilotWorkspaceStateKeys(sourceCopilotDir, destinations);
     await copyCopilotStateToRemoteServer(vm, vmId, sourceCopilotDir, destinations, utils);
     return { status: "copied", count: destinations.length };
 }
-
-async function syncLocalCopilotForRemoteUri(vm: RemoteVm, vmId: string, contextCandidates: ContextCandidate[], remoteWorkspaceUri: string, utils: PushvmPluginUtils): Promise<CopyResult> {
+async function syncLocalCopilotForRemoteUri(vm, vmId, contextCandidates, remoteWorkspaceUri, utils) {
     const sourceCopilotDir = selectedCurrentCopilotSource(contextCandidates);
-    if (!sourceCopilotDir || !(await exists(sourceCopilotDir))) return { status: "skipped", count: 0 };
-
+    if (!sourceCopilotDir || !(await exists(sourceCopilotDir)))
+        return { status: "skipped", count: 0 };
     for (let attempt = 0; attempt < 20; attempt += 1) {
-        const destinations: string[] = [];
+        const destinations = [];
         for (const codeRoot of codeUserRoots(homedir())) {
             const workspaceStorage = path.join(codeRoot, "workspaceStorage");
             const workspaceDirs = await listDirectories(workspaceStorage);
@@ -152,26 +145,22 @@ async function syncLocalCopilotForRemoteUri(vm: RemoteVm, vmId: string, contextC
                 }
             }
         }
-
         if (destinations.length > 0) {
             await copyCopilotState(sourceCopilotDir, destinations);
             await copyCopilotWorkspaceStateKeys(sourceCopilotDir, destinations);
             await copyCopilotStateToRemoteServer(vm, vmId, sourceCopilotDir, destinations, utils);
             return { status: "copied", count: destinations.length };
         }
-
         await utils.delay(500);
     }
-
     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, vmId, contextCandidates, scheme, remoteWorkspaceUri, utils) {
     const sourceCopilotDir = selectedCurrentCopilotSource(contextCandidates);
-    if (!sourceCopilotDir || !(await exists(sourceCopilotDir))) return { status: "skipped", count: 0 };
-
+    if (!sourceCopilotDir || !(await exists(sourceCopilotDir)))
+        return { status: "skipped", count: 0 };
     const workspaceId = utils.md5(remoteWorkspaceUri);
-    const destinations: string[] = [];
+    const destinations = [];
     for (const codeRoot of codeUserRootsForScheme(homedir(), scheme)) {
         const workspaceDir = path.join(codeRoot, "workspaceStorage", workspaceId);
         await mkdir(workspaceDir, { recursive: true });
@@ -179,19 +168,16 @@ async function preseedLocalCopilotForRemoteUri(vm: RemoteVm, vmId: string, conte
         await ensureWorkspaceStateDb(path.join(workspaceDir, "state.vscdb"));
         destinations.push(path.join(workspaceDir, "GitHub.copilot-chat"));
     }
-
     await copyCopilotState(sourceCopilotDir, destinations);
     await copyCopilotWorkspaceStateKeys(sourceCopilotDir, destinations);
     await copyCopilotStateToRemoteServer(vm, vmId, sourceCopilotDir, destinations, utils);
     return { status: "copied", count: destinations.length };
 }
-
-function selectedCurrentCopilotSource(contextCandidates: ContextCandidate[]) {
+function selectedCurrentCopilotSource(contextCandidates) {
     return contextCandidates.find((candidate) => candidate.preferenceKey === "context:copilot-current-workspace")?.source;
 }
-
-async function findRemoteWorkspaceCopilotDestinations(vmId: string, remoteProjectDir: string) {
-    const destinations: string[] = [];
+async function findRemoteWorkspaceCopilotDestinations(vmId, remoteProjectDir) {
+    const destinations = [];
     for (const codeRoot of codeUserRoots(homedir())) {
         const workspaceStorage = path.join(codeRoot, "workspaceStorage");
         const workspaceDirs = await listDirectories(workspaceStorage);
@@ -203,8 +189,7 @@ async function findRemoteWorkspaceCopilotDestinations(vmId: string, remoteProjec
     }
     return destinations;
 }
-
-async function copyCopilotState(sourceCopilotDir: string, destinations: string[]) {
+async function copyCopilotState(sourceCopilotDir, destinations) {
     for (const destination of destinations) {
         await rm(destination, { recursive: true, force: true });
         await mkdir(path.dirname(destination), { recursive: true });
@@ -213,8 +198,7 @@ async function copyCopilotState(sourceCopilotDir: string, destinations: string[]
         await copyCoreChatState(sourceCopilotDir, destination);
     }
 }
-
-async function copyCoreChatState(sourceCopilotDir: string, destinationCopilotDir: string) {
+async function copyCoreChatState(sourceCopilotDir, destinationCopilotDir) {
     const sourceWorkspaceDir = path.dirname(sourceCopilotDir);
     const destinationWorkspaceDir = path.dirname(destinationCopilotDir);
     const sessionIds = await copiedCopilotSessionIds(destinationCopilotDir);
@@ -226,7 +210,6 @@ async function copyCoreChatState(sourceCopilotDir: string, destinationCopilotDir
             await cp(sourceChatSession, destinationChatSession, { force: true });
             await trimTranscriptToCompletedTurn(destinationChatSession);
         }
-
         const sourceEditingSession = path.join(sourceWorkspaceDir, "chatEditingSessions", sessionId);
         if (await exists(sourceEditingSession)) {
             const destinationEditingSession = path.join(destinationWorkspaceDir, "chatEditingSessions", sessionId);
@@ -236,29 +219,29 @@ async function copyCoreChatState(sourceCopilotDir: string, destinationCopilotDir
         }
     }
 }
-
-async function copiedCopilotSessionIds(copilotDir: string) {
+async function copiedCopilotSessionIds(copilotDir) {
     const transcripts = await listFiles(path.join(copilotDir, "transcripts"));
     return transcripts.filter((transcript) => transcript.endsWith(".jsonl")).map((transcript) => path.basename(transcript, ".jsonl"));
 }
-
-async function sanitizeCopilotTranscripts(copilotDir: string) {
+async function sanitizeCopilotTranscripts(copilotDir) {
     const entries = await listFiles(path.join(copilotDir, "transcripts"));
     for (const transcript of entries.filter((entry) => entry.endsWith(".jsonl"))) {
         await trimTranscriptToCompletedTurn(transcript);
     }
 }
-
-async function trimTranscriptToCompletedTurn(transcriptPath: string) {
+async function trimTranscriptToCompletedTurn(transcriptPath) {
     const content = await readFile(transcriptPath, "utf8").catch(() => undefined);
-    if (!content) return;
+    if (!content)
+        return;
     const lines = content.trimEnd().split("\n");
     let lastCompletedLine = -1;
     for (let index = 0; index < lines.length; index += 1) {
         try {
-            const event = JSON.parse(lines[index]) as { type?: string };
-            if (event.type === "assistant.turn_end") lastCompletedLine = index;
-        } catch {
+            const event = JSON.parse(lines[index]);
+            if (event.type === "assistant.turn_end")
+                lastCompletedLine = index;
+        }
+        catch {
             break;
         }
     }
@@ -266,14 +249,14 @@ async function trimTranscriptToCompletedTurn(transcriptPath: string) {
         await writeFile(transcriptPath, `${lines.slice(0, lastCompletedLine + 1).join("\n")}\n`, "utf8");
     }
 }
-
-async function copyCopilotWorkspaceStateKeys(sourceCopilotDir: string, destinations: string[]) {
+async function copyCopilotWorkspaceStateKeys(sourceCopilotDir, destinations) {
     const sourceStateDb = path.join(path.dirname(sourceCopilotDir), "state.vscdb");
-    if (!(await exists(sourceStateDb))) return;
-
+    if (!(await exists(sourceStateDb)))
+        return;
     for (const destination of destinations) {
         const destinationStateDb = path.join(path.dirname(destination), "state.vscdb");
-        if (!(await exists(destinationStateDb))) continue;
+        if (!(await exists(destinationStateDb)))
+            continue;
         await mergeWorkspaceStateKeys(sourceStateDb, destinationStateDb).catch((error) => {
             console.warn(`Copilot sidebar state database merge skipped: ${error instanceof Error ? error.message : String(error)}`);
         });
@@ -282,8 +265,7 @@ async function copyCopilotWorkspaceStateKeys(sourceCopilotDir: string, destinati
         });
     }
 }
-
-async function mergeWorkspaceStateKeys(sourceStateDb: string, destinationStateDb: string) {
+async function mergeWorkspaceStateKeys(sourceStateDb, destinationStateDb) {
     await execFileAsync("sqlite3", [
         destinationStateDb,
         `PRAGMA busy_timeout=5000;
@@ -300,17 +282,16 @@ WHERE key IN (
 DETACH DATABASE source_state;`,
     ]);
 }
-
-async function normalizeCopiedChatIndex(copilotDir: string) {
+async function normalizeCopiedChatIndex(copilotDir) {
     const stateDb = path.join(path.dirname(copilotDir), "state.vscdb");
-    if (!(await exists(stateDb))) return;
-
+    if (!(await exists(stateDb)))
+        return;
     const { stdout } = await execFileAsync("sqlite3", [stateDb, "SELECT value FROM ItemTable WHERE key='chat.ChatSessionStore.index';"]);
-    if (!stdout.trim()) return;
-
-    const index = JSON.parse(stdout) as { entries?: Record<string, Record<string, unknown>> };
-    if (!index.entries) return;
-
+    if (!stdout.trim())
+        return;
+    const index = JSON.parse(stdout);
+    if (!index.entries)
+        return;
     for (const sessionId of Object.keys(index.entries)) {
         const transcriptPath = path.join(copilotDir, "transcripts", `${sessionId}.jsonl`);
         const lastCompletedTimestamp = await lastCompletedTurnTimestamp(transcriptPath);
@@ -322,36 +303,36 @@ async function normalizeCopiedChatIndex(copilotDir: string) {
         entry.lastResponseState = 1;
         entry.hasPendingEdits = false;
         entry.lastMessageDate = lastCompletedTimestamp;
-        const timing = typeof entry.timing === "object" && entry.timing !== null ? entry.timing as Record<string, unknown> : {};
+        const timing = typeof entry.timing === "object" && entry.timing !== null ? entry.timing : {};
         timing.lastRequestEnded = lastCompletedTimestamp;
         entry.timing = timing;
     }
-
     await execFileAsync("sqlite3", [
         stateDb,
         `INSERT OR REPLACE INTO ItemTable(key, value) VALUES ('chat.ChatSessionStore.index', ${sqliteLiteral(JSON.stringify(index))});`,
     ]);
 }
-
-async function lastCompletedTurnTimestamp(transcriptPath: string) {
+async function lastCompletedTurnTimestamp(transcriptPath) {
     const content = await readFile(transcriptPath, "utf8").catch(() => undefined);
-    if (!content) return undefined;
+    if (!content)
+        return undefined;
     const lines = content.trimEnd().split("\n");
     for (let index = lines.length - 1; index >= 0; index -= 1) {
         try {
-            const event = JSON.parse(lines[index]) as { type?: string; timestamp?: string };
-            if (event.type === "assistant.turn_end" && event.timestamp) return Date.parse(event.timestamp);
-        } catch {
+            const event = JSON.parse(lines[index]);
+            if (event.type === "assistant.turn_end" && event.timestamp)
+                return Date.parse(event.timestamp);
+        }
+        catch {
             return undefined;
         }
     }
     return undefined;
 }
-
-async function copyCopilotStateToRemoteServer(vm: RemoteVm, vmId: string, sourceCopilotDir: string, localDestinations: string[], utils: PushvmPluginUtils) {
+async function copyCopilotStateToRemoteServer(vm, vmId, sourceCopilotDir, localDestinations, utils) {
     const workspaceIds = localDestinations.map((destination) => path.basename(path.dirname(destination)));
-    if (workspaceIds.length === 0) return;
-
+    if (workspaceIds.length === 0)
+        return;
     const archive = await createRemoteServerWorkspaceStateArchive(sourceCopilotDir, localDestinations, utils);
     try {
         await utils.uploadArchiveInChunks(vm, vmId, archive, "/tmp/vmpush-copilot-chat.tgz", "copilot-chat");
@@ -363,17 +344,16 @@ async function copyCopilotStateToRemoteServer(vm: RemoteVm, vmId: string, source
         commands.push(`tar --no-same-owner --no-same-permissions -xzf /tmp/vmpush-copilot-chat.tgz -C ${utils.shellQuote(baseDir)}`);
         commands.push("rm -f /tmp/vmpush-copilot-chat.tgz");
         await utils.checkedExec(vm, commands.join("\n"));
-    } finally {
+    }
+    finally {
         await rm(path.dirname(archive), { recursive: true, force: true });
     }
 }
-
-async function createRemoteServerWorkspaceStateArchive(sourceCopilotDir: string, localDestinations: string[], utils: PushvmPluginUtils) {
+async function createRemoteServerWorkspaceStateArchive(sourceCopilotDir, localDestinations, utils) {
     const tempDir = await mkdtemp(path.join(tmpdir(), "vmpush-copilot-"));
     const stagingDir = path.join(tempDir, "staging");
     const archivePath = path.join(tempDir, "copilot-chat.tgz");
     await mkdir(stagingDir, { recursive: true });
-
     for (const destination of localDestinations) {
         const workspaceId = path.basename(path.dirname(destination));
         const workspaceDir = path.join(stagingDir, workspaceId);
@@ -382,93 +362,99 @@ async function createRemoteServerWorkspaceStateArchive(sourceCopilotDir: string,
         await sanitizeCopilotTranscripts(path.join(workspaceDir, "GitHub.copilot-chat"));
         await copyCoreChatState(sourceCopilotDir, path.join(workspaceDir, "GitHub.copilot-chat"));
         const stateDb = path.join(path.dirname(destination), "state.vscdb");
-        if (await exists(stateDb)) await cp(stateDb, path.join(workspaceDir, "state.vscdb"), { force: true });
+        if (await exists(stateDb))
+            await cp(stateDb, path.join(workspaceDir, "state.vscdb"), { force: true });
     }
-
     await utils.createTar(["--no-xattrs", "-czf", archivePath, "-C", stagingDir, "."]);
     return archivePath;
 }
-
-async function isRemoteWorkspaceStorageForVmProject(workspaceDir: string, vmId: string, remoteProjectDir: string) {
+async function isRemoteWorkspaceStorageForVmProject(workspaceDir, vmId, remoteProjectDir) {
     try {
         const raw = await readFile(path.join(workspaceDir, "workspace.json"), "utf8");
-        const parsed = JSON.parse(raw) as { folder?: string; workspace?: string };
+        const parsed = JSON.parse(raw);
         const workspaceUri = parsed.folder ?? parsed.workspace;
-        if (!workspaceUri?.startsWith("vscode-remote://")) return false;
+        if (!workspaceUri?.startsWith("vscode-remote://"))
+            return false;
         const decodedUri = decodeURIComponent(workspaceUri);
         return decodedUri.includes(vmId) && remoteWorkspacePath(decodedUri) === remoteProjectDir;
-    } catch {
+    }
+    catch {
         return false;
     }
 }
-
-async function isWorkspaceStorageForRemoteUri(workspaceDir: string, remoteWorkspaceUri: string) {
+async function isWorkspaceStorageForRemoteUri(workspaceDir, remoteWorkspaceUri) {
     try {
         const raw = await readFile(path.join(workspaceDir, "workspace.json"), "utf8");
-        const parsed = JSON.parse(raw) as { folder?: string; workspace?: string };
+        const parsed = JSON.parse(raw);
         const workspaceUri = parsed.folder ?? parsed.workspace;
         return workspaceUri === remoteWorkspaceUri;
-    } catch {
+    }
+    catch {
         return false;
     }
 }
-
-async function isWorkspaceStorageForProject(workspaceDir: string, projectRoot: string) {
+async function isWorkspaceStorageForProject(workspaceDir, projectRoot) {
     try {
         const raw = await readFile(path.join(workspaceDir, "workspace.json"), "utf8");
-        const parsed = JSON.parse(raw) as { folder?: string; workspace?: string };
+        const parsed = JSON.parse(raw);
         const workspacePath = workspaceJsonPath(parsed.folder ?? parsed.workspace);
         return workspacePath !== undefined && isSameOrParentPath(workspacePath, projectRoot);
-    } catch {
+    }
+    catch {
         return false;
     }
 }
-
-function workspaceJsonPath(uri: string | undefined) {
-    if (!uri) return undefined;
+function workspaceJsonPath(uri) {
+    if (!uri)
+        return undefined;
     try {
-        if (uri.startsWith("file://")) return path.resolve(fileURLToPath(uri));
+        if (uri.startsWith("file://"))
+            return path.resolve(fileURLToPath(uri));
         return path.resolve(uri);
-    } catch {
+    }
+    catch {
         return undefined;
     }
 }
-
-function isSameOrParentPath(workspacePath: string, projectRoot: string) {
+function isSameOrParentPath(workspacePath, projectRoot) {
     const relative = path.relative(workspacePath, projectRoot);
     return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
 }
-
-function remoteWorkspacePath(decodedRemoteUri: string) {
+function remoteWorkspacePath(decodedRemoteUri) {
     const hostEnd = decodedRemoteUri.indexOf("/", "vscode-remote://".length);
-    if (hostEnd === -1) return "/";
+    if (hostEnd === -1)
+        return "/";
     return normalizeRemotePath(decodedRemoteUri.slice(hostEnd));
 }
-
-function normalizeRemotePath(value: string) {
+function normalizeRemotePath(value) {
     const normalized = path.posix.normalize(value.replace(/\\/g, "/"));
-    if (!normalized.startsWith("/")) return "/";
+    if (!normalized.startsWith("/"))
+        return "/";
     return normalized;
 }
-
-async function ensureWorkspaceStateDb(stateDb: string) {
+async function ensureWorkspaceStateDb(stateDb) {
     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, scheme) {
+    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 codeUserRoots(home: string) {
+function isSupportedEditorScheme(scheme) {
+    return scheme === "vscode" || scheme === "cursor";
+}
+function codeUserRoots(home) {
     return [
         path.join(home, "Library", "Application Support", "Code", "User"),
         path.join(home, "Library", "Application Support", "Code - Insiders", "User"),
@@ -478,65 +464,66 @@ function codeUserRoots(home: string) {
         path.join(home, ".config", "Cursor", "User"),
     ];
 }
-
-function remoteCodeRoot(localCodeUserRoot: string) {
-    if (localCodeUserRoot.includes("Cursor")) return "~/.config/Cursor/User";
-    if (localCodeUserRoot.includes("Code - Insiders")) return "~/.config/Code - Insiders/User";
+function remoteCodeRoot(localCodeUserRoot) {
+    if (localCodeUserRoot.includes("Cursor"))
+        return "~/.config/Cursor/User";
+    if (localCodeUserRoot.includes("Code - Insiders"))
+        return "~/.config/Code - Insiders/User";
     return "~/.config/Code/User";
 }
-
-async function listDirectories(directory: string) {
+async function listDirectories(directory) {
     try {
         const dirents = await import("node:fs/promises").then((fs) => fs.readdir(directory, { withFileTypes: true }));
         return dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => path.join(directory, dirent.name));
-    } catch {
+    }
+    catch {
         return [];
     }
 }
-
-async function listFiles(directory: string): Promise<string[]> {
-    const result: string[] = [];
-    async function visit(current: string) {
+async function listFiles(directory) {
+    const result = [];
+    async function visit(current) {
         const dirents = await import("node:fs/promises").then((fs) => fs.readdir(current, { withFileTypes: true })).catch(() => []);
         for (const dirent of dirents) {
             const child = path.join(current, dirent.name);
-            if (dirent.isDirectory()) await visit(child);
-            else if (dirent.isFile()) result.push(child);
+            if (dirent.isDirectory())
+                await visit(child);
+            else if (dirent.isFile())
+                result.push(child);
         }
     }
     await visit(directory);
     return result;
 }
-
-function addCandidate(candidates: ContextCandidate[], source: string, remoteRoot: string, label: string, preferenceKey: string) {
+function addCandidate(candidates, source, remoteRoot, label, preferenceKey) {
     candidates.push({ source, remoteRoot: expandRemoteHome(remoteRoot), label, sensitive: true, preferenceKey, promptLabel: label });
 }
-
-function dedupeCandidates(candidates: ContextCandidate[]) {
-    const seen = new Set<string>();
+function dedupeCandidates(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;
     });
 }
-
-function expandRemoteHome(value: string): string {
-    if (value === "~") return "/root";
-    if (value.startsWith("~/")) return `/root/${value.slice(2)}`;
+function expandRemoteHome(value) {
+    if (value === "~")
+        return "/root";
+    if (value.startsWith("~/"))
+        return `/root/${value.slice(2)}`;
     return value;
 }
-
-function sqliteLiteral(value: string) {
+function sqliteLiteral(value) {
     return `'${value.replace(/'/g, "''")}'`;
 }
-
-async function exists(filePath: string) {
+async function exists(filePath) {
     try {
         await stat(filePath);
         return true;
-    } catch {
+    }
+    catch {
         return false;
     }
 }

package/{plugins/auth-aws/src/index.ts → dist/plugins/auth-aws/src/index.js}

@@ -1,23 +1,29 @@
 import { stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
-import { definePlugin, type ContextCandidate } from "../../../src/plugin-api.ts";
-
+import { definePlugin } from "../../../src/plugin-api.js";
 export function awsAuthPlugin() {
     return definePlugin({
         name: "@freestyle-sync/auth-aws",
         async discoverContextCandidates({ options }) {
-            if (!options.includeAuth) return [];
-            const item: ContextCandidate = { source: path.join(homedir(), ".aws"), remoteRoot: "/root/.aws", label: "AWS credentials", sensitive: true, preferenceKey: "context:aws", promptLabel: "AWS credentials" };
+            if (!options.includeAuth)
+                return [];
+            const item = { source: path.join(homedir(), ".aws"), remoteRoot: "/root/.aws", label: "AWS credentials", sensitive: true, preferenceKey: "context:aws", promptLabel: "AWS credentials" };
             return await exists(item.source) ? [item] : [];
         },
         async afterContextSync({ vm, changedRemotePaths, utils }) {
-            if (!changedRemotePaths.some((remotePath) => remotePath === "/root/.aws" || remotePath.startsWith("/root/.aws/"))) return;
+            if (!changedRemotePaths.some((remotePath) => remotePath === "/root/.aws" || remotePath.startsWith("/root/.aws/")))
+                return;
             await utils.checkedExec(vm, "chown -R root:root /root/.aws 2>/dev/null || true; chmod 700 /root/.aws 2>/dev/null || true");
         },
     });
 }
-
-async function exists(filePath: string) {
-    try { await stat(filePath); return true; } catch { return false; }
+async function exists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }