freestyle-sync 0.1.0

package/plugins/node-npm/src/index.ts

@@ -0,0 +1,390 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { definePlugin } from "../../../src/plugin-api.ts";
+
+const execFileAsync = promisify(execFile);
+
+export function nodeNpmPlugin() {
+    return definePlugin({
+        name: "@freestyle-sync/node-npm",
+        async afterProjectSync({ vm, options }) {
+            const nodeVersion = process.versions.node;
+            const npmVersion = await localNpmVersion();
+            const script = `
+set -e
+export HOME="\${HOME:-/root}"
+set -u
+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=.freestyle-sync/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 .freestyle-sync
+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
+
+node <<'NODE'
+const fs = require('node:fs');
+const path = require('node:path');
+
+const root = process.cwd();
+const rootPackage = readJson(path.join(root, 'package.json'));
+const workspaces = Array.isArray(rootPackage.workspaces)
+    ? rootPackage.workspaces
+    : Array.isArray(rootPackage.workspaces && rootPackage.workspaces.packages)
+        ? rootPackage.workspaces.packages
+        : [];
+
+let repaired = 0;
+for (const packageDir of unique(workspaces.flatMap(expandWorkspacePattern))) {
+    const packageJson = readJson(path.join(packageDir, 'package.json'));
+    if (typeof packageJson.name !== 'string' || packageJson.name.length === 0) continue;
+
+    const linkPath = path.join(root, 'node_modules', ...packageJson.name.split('/'));
+    const target = path.relative(path.dirname(linkPath), packageDir) || '.';
+    fs.mkdirSync(path.dirname(linkPath), { recursive: true });
+
+    try {
+        const stats = fs.lstatSync(linkPath);
+        if (stats.isSymbolicLink()) {
+            const currentTarget = fs.readlinkSync(linkPath);
+            if (currentTarget === target || path.resolve(path.dirname(linkPath), currentTarget) === packageDir) continue;
+            fs.unlinkSync(linkPath);
+        } else {
+            continue;
+        }
+    } catch (error) {
+        if (error.code !== 'ENOENT') continue;
+    }
+
+    fs.symlinkSync(target, linkPath, 'dir');
+    repaired += 1;
+}
+
+if (repaired > 0) console.log('Repaired npm workspace links: ' + repaired);
+
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch {
+        return {};
+    }
+}
+
+function expandWorkspacePattern(pattern) {
+    if (typeof pattern !== 'string' || pattern.length === 0 || pattern.includes('**')) return [];
+    const segments = pattern.split(/[\\/]+/).filter(Boolean);
+    const starIndex = segments.indexOf('*');
+    if (starIndex === -1) return [path.resolve(root, ...segments)];
+    if (segments.indexOf('*', starIndex + 1) !== -1) return [];
+
+    const baseDir = path.resolve(root, ...segments.slice(0, starIndex));
+    const suffix = segments.slice(starIndex + 1);
+    let entries;
+    try {
+        entries = fs.readdirSync(baseDir, { withFileTypes: true });
+    } catch {
+        return [];
+    }
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(baseDir, entry.name, ...suffix));
+}
+
+function unique(values) {
+    return Array.from(new Set(values));
+}
+NODE
+
+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=.freestyle-sync/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(String.fromCharCode(0));
+    hash.update(process.arch);
+    hash.update(String.fromCharCode(0));
+    hash.update(process.versions.modules || '');
+    hash.update(String.fromCharCode(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(String.fromCharCode(0));
+            hash.update(String(stats.size));
+            hash.update(String.fromCharCode(0));
+            hash.update(String(stats.mtimeMs));
+            hash.update(String.fromCharCode(0));
+            hash.update(String(stats.mode));
+            hash.update(String.fromCharCode(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) + String.fromCharCode(10));
+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 .freestyle-sync
+    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 .freestyle-sync
+cp "$fingerprint_file" "$cache_file"
+`;
+            const scriptPath = `/tmp/vmpush-node-npm-${Date.now()}.sh`;
+            await vm.fs.writeTextFile(scriptPath, script);
+            const result = await vm.exec({
+                command: `bash ${shellQuote(scriptPath)}\nexit_code=$?\nrm -f ${shellQuote(scriptPath)}\nexit "$exit_code"`,
+                timeoutMs: 20 * 60 * 1000,
+            });
+            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());
+        },
+    });
+}
+
+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: string): string {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}

package/plugins/shell-history/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@freestyle-sync/shell-history",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  }
+}

package/plugins/shell-history/src/index.ts

@@ -0,0 +1,64 @@
+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";
+
+export function shellHistoryPlugin() {
+    return definePlugin({
+        name: "@freestyle-sync/shell-history",
+        async discoverContextCandidates() {
+            const item: ContextCandidate = {
+                source: path.join(homedir(), ".zsh_history"),
+                remoteRoot: "/root/.zsh_history",
+                label: "zsh history",
+                sensitive: true,
+                preferenceKey: "context:zsh-history",
+                promptLabel: "zsh history",
+            };
+            return await exists(item.source) ? [item] : [];
+        },
+        async afterContextSync({ vm, changedRemotePaths, utils }) {
+            if (!changedRemotePaths.includes("/root/.zsh_history")) return;
+            await seedRemoteShellHistory(vm, utils.checkedExec);
+        },
+        async afterSync({ vm, utils }) {
+            await seedRemoteShellHistory(vm, utils.checkedExec);
+        },
+    });
+}
+
+async function seedRemoteShellHistory(
+    vm: RemoteVm,
+    checkedExec: PushvmPluginUtils["checkedExec"],
+) {
+    await checkedExec(vm, `
+set -eu
+if [ ! -f /root/.zsh_history ]; then
+    exit 0
+fi
+node <<'NODE'
+const fs = require('node:fs');
+
+const zshHistory = '/root/.zsh_history';
+const bashHistory = '/root/.bash_history';
+const newline = String.fromCharCode(10);
+const raw = fs.readFileSync(zshHistory, 'utf8');
+const commands = raw
+    .split(newline)
+    .map((line) => {
+        const extended = line.match(/^: [0-9]+:[0-9]+;(.*)$/);
+        return extended ? extended[1] : line;
+    })
+    .map((line) => line.trimEnd())
+    .filter((line) => line.length > 0);
+
+fs.writeFileSync(bashHistory, commands.join(newline) + (commands.length > 0 ? newline : ''), { mode: 0o600 });
+NODE
+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; }
+}

package/plugins/vscode/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@freestyle-sync/vscode",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  }
+}

package/plugins/vscode/src/index.ts

@@ -0,0 +1,162 @@
+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";
+
+const execFileAsync = promisify(execFile);
+
+export function vscodePlugin() {
+    return definePlugin({
+        name: "@freestyle-sync/vscode",
+        async beforeSnapshot({ vm, utils }) {
+            await warmVsCodeServerCache(vm, utils.shellQuote, utils.checkedExec).catch((error) => {
+                console.warn(`VS Code Server cache warm-up skipped: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        },
+        async connect(context) {
+            const editorScheme = await detectEditorScheme();
+            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 }>,
+) {
+    const commit = await localVsCodeCommit();
+    if (!commit) return;
+
+    const script = `
+set -eu
+commit=${shellQuote(commit)}
+machine=$(uname -m)
+case "$machine" in
+    x86_64|amd64) arch=x64 ;;
+    aarch64|arm64) arch=arm64 ;;
+    armv7l|armv8l) arch=armhf ;;
+    *) echo "unsupported VS Code Server architecture: $machine" >&2; exit 0 ;;
+esac
+bin_dir=/root/.vscode-server/bin/$commit
+cli_server_dir=/root/.vscode-server/cli/servers/Stable-$commit/server
+if { [ -x "$bin_dir/server.sh" ] || [ -x "$bin_dir/bin/code-server" ]; } && [ -x "$cli_server_dir/bin/code-server" ]; then
+    echo "VS Code Server $commit already cached"
+    exit 0
+fi
+tmp=$(mktemp -d /tmp/vmpush-vscode-server.XXXXXX)
+trap 'rm -rf "$tmp"' EXIT
+url=https://update.code.visualstudio.com/commit:$commit/server-linux-$arch/stable
+archive=$tmp/server.tgz
+if command -v curl >/dev/null 2>&1; then
+    curl -fsSL "$url" -o "$archive"
+elif command -v wget >/dev/null 2>&1; then
+    wget -qO "$archive" "$url"
+else
+    echo "curl or wget is required to cache VS Code Server" >&2
+    exit 0
+fi
+tar -xzf "$archive" -C "$tmp"
+extracted=$(find "$tmp" -mindepth 1 -maxdepth 1 -type d | head -n 1)
+if [ -z "$extracted" ]; then
+    echo "VS Code Server archive did not contain a directory" >&2
+    exit 1
+fi
+if ! { [ -x "$bin_dir/server.sh" ] || [ -x "$bin_dir/bin/code-server" ]; }; then
+    mkdir -p "$bin_dir"
+    cp -a "$extracted"/. "$bin_dir"/
+    touch "$bin_dir/0"
+fi
+if [ ! -x "$cli_server_dir/bin/code-server" ]; then
+    mkdir -p "$cli_server_dir"
+    cp -a "$extracted"/. "$cli_server_dir"/
+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());
+}
+
+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 {
+        return undefined;
+    }
+}
+
+async function openRemoteEditor(context: ConnectHookContext, scheme: "vscode" | "cursor") {
+    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();
+    await identity.permissions.vms.grant({ vmId });
+    const { token, tokenId } = await identity.tokens.create();
+    const remoteWorkspaceUri = `vscode-remote://ssh-remote%2B${vmId}%2C${token}@${vmId}.vm-ssh.freestyle.sh${encodeRemotePath(options.remoteProjectDir)}`;
+    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);
+        await openUri(uri);
+    } 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);
+    console.log(`Opened ${scheme === "cursor" ? "Cursor" : "VS Code"}. SSH identity ${identityId} remains active for the editor session.`);
+}
+
+async function detectEditorScheme(): Promise<"vscode" | "cursor" | undefined> {
+    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;
+
+    const parentCommands = await processCommandChain(process.ppid);
+    if (parentCommands.some((command) => command.toLowerCase().includes("cursor"))) return "cursor";
+    return "vscode";
+}
+
+async function processCommandChain(startPid: number) {
+    const commands: string[] = [];
+    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;
+            const match = line.match(/^(\d+)\s+(.+)$/);
+            if (!match) break;
+            pid = Number(match[1]);
+            commands.push(match[2]);
+        } catch {
+            break;
+        }
+    }
+    return commands;
+}
+
+function encodeRemotePath(remoteProjectDir: string) {
+    return remoteProjectDir.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+
+async function openUri(uri: string) {
+    if (process.platform === "darwin") {
+        await execFileAsync("open", [uri]);
+    } else if (process.platform === "win32") {
+        await execFileAsync("cmd", ["/c", "start", "", uri]);
+    } else {
+        await execFileAsync("xdg-open", [uri]);
+    }
+}