aicomputer 0.1.15 → 0.1.16

package/README.md

@@ -120,7 +120,8 @@ 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.
+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";
@@ -4046,7 +4045,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 +4096,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: []
       },
@@ -4197,24 +4202,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 = mount.state === "mounted" ? chalk8.green(mount.state) : mount.state === "reconnecting" ? chalk8.cyan(mount.state) : mount.state === "degraded" ? chalk8.yellow(mount.state) : mount.state === "pending" ? chalk8.yellow(mount.state) : chalk8.red(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();
   })

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.16",
   "description": "Computer CLI - manage your Agent Computer machines from the terminal",
   "homepage": "https://agentcomputer.ai",
   "repository": {