freestyle-sync 0.1.4 → 0.1.5

package/dist/plugins/agent-copilot/src/index.js

@@ -1,529 +0,0 @@
-import { cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { definePlugin } from "../../../src/plugin-api.js";
-const execFileAsync = promisify(execFile);
-export function copilotAgentPlugin() {
-    return definePlugin({
-        name: "@freestyle-sync/agent-copilot",
-        async discoverContextCandidates({ options }) {
-            if (!options.includeAgentContext)
-                return [];
-            const candidates = [];
-            for (const codeRoot of codeUserRoots(homedir())) {
-                await addCopilotCandidates(candidates, codeRoot, options.projectRoot, options.includeAllCopilotWorkspaces);
-            }
-            return dedupeCandidates(candidates);
-        },
-        async afterProjectSync({ vm, utils }) {
-            await installAgentCli(vm, utils.checkedExec, "copilot", "@github/copilot");
-        },
-        async afterSync({ vm, vmId, options, contextCandidates, utils }) {
-            const result = await syncLocalCopilotForRemoteWorkspaces(vm, vmId, options.remoteProjectDir, contextCandidates, utils);
-            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}`];
-            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."];
-            return [];
-        },
-    });
-}
-async function installAgentCli(vm, checkedExec, binary, packageName) {
-    await checkedExec(vm, `
-set -e
-export HOME="\${HOME:-/root}"
-export NVM_DIR=/root/.nvm
-if [ -s "$NVM_DIR/nvm.sh" ]; then
-    . "$NVM_DIR/nvm.sh"
-    nvm use --silent default >/dev/null 2>&1 || true
-fi
-binary_path=$(command -v ${binary} || true)
-if [ -z "$binary_path" ] && command -v npm >/dev/null 2>&1; then
-    npm_prefix=$(npm prefix -g 2>/dev/null || true)
-    if [ -n "$npm_prefix" ] && [ -x "$npm_prefix/bin/${binary}" ]; then
-        binary_path="$npm_prefix/bin/${binary}"
-    fi
-fi
-if [ -z "$binary_path" ]; then
-    if ! command -v npm >/dev/null 2>&1; then
-        echo "npm is required to install ${binary}" >&2
-        exit 1
-    fi
-    npm install -g ${packageName}@latest
-    binary_path=$(command -v ${binary} || true)
-    if [ -z "$binary_path" ]; then
-        npm_prefix=$(npm prefix -g 2>/dev/null || true)
-        if [ -n "$npm_prefix" ] && [ -x "$npm_prefix/bin/${binary}" ]; then
-            binary_path="$npm_prefix/bin/${binary}"
-        fi
-    fi
-fi
-if [ -z "$binary_path" ]; then
-    echo "${binary} was not found after installing ${packageName}" >&2
-    exit 1
-fi
-mkdir -p /usr/local/bin
-if [ "$binary_path" != "/usr/local/bin/${binary}" ]; then
-    ln -sf "$binary_path" /usr/local/bin/${binary}
-fi
-test -x /usr/local/bin/${binary}
-`, 600000);
-}
-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) {
-        const copilotRoot = path.join(workspaceDir, "GitHub.copilot-chat");
-        const isCurrentWorkspace = await isWorkspaceStorageForProject(workspaceDir, projectRoot);
-        if (await exists(copilotRoot) && (isCurrentWorkspace || includeAllWorkspaces)) {
-            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, `${remoteUserRoot}/workspaceStorage/${workspaceId}/GitHub.copilot-chat`, label, key);
-        }
-    }
-}
-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 {
-            status: "pending",
-            count: 0,
-            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, vmId, contextCandidates, remoteWorkspaceUri, utils) {
-    const sourceCopilotDir = selectedCurrentCopilotSource(contextCandidates);
-    if (!sourceCopilotDir || !(await exists(sourceCopilotDir)))
-        return { status: "skipped", count: 0 };
-    for (let attempt = 0; attempt < 20; attempt += 1) {
-        const destinations = [];
-        for (const codeRoot of codeUserRoots(homedir())) {
-            const workspaceStorage = path.join(codeRoot, "workspaceStorage");
-            const workspaceDirs = await listDirectories(workspaceStorage);
-            for (const workspaceDir of workspaceDirs) {
-                if (await isWorkspaceStorageForRemoteUri(workspaceDir, remoteWorkspaceUri)) {
-                    destinations.push(path.join(workspaceDir, "GitHub.copilot-chat"));
-                }
-            }
-        }
-        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, vmId, contextCandidates, scheme, remoteWorkspaceUri, utils) {
-    const sourceCopilotDir = selectedCurrentCopilotSource(contextCandidates);
-    if (!sourceCopilotDir || !(await exists(sourceCopilotDir)))
-        return { status: "skipped", count: 0 };
-    const workspaceId = utils.md5(remoteWorkspaceUri);
-    const destinations = [];
-    for (const codeRoot of codeUserRootsForScheme(homedir(), scheme)) {
-        const workspaceDir = path.join(codeRoot, "workspaceStorage", workspaceId);
-        await mkdir(workspaceDir, { recursive: true });
-        await writeFile(path.join(workspaceDir, "workspace.json"), `${JSON.stringify({ folder: remoteWorkspaceUri }, null, 2)}\n`, "utf8");
-        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) {
-    return contextCandidates.find((candidate) => candidate.preferenceKey === "context:copilot-current-workspace")?.source;
-}
-async function findRemoteWorkspaceCopilotDestinations(vmId, remoteProjectDir) {
-    const destinations = [];
-    for (const codeRoot of codeUserRoots(homedir())) {
-        const workspaceStorage = path.join(codeRoot, "workspaceStorage");
-        const workspaceDirs = await listDirectories(workspaceStorage);
-        for (const workspaceDir of workspaceDirs) {
-            if (await isRemoteWorkspaceStorageForVmProject(workspaceDir, vmId, remoteProjectDir)) {
-                destinations.push(path.join(workspaceDir, "GitHub.copilot-chat"));
-            }
-        }
-    }
-    return destinations;
-}
-async function copyCopilotState(sourceCopilotDir, destinations) {
-    for (const destination of destinations) {
-        await rm(destination, { recursive: true, force: true });
-        await mkdir(path.dirname(destination), { recursive: true });
-        await cp(sourceCopilotDir, destination, { recursive: true, force: true });
-        await sanitizeCopilotTranscripts(destination);
-        await copyCoreChatState(sourceCopilotDir, destination);
-    }
-}
-async function copyCoreChatState(sourceCopilotDir, destinationCopilotDir) {
-    const sourceWorkspaceDir = path.dirname(sourceCopilotDir);
-    const destinationWorkspaceDir = path.dirname(destinationCopilotDir);
-    const sessionIds = await copiedCopilotSessionIds(destinationCopilotDir);
-    for (const sessionId of sessionIds) {
-        const sourceChatSession = path.join(sourceWorkspaceDir, "chatSessions", `${sessionId}.jsonl`);
-        if (await exists(sourceChatSession)) {
-            const destinationChatSession = path.join(destinationWorkspaceDir, "chatSessions", `${sessionId}.jsonl`);
-            await mkdir(path.dirname(destinationChatSession), { recursive: true });
-            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);
-            await rm(destinationEditingSession, { recursive: true, force: true });
-            await mkdir(path.dirname(destinationEditingSession), { recursive: true });
-            await cp(sourceEditingSession, destinationEditingSession, { recursive: true, force: true });
-        }
-    }
-}
-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) {
-    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) {
-    const content = await readFile(transcriptPath, "utf8").catch(() => undefined);
-    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]);
-            if (event.type === "assistant.turn_end")
-                lastCompletedLine = index;
-        }
-        catch {
-            break;
-        }
-    }
-    if (lastCompletedLine >= 0 && lastCompletedLine < lines.length - 1) {
-        await writeFile(transcriptPath, `${lines.slice(0, lastCompletedLine + 1).join("\n")}\n`, "utf8");
-    }
-}
-async function copyCopilotWorkspaceStateKeys(sourceCopilotDir, destinations) {
-    const sourceStateDb = path.join(path.dirname(sourceCopilotDir), "state.vscdb");
-    if (!(await exists(sourceStateDb)))
-        return;
-    for (const destination of destinations) {
-        const destinationStateDb = path.join(path.dirname(destination), "state.vscdb");
-        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)}`);
-        });
-        await normalizeCopiedChatIndex(destination).catch((error) => {
-            console.warn(`Copilot sidebar index normalization skipped: ${error instanceof Error ? error.message : String(error)}`);
-        });
-    }
-}
-async function mergeWorkspaceStateKeys(sourceStateDb, destinationStateDb) {
-    await execFileAsync("sqlite3", [
-        destinationStateDb,
-        `PRAGMA busy_timeout=5000;
-ATTACH DATABASE ${sqliteLiteral(sourceStateDb)} AS source_state;
-INSERT OR REPLACE INTO ItemTable(key, value)
-SELECT key, value FROM source_state.ItemTable
-WHERE key IN (
-    'GitHub.copilot-chat',
-    'chat.ChatSessionStore.index',
-    'memento/interactive-session-view-copilot',
-    'workbench.panel.chat',
-    'workbench.panel.chat.numberOfVisibleViews'
-) OR key LIKE 'chat.%';
-DETACH DATABASE source_state;`,
-    ]);
-}
-async function normalizeCopiedChatIndex(copilotDir) {
-    const stateDb = path.join(path.dirname(copilotDir), "state.vscdb");
-    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);
-    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);
-        if (!lastCompletedTimestamp) {
-            delete index.entries[sessionId];
-            continue;
-        }
-        const entry = index.entries[sessionId];
-        entry.lastResponseState = 1;
-        entry.hasPendingEdits = false;
-        entry.lastMessageDate = lastCompletedTimestamp;
-        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) {
-    const content = await readFile(transcriptPath, "utf8").catch(() => 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]);
-            if (event.type === "assistant.turn_end" && event.timestamp)
-                return Date.parse(event.timestamp);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    return undefined;
-}
-async function copyCopilotStateToRemoteServer(vm, vmId, sourceCopilotDir, localDestinations, utils) {
-    const workspaceIds = localDestinations.map((destination) => path.basename(path.dirname(destination)));
-    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");
-        const baseDir = "/root/.vscode-server/data/User/workspaceStorage";
-        const commands = [`mkdir -p ${utils.shellQuote(baseDir)}`];
-        for (const workspaceId of workspaceIds) {
-            commands.push(`mkdir -p ${utils.shellQuote(`${baseDir}/${workspaceId}`)} && rm -rf ${utils.shellQuote(`${baseDir}/${workspaceId}/GitHub.copilot-chat`)}`);
-        }
-        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 {
-        await rm(path.dirname(archive), { recursive: true, force: true });
-    }
-}
-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);
-        await mkdir(workspaceDir, { recursive: true });
-        await cp(sourceCopilotDir, path.join(workspaceDir, "GitHub.copilot-chat"), { recursive: true, force: true });
-        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 });
-    }
-    await utils.createTar(["--no-xattrs", "-czf", archivePath, "-C", stagingDir, "."]);
-    return archivePath;
-}
-async function isRemoteWorkspaceStorageForVmProject(workspaceDir, vmId, remoteProjectDir) {
-    try {
-        const raw = await readFile(path.join(workspaceDir, "workspace.json"), "utf8");
-        const parsed = JSON.parse(raw);
-        const workspaceUri = parsed.folder ?? parsed.workspace;
-        if (!workspaceUri?.startsWith("vscode-remote://"))
-            return false;
-        const decodedUri = decodeURIComponent(workspaceUri);
-        return decodedUri.includes(vmId) && remoteWorkspacePath(decodedUri) === remoteProjectDir;
-    }
-    catch {
-        return false;
-    }
-}
-async function isWorkspaceStorageForRemoteUri(workspaceDir, remoteWorkspaceUri) {
-    try {
-        const raw = await readFile(path.join(workspaceDir, "workspace.json"), "utf8");
-        const parsed = JSON.parse(raw);
-        const workspaceUri = parsed.folder ?? parsed.workspace;
-        return workspaceUri === remoteWorkspaceUri;
-    }
-    catch {
-        return false;
-    }
-}
-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 remoteWorkspacePath(decodedRemoteUri) {
-    const hostEnd = decodedRemoteUri.indexOf("/", "vscode-remote://".length);
-    if (hostEnd === -1)
-        return "/";
-    return normalizeRemotePath(decodedRemoteUri.slice(hostEnd));
-}
-function normalizeRemotePath(value) {
-    const normalized = path.posix.normalize(value.replace(/\\/g, "/"));
-    if (!normalized.startsWith("/"))
-        return "/";
-    return normalized;
-}
-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, 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 [];
-    }
-}
-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"),
-        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"),
-    ];
-}
-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) {
-    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 [];
-    }
-}
-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);
-        }
-    }
-    await visit(directory);
-    return result;
-}
-function addCandidate(candidates, source, remoteRoot, label, preferenceKey) {
-    candidates.push({ source, remoteRoot: expandRemoteHome(remoteRoot), label, sensitive: true, preferenceKey, promptLabel: label });
-}
-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 expandRemoteHome(value) {
-    if (value === "~")
-        return "/root";
-    if (value.startsWith("~/"))
-        return `/root/${value.slice(2)}`;
-    return value;
-}
-function sqliteLiteral(value) {
-    return `'${value.replace(/'/g, "''")}'`;
-}
-async function exists(filePath) {
-    try {
-        await stat(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

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

@@ -1,29 +0,0 @@
-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 awsAuthPlugin() {
-    return definePlugin({
-        name: "@freestyle-sync/auth-aws",
-        async discoverContextCandidates({ options }) {
-            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;
-            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) {
-    try {
-        await stat(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

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

@@ -1,29 +0,0 @@
-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 azureAuthPlugin() {
-    return definePlugin({
-        name: "@freestyle-sync/auth-azure",
-        async discoverContextCandidates({ options }) {
-            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;
-            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) {
-    try {
-        await stat(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}