freestyle-sync 0.1.2 → 0.1.4

package/{plugins/auth-azure/src/index.ts → dist/plugins/auth-azure/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 azureAuthPlugin() {
     return definePlugin({
         name: "@freestyle-sync/auth-azure",
         async discoverContextCandidates({ options }) {
-            if (!options.includeAuth) return [];
-            const item: ContextCandidate = { source: path.join(homedir(), ".azure"), remoteRoot: "/root/.azure", label: "Azure credentials", sensitive: true, preferenceKey: "context:azure", promptLabel: "Azure credentials" };
+            if (!options.includeAuth)
+                return [];
+            const item = { source: path.join(homedir(), ".azure"), remoteRoot: "/root/.azure", label: "Azure credentials", sensitive: true, preferenceKey: "context:azure", promptLabel: "Azure credentials" };
             return await exists(item.source) ? [item] : [];
         },
         async afterContextSync({ vm, changedRemotePaths, utils }) {
-            if (!changedRemotePaths.some((remotePath) => remotePath === "/root/.azure" || remotePath.startsWith("/root/.azure/"))) return;
+            if (!changedRemotePaths.some((remotePath) => remotePath === "/root/.azure" || remotePath.startsWith("/root/.azure/")))
+                return;
             await utils.checkedExec(vm, "chown -R root:root /root/.azure 2>/dev/null || true; chmod 700 /root/.azure 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;
+    }
 }

package/dist/plugins/auth-context.js

@@ -0,0 +1,213 @@
+import { stat, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export async function discoverContextCandidates(options) {
+    const candidates = [];
+    const home = homedir();
+    if (options.includeAuth) {
+        addCandidate(candidates, path.join(home, ".gitconfig"), "~/.gitconfig", "git config", true, "context:git-config");
+        addCandidate(candidates, path.join(home, ".git-credentials"), "~/.git-credentials", "git credentials", true, "context:git-credentials");
+        addCandidate(candidates, path.join(home, ".netrc"), "~/.netrc", "netrc credentials", true, "context:netrc");
+        addCandidate(candidates, path.join(home, ".ssh"), "~/.ssh", "ssh credentials", true, "context:ssh");
+        addCandidate(candidates, path.join(home, ".config", "git"), "~/.config/git", "git config directory", true, "context:git-config-directory");
+        addCandidate(candidates, path.join(home, ".config", "gh"), "~/.config/gh", "GitHub CLI auth", true, "context:github-cli");
+        addCandidate(candidates, path.join(home, ".npmrc"), "~/.npmrc", "npm auth", true, "context:npm-auth");
+        addCandidate(candidates, path.join(home, ".yarnrc.yml"), "~/.yarnrc.yml", "Yarn auth", true, "context:yarn-auth");
+        addCandidate(candidates, path.join(home, ".docker", "config.json"), "~/.docker/config.json", "Docker auth", true, "context:docker-auth");
+        addCandidate(candidates, path.join(home, ".aws"), "~/.aws", "AWS credentials", true, "context:aws");
+        addCandidate(candidates, path.join(home, ".azure"), "~/.azure", "Azure credentials", true, "context:azure");
+        addCandidate(candidates, path.join(home, ".config", "gcloud"), "~/.config/gcloud", "Google Cloud auth", true, "context:gcloud");
+    }
+    if (options.includeAgentContext) {
+        addCandidate(candidates, path.join(home, ".claude"), "~/.claude", "Claude conversations", true, "context:claude-conversations");
+        addCandidate(candidates, path.join(home, ".claude.json"), "~/.claude.json", "Claude settings", true, "context:claude-settings");
+        addCandidate(candidates, path.join(home, ".codex"), "~/.codex", "Codex conversations", true, "context:codex-conversations");
+        for (const codeRoot of codeUserRoots(home)) {
+            await addCopilotCandidates(candidates, codeRoot, options);
+        }
+    }
+    const existing = [];
+    for (const candidate of candidates) {
+        if (await exists(candidate.source)) {
+            existing.push(candidate);
+        }
+    }
+    return dedupeCandidates(existing);
+}
+export function collectEnvironment(extraKeys) {
+    const allow = new Set(extraKeys);
+    const env = {};
+    const tokenPattern = /(^|_)(TOKEN|SECRET|PASSWORD|PASS|API_KEY|ACCESS_KEY|PRIVATE_KEY|AUTH|CREDENTIALS?)(_|$)/i;
+    const exactNames = new Set([
+        "ANTHROPIC_API_KEY",
+        "CODEX_HOME",
+        "GH_TOKEN",
+        "GITHUB_TOKEN",
+        "GIT_ASKPASS",
+        "NPM_TOKEN",
+        "OPENAI_API_KEY",
+        "FREESTYLE_API_KEY",
+    ]);
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!value)
+            continue;
+        if (!isValidEnvName(key))
+            continue;
+        if (allow.has(key) || exactNames.has(key) || tokenPattern.test(key)) {
+            env[key] = value;
+        }
+    }
+    return env;
+}
+export function shouldSkipContextDirectory(_relativePath, _name) {
+    return false;
+}
+export function isProtectedRemotePath(remotePath) {
+    return remotePath === "/root/.ssh/authorized_keys" || remotePath === "/root/.ssh/authorized_keys2";
+}
+export async function hardenRemoteSecrets(vm, changedRemotePaths) {
+    const commands = ["chown root:root /root && chmod 700 /root"];
+    const touchedRoots = new Set();
+    for (const remotePath of changedRemotePaths) {
+        const secretRoot = remoteSecretRoot(remotePath);
+        if (secretRoot)
+            touchedRoots.add(secretRoot);
+    }
+    for (const secretRoot of touchedRoots) {
+        commands.push(`chown -R root:root ${shellQuote(secretRoot)} 2>/dev/null || true`);
+        commands.push(`chmod 700 ${shellQuote(secretRoot)} 2>/dev/null || true`);
+    }
+    if (touchedRoots.has("/root/.ssh")) {
+        commands.push("find /root/.ssh -type f ! -name authorized_keys ! -name authorized_keys2 -exec chmod 600 {} + 2>/dev/null || true");
+    }
+    for (const filePath of ["/root/.git-credentials", "/root/.netrc", "/root/.npmrc", "/root/.docker/config.json"]) {
+        if (changedRemotePaths.includes(filePath)) {
+            commands.push(`chmod 600 ${shellQuote(filePath)} 2>/dev/null || true`);
+        }
+    }
+    await checkedExec(vm, commands.join("; "));
+}
+function addCandidate(candidates, source, remoteRoot, label, sensitive, preferenceKey = `context:${label}:${remoteRoot}`, promptLabel = label) {
+    candidates.push({ source, remoteRoot: expandRemoteHome(remoteRoot), label, sensitive, preferenceKey, promptLabel });
+}
+async function addCopilotCandidates(candidates, codeUserRoot, options) {
+    if (!(await exists(codeUserRoot)))
+        return;
+    const remoteCodeUserRoot = remoteCodeRoot(codeUserRoot);
+    const globalStorage = path.join(codeUserRoot, "globalStorage", "github.copilot-chat");
+    addCandidate(candidates, globalStorage, `${remoteCodeUserRoot}/globalStorage/github.copilot-chat`, "Copilot global chat state", true, "context:copilot-global", "Copilot global chat state");
+    const workspaceStorage = path.join(codeUserRoot, "workspaceStorage");
+    const workspaceDirs = await listDirectories(workspaceStorage);
+    for (const workspaceDir of workspaceDirs) {
+        const copilotRoot = path.join(workspaceDir, "GitHub.copilot-chat");
+        const isCurrentWorkspace = await isWorkspaceStorageForProject(workspaceDir, options.projectRoot);
+        if (await exists(copilotRoot) && (isCurrentWorkspace || options.includeAllCopilotWorkspaces)) {
+            const workspaceId = path.basename(workspaceDir);
+            const key = isCurrentWorkspace ? "context:copilot-current-workspace" : "context:copilot-all-workspaces";
+            const label = isCurrentWorkspace ? "Copilot current workspace conversations" : "Copilot other workspace conversations";
+            addCandidate(candidates, copilotRoot, `${remoteCodeUserRoot}/workspaceStorage/${workspaceId}/GitHub.copilot-chat`, label, true, key, label);
+        }
+    }
+}
+async function isWorkspaceStorageForProject(workspaceDir, projectRoot) {
+    try {
+        const raw = await readFile(path.join(workspaceDir, "workspace.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        const workspacePath = workspaceJsonPath(parsed.folder ?? parsed.workspace);
+        return workspacePath !== undefined && isSameOrParentPath(workspacePath, projectRoot);
+    }
+    catch {
+        return false;
+    }
+}
+function workspaceJsonPath(uri) {
+    if (!uri)
+        return undefined;
+    try {
+        if (uri.startsWith("file://"))
+            return path.resolve(fileURLToPath(uri));
+        return path.resolve(uri);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSameOrParentPath(workspacePath, projectRoot) {
+    const relative = path.relative(workspacePath, projectRoot);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+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";
+}
+function codeUserRoots(home) {
+    return [
+        path.join(home, "Library", "Application Support", "Code", "User"),
+        path.join(home, "Library", "Application Support", "Code - Insiders", "User"),
+        path.join(home, "Library", "Application Support", "Cursor", "User"),
+        path.join(home, ".config", "Code", "User"),
+        path.join(home, ".config", "Code - Insiders", "User"),
+        path.join(home, ".config", "Cursor", "User"),
+    ];
+}
+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 {
+        return [];
+    }
+}
+function dedupeCandidates(candidates) {
+    const seen = new Set();
+    return candidates.filter((candidate) => {
+        const key = `${candidate.source}\0${candidate.remoteRoot}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function remoteSecretRoot(remotePath) {
+    for (const secretRoot of ["/root/.ssh", "/root/.config/gh", "/root/.config/gcloud", "/root/.aws", "/root/.azure", "/root/.docker", "/root/.vmpush"]) {
+        if (remotePath === secretRoot || remotePath.startsWith(`${secretRoot}/`))
+            return secretRoot;
+    }
+    return undefined;
+}
+function expandRemoteHome(value) {
+    if (value === "~")
+        return "/root";
+    if (value.startsWith("~/"))
+        return `/root/${value.slice(2)}`;
+    return value;
+}
+function isValidEnvName(value) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+async function exists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+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;
+}

package/{plugins/auth-docker/src/index.ts → dist/plugins/auth-docker/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 dockerAuthPlugin() {
     return definePlugin({
         name: "@freestyle-sync/auth-docker",
         async discoverContextCandidates({ options }) {
-            if (!options.includeAuth) return [];
-            const item: ContextCandidate = { source: path.join(homedir(), ".docker", "config.json"), remoteRoot: "/root/.docker/config.json", label: "Docker auth", sensitive: true, preferenceKey: "context:docker-auth", promptLabel: "Docker auth" };
+            if (!options.includeAuth)
+                return [];
+            const item = { source: path.join(homedir(), ".docker", "config.json"), remoteRoot: "/root/.docker/config.json", label: "Docker auth", sensitive: true, preferenceKey: "context:docker-auth", promptLabel: "Docker auth" };
             return await exists(item.source) ? [item] : [];
         },
         async afterContextSync({ vm, changedRemotePaths, utils }) {
-            if (!changedRemotePaths.includes("/root/.docker/config.json")) return;
+            if (!changedRemotePaths.includes("/root/.docker/config.json"))
+                return;
             await utils.checkedExec(vm, "mkdir -p /root/.docker; chown -R root:root /root/.docker 2>/dev/null || true; chmod 700 /root/.docker 2>/dev/null || true; chmod 600 /root/.docker/config.json 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;
+    }
 }

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

@@ -1,18 +1,17 @@
-import { definePlugin } from "../../../src/plugin-api.ts";
-
+import { definePlugin } from "../../../src/plugin-api.js";
 export function envAuthPlugin() {
     return definePlugin({
         name: "@freestyle-sync/auth-env",
         collectEnvironment({ options }) {
-            if (!options.includeAuth) return {};
+            if (!options.includeAuth)
+                return {};
             return collectEnvironment(options.envKeys);
         },
     });
 }
-
-function collectEnvironment(extraKeys: string[]): Record<string, string> {
+function collectEnvironment(extraKeys) {
     const allow = new Set(extraKeys);
-    const env: Record<string, string> = {};
+    const env = {};
     const tokenPattern = /(^|_)(TOKEN|SECRET|PASSWORD|PASS|API_KEY|ACCESS_KEY|PRIVATE_KEY|AUTH|CREDENTIALS?)(_|$)/i;
     const exactNames = new Set([
         "ANTHROPIC_API_KEY",
@@ -24,12 +23,13 @@ function collectEnvironment(extraKeys: string[]): Record<string, string> {
         "OPENAI_API_KEY",
         "FREESTYLE_API_KEY",
     ]);
-
     for (const [key, value] of Object.entries(process.env)) {
-        if (!value) continue;
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
-        if (allow.has(key) || exactNames.has(key) || tokenPattern.test(key)) env[key] = value;
+        if (!value)
+            continue;
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            continue;
+        if (allow.has(key) || exactNames.has(key) || tokenPattern.test(key))
+            env[key] = value;
     }
-
     return env;
 }

package/{plugins/auth-gcloud/src/index.ts → dist/plugins/auth-gcloud/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 gcloudAuthPlugin() {
     return definePlugin({
         name: "@freestyle-sync/auth-gcloud",
         async discoverContextCandidates({ options }) {
-            if (!options.includeAuth) return [];
-            const item: ContextCandidate = { source: path.join(homedir(), ".config", "gcloud"), remoteRoot: "/root/.config/gcloud", label: "Google Cloud auth", sensitive: true, preferenceKey: "context:gcloud", promptLabel: "Google Cloud auth" };
+            if (!options.includeAuth)
+                return [];
+            const item = { source: path.join(homedir(), ".config", "gcloud"), remoteRoot: "/root/.config/gcloud", label: "Google Cloud auth", sensitive: true, preferenceKey: "context:gcloud", promptLabel: "Google Cloud auth" };
             return await exists(item.source) ? [item] : [];
         },
         async afterContextSync({ vm, changedRemotePaths, utils }) {
-            if (!changedRemotePaths.some((remotePath) => remotePath === "/root/.config/gcloud" || remotePath.startsWith("/root/.config/gcloud/"))) return;
+            if (!changedRemotePaths.some((remotePath) => remotePath === "/root/.config/gcloud" || remotePath.startsWith("/root/.config/gcloud/")))
+                return;
             await utils.checkedExec(vm, "chown -R root:root /root/.config/gcloud 2>/dev/null || true; chmod 700 /root/.config/gcloud 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;
+    }
 }

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

@@ -1,13 +1,13 @@
 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 gitAuthPlugin() {
     return definePlugin({
         name: "@freestyle-sync/auth-git",
         async discoverContextCandidates({ options }) {
-            if (!options.includeAuth) return [];
+            if (!options.includeAuth)
+                return [];
             return existing([
                 candidate(path.join(homedir(), ".gitconfig"), "~/.gitconfig", "git config", "context:git-config"),
                 candidate(path.join(homedir(), ".git-credentials"), "~/.git-credentials", "git credentials", "context:git-credentials"),
@@ -17,27 +17,34 @@ export function gitAuthPlugin() {
         },
         async afterContextSync({ vm, changedRemotePaths, utils }) {
             const files = ["/root/.git-credentials", "/root/.netrc"].filter((file) => changedRemotePaths.includes(file));
-            if (files.length > 0) await utils.checkedExec(vm, files.map((file) => `chmod 600 ${utils.shellQuote(file)} 2>/dev/null || true`).join("; "));
+            if (files.length > 0)
+                await utils.checkedExec(vm, files.map((file) => `chmod 600 ${utils.shellQuote(file)} 2>/dev/null || true`).join("; "));
         },
     });
 }
-
-function candidate(source: string, remoteRoot: string, label: string, preferenceKey: string): ContextCandidate {
+function candidate(source, remoteRoot, label, preferenceKey) {
     return { source, remoteRoot: expandRemoteHome(remoteRoot), label, sensitive: true, preferenceKey, promptLabel: label };
 }
-
-async function existing(candidates: ContextCandidate[]) {
-    const result: ContextCandidate[] = [];
-    for (const item of candidates) if (await exists(item.source)) result.push(item);
+async function existing(candidates) {
+    const result = [];
+    for (const item of candidates)
+        if (await exists(item.source))
+            result.push(item);
     return result;
 }
-
-function expandRemoteHome(value: 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;
 }
-
-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;
+    }
 }

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

@@ -1,33 +1,39 @@
 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 githubCliAuthPlugin() {
     return singleAuthDirectoryPlugin("@freestyle-sync/auth-github-cli", path.join(homedir(), ".config", "gh"), "~/.config/gh", "GitHub CLI auth", "context:github-cli");
 }
-
-function singleAuthDirectoryPlugin(name: string, source: string, remoteRoot: string, label: string, preferenceKey: string) {
+function singleAuthDirectoryPlugin(name, source, remoteRoot, label, preferenceKey) {
     return definePlugin({
         name,
         async discoverContextCandidates({ options }) {
-            if (!options.includeAuth) return [];
-            const item: ContextCandidate = { source, remoteRoot: expandRemoteHome(remoteRoot), label, sensitive: true, preferenceKey, promptLabel: label };
+            if (!options.includeAuth)
+                return [];
+            const item = { source, remoteRoot: expandRemoteHome(remoteRoot), label, sensitive: true, preferenceKey, promptLabel: label };
             return await exists(source) ? [item] : [];
         },
         async afterContextSync({ vm, changedRemotePaths, utils }) {
-            if (!changedRemotePaths.some((remotePath) => remotePath === expandRemoteHome(remoteRoot) || remotePath.startsWith(`${expandRemoteHome(remoteRoot)}/`))) return;
+            if (!changedRemotePaths.some((remotePath) => remotePath === expandRemoteHome(remoteRoot) || remotePath.startsWith(`${expandRemoteHome(remoteRoot)}/`)))
+                return;
             await utils.checkedExec(vm, `chown -R root:root ${utils.shellQuote(expandRemoteHome(remoteRoot))} 2>/dev/null || true; chmod 700 ${utils.shellQuote(expandRemoteHome(remoteRoot))} 2>/dev/null || true`);
         },
     });
 }
-
-function expandRemoteHome(value: 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;
 }
-
-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;
+    }
 }

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

@@ -1,32 +1,38 @@
 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 npmAuthPlugin() {
     return definePlugin({
         name: "@freestyle-sync/auth-npm",
         async discoverContextCandidates({ options }) {
-            if (!options.includeAuth) return [];
+            if (!options.includeAuth)
+                return [];
             const item = candidate(path.join(homedir(), ".npmrc"), "~/.npmrc", "npm auth", "context:npm-auth");
             return await exists(item.source) ? [item] : [];
         },
         async afterContextSync({ vm, changedRemotePaths, utils }) {
-            if (changedRemotePaths.includes("/root/.npmrc")) await utils.checkedExec(vm, "chmod 600 /root/.npmrc 2>/dev/null || true");
+            if (changedRemotePaths.includes("/root/.npmrc"))
+                await utils.checkedExec(vm, "chmod 600 /root/.npmrc 2>/dev/null || true");
         },
     });
 }
-
-function candidate(source: string, remoteRoot: string, label: string, preferenceKey: string): ContextCandidate {
+function candidate(source, remoteRoot, label, preferenceKey) {
     return { source, remoteRoot: expandRemoteHome(remoteRoot), label, sensitive: true, preferenceKey, promptLabel: label };
 }
-
-function expandRemoteHome(value: 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;
 }
-
-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;
+    }
 }

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

@@ -1,13 +1,13 @@
 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 sshAuthPlugin() {
     return definePlugin({
         name: "@freestyle-sync/auth-ssh",
         async discoverContextCandidates({ options }) {
-            if (!options.includeAuth) return [];
+            if (!options.includeAuth)
+                return [];
             const item = candidate(path.join(homedir(), ".ssh"), "~/.ssh", "ssh credentials", "context:ssh");
             return await exists(item.source) ? [item] : [];
         },
@@ -15,22 +15,28 @@ export function sshAuthPlugin() {
             return remotePath === "/root/.ssh/authorized_keys" || remotePath === "/root/.ssh/authorized_keys2";
         },
         async afterContextSync({ vm, changedRemotePaths, utils }) {
-            if (!changedRemotePaths.some((remotePath) => remotePath === "/root/.ssh" || remotePath.startsWith("/root/.ssh/"))) return;
+            if (!changedRemotePaths.some((remotePath) => remotePath === "/root/.ssh" || remotePath.startsWith("/root/.ssh/")))
+                return;
             await utils.checkedExec(vm, "chown -R root:root /root/.ssh 2>/dev/null || true; chmod 700 /root/.ssh 2>/dev/null || true; find /root/.ssh -type f ! -name authorized_keys ! -name authorized_keys2 -exec chmod 600 {} + 2>/dev/null || true");
         },
     });
 }
-
-function candidate(source: string, remoteRoot: string, label: string, preferenceKey: string): ContextCandidate {
+function candidate(source, remoteRoot, label, preferenceKey) {
     return { source, remoteRoot: expandRemoteHome(remoteRoot), label, sensitive: true, preferenceKey, promptLabel: label };
 }
-
-function expandRemoteHome(value: 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;
 }
-
-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;
+    }
 }

package/dist/plugins/auth-yarn/src/index.js

@@ -0,0 +1,24 @@
+import { stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { definePlugin } from "../../../src/plugin-api.js";
+export function yarnAuthPlugin() {
+    return definePlugin({
+        name: "@freestyle-sync/auth-yarn",
+        async discoverContextCandidates({ options }) {
+            if (!options.includeAuth)
+                return [];
+            const item = { source: path.join(homedir(), ".yarnrc.yml"), remoteRoot: "/root/.yarnrc.yml", label: "Yarn auth", sensitive: true, preferenceKey: "context:yarn-auth", promptLabel: "Yarn auth" };
+            return await exists(item.source) ? [item] : [];
+        },
+    });
+}
+async function exists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}