agent-dev-env 0.1.0

package/dist/settings/ubuntu-copy.js

@@ -0,0 +1,223 @@
+// settings/ubuntu-copy.ts — the IO half of the Ubuntu user-settings
+// copy: stage the host settings into the guest's layout, tar them
+// locally (--no-xattrs, AppleDouble stripped), move the archive over
+// SFTP and unpack with ssh exec (the legacy scp + settings_ssh flow, now
+// ssh2). The marker-gated `ensure` flow and the on-demand `sync` flow
+// mirror settings/macos-copy.ts — only the transport differs.
+//
+// The guest-side unpack needs the user's password for `sudo -S` (the
+// image up to this release shipped root-owned ~/.local); callers hold
+// the credentials and pass the password through.
+import { cpSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { run } from '../lib/exec.js';
+import { logger } from '../lib/logger.js';
+import { confirm } from '../lib/prompt.js';
+import { sanitizeGitconfig } from './common.js';
+import { collectSettingsFiles, guestSettingsCheckScript, guestSettingsMarkerScript, guestUnpackScript, GUEST_HOME, mapGuestPath, openchamberRestartCommand, SETTINGS_VERSION, } from './ubuntu.js';
+/** True when the guest already has settings of the current version
+ *  (numeric marker compare, like the shell's `-ge`).
+ *
+ * @param session - The connected guest session.
+ * @returns True when the marker is current.
+ */
+async function guestSettingsUpToDate(session) {
+    const res = await session.exec(`sh -s ${SETTINGS_VERSION}`, {
+        input: guestSettingsCheckScript(),
+    });
+    return res.code === 0;
+}
+/** @internal — copies one host file into the staged guest tree.
+ *
+ * @param home - The host home directory.
+ * @param tree - The staging tree root.
+ * @param file - The path relative to home (host layout).
+ * @returns True when staged.
+ */
+function stageFile(home, tree, file) {
+    const target = join(tree, mapGuestPath(file));
+    try {
+        mkdirSync(dirname(target), { recursive: true });
+        cpSync(join(home, file), target, { recursive: true, preserveTimestamps: true });
+        return true;
+    }
+    catch {
+        logger.warn(`could not stage ${file} — continuing.`);
+        return false;
+    }
+}
+/** @internal — sanitizes the host .gitconfig into the tree (host home →
+ *  guest home, mode preserved); falls back to shipping it as-is.
+ *
+ * @param home - The host home directory.
+ * @param tree - The staging tree root.
+ * @returns True when staged.
+ */
+function stageGitconfig(home, tree) {
+    const source = join(home, '.gitconfig');
+    const target = join(tree, '.gitconfig');
+    try {
+        const sanitized = sanitizeGitconfig(readFileSync(source, 'utf8'), home, GUEST_HOME);
+        const { mode } = statSync(source);
+        writeFileSync(target, sanitized, { mode: mode & 0o777 });
+        return true;
+    }
+    catch {
+        logger.warn('could not sanitize .gitconfig — shipping it as-is.');
+        return stageFile(home, tree, '.gitconfig');
+    }
+}
+/** @internal — removes AppleDouble companions and .DS_Store from the
+ *  staged tree (legacy junk Linux does not need; packed, they made some
+ *  guests' tar abort). */
+function stripAppleDouble(dir) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            stripAppleDouble(full);
+            continue;
+        }
+        if (entry.name.startsWith('._') || entry.name === '.DS_Store') {
+            rmSync(full, { force: true });
+        }
+    }
+}
+/** Copies the settings into the guest: staged tree → tar.gz → sftp →
+ *  unpack + cleanup, then the version marker (the legacy dance, with the
+ *  password piped into sudo -S for the root-owned ~/.local fix).
+ *
+ * @param session - The connected guest session.
+ * @param files - The settings paths (relative to the host home).
+ * @param home - The host home directory.
+ * @param password - The guest user's password (sudo -S).
+ * @throws Error when the pack, upload, unpack or marker write fails.
+ */
+async function copySettingsToGuest(session, files, home, password) {
+    const staging = mkdtempSync(join(tmpdir(), 'agent-dev-env-settings.'));
+    try {
+        const tree = join(staging, 'tree');
+        mkdirSync(tree, { recursive: true });
+        let copied = 0;
+        for (const file of files) {
+            if (file === '.gitconfig') {
+                continue;
+            }
+            if (stageFile(home, tree, file)) {
+                copied += 1;
+            }
+        }
+        if (files.includes('.gitconfig') && stageGitconfig(home, tree)) {
+            copied += 1;
+        }
+        if (copied === 0) {
+            throw new Error('nothing was staged — no settings to copy.');
+        }
+        stripAppleDouble(tree);
+        const archive = join(staging, 'settings.tar.gz');
+        const pack = await run('tar', ['--no-xattrs', '-czf', archive, '-C', tree, '.']);
+        if (pack.code !== 0) {
+            throw new Error('could not pack the staged settings.');
+        }
+        await session.sftpWrite('/tmp/agent-sandbox-settings.tar.gz', readFileSync(archive));
+        const unpack = await session.exec(guestUnpackScript(password));
+        if (unpack.code !== 0) {
+            throw new Error(`could not unpack the settings in the guest:\n${unpack.stderr.trim()}`);
+        }
+        const marker = await session.exec(`sh -s ${SETTINGS_VERSION}`, {
+            input: guestSettingsMarkerScript(),
+        });
+        if (marker.code !== 0) {
+            throw new Error('settings were copied, but the version marker could not be written — ' +
+                'they will be offered again on the next run.');
+        }
+    }
+    finally {
+        rmSync(staging, { recursive: true, force: true });
+    }
+}
+/** Restarts OpenChamber so a fresh settings copy takes effect (the
+ *  systemd user service; non-fatal — warns on failure like the shell).
+ *
+ * @param session - The connected guest session.
+ * @returns True when restarted.
+ */
+export async function restartOpenchamber(session) {
+    const res = await session.exec(openchamberRestartCommand());
+    if (res.code !== 0) {
+        logger.warn('could not restart OpenChamber — it will pick up the new settings on its next start.');
+        return false;
+    }
+    logger.ok('Restarted OpenChamber so it picks up the new user settings.');
+    return true;
+}
+/** Prints the file list and asks the standard confirmation.
+ *
+ * @param home - The host home directory (display paths).
+ * @param files - The settings paths.
+ * @param yes - Skip the confirmation.
+ * @returns True when the user confirmed.
+ */
+async function confirmSettingsCopy(home, files, yes) {
+    logger.info("Found on the host — will copy into the guest's home directory:");
+    for (const file of files) {
+        logger.info(`  ${join(home, file)}`);
+    }
+    if (yes) {
+        return true;
+    }
+    return confirm('Copy these user settings into the guest?', { default: 'y' });
+}
+/** The run step: marker-gated copy (offered once per settings version).
+ *
+ * @param session - The connected guest session.
+ * @param home - The host home directory.
+ * @param yes - Skip confirmations.
+ * @param password - The guest user's password (sudo -S).
+ * @returns The step outcome (see SettingsState).
+ */
+export async function ensureUserSettings(session, home = homedir(), yes = false, password = '') {
+    if (await guestSettingsUpToDate(session)) {
+        logger.ok(`User settings are already in the guest (version ${SETTINGS_VERSION}) — skipping.`);
+        return 'uptodate';
+    }
+    const files = collectSettingsFiles(home);
+    if (files.length === 0) {
+        logger.info('No user settings found on the host (opencode config and auth, ' +
+            'OpenCodeReview config, Copilot config, VS Code config and extensions, ' +
+            '~/.ssh, ~/.gitconfig) — nothing to copy.');
+        return 'none';
+    }
+    if (!(await confirmSettingsCopy(home, files, yes))) {
+        logger.info('Skipped — re-run `agent-dev-env run` to copy them later.');
+        return 'declined';
+    }
+    await copySettingsToGuest(session, files, home, password);
+    logger.ok(`Copied ${files.length} item(s) into the guest.`);
+    return 'copied';
+}
+/** The `sync` flow: always copies (no marker gate) + restarts OpenChamber.
+ *
+ * @param session - The connected guest session.
+ * @param home - The host home directory.
+ * @param yes - Skip confirmations.
+ * @param password - The guest user's password (sudo -S).
+ * @returns The outcome (copied | none | declined | failed).
+ */
+export async function syncUserSettings(session, home = homedir(), yes = false, password = '') {
+    const files = collectSettingsFiles(home);
+    if (files.length === 0) {
+        logger.info('No user settings found on the host (opencode config and auth, ' +
+            'OpenCodeReview config, Copilot config, VS Code config and extensions, ' +
+            '~/.ssh, ~/.gitconfig) — nothing to copy.');
+        return 'none';
+    }
+    if (!(await confirmSettingsCopy(home, files, yes))) {
+        logger.info('Skipped — re-run `agent-dev-env sync` to copy them later.');
+        return 'declined';
+    }
+    await copySettingsToGuest(session, files, home, password);
+    logger.ok(`Copied ${files.length} item(s) into the guest (version ${SETTINGS_VERSION}).`);
+    await restartOpenchamber(session);
+    return 'copied';
+}

package/dist/settings/ubuntu.js

@@ -0,0 +1,68 @@
+// settings/ubuntu.ts — the Ubuntu user-settings copy: the pure builders
+// (version, guest home, host→guest path mapping) — port of
+// scripts/lib/ubuntu-vmware/settings.sh, with the marker moved to the
+// green-field `~/.config/agent-dev-env/` path (AGENTS.md conventions).
+//
+// The IO half (stage tree → tar.gz → sftp → unpack over ssh2) lives in
+// ubuntu-copy.ts; this module stays free of process spawning so the
+// mapping is unit-testable. The candidate file set, the marker scripts
+// and the .gitconfig sanitization are shared with macOS (common.ts) —
+// the two backends differ in version, guest home and transport only.
+export { collectSettingsFiles, guestSettingsCheckScript, guestSettingsMarkerScript, } from './common.js';
+/** Version of the settings copy. Bump when the file set or the copy logic
+ *  changes: guests whose marker is older are offered the copy again. */
+export const SETTINGS_VERSION = 3;
+/** The sandbox user in the Ubuntu base image — fixed, so host home paths
+ *  are rewritten to it when the settings are copied (see sanitize). */
+export const GUEST_HOME = '/home/admin';
+/** Maps a host (macOS) settings path to the guest (Linux) layout. Two
+ *  paths move on Linux:
+ *  - the VS Code user config (macOS `Library/Application Support/Code/
+ *    User/`) lands in `~/.config/Code/User/`,
+ *  - the mcp-compress-router settings (also under Library/Application
+ *    Support/) land in `~/.local/share/mcp-compress-router/` — its Linux
+ *    XDG *data* dir, the only place it reads mcp.json/.jsonc from.
+ *  Everything else keeps the same relative path.
+ *
+ * @param hostPath - The path relative to the host $HOME.
+ * @returns The path relative to the guest home.
+ */
+export function mapGuestPath(hostPath) {
+    const codeUser = 'Library/Application Support/Code/User/';
+    if (hostPath.startsWith(codeUser)) {
+        return `.config/Code/User/${hostPath.slice(codeUser.length)}`;
+    }
+    if (hostPath.startsWith('Library/Application Support/mcp-compress-router')) {
+        return '.local/share/mcp-compress-router';
+    }
+    return hostPath;
+}
+/** The guest-side settings unpack + cleanup — `sh -c` over ssh exec.
+ *  Runs with the user's password piped into `sudo -S` (legacy flow: the
+ *  image up to this release shipped root-owned ~/.local).
+ *
+ * @param password - The guest user's password (sudo -S input).
+ * @returns The script text.
+ */
+export function guestUnpackScript(password) {
+    return [
+        'printf "%s\\n" "' +
+            password +
+            '" | sudo -S chown -R "$USER:$USER" "$HOME/.local" 2>/dev/null || true',
+        'tar -C "$HOME" -xzf /tmp/agent-sandbox-settings.tar.gz || exit 1',
+        'rm -rf "$HOME/.config/mcp-compress-router" 2>/dev/null || true',
+        'find "$HOME/.local" "$HOME/.config" "$HOME/.copilot" "$HOME/.opencodereview" "$HOME/.ssh" ' +
+            '-name "._*" -delete 2>/dev/null || true',
+        'chmod 700 "$HOME/.ssh" 2>/dev/null || true',
+        'rm -f /tmp/agent-sandbox-settings.tar.gz',
+        '',
+    ].join('\n');
+}
+/** The guest-side OpenChamber restart (the systemd user service; the
+ *  login-shell PATH comes from /etc/profile.d at boot).
+ *
+ * @returns The script text.
+ */
+export function openchamberRestartCommand() {
+    return 'export XDG_RUNTIME_DIR="/run/user/$(id -u)"; systemctl --user restart agent-sandbox-openchamber';
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "agent-dev-env",
+  "version": "0.1.0",
+  "description": "Sandbox VM runner and image lifecycle CLI for developer agent sandboxes (macOS, Windows, Ubuntu image recipes).",
+  "license": "MIT",
+  "author": "Andrey Meshkov <am@adguard.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ameshkov/agent-sandbox.git"
+  },
+  "homepage": "https://github.com/ameshkov/agent-sandbox#readme",
+  "bugs": {
+    "url": "https://github.com/ameshkov/agent-sandbox/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "agent-dev-env": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=26"
+  },
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "keywords": [
+    "sandbox",
+    "vm",
+    "virtual-machine",
+    "tart",
+    "vmware",
+    "qemu",
+    "packer",
+    "developer-environment",
+    "cli"
+  ],
+  "dependencies": {
+    "commander": "15.0.0",
+    "ssh2": "1.17.0"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.app.json --noEmit && tsc -p tsconfig.test.json"
+  }
+}