aicomputer 0.1.15 → 0.1.17

package/README.md

@@ -95,6 +95,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,10 +118,18 @@ 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.
+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` and requires Mutagen plus
-OpenSSH client tools (`ssh` and `scp`) to already be installed locally.
+OpenSSH client tools (`ssh` and `scp`) to already be installed 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-KQQUR2YX.js → chunk-5IEWKH52.js}

@@ -1,15 +1,15 @@
 import {
+  MOUNT_SERVICE_LABEL,
   ensureHandleDirectories,
   ensureMountDirectories,
-  getMountHandlePaths,
   readMountStatusSnapshot,
   removeMountHandleState,
   writeMountHandleMeta,
   writeMountStatusSnapshot
-} from "./chunk-5JVJROSI.js";
+} from "./chunk-KXLTHWW3.js";
 
 // src/lib/mount-reconcile.ts
-import { readdir, mkdir, rename, rm } from "fs/promises";
+import { readdir, mkdir, rm } from "fs/promises";
 import { join as join3 } from "path";
 
 // src/lib/config.ts
@@ -248,16 +248,6 @@ function timeAgo(dateStr) {
   const days = Math.floor(hours / 24);
   return `${days}d ago`;
 }
-function minuteSecondAgo(dateStr) {
-  const timestamp = new Date(dateStr).getTime();
-  if (!Number.isFinite(timestamp)) {
-    return "unknown";
-  }
-  const totalSeconds = Math.max(0, Math.floor((Date.now() - timestamp) / 1e3));
-  const totalMinutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  return `${totalMinutes}:${String(seconds).padStart(2, "0")} ago`;
-}
 function formatStatus(status) {
   switch (status) {
     case "running":
@@ -312,9 +302,15 @@ function describeSSHChoice(computer) {
 }
 
 // src/lib/mount-mutagen.ts
-import { chmodSync, existsSync as existsSync2, readFileSync as readFileSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { chmodSync, readFileSync as readFileSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { spawnSync } from "child_process";
-import { basename, join as join2 } from "path";
+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");
@@ -324,47 +320,174 @@ function ensureMutagenSshEnvironment(config, paths) {
   writeExecutableLink(paths.sshToolsDir, basename(sshPath), sshPath);
   writeExecutableLink(paths.sshToolsDir, basename(scpPath), scpPath);
 }
-function writeHandleProjectFile(handle, config, paths) {
-  const handlePaths = ensureHandleDirectories(handle, config.rootPath);
-  const content = [
-    "sync:",
-    "  defaults:",
-    "    flushOnCreate: true",
-    "  mirror:",
-    `    alpha: ${yamlString(join2(paths.rootPath, handle))}`,
-    `    beta: ${yamlString(`${handle}@${config.alias}:/home/node`)}`,
-    ""
-  ].join("\n");
-  writeFileSync2(handlePaths.projectFilePath, content, { mode: 384 });
-  return handlePaths.projectFilePath;
-}
-function startHandleProject(handle, config, paths) {
-  const handlePaths = getMountHandlePaths(handle, config.rootPath);
-  runMutagen(["project", "start", "-f", handlePaths.projectFilePath], config, paths, handle);
-  runMutagen(["project", "flush", "-f", handlePaths.projectFilePath], config, paths, handle);
-}
-function terminateHandleProject(handle, config, paths) {
-  const handlePaths = getMountHandlePaths(handle, config.rootPath);
-  if (!existsSync2(handlePaths.projectFilePath)) {
-    return;
-  }
-  runMutagen(["project", "terminate", "-f", handlePaths.projectFilePath], config, paths, handle, true);
+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 inspectHandleProject(handle, config, paths) {
-  const handlePaths = getMountHandlePaths(handle, config.rootPath);
-  if (!existsSync2(handlePaths.projectFilePath)) {
+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 {
-      ok: false,
-      stdout: "",
-      stderr: "project file missing"
+      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;
+    }
   }
-  return runMutagen(["project", "list", "-f", handlePaths.projectFilePath], config, paths, handle, true);
+  finishCurrent();
+  return sessions;
 }
-function cleanupKnownHandleProjects(config, paths, handles) {
-  for (const handle of handles) {
-    terminateHandleProject(handle, config, paths);
-  }
+function parseConnected(line) {
+  return line.slice("Connected: ".length).trim().toLowerCase() === "yes";
 }
 function runMutagen(args, config, paths, handle, ignoreFailure = false) {
   const result = spawnSync("mutagen", args, {
@@ -383,7 +506,8 @@ function runMutagen(args, config, paths, handle, ignoreFailure = false) {
   return {
     ok: result.status === 0,
     stdout,
-    stderr
+    stderr,
+    status: result.status
   };
 }
 function resolveCommandPath(command) {
@@ -422,35 +546,41 @@ exec "${escapeShell(target)}" "$@"
     chmodSync(linkPath, 493);
   }
 }
-function yamlString(value) {
-  return JSON.stringify(value);
-}
 function escapeShell(value) {
   return value.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("$", "\\$").replaceAll('"', '\\"');
 }
 
 // src/lib/mount-reconcile.ts
 function computeMountPlan(input) {
-  const previousByHandle = new Map(
-    (input.previousSnapshot?.mounts ?? []).map((mount) => [mount.handle, mount])
-  );
-  const desiredHandles = new Set(
-    [...input.desired, ...input.pending].map((entry) => entry.handle)
-  );
-  const toStart = [];
-  const toCheck = [];
-  for (const entry of input.desired) {
-    const previous = previousByHandle.get(entry.handle);
-    if (previous?.state === "mounted") {
-      toCheck.push(entry);
+  const desiredHandles = new Set(input.desired.map((entry) => entry.handle));
+  const sessionGroups = /* @__PURE__ */ new Map();
+  for (const session of input.ownedSessions) {
+    const group = sessionGroups.get(session.handle);
+    if (group) {
+      group.push(session);
     } else {
-      toStart.push(entry);
+      sessionGroups.set(session.handle, [session]);
+    }
+  }
+  const toCreate = [];
+  const toInspect = [];
+  const toReset = /* @__PURE__ */ new Set();
+  for (const entry of input.desired) {
+    const sessions = sessionGroups.get(entry.handle) ?? [];
+    const reusable = sessions.length === 1 && !sessions[0].legacy;
+    if (reusable) {
+      toInspect.push(entry);
+      continue;
     }
+    if (sessions.length > 0) {
+      toReset.add(entry.handle);
+    }
+    toCreate.push(entry);
   }
   const toStop = /* @__PURE__ */ new Set();
-  for (const mount of input.previousSnapshot?.mounts ?? []) {
-    if (!desiredHandles.has(mount.handle)) {
-      toStop.add(mount.handle);
+  for (const session of input.ownedSessions) {
+    if (!desiredHandles.has(session.handle)) {
+      toStop.add(session.handle);
     }
   }
   for (const entry of input.rootEntries) {
@@ -458,9 +588,13 @@ function computeMountPlan(input) {
       toStop.add(entry);
     }
   }
+  for (const handle of toReset) {
+    toStop.delete(handle);
+  }
   return {
-    toStart,
-    toCheck,
+    toCreate,
+    toInspect,
+    toReset: Array.from(toReset).sort(),
     toStop: Array.from(toStop).sort(),
     pending: input.pending
   };
@@ -497,52 +631,81 @@ async function planMountReconcile(config, paths) {
       ready: true
     });
   }
-  const previousSnapshot = readMountStatusSnapshot(config.rootPath);
+  const ownedSessions = listOwnedSessions(config, paths);
   const rootEntries = await listRootHandleDirectories(paths.rootPath);
-  return computeMountPlan({
-    desired,
-    pending,
-    previousSnapshot,
-    rootEntries
-  });
+  return {
+    plan: computeMountPlan({
+      desired,
+      pending,
+      ownedSessions,
+      rootEntries
+    }),
+    ownedSessions
+  };
 }
 async function reconcileMounts(config, paths, controllerPid = process.pid) {
   ensureMutagenSshEnvironment(config, paths);
-  const plan = await planMountReconcile(config, paths);
+  const { plan, ownedSessions } = await planMountReconcile(config, paths);
   const mounts = [];
-  const errors = [];
-  for (const handle of plan.toStop) {
+  const issues = [];
+  const ownedByHandle = groupSessionsByHandle(ownedSessions);
+  for (const handle of [...plan.toStop, ...plan.toReset]) {
+    const sessions = ownedByHandle.get(handle) ?? [];
     try {
-      terminateHandleProject(handle, config, paths);
-      await moveHandleOutOfRoot(handle, paths);
+      terminateOwnedSessions(sessions, config, paths);
+      await removeHandleFromRoot(handle, paths);
       removeMountHandleState(handle, config.rootPath);
     } catch (error) {
-      errors.push(
+      issues.push(
         error instanceof Error ? `${handle}: ${error.message}` : `${handle}: teardown failed`
       );
     }
   }
-  for (const entry of plan.toCheck) {
+  for (const entry of plan.toCreate) {
     try {
-      const inspection = inspectHandleProject(entry.handle, config, paths);
-      if (!inspection.ok) {
-        await ensureMountedHandle(entry, config, paths);
+      await ensureMountedHandle(entry, config, paths);
+      const session = selectPreferredSession(
+        entry.handle,
+        listOwnedSessions(config, paths).filter((candidate) => candidate.handle === entry.handle)
+      );
+      const inspected = inspectSnapshotEntry(session, entry.mountPath);
+      mounts.push(inspected.snapshot);
+      if (inspected.issue) {
+        issues.push(inspected.issue);
       }
-      mounts.push(snapshotEntry(entry.handle, entry.mountPath, "mounted"));
     } catch (error) {
-      const message = error instanceof Error ? error.message : "sync check failed";
+      const message = error instanceof Error ? error.message : "sync start failed";
       mounts.push(snapshotEntry(entry.handle, entry.mountPath, "error", message));
-      errors.push(`${entry.handle}: ${message}`);
+      issues.push(`${entry.handle}: ${message}`);
     }
   }
-  for (const entry of plan.toStart) {
+  const postCreateSessions = groupSessionsByHandle(listOwnedSessions(config, paths));
+  for (const entry of plan.toInspect) {
     try {
-      await ensureMountedHandle(entry, config, paths);
-      mounts.push(snapshotEntry(entry.handle, entry.mountPath, "mounted"));
+      const sessions = postCreateSessions.get(entry.handle) ?? [];
+      if (sessions.length === 0) {
+        await ensureMountedHandle(entry, config, paths);
+        const createdSession = selectPreferredSession(
+          entry.handle,
+          listOwnedSessions(config, paths).filter((candidate) => candidate.handle === entry.handle)
+        );
+        const inspected2 = inspectSnapshotEntry(createdSession, entry.mountPath);
+        mounts.push(inspected2.snapshot);
+        if (inspected2.issue) {
+          issues.push(inspected2.issue);
+        }
+        continue;
+      }
+      const session = selectPreferredSession(entry.handle, sessions);
+      const inspected = inspectSnapshotEntry(session, entry.mountPath);
+      mounts.push(inspected.snapshot);
+      if (inspected.issue) {
+        issues.push(inspected.issue);
+      }
     } catch (error) {
-      const message = error instanceof Error ? error.message : "sync start failed";
+      const message = error instanceof Error ? error.message : "sync inspection failed";
       mounts.push(snapshotEntry(entry.handle, entry.mountPath, "error", message));
-      errors.push(`${entry.handle}: ${message}`);
+      issues.push(`${entry.handle}: ${message}`);
     }
   }
   for (const entry of plan.pending) {
@@ -550,47 +713,93 @@ async function reconcileMounts(config, paths, controllerPid = process.pid) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const previousSnapshot = readMountStatusSnapshot(config.rootPath);
+  const healthy = mounts.every((mount) => mount.state === "mounted" || mount.state === "pending");
   const snapshot = {
     updatedAt: now,
     controllerPid,
     running: true,
-    lastSuccessfulSyncAt: errors.length === 0 ? now : previousSnapshot?.lastSuccessfulSyncAt,
-    lastError: errors[0],
+    lastHealthySyncAt: healthy ? now : previousSnapshot?.lastHealthySyncAt,
+    lastSuccessfulSyncAt: healthy ? now : previousSnapshot?.lastSuccessfulSyncAt,
+    lastIssueAt: issues.length > 0 ? now : previousSnapshot?.lastIssueAt,
+    lastIssue: issues[0],
+    lastError: mounts.some((mount) => mount.state === "error") ? issues[0] : void 0,
     mounts: sortSnapshots(mounts)
   };
   writeMountStatusSnapshot(snapshot, config.rootPath);
   return snapshot;
 }
 async function teardownManagedSessions(config, paths) {
-  const handles = await listKnownHandleStates(paths);
-  cleanupKnownHandleProjects(config, paths, handles);
+  const ownedSessions = listOwnedSessions(config, paths);
+  terminateOwnedSessions(ownedSessions, config, paths);
+  const handles = new Set(ownedSessions.map((session) => session.handle));
+  for (const handle of await listKnownHandleStates(paths)) {
+    handles.add(handle);
+  }
+  for (const handle of await listRootHandleDirectories(paths.rootPath)) {
+    handles.add(handle);
+  }
   for (const handle of handles) {
     removeMountHandleState(handle, config.rootPath);
   }
+  await rm(paths.rootPath, { recursive: true, force: true });
 }
 async function ensureMountedHandle(entry, config, paths) {
   await mkdir(entry.mountPath, { recursive: true });
-  ensureHandleDirectories(entry.handle, config.rootPath);
-  writeHandleProjectFile(entry.handle, config, paths);
-  startHandleProject(entry.handle, config, paths);
+  createHandleSession(entry.handle, config, paths);
   writeMountHandleMeta(
     entry.handle,
     {
       handle: entry.handle,
+      sessionName: getHandleSessionName(entry.handle),
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       lastStartedAt: (/* @__PURE__ */ new Date()).toISOString()
     },
     config.rootPath
   );
 }
-async function moveHandleOutOfRoot(handle, paths) {
-  const sourcePath = join3(paths.rootPath, handle);
-  const stalePath = join3(paths.staleDir, `${handle}-${Date.now()}`);
-  try {
-    await rename(sourcePath, stalePath);
-  } catch {
-    await rm(sourcePath, { recursive: true, force: true });
+function inspectSnapshotEntry(session, mountPath) {
+  const status = (session.status ?? "").toLowerCase();
+  const problemParts = [];
+  if (session.conflictCount > 0) {
+    problemParts.push(
+      `${session.conflictCount} conflict${session.conflictCount === 1 ? "" : "s"}`
+    );
+  }
+  if (session.scanProblemCount > 0) {
+    problemParts.push(
+      `${session.scanProblemCount} scan problem${session.scanProblemCount === 1 ? "" : "s"}`
+    );
+  }
+  if (problemParts.length > 0) {
+    const message = problemParts.join(", ");
+    return {
+      snapshot: snapshotEntry(session.handle, mountPath, "degraded", message),
+      issue: `${session.handle}: ${message}`
+    };
+  }
+  if (!session.alphaConnected) {
+    const message = session.lastError ?? "local sync endpoint disconnected";
+    return {
+      snapshot: snapshotEntry(session.handle, mountPath, "error", message),
+      issue: `${session.handle}: ${message}`
+    };
+  }
+  if (!session.betaConnected || status.includes("connecting") || status.includes("reconnect")) {
+    const message = session.lastError ?? "reconnecting to remote machine";
+    return {
+      snapshot: snapshotEntry(session.handle, mountPath, "reconnecting", message),
+      issue: `${session.handle}: ${message}`
+    };
   }
+  if (session.lastError && !status.includes("watching")) {
+    return {
+      snapshot: snapshotEntry(session.handle, mountPath, "degraded", session.lastError),
+      issue: `${session.handle}: ${session.lastError}`
+    };
+  }
+  return {
+    snapshot: snapshotEntry(session.handle, mountPath, "mounted")
+  };
 }
 function snapshotEntry(handle, mountPath, state, message) {
   return {
@@ -604,6 +813,26 @@ function snapshotEntry(handle, mountPath, state, message) {
 function sortSnapshots(mounts) {
   return mounts.slice().sort((left, right) => left.handle.localeCompare(right.handle));
 }
+function groupSessionsByHandle(sessions) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const group = grouped.get(session.handle);
+    if (group) {
+      group.push(session);
+    } else {
+      grouped.set(session.handle, [session]);
+    }
+  }
+  return grouped;
+}
+function terminateOwnedSessions(sessions, config, paths) {
+  for (const session of sessions) {
+    terminateSession(session, config, paths);
+  }
+}
+async function removeHandleFromRoot(handle, paths) {
+  await rm(join3(paths.rootPath, handle), { recursive: true, force: true });
+}
 async function listRootHandleDirectories(rootPath) {
   try {
     return (await readdir(rootPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
@@ -645,7 +874,6 @@ export {
   vncURL,
   padEnd,
   timeAgo,
-  minuteSecondAgo,
   formatStatus,
   promptForSSHComputer,
   computeMountPlan,

package/dist/{chunk-5JVJROSI.js → chunk-KXLTHWW3.js}

@@ -35,7 +35,6 @@ function getMountHandlePaths(handle, rootPath = getDefaultMountRoot()) {
   const stateDir = join(paths.handlesDir, handle);
   return {
     stateDir,
-    projectFilePath: join(stateDir, "mutagen.yml"),
     metaPath: join(stateDir, "meta.json"),
     sshToolsDir: join(stateDir, "ssh-tools")
   };
@@ -53,7 +52,6 @@ function defaultMountServiceConfig() {
 function ensureMountDirectories(paths) {
   for (const directory of [
     paths.stateDir,
-    paths.rootPath,
     paths.handlesDir,
     paths.sshToolsDir,
     paths.staleDir

package/dist/index.js

@@ -23,7 +23,6 @@ import {
   hasEnvAPIKey,
   listComputers,
   listPublishedPorts,
-  minuteSecondAgo,
   padEnd,
   promptForSSHComputer,
   publishPort,
@@ -34,7 +33,7 @@ import {
   timeAgo,
   vncURL,
   webURL
-} from "./chunk-KQQUR2YX.js";
+} from "./chunk-5IEWKH52.js";
 import {
   defaultMountServiceConfig,
   ensureMountDirectories,
@@ -46,7 +45,7 @@ import {
   writeMountConfig,
   writeMountControllerLock,
   writeMountStatusSnapshot
-} from "./chunk-5JVJROSI.js";
+} from "./chunk-KXLTHWW3.js";
 
 // src/index.ts
 import { Command as Command14 } from "commander";
@@ -2461,7 +2460,7 @@ _computer() {
     'open:Open in browser'
     'ssh:SSH into a computer'
     'ports:Manage published ports'
-    'mount:Mirror SSH-ready machine homes into ~/agentcomputer while running'
+    'mount:Mirror SSH-ready machine homes into ~/agentcomputer'
     'agent:Manage cloud agent sessions'
     'acp:Run a local ACP bridge for remote agent sessions'
     'rm:Delete a computer'
@@ -2601,6 +2600,7 @@ _computer() {
           ;;
         mount)
           _arguments -C \\
+            '--background[Run the mount controller in the background and print its PID]' \\
             '--alias[SSH host alias]:alias:' \\
             '--host[SSH gateway host]:host:' \\
             '--port[SSH gateway port]:port:' \\
@@ -2772,9 +2772,9 @@ var BASH_SCRIPT = `_computer() {
       ;;
     mount)
       if [[ $cword -eq 2 ]]; then
-        COMPREPLY=($(compgen -W "$mount_commands" -- "$cur"))
+        COMPREPLY=($(compgen -W "$mount_commands --background --alias --host --port --poll-interval --connect-timeout" -- "$cur"))
       elif [[ $cword -ge 3 ]]; then
-        COMPREPLY=($(compgen -W "--alias --host --port --poll-interval --connect-timeout" -- "$cur"))
+        COMPREPLY=($(compgen -W "--background --alias --host --port --poll-interval --connect-timeout" -- "$cur"))
       fi
       ;;
     ports)
@@ -3988,7 +3988,8 @@ function printNextStep(machineHandle) {
 }
 
 // src/commands/mount.ts
-import { Command as Command10 } from "commander";
+import { spawn as spawn4 } from "child_process";
+import { Command as Command10, Option } from "commander";
 import chalk8 from "chalk";
 import ora9 from "ora";
 
@@ -4005,7 +4006,8 @@ function getMountControllerState(rootPath = defaultMountServiceConfig().rootPath
   }
   return { running: true, pid: lock.pid };
 }
-async function runMountDaemon(config) {
+async function runMountDaemon(config, options = {}) {
+  const { onStarted } = options;
   const paths = getMountPaths(config.rootPath);
   ensureMountDirectories(paths);
   await mkdir3(paths.rootPath, { recursive: true });
@@ -4019,6 +4021,7 @@ async function runMountDaemon(config) {
     },
     config.rootPath
   );
+  onStarted?.();
   await teardownManagedSessions(config, paths);
   let running = false;
   let queued = false;
@@ -4046,7 +4049,10 @@ async function runMountDaemon(config) {
             updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
             controllerPid: process.pid,
             running: true,
+            lastHealthySyncAt: previous?.lastHealthySyncAt,
             lastSuccessfulSyncAt: previous?.lastSuccessfulSyncAt,
+            lastIssueAt: (/* @__PURE__ */ new Date()).toISOString(),
+            lastIssue: error instanceof Error ? error.message : "mount reconcile failed",
             lastError: error instanceof Error ? error.message : "mount reconcile failed",
             mounts: previous?.mounts ?? []
           },
@@ -4094,7 +4100,10 @@ async function runMountDaemon(config) {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         controllerPid: previous?.controllerPid,
         running: false,
+        lastHealthySyncAt: previous?.lastHealthySyncAt,
         lastSuccessfulSyncAt: previous?.lastSuccessfulSyncAt,
+        lastIssueAt: previous?.lastIssueAt,
+        lastIssue: void 0,
         lastError: void 0,
         mounts: []
       },
@@ -4140,40 +4149,39 @@ function processExists(pid) {
 }
 
 // src/commands/mount.ts
-var mountCommand = new Command10("mount").description("Mirror SSH-ready machines under ~/agentcomputer while this command is running").option("--alias <alias>", "SSH host alias", "agentcomputer.ai").option("--host <host>", "SSH gateway host", "ssh.agentcomputer.ai").option("--port <port>", "SSH gateway port", "443").option("--poll-interval <ms>", "Reconcile interval in milliseconds", "5000").option("--connect-timeout <seconds>", "SSH connect timeout for Mutagen", "5").action(async (options) => {
-  const spinner = ora9("Starting machine mount controller...").start();
+var mountCommand = new Command10("mount").description("Mirror SSH-ready machines under ~/agentcomputer with a local mount controller").option("--alias <alias>", "SSH host alias", "agentcomputer.ai").option("--host <host>", "SSH gateway host", "ssh.agentcomputer.ai").option("--port <port>", "SSH gateway port", "443").option("--poll-interval <ms>", "Reconcile interval in milliseconds", "5000").option("--connect-timeout <seconds>", "SSH connect timeout for Mutagen", "5").option(
+  "--background",
+  "Run the mount controller in the background and print its PID"
+).addOption(new Option("--daemonized").hideHelp()).action(async (options) => {
+  const spinner = ora9(
+    options.background ? "Starting machine mount controller in background..." : "Starting machine mount controller..."
+  ).start();
   try {
-    const issues = getMountHostValidationIssues();
-    if (issues.length > 0) {
-      throw new Error(
-        [
-          ...issues.map((issue) => issue.message),
-          ...formatMountHostInstallGuidance(issues)
-        ].join("\n")
-      );
+    if (options.daemonized) {
+      const config2 = readMountConfig() ?? defaultMountServiceConfig();
+      await runMountDaemon(config2, {
+        onStarted: () => {
+          spinner.succeed("Machine mount controller running");
+          printMountStartSummary(config2, process.pid, "foreground");
+        }
+      });
+      return;
     }
-    const sshSetup = await ensureSSHAccessConfigured(options);
-    const config = {
-      ...defaultMountServiceConfig(),
-      alias: sshSetup.alias,
-      host: sshSetup.host,
-      port: sshSetup.port,
-      pollIntervalMs: parsePositiveInt(options.pollInterval, "poll interval"),
-      connectTimeoutSeconds: parsePositiveInt(
-        options.connectTimeout,
-        "connect timeout"
-      )
-    };
+    const config = await resolveMountServiceConfig(options);
     writeMountConfig(config);
-    spinner.succeed("Machine mount controller running");
-    console.log();
-    console.log(chalk8.dim(`  Root:        ${config.rootPath}`));
-    console.log(chalk8.dim(`  SSH alias:   ${config.alias}`));
-    console.log(chalk8.dim(`  Poll:        ${config.pollIntervalMs}ms`));
-    console.log();
-    console.log(chalk8.dim("  Press Ctrl-C to stop syncing."));
-    console.log();
-    await runMountDaemon(config);
+    if (options.background) {
+      const pid = await startMountControllerInBackground(config.rootPath);
+      spinner.succeed("Machine mount controller running in background");
+      printMountStartSummary(config, pid, "background");
+      return;
+    }
+    await runMountDaemon(config, {
+      onStarted: () => {
+        spinner.succeed("Machine mount controller running");
+        printMountStartSummary(config, process.pid, "foreground");
+        revealMountRootInFinder(config.rootPath);
+      }
+    });
   } catch (error) {
     spinner.fail(
       error instanceof Error ? error.message : "Failed to start machine mount controller"
@@ -4197,24 +4205,24 @@ var mountCommand = new Command10("mount").description("Mirror SSH-ready machines
     console.log(`  ${chalk8.dim("Root")}       ${config.rootPath}`);
     console.log(`  ${chalk8.dim("Alias")}      ${config.alias}`);
     console.log(
-      `  ${chalk8.dim("Updated")}    ${snapshot?.updatedAt ? minuteSecondAgo(snapshot.updatedAt) : chalk8.dim("never")}`
+      `  ${chalk8.dim("Updated")}    ${snapshot?.updatedAt ? timeAgo(snapshot.updatedAt) : chalk8.dim("never")}`
     );
     console.log(
-      `  ${chalk8.dim("Last sync")}  ${snapshot?.lastSuccessfulSyncAt ? minuteSecondAgo(snapshot.lastSuccessfulSyncAt) : chalk8.dim("never")}`
+      `  ${chalk8.dim("Healthy")}    ${snapshot?.lastHealthySyncAt ? timeAgo(snapshot.lastHealthySyncAt) : chalk8.dim("never")}`
     );
     if (controller.running && snapshot?.mounts.length) {
       console.log();
       for (const mount of snapshot.mounts) {
-        const state = mount.state === "mounted" ? chalk8.green(mount.state) : mount.state === "pending" ? chalk8.yellow(mount.state) : chalk8.red(mount.state);
+        const state = formatMountState(mount.state);
         console.log(`  ${chalk8.white(mount.handle)}  ${state}  ${chalk8.dim(mount.mountPath)}`);
         if (mount.message) {
           console.log(`  ${chalk8.dim(mount.message)}`);
         }
       }
     }
-    if (snapshot?.lastError) {
+    if (snapshot?.lastIssue) {
       console.log();
-      console.log(`  ${chalk8.dim("Last error")} ${chalk8.red(snapshot.lastError)}`);
+      console.log(`  ${chalk8.dim("Last issue")} ${chalk8.yellow(snapshot.lastIssue)}`);
     }
     console.log();
   })
@@ -4226,6 +4234,115 @@ function parsePositiveInt(raw, label) {
   }
   return Math.round(value);
 }
+async function resolveMountServiceConfig(options) {
+  const issues = getMountHostValidationIssues();
+  if (issues.length > 0) {
+    throw new Error(
+      [
+        ...issues.map((issue) => issue.message),
+        ...formatMountHostInstallGuidance(issues)
+      ].join("\n")
+    );
+  }
+  const sshSetup = await ensureSSHAccessConfigured(options);
+  return {
+    ...defaultMountServiceConfig(),
+    alias: sshSetup.alias,
+    host: sshSetup.host,
+    port: sshSetup.port,
+    pollIntervalMs: parsePositiveInt(options.pollInterval, "poll interval"),
+    connectTimeoutSeconds: parsePositiveInt(
+      options.connectTimeout,
+      "connect timeout"
+    )
+  };
+}
+async function startMountControllerInBackground(rootPath) {
+  const controller = getMountControllerState(rootPath);
+  if (controller.running) {
+    throw new Error(`computer mount is already running (pid ${controller.pid})`);
+  }
+  const entrypoint = process.argv[1];
+  if (!entrypoint) {
+    throw new Error("unable to determine CLI entrypoint for background mount");
+  }
+  const child = spawn4(process.execPath, [entrypoint, "mount", "--daemonized"], {
+    cwd: process.cwd(),
+    detached: true,
+    env: process.env,
+    stdio: "ignore"
+  });
+  if (!child.pid) {
+    throw new Error("failed to start machine mount controller in background");
+  }
+  child.unref();
+  await waitForBackgroundMountController(rootPath, child.pid);
+  return child.pid;
+}
+async function waitForBackgroundMountController(rootPath, pid) {
+  const deadline = Date.now() + 3e3;
+  while (Date.now() < deadline) {
+    const controller = getMountControllerState(rootPath);
+    if (controller.running && controller.pid === pid) {
+      return;
+    }
+    if (!processExists2(pid)) {
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  throw new Error("failed to start machine mount controller in background");
+}
+function printMountStartSummary(config, pid, mode) {
+  console.log();
+  console.log(chalk8.dim(`  PID:         ${pid}`));
+  console.log(chalk8.dim(`  Root:        ${config.rootPath}`));
+  console.log(chalk8.dim(`  SSH alias:   ${config.alias}`));
+  console.log(chalk8.dim(`  Poll:        ${config.pollIntervalMs}ms`));
+  console.log();
+  console.log(
+    chalk8.dim(
+      mode === "background" ? "  Use `computer mount status` to inspect sync state." : "  Press Ctrl-C to stop syncing."
+    )
+  );
+  console.log();
+}
+function processExists2(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function revealMountRootInFinder(rootPath) {
+  if (process.platform !== "darwin") {
+    return;
+  }
+  const child = spawn4("open", [rootPath], {
+    stdio: "ignore",
+    detached: true
+  });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function formatMountState(state) {
+  switch (state) {
+    case "mounted":
+      return chalk8.green(state);
+    case "reconnecting":
+      return chalk8.cyan(state);
+    case "degraded":
+    case "pending":
+      return chalk8.yellow(state);
+    default:
+      return chalk8.red(state);
+  }
+}
 
 // src/commands/logout.ts
 import { Command as Command11 } from "commander";

package/dist/lib/mount-config.d.ts

@@ -10,7 +10,7 @@ interface MountServiceConfig {
 interface ManagedMountSnapshot {
     handle: string;
     mountPath: string;
-    state: "mounted" | "pending" | "error";
+    state: "mounted" | "reconnecting" | "degraded" | "pending" | "error";
     message?: string;
     updatedAt: string;
 }
@@ -18,7 +18,10 @@ interface MountStatusSnapshot {
     updatedAt: string;
     controllerPid?: number;
     running: boolean;
+    lastHealthySyncAt?: string;
     lastSuccessfulSyncAt?: string;
+    lastIssueAt?: string;
+    lastIssue?: string;
     lastError?: string;
     mounts: ManagedMountSnapshot[];
 }
@@ -35,12 +38,12 @@ interface MountPaths {
 }
 interface MountHandlePaths {
     stateDir: string;
-    projectFilePath: string;
     metaPath: string;
     sshToolsDir: string;
 }
 interface MountHandleMeta {
     handle: string;
+    sessionName?: string;
     startedAt: string;
     lastStartedAt?: string;
 }

package/dist/lib/mount-config.js

@@ -17,7 +17,7 @@ import {
   writeMountControllerLock,
   writeMountHandleMeta,
   writeMountStatusSnapshot
-} from "../chunk-5JVJROSI.js";
+} from "../chunk-KXLTHWW3.js";
 export {
   MOUNT_SERVICE_LABEL,
   defaultMountServiceConfig,

package/dist/lib/mount-reconcile.d.ts

@@ -1,4 +1,19 @@
-import { MountStatusSnapshot, MountServiceConfig, MountPaths } from './mount-config.js';
+import { MountServiceConfig, MountPaths, MountStatusSnapshot } from './mount-config.js';
+
+interface OwnedMountSession {
+    identifier: string;
+    name?: string;
+    handle: string;
+    alphaPath: string;
+    betaUrl?: string;
+    alphaConnected: boolean;
+    betaConnected: boolean;
+    status?: string;
+    lastError?: string;
+    scanProblemCount: number;
+    conflictCount: number;
+    legacy: boolean;
+}
 
 interface DesiredMount {
     handle: string;
@@ -7,18 +22,22 @@ interface DesiredMount {
     message?: string;
 }
 interface MountPlan {
-    toStart: DesiredMount[];
-    toCheck: DesiredMount[];
+    toCreate: DesiredMount[];
+    toInspect: DesiredMount[];
+    toReset: string[];
     toStop: string[];
     pending: DesiredMount[];
 }
 declare function computeMountPlan(input: {
     desired: DesiredMount[];
     pending: DesiredMount[];
-    previousSnapshot: MountStatusSnapshot | null;
+    ownedSessions: Pick<OwnedMountSession, "handle" | "legacy">[];
     rootEntries: string[];
 }): MountPlan;
-declare function planMountReconcile(config: MountServiceConfig, paths: MountPaths): Promise<MountPlan>;
+declare function planMountReconcile(config: MountServiceConfig, paths: MountPaths): Promise<{
+    plan: MountPlan;
+    ownedSessions: OwnedMountSession[];
+}>;
 declare function reconcileMounts(config: MountServiceConfig, paths: MountPaths, controllerPid?: number): Promise<MountStatusSnapshot>;
 declare function teardownManagedSessions(config: MountServiceConfig, paths: MountPaths): Promise<void>;
 

package/dist/lib/mount-reconcile.js

@@ -3,8 +3,8 @@ import {
   planMountReconcile,
   reconcileMounts,
   teardownManagedSessions
-} from "../chunk-KQQUR2YX.js";
-import "../chunk-5JVJROSI.js";
+} from "../chunk-5IEWKH52.js";
+import "../chunk-KXLTHWW3.js";
 export {
   computeMountPlan,
   planMountReconcile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicomputer",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Computer CLI - manage your Agent Computer machines from the terminal",
   "homepage": "https://agentcomputer.ai",
   "repository": {