aicomputer 0.1.16 → 0.1.18

package/README.md

@@ -8,6 +8,9 @@ Agent Computer CLI for creating, opening, and managing computers from the termin
 npm install -g aicomputer
 ```
 
+On macOS and Linux, the npm install and update flow also installs the CLI-managed
+Mutagen binary used by `computer mount`.
+
 Upgrade the installed CLI later with:
 
 ```bash
@@ -95,6 +98,7 @@ computer ssh
 computer ssh my-box
 computer ssh --setup
 computer mount
+computer mount --background
 computer mount status
 computer agent agents my-box
 computer agent sessions list my-box
@@ -117,11 +121,20 @@ ssh agentcomputer.ai
 ssh my-box@agentcomputer.ai
 ```
 
-Run `computer mount` to start a foreground controller that mirrors all SSH-ready
-machine homes under `~/agentcomputer/<handle>` while the command is running.
-This uses the same SSH setup as `computer ssh --setup` and requires Mutagen plus
-OpenSSH client tools (`ssh` and `scp`) to already be installed locally. The
-temporary `~/agentcomputer` root is removed when the command exits.
+Run `computer mount` to start the mount controller in the foreground and mirror
+all SSH-ready machine homes under `~/agentcomputer/<handle>`.
+On macOS, the foreground command also opens Finder to `~/agentcomputer` after
+the controller starts.
+
+Run `computer mount --background` to start the same controller detached from
+your terminal. It prints the controller PID immediately so you can inspect it
+later with `computer mount status`.
+
+This uses the same SSH setup as `computer ssh --setup`. For npm installs on
+macOS and Linux, the CLI auto-installs its bundled Mutagen copy and will retry
+that install on first mount if npm scripts were skipped. You still need the
+OpenSSH client tools (`ssh` and `scp`) available locally. The temporary
+`~/agentcomputer` root is removed when the command exits.
 
 Use `computer agent` to inspect agents on one machine and manage remote sessions. Use `computer acp serve` when you want to expose one remote session through a local ACP bridge.
 

package/dist/{chunk-5IEWKH52.js → chunk-3ZUTAUUD.js}

@@ -1,7 +1,13 @@
 import {
-  MOUNT_SERVICE_LABEL,
-  ensureHandleDirectories,
-  ensureMountDirectories,
+  createHandleSession,
+  ensureMutagenSshEnvironment,
+  getHandleSessionName,
+  isAbortError,
+  listOwnedSessions,
+  selectPreferredSession,
+  terminateSession
+} from "./chunk-F2U4SFJ4.js";
+import {
   readMountStatusSnapshot,
   removeMountHandleState,
   writeMountHandleMeta,
@@ -10,7 +16,7 @@ import {
 
 // src/lib/mount-reconcile.ts
 import { readdir, mkdir, rm } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 
 // src/lib/config.ts
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
@@ -145,8 +151,8 @@ async function readErrorMessage(response) {
 }
 
 // src/lib/computers.ts
-async function listComputers() {
-  const response = await api("/v1/computers");
+async function listComputers(signal) {
+  const response = await api("/v1/computers", { signal });
   return response.computers;
 }
 async function getComputerByID(id) {
@@ -166,8 +172,10 @@ async function deleteComputer(computerID) {
 async function getFilesystemSettings() {
   return api("/v1/me/filesystem");
 }
-async function getConnectionInfo(computerID) {
-  return api(`/v1/computers/${computerID}/connection`);
+async function getConnectionInfo(computerID, signal) {
+  return api(`/v1/computers/${computerID}/connection`, {
+    signal
+  });
 }
 async function createBrowserAccess(computerID) {
   return api(`/v1/computers/${computerID}/access/browser`, {
@@ -301,255 +309,6 @@ function describeSSHChoice(computer) {
   return `${computer.runtime_family}  ${timeAgo(computer.updated_at)}`;
 }
 
-// src/lib/mount-mutagen.ts
-import { chmodSync, readFileSync as readFileSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { spawnSync } from "child_process";
-import { basename, join as join2, relative, resolve } from "path";
-var SYNC_NAME_PREFIX = "agentcomputer-mount-";
-var DEFAULT_IGNORE_PATHS = [
-  ".codex/tmp",
-  ".local",
-  ".ssh/sshd.log"
-];
-function ensureMutagenSshEnvironment(config, paths) {
-  ensureMountDirectories(paths);
-  const sshPath = resolveCommandPath("ssh");
-  const scpPath = resolveCommandPath("scp");
-  writeExecutableLink(paths.sshToolsDir, "ssh", sshPath);
-  writeExecutableLink(paths.sshToolsDir, "scp", scpPath);
-  writeExecutableLink(paths.sshToolsDir, basename(sshPath), sshPath);
-  writeExecutableLink(paths.sshToolsDir, basename(scpPath), scpPath);
-}
-function getHandleSessionName(handle) {
-  return `${SYNC_NAME_PREFIX}${handle}`;
-}
-function createHandleSession(handle, config, paths) {
-  ensureHandleDirectories(handle, config.rootPath);
-  const sessionName = getHandleSessionName(handle);
-  const args = [
-    "sync",
-    "create",
-    join2(paths.rootPath, handle),
-    `${handle}@${config.alias}:/home/node`,
-    "--name",
-    sessionName,
-    "--label",
-    `${MOUNT_SERVICE_LABEL}=true`,
-    "--label",
-    `${MOUNT_SERVICE_LABEL}.handle=${handle}`,
-    "--symlink-mode",
-    "posix-raw"
-  ];
-  for (const ignorePath of DEFAULT_IGNORE_PATHS) {
-    args.push("--ignore", ignorePath);
-  }
-  runMutagen(args, config, paths, handle);
-  runMutagen(["sync", "flush", sessionName, "--skip-wait"], config, paths, handle);
-}
-function terminateSession(session, config, paths) {
-  runMutagen(
-    ["sync", "terminate", session.identifier],
-    config,
-    paths,
-    session.handle,
-    true
-  );
-}
-function listOwnedSessions(config, paths) {
-  const result = runMutagen(["sync", "list", "-l"], config, paths, "mount", true);
-  const raw = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
-  if (!raw) {
-    return [];
-  }
-  if (!result.ok && raw.includes("No synchronization sessions found")) {
-    return [];
-  }
-  const rootPath = resolve(paths.rootPath);
-  const sessions = parseMutagenSyncList(raw).filter((session) => session.alphaPath).map((session) => {
-    const alphaPath = resolve(session.alphaPath);
-    const handle = basename(alphaPath);
-    const expectedName = getHandleSessionName(handle);
-    const expectedBeta = `${handle}@${config.alias}:/home/node`;
-    const owned = alphaPath === rootPath || relative(rootPath, alphaPath) === "" || !relative(rootPath, alphaPath).startsWith("..") && !relative(rootPath, alphaPath).startsWith("../");
-    if (!owned || !session.identifier) {
-      return null;
-    }
-    return {
-      identifier: session.identifier,
-      name: session.name,
-      handle,
-      alphaPath,
-      betaUrl: session.betaUrl,
-      alphaConnected: session.alphaConnected,
-      betaConnected: session.betaConnected,
-      status: session.status,
-      lastError: session.lastError,
-      scanProblemCount: session.scanProblemCount,
-      conflictCount: session.conflictCount,
-      legacy: session.name !== expectedName || session.betaUrl !== expectedBeta || alphaPath !== resolve(join2(rootPath, handle))
-    };
-  }).filter((session) => session !== null);
-  return sessions.sort((left, right) => left.handle.localeCompare(right.handle));
-}
-function selectPreferredSession(handle, sessions) {
-  const expectedName = getHandleSessionName(handle);
-  const exact = sessions.find((session) => session.name === expectedName);
-  return exact ?? sessions[0];
-}
-function parseMutagenSyncList(output) {
-  const sessions = [];
-  let current = null;
-  let section = "";
-  const finishCurrent = () => {
-    if (current?.identifier) {
-      sessions.push(current);
-    }
-    current = null;
-    section = "";
-  };
-  for (const line of output.split(/\r?\n/)) {
-    if (/^-{20,}$/.test(line.trim())) {
-      finishCurrent();
-      continue;
-    }
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    if (!current) {
-      current = {
-        alphaConnected: false,
-        betaConnected: false,
-        scanProblemCount: 0,
-        conflictCount: 0
-      };
-    }
-    if (trimmed.endsWith(":")) {
-      switch (trimmed.slice(0, -1)) {
-        case "Alpha":
-        case "Beta":
-        case "Scan problems":
-        case "Conflicts":
-          section = trimmed.slice(0, -1);
-          continue;
-        default:
-          continue;
-      }
-    }
-    if (trimmed.startsWith("Name: ")) {
-      current.name = trimmed.slice("Name: ".length);
-      continue;
-    }
-    if (trimmed.startsWith("Identifier: ")) {
-      current.identifier = trimmed.slice("Identifier: ".length);
-      continue;
-    }
-    if (trimmed.startsWith("Status: ")) {
-      current.status = trimmed.slice("Status: ".length);
-      continue;
-    }
-    if (trimmed.startsWith("Last error: ")) {
-      current.lastError = trimmed.slice("Last error: ".length);
-      continue;
-    }
-    if (section === "Alpha") {
-      if (trimmed.startsWith("URL: ")) {
-        current.alphaPath = trimmed.slice("URL: ".length);
-        continue;
-      }
-      if (trimmed.startsWith("Connected: ")) {
-        current.alphaConnected = parseConnected(trimmed);
-        continue;
-      }
-    }
-    if (section === "Beta") {
-      if (trimmed.startsWith("URL: ")) {
-        current.betaUrl = trimmed.slice("URL: ".length);
-        continue;
-      }
-      if (trimmed.startsWith("Connected: ")) {
-        current.betaConnected = parseConnected(trimmed);
-        continue;
-      }
-    }
-    if (section === "Scan problems") {
-      current.scanProblemCount += 1;
-      continue;
-    }
-    if (section === "Conflicts") {
-      if (trimmed.startsWith("(alpha)")) {
-        current.conflictCount += 1;
-      }
-      continue;
-    }
-  }
-  finishCurrent();
-  return sessions;
-}
-function parseConnected(line) {
-  return line.slice("Connected: ".length).trim().toLowerCase() === "yes";
-}
-function runMutagen(args, config, paths, handle, ignoreFailure = false) {
-  const result = spawnSync("mutagen", args, {
-    encoding: "utf8",
-    env: {
-      ...process.env,
-      MUTAGEN_SSH_PATH: paths.sshToolsDir,
-      MUTAGEN_SSH_CONNECT_TIMEOUT: String(config.connectTimeoutSeconds)
-    }
-  });
-  const stdout = result.stdout?.trim() ?? "";
-  const stderr = result.stderr?.trim() ?? "";
-  if (result.status !== 0 && !ignoreFailure) {
-    throw new Error(stderr || stdout || `mutagen failed for ${handle}`);
-  }
-  return {
-    ok: result.status === 0,
-    stdout,
-    stderr,
-    status: result.status
-  };
-}
-function resolveCommandPath(command) {
-  const result = spawnSync("which", [command], { encoding: "utf8" });
-  if (result.status !== 0) {
-    throw new Error(`failed to resolve ${command}`);
-  }
-  return result.stdout.trim();
-}
-function writeExecutableLink(directory, name, target) {
-  const linkPath = join2(directory, name);
-  try {
-    unlinkSync(linkPath);
-  } catch {
-  }
-  try {
-    symlinkSync(target, linkPath);
-  } catch {
-    const script = `#!/bin/sh
-exec "${escapeShell(target)}" "$@"
-`;
-    writeFileSync2(linkPath, script, { mode: 493 });
-    chmodSync(linkPath, 493);
-    return;
-  }
-  try {
-    const stat = readFileSync2(linkPath);
-    if (!stat) {
-      throw new Error("empty");
-    }
-  } catch {
-    const script = `#!/bin/sh
-exec "${escapeShell(target)}" "$@"
-`;
-    writeFileSync2(linkPath, script, { mode: 493 });
-    chmodSync(linkPath, 493);
-  }
-}
-function escapeShell(value) {
-  return value.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("$", "\\$").replaceAll('"', '\\"');
-}
-
 // src/lib/mount-reconcile.ts
 function computeMountPlan(input) {
   const desiredHandles = new Set(input.desired.map((entry) => entry.handle));
@@ -599,14 +358,14 @@ function computeMountPlan(input) {
     pending: input.pending
   };
 }
-async function planMountReconcile(config, paths) {
-  const computers = await listComputers();
+async function planMountReconcile(config, paths, signal) {
+  const computers = await listComputers(signal);
   const desired = [];
   const pending = [];
   for (const computer of computers.filter(isSSHSelectable)) {
-    const mountPath = join3(paths.rootPath, computer.handle);
+    const mountPath = join2(paths.rootPath, computer.handle);
     try {
-      const info = await getConnectionInfo(computer.id);
+      const info = await getConnectionInfo(computer.id, signal);
       if (!info.connection.ssh_available) {
         pending.push({
           handle: computer.handle,
@@ -631,7 +390,8 @@ async function planMountReconcile(config, paths) {
       ready: true
     });
   }
-  const ownedSessions = listOwnedSessions(config, paths);
+  throwIfAborted(signal);
+  const ownedSessions = await listOwnedSessions(config, paths, signal);
   const rootEntries = await listRootHandleDirectories(paths.rootPath);
   return {
     plan: computeMountPlan({
@@ -643,30 +403,38 @@ async function planMountReconcile(config, paths) {
     ownedSessions
   };
 }
-async function reconcileMounts(config, paths, controllerPid = process.pid) {
+async function reconcileMounts(config, paths, controllerPid = process.pid, signal) {
   ensureMutagenSshEnvironment(config, paths);
-  const { plan, ownedSessions } = await planMountReconcile(config, paths);
+  throwIfAborted(signal);
+  const { plan, ownedSessions } = await planMountReconcile(config, paths, signal);
   const mounts = [];
   const issues = [];
   const ownedByHandle = groupSessionsByHandle(ownedSessions);
   for (const handle of [...plan.toStop, ...plan.toReset]) {
+    throwIfAborted(signal);
     const sessions = ownedByHandle.get(handle) ?? [];
     try {
-      terminateOwnedSessions(sessions, config, paths);
+      await terminateOwnedSessions(sessions, config, paths, signal);
       await removeHandleFromRoot(handle, paths);
       removeMountHandleState(handle, config.rootPath);
     } catch (error) {
+      if (isAbortError(error)) {
+        throw error;
+      }
       issues.push(
         error instanceof Error ? `${handle}: ${error.message}` : `${handle}: teardown failed`
       );
     }
   }
   for (const entry of plan.toCreate) {
+    throwIfAborted(signal);
     try {
-      await ensureMountedHandle(entry, config, paths);
+      await ensureMountedHandle(entry, config, paths, signal);
       const session = selectPreferredSession(
         entry.handle,
-        listOwnedSessions(config, paths).filter((candidate) => candidate.handle === entry.handle)
+        (await listOwnedSessions(config, paths, signal)).filter(
+          (candidate) => candidate.handle === entry.handle
+        )
       );
       const inspected = inspectSnapshotEntry(session, entry.mountPath);
       mounts.push(inspected.snapshot);
@@ -674,20 +442,29 @@ async function reconcileMounts(config, paths, controllerPid = process.pid) {
         issues.push(inspected.issue);
       }
     } catch (error) {
+      if (isAbortError(error)) {
+        throw error;
+      }
       const message = error instanceof Error ? error.message : "sync start failed";
       mounts.push(snapshotEntry(entry.handle, entry.mountPath, "error", message));
       issues.push(`${entry.handle}: ${message}`);
     }
   }
-  const postCreateSessions = groupSessionsByHandle(listOwnedSessions(config, paths));
+  throwIfAborted(signal);
+  const postCreateSessions = groupSessionsByHandle(
+    await listOwnedSessions(config, paths, signal)
+  );
   for (const entry of plan.toInspect) {
+    throwIfAborted(signal);
     try {
       const sessions = postCreateSessions.get(entry.handle) ?? [];
       if (sessions.length === 0) {
-        await ensureMountedHandle(entry, config, paths);
+        await ensureMountedHandle(entry, config, paths, signal);
         const createdSession = selectPreferredSession(
           entry.handle,
-          listOwnedSessions(config, paths).filter((candidate) => candidate.handle === entry.handle)
+          (await listOwnedSessions(config, paths, signal)).filter(
+            (candidate) => candidate.handle === entry.handle
+          )
         );
         const inspected2 = inspectSnapshotEntry(createdSession, entry.mountPath);
         mounts.push(inspected2.snapshot);
@@ -703,6 +480,9 @@ async function reconcileMounts(config, paths, controllerPid = process.pid) {
         issues.push(inspected.issue);
       }
     } catch (error) {
+      if (isAbortError(error)) {
+        throw error;
+      }
       const message = error instanceof Error ? error.message : "sync inspection failed";
       mounts.push(snapshotEntry(entry.handle, entry.mountPath, "error", message));
       issues.push(`${entry.handle}: ${message}`);
@@ -718,6 +498,8 @@ async function reconcileMounts(config, paths, controllerPid = process.pid) {
     updatedAt: now,
     controllerPid,
     running: true,
+    startupPhase: "ready",
+    startupMessage: void 0,
     lastHealthySyncAt: healthy ? now : previousSnapshot?.lastHealthySyncAt,
     lastSuccessfulSyncAt: healthy ? now : previousSnapshot?.lastSuccessfulSyncAt,
     lastIssueAt: issues.length > 0 ? now : previousSnapshot?.lastIssueAt,
@@ -728,9 +510,10 @@ async function reconcileMounts(config, paths, controllerPid = process.pid) {
   writeMountStatusSnapshot(snapshot, config.rootPath);
   return snapshot;
 }
-async function teardownManagedSessions(config, paths) {
-  const ownedSessions = listOwnedSessions(config, paths);
-  terminateOwnedSessions(ownedSessions, config, paths);
+async function teardownManagedSessions(config, paths, signal) {
+  throwIfAborted(signal);
+  const ownedSessions = await listOwnedSessions(config, paths, signal);
+  await terminateOwnedSessions(ownedSessions, config, paths, signal);
   const handles = new Set(ownedSessions.map((session) => session.handle));
   for (const handle of await listKnownHandleStates(paths)) {
     handles.add(handle);
@@ -743,9 +526,9 @@ async function teardownManagedSessions(config, paths) {
   }
   await rm(paths.rootPath, { recursive: true, force: true });
 }
-async function ensureMountedHandle(entry, config, paths) {
+async function ensureMountedHandle(entry, config, paths, signal) {
   await mkdir(entry.mountPath, { recursive: true });
-  createHandleSession(entry.handle, config, paths);
+  await createHandleSession(entry.handle, config, paths, signal);
   writeMountHandleMeta(
     entry.handle,
     {
@@ -825,13 +608,13 @@ function groupSessionsByHandle(sessions) {
   }
   return grouped;
 }
-function terminateOwnedSessions(sessions, config, paths) {
-  for (const session of sessions) {
-    terminateSession(session, config, paths);
-  }
+function terminateOwnedSessions(sessions, config, paths, signal) {
+  return Promise.all(
+    sessions.map((session) => terminateSession(session, config, paths, signal))
+  ).then(() => void 0);
 }
 async function removeHandleFromRoot(handle, paths) {
-  await rm(join3(paths.rootPath, handle), { recursive: true, force: true });
+  await rm(join2(paths.rootPath, handle), { recursive: true, force: true });
 }
 async function listRootHandleDirectories(rootPath) {
   try {
@@ -847,6 +630,13 @@ async function listKnownHandleStates(paths) {
     return [];
   }
 }
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    const error = new Error("mount operation cancelled");
+    error.name = "AbortError";
+    throw error;
+  }
+}
 
 export {
   getAPIKey,