freestyle-sync 0.1.2 → 0.1.4

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

@@ -1,9 +1,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { definePlugin } from "../../../src/plugin-api.ts";
-
+import { definePlugin } from "../../../src/plugin-api.js";
 const execFileAsync = promisify(execFile);
-
 export function nodeNpmPlugin() {
     return definePlugin({
         name: "@freestyle-sync/node-npm",
@@ -370,21 +368,21 @@ cp "$fingerprint_file" "$cache_file"
             if (result.statusCode && result.statusCode !== 0) {
                 throw new Error(result.stderr ?? result.stdout ?? `Node/npm fixup failed with status ${result.statusCode}`);
             }
-            if (result.stdout?.trim()) console.log(result.stdout.trim());
+            if (result.stdout?.trim())
+                console.log(result.stdout.trim());
         },
     });
 }
-
 async function localNpmVersion() {
     try {
         const { stdout } = await execFileAsync("npm", ["--version"]);
         const version = stdout.trim();
         return version.length > 0 ? version : undefined;
-    } catch {
+    }
+    catch {
         return undefined;
     }
 }
-
-function shellQuote(value: string): string {
+function shellQuote(value) {
     return `'${value.replace(/'/g, `'"'"'`)}'`;
 }

package/dist/plugins/npm-native-deps.js

@@ -0,0 +1,307 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export const npmNativeDepsPlugin = {
+    name: "npm-native-deps",
+    async afterProjectSync({ vm, options }) {
+        const nodeVersion = process.versions.node;
+        const npmVersion = await localNpmVersion();
+        const script = `
+set -eu
+cd ${shellQuote(options.remoteProjectDir)}
+if [ ! -f package.json ]; then
+    exit 0
+fi
+desired_node=${shellQuote(nodeVersion)}
+desired_npm=${shellQuote(npmVersion ?? "")}
+nvm_version=v0.40.3
+export NVM_DIR=/root/.nvm
+runtime_cache=.vmpush/node-runtime-cache.json
+
+install_nvm() {
+    if [ -s "$NVM_DIR/nvm.sh" ]; then
+        return 0
+    fi
+    mkdir -p "$NVM_DIR"
+    if command -v git >/dev/null 2>&1; then
+        rm -rf "$NVM_DIR"
+        git clone --depth 1 --branch "$nvm_version" https://github.com/nvm-sh/nvm.git "$NVM_DIR"
+    elif command -v curl >/dev/null 2>&1; then
+        curl -fsSL "https://raw.githubusercontent.com/nvm-sh/nvm/$nvm_version/install.sh" | PROFILE=/dev/null bash
+    elif command -v wget >/dev/null 2>&1; then
+        wget -qO- "https://raw.githubusercontent.com/nvm-sh/nvm/$nvm_version/install.sh" | PROFILE=/dev/null bash
+    else
+        echo "git, curl, or wget is required to install nvm" >&2
+        return 1
+    fi
+}
+
+install_nvm
+. "$NVM_DIR/nvm.sh"
+installed_node=$(nvm version "$desired_node" || true)
+if [ "$installed_node" = "N/A" ]; then
+    echo "Installing Node $desired_node with nvm"
+    nvm install "$desired_node"
+fi
+nvm alias default "$desired_node" >/dev/null
+nvm use --silent "$desired_node"
+actual_node=$(node -p 'process.versions.node')
+if [ "$actual_node" != "$desired_node" ]; then
+    echo "Expected Node $desired_node but activated $actual_node" >&2
+    exit 1
+fi
+actual_npm=$(npm --version 2>/dev/null || true)
+if [ -n "$desired_npm" ] && [ "$actual_npm" != "$desired_npm" ]; then
+    echo "Installing npm $desired_npm for Node $desired_node"
+    npm install -g "npm@$desired_npm"
+    actual_npm=$(npm --version)
+fi
+mkdir -p .vmpush
+printf '{"node":"%s","npm":"%s","nvm":"%s"}\n' "$actual_node" "$actual_npm" "$nvm_version" > "$runtime_cache"
+grep -qxF 'export NVM_DIR=/root/.nvm' /root/.profile || printf '\n%s\n' 'export NVM_DIR=/root/.nvm' >> /root/.profile
+grep -qxF '[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh" && nvm use --silent default >/dev/null 2>&1' /root/.profile || printf '%s\n' '[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh" && nvm use --silent default >/dev/null 2>&1' >> /root/.profile
+
+if [ ! -d node_modules ]; then
+    exit 0
+fi
+package_list=$(mktemp /tmp/vmpush-native-packages.XXXXXX)
+fingerprint_file=$(mktemp /tmp/vmpush-native-fingerprints.XXXXXX)
+scanner_file=$(mktemp /tmp/vmpush-native-scanner.XXXXXX.js)
+cache_file=.vmpush/npm-native-deps-cache.json
+trap 'rm -f "$package_list" "$fingerprint_file" "$scanner_file"' EXIT
+cat > "$scanner_file" <<'NODE'
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const cachePath = path.resolve(process.argv[2]);
+const fingerprintPath = process.argv[3];
+const mode = process.argv[4];
+const nodeModules = path.resolve('node_modules');
+const packages = new Set();
+const packageInfos = [];
+const incompatiblePlatformPackages = new Set();
+const nativeFilesByPackage = new Map();
+const platformPackagesByWrapper = new Map();
+
+function readPackageJson(packageDir) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8'));
+    } catch {
+        return undefined;
+    }
+}
+
+function addPackage(packageDir) {
+    const packageJson = readPackageJson(packageDir);
+    if (typeof packageJson?.name !== 'string' || packageJson.name.length === 0) return;
+    packageInfos.push({ dir: packageDir, json: packageJson, name: packageJson.name });
+}
+
+function listAllowsCurrent(value, current) {
+    if (value === undefined) return true;
+    const list = Array.isArray(value) ? value : [value];
+    const positives = list.filter((item) => typeof item === 'string' && !item.startsWith('!'));
+    const negatives = list.filter((item) => typeof item === 'string' && item.startsWith('!')).map((item) => item.slice(1));
+    if (negatives.includes(current)) return false;
+    return positives.length === 0 || positives.includes(current);
+}
+
+function packageAllowsCurrentPlatform(packageJson) {
+    return listAllowsCurrent(packageJson.os, process.platform) && listAllowsCurrent(packageJson.cpu, process.arch);
+}
+
+function dependencyNames(packageJson) {
+    return Object.keys(Object.assign({}, packageJson.dependencies, packageJson.optionalDependencies));
+}
+
+function addMapSet(map, key, value) {
+    const existing = map.get(key);
+    if (existing) existing.add(value);
+    else map.set(key, new Set([value]));
+}
+
+function relativeToProject(filePath) {
+    return path.relative(process.cwd(), filePath).split(path.sep).join('/');
+}
+
+function collectPackageFiles(packageDir, files) {
+    let entries;
+    try {
+        entries = fs.readdirSync(packageDir, { withFileTypes: true });
+    } catch {
+        return;
+    }
+
+    for (const entry of entries) {
+        const child = path.join(packageDir, entry.name);
+        if (entry.isDirectory()) collectPackageFiles(child, files);
+        else if (entry.isFile()) files.push(child);
+    }
+}
+
+function packageFingerprint(packageName) {
+    const info = packageInfos.find((candidate) => candidate.name === packageName);
+    if (!info) return undefined;
+    const files = [path.join(info.dir, 'package.json')];
+    for (const nativeFile of nativeFilesByPackage.get(packageName) || []) files.push(nativeFile);
+    for (const platformPackageName of platformPackagesByWrapper.get(packageName) || []) {
+        const platformInfo = packageInfos.find((candidate) => candidate.name === platformPackageName);
+        if (!platformInfo) continue;
+        files.push(path.join(platformInfo.dir, 'package.json'));
+        collectPackageFiles(platformInfo.dir, files);
+    }
+
+    const hash = crypto.createHash('sha256');
+    hash.update(process.platform);
+    hash.update('\0');
+    hash.update(process.arch);
+    hash.update('\0');
+    hash.update(process.versions.modules || '');
+    hash.update('\0');
+    for (const filePath of Array.from(new Set(files)).sort()) {
+        try {
+            const stats = fs.statSync(filePath);
+            if (!stats.isFile()) continue;
+            hash.update(relativeToProject(filePath));
+            hash.update('\0');
+            hash.update(String(stats.size));
+            hash.update('\0');
+            hash.update(String(stats.mtimeMs));
+            hash.update('\0');
+            hash.update(String(stats.mode));
+            hash.update('\0');
+        } catch {
+            // Ignore files that disappeared while scanning.
+        }
+    }
+    return hash.digest('hex');
+}
+
+function nearestPackageDir(start) {
+    let current = start;
+    while (current.startsWith(nodeModules)) {
+        if (fs.existsSync(path.join(current, 'package.json'))) return current;
+        const parent = path.dirname(current);
+        if (parent === current) break;
+        current = parent;
+    }
+    return undefined;
+}
+
+function addNativePackage(nativeFile) {
+    const packageDir = nearestPackageDir(path.dirname(nativeFile));
+    if (!packageDir) return;
+    const packageJson = readPackageJson(packageDir);
+    if (typeof packageJson?.name !== 'string' || packageJson.name.length === 0) return;
+    packages.add(packageJson.name);
+    addMapSet(nativeFilesByPackage, packageJson.name, nativeFile);
+}
+
+function walk(directory) {
+    let entries;
+    try {
+        entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch {
+        return;
+    }
+
+    for (const entry of entries) {
+        const child = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name !== 'node_modules' && fs.existsSync(path.join(child, 'package.json'))) addPackage(child);
+            walk(child);
+        } else if (entry.isFile() && entry.name.endsWith('.node')) {
+            addNativePackage(child);
+        }
+    }
+}
+
+function cacheEntryMatches(entry, fingerprint) {
+    if (entry === fingerprint) return true;
+    if (entry && typeof entry === 'object' && (entry.input === fingerprint || entry.fixed === fingerprint)) return true;
+    return false;
+}
+
+walk(nodeModules);
+for (const info of packageInfos) {
+    if ((info.json.os !== undefined || info.json.cpu !== undefined) && !packageAllowsCurrentPlatform(info.json)) {
+        incompatiblePlatformPackages.add(info.name);
+    }
+}
+for (const info of packageInfos) {
+    const platformDependencies = dependencyNames(info.json).filter((dependency) => incompatiblePlatformPackages.has(dependency));
+    if (platformDependencies.length === 0) continue;
+    packages.add(info.name);
+    for (const dependency of platformDependencies) addMapSet(platformPackagesByWrapper, info.name, dependency);
+}
+
+let previous = {};
+try {
+    previous = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+} catch {
+    previous = {};
+}
+const next = Object.assign({}, previous);
+const changedPackages = [];
+for (const packageName of Array.from(packages).sort()) {
+    const fingerprint = packageFingerprint(packageName);
+    if (!fingerprint) continue;
+    const previousEntry = previous[packageName];
+    if (mode !== 'record' && !cacheEntryMatches(previousEntry, fingerprint)) changedPackages.push(packageName);
+    const previousObject = previousEntry && typeof previousEntry === 'object' ? previousEntry : {};
+    next[packageName] = mode === 'record'
+        ? Object.assign({}, previousObject, { fixed: fingerprint })
+        : Object.assign({}, previousObject, { input: fingerprint });
+}
+fs.mkdirSync(path.dirname(fingerprintPath), { recursive: true });
+fs.writeFileSync(fingerprintPath, JSON.stringify(next, null, 2) + '\n');
+if (mode !== 'record') {
+    for (const packageName of changedPackages) console.log(packageName);
+}
+NODE
+node "$scanner_file" "$cache_file" "$fingerprint_file" detect > "$package_list"
+if [ ! -s "$package_list" ]; then
+    mkdir -p .vmpush
+    cp "$fingerprint_file" "$cache_file"
+    exit 0
+fi
+echo "Rebuilding native Node dependencies: $(tr '\n' ' ' < "$package_list")"
+if [ -f pnpm-lock.yaml ] && command -v corepack >/dev/null 2>&1; then
+    corepack enable >/dev/null 2>&1 || true
+    xargs pnpm rebuild < "$package_list"
+elif [ -f yarn.lock ] && command -v corepack >/dev/null 2>&1; then
+    corepack enable >/dev/null 2>&1 || true
+    if yarn rebuild --help >/dev/null 2>&1; then
+        xargs yarn rebuild < "$package_list"
+    else
+        echo "Yarn does not support targeted rebuild here; skipping broad reinstall"
+    fi
+elif command -v npm >/dev/null 2>&1; then
+    xargs npm rebuild < "$package_list"
+fi
+node "$scanner_file" "$cache_file" "$fingerprint_file" record > /dev/null
+mkdir -p .vmpush
+cp "$fingerprint_file" "$cache_file"
+`;
+        const result = await vm.exec({ command: script, timeoutMs: 20 * 60 * 1000 });
+        if (result.statusCode && result.statusCode !== 0) {
+            throw new Error(result.stderr ?? result.stdout ?? `npm native dependency fixup failed with status ${result.statusCode}`);
+        }
+        if (result.stdout?.trim())
+            console.log(result.stdout.trim());
+    },
+};
+async function localNpmVersion() {
+    try {
+        const { stdout } = await execFileAsync("npm", ["--version"]);
+        const version = stdout.trim();
+        return version.length > 0 ? version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}

package/{plugins/shell-history/src/index.ts → dist/plugins/shell-history/src/index.js}

@@ -1,13 +1,12 @@
 import { stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
-import { definePlugin, type ContextCandidate, type PushvmPluginUtils, type RemoteVm } from "../../../src/plugin-api.ts";
-
+import { definePlugin } from "../../../src/plugin-api.js";
 export function shellHistoryPlugin() {
     return definePlugin({
         name: "@freestyle-sync/shell-history",
         async discoverContextCandidates() {
-            const item: ContextCandidate = {
+            const item = {
                 source: path.join(homedir(), ".zsh_history"),
                 remoteRoot: "/root/.zsh_history",
                 label: "zsh history",
@@ -18,7 +17,8 @@ export function shellHistoryPlugin() {
             return await exists(item.source) ? [item] : [];
         },
         async afterContextSync({ vm, changedRemotePaths, utils }) {
-            if (!changedRemotePaths.includes("/root/.zsh_history")) return;
+            if (!changedRemotePaths.includes("/root/.zsh_history"))
+                return;
             await seedRemoteShellHistory(vm, utils.checkedExec);
         },
         async afterSync({ vm, utils }) {
@@ -26,11 +26,7 @@ export function shellHistoryPlugin() {
         },
     });
 }
-
-async function seedRemoteShellHistory(
-    vm: RemoteVm,
-    checkedExec: PushvmPluginUtils["checkedExec"],
-) {
+async function seedRemoteShellHistory(vm, checkedExec) {
     await checkedExec(vm, `
 set -eu
 if [ ! -f /root/.zsh_history ]; then
@@ -58,7 +54,12 @@ chown root:root /root/.zsh_history /root/.bash_history 2>/dev/null || true
 chmod 600 /root/.zsh_history /root/.bash_history 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/vscode/src/index.ts → dist/plugins/vscode/src/index.js}

@@ -1,10 +1,8 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { freestyle } from "freestyle";
-import { definePlugin, type ConnectHookContext, type RemoteVm } from "../../../src/plugin-api.ts";
-
+import { definePlugin } from "../../../src/plugin-api.js";
 const execFileAsync = promisify(execFile);
-
 export function vscodePlugin() {
     return definePlugin({
         name: "@freestyle-sync/vscode",
@@ -15,21 +13,17 @@ export function vscodePlugin() {
         },
         async connect(context) {
             const editorScheme = await detectEditorScheme();
-            if (!editorScheme) return false;
+            if (!editorScheme)
+                return false;
             await openRemoteEditor(context, editorScheme);
             return true;
         },
     });
 }
-
-async function warmVsCodeServerCache(
-    vm: RemoteVm,
-    shellQuote: (value: string) => string,
-    checkedExec: (vm: RemoteVm, command: string, timeoutMs?: number) => Promise<{ stdout?: string | null }>,
-) {
+async function warmVsCodeServerCache(vm, shellQuote, checkedExec) {
     const commit = await localVsCodeCommit();
-    if (!commit) return;
-
+    if (!commit)
+        return;
     const script = `
 set -eu
 commit=${shellQuote(commit)}
@@ -75,22 +69,21 @@ if [ ! -x "$cli_server_dir/bin/code-server" ]; then
 fi
 echo "Cached VS Code Server $commit for linux-$arch"
 `;
-
     const result = await checkedExec(vm, script);
-    if (result.stdout?.trim()) console.log(result.stdout.trim());
+    if (result.stdout?.trim())
+        console.log(result.stdout.trim());
 }
-
 async function localVsCodeCommit() {
     try {
         const { stdout } = await execFileAsync("code", ["--version"]);
         const commit = stdout.split(/\r?\n/)[1]?.trim();
         return /^[0-9a-f]{40}$/i.test(commit ?? "") ? commit : undefined;
-    } catch {
+    }
+    catch {
         return undefined;
     }
 }
-
-async function openRemoteEditor(context: ConnectHookContext, scheme: "vscode" | "cursor") {
+async function openRemoteEditor(context, scheme) {
     const { vmId, options } = context;
     console.log(`Opening ${scheme === "cursor" ? "Cursor" : "VS Code"} Remote SSH window for VM ${vmId}...`);
     const { identity, identityId } = await freestyle.identities.create();
@@ -100,63 +93,68 @@ async function openRemoteEditor(context: ConnectHookContext, scheme: "vscode" |
     const uri = `${scheme}://vscode-remote/ssh-remote+${vmId},${token}@${vmId}.vm-ssh.freestyle.sh${encodeRemotePath(options.remoteProjectDir)}?windowId=_blank`;
     try {
         const preOpenMessages = await context.runBeforeOpenRemoteEditor({ scheme, remoteWorkspaceUri });
-        for (const message of preOpenMessages) console.log(message);
+        for (const message of preOpenMessages)
+            console.log(message);
         await openUri(uri);
-    } catch (error) {
+    }
+    catch (error) {
         await identity.tokens.revoke({ tokenId }).catch(() => undefined);
         await freestyle.identities.delete({ identityId }).catch(() => undefined);
         throw error;
     }
     await context.utils.delay(5000);
     const postOpenMessages = await context.runAfterOpenRemoteEditor({ scheme, remoteWorkspaceUri });
-    for (const message of postOpenMessages) console.log(message);
+    for (const message of postOpenMessages)
+        console.log(message);
     console.log(`Opened ${scheme === "cursor" ? "Cursor" : "VS Code"}. SSH identity ${identityId} remains active for the editor session.`);
 }
-
-async function detectEditorScheme(): Promise<"vscode" | "cursor" | undefined> {
+async function detectEditorScheme() {
     const envText = Object.entries(process.env)
         .filter(([key]) => key.startsWith("VSCODE_") || key.startsWith("CURSOR") || key === "TERM_PROGRAM")
         .map(([key, value]) => `${key}=${value ?? ""}`)
         .join("\n")
         .toLowerCase();
-
-    if (envText.includes("cursor")) return "cursor";
-    if (!envText.includes("term_program=vscode") && !envText.includes("vscode_")) return undefined;
-
+    if (envText.includes("cursor"))
+        return "cursor";
+    if (!envText.includes("term_program=vscode") && !envText.includes("vscode_"))
+        return undefined;
     const parentCommands = await processCommandChain(process.ppid);
-    if (parentCommands.some((command) => command.toLowerCase().includes("cursor"))) return "cursor";
+    if (parentCommands.some((command) => command.toLowerCase().includes("cursor")))
+        return "cursor";
     return "vscode";
 }
-
-async function processCommandChain(startPid: number) {
-    const commands: string[] = [];
+async function processCommandChain(startPid) {
+    const commands = [];
     let pid = startPid;
     for (let depth = 0; depth < 20 && pid > 1; depth += 1) {
         try {
             const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "ppid=", "-o", "comm="]);
             const line = stdout.trim();
-            if (!line) break;
+            if (!line)
+                break;
             const match = line.match(/^(\d+)\s+(.+)$/);
-            if (!match) break;
+            if (!match)
+                break;
             pid = Number(match[1]);
             commands.push(match[2]);
-        } catch {
+        }
+        catch {
             break;
         }
     }
     return commands;
 }
-
-function encodeRemotePath(remoteProjectDir: string) {
+function encodeRemotePath(remoteProjectDir) {
     return remoteProjectDir.split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
-
-async function openUri(uri: string) {
+async function openUri(uri) {
     if (process.platform === "darwin") {
         await execFileAsync("open", [uri]);
-    } else if (process.platform === "win32") {
+    }
+    else if (process.platform === "win32") {
         await execFileAsync("cmd", ["/c", "start", "", uri]);
-    } else {
+    }
+    else {
         await execFileAsync("xdg-open", [uri]);
     }
 }