aicomputer 0.1.19 → 0.1.21

package/README.md

@@ -93,10 +93,14 @@ computer claude-login
 computer codex-login
 computer whoami
 computer create my-box
+computer power-off my-box
+computer power-on my-box
 computer open my-box
 computer ssh
 computer ssh my-box
+computer ssh my-box --tmux
 computer ssh --setup
+computer ssh my-box -N -L 3000:localhost:3000
 computer mount
 computer mount --background
 computer mount status
@@ -112,6 +116,10 @@ Codex credentials onto a machine after the CLI is already logged in. Use
 `computer upgrade` to update a global npm install or the matching Nix profile
 entry.
 
+Use `computer power-off` to stop a managed worker without deleting its durable
+home volume. Use `computer power-on` to recreate the runtime against the same
+stored machine and home state.
+
 Run `computer ssh` without a handle in an interactive terminal to pick from your available machines.
 
 Run `computer ssh --setup` once to register your SSH key and add a global alias:
@@ -121,6 +129,26 @@ ssh agentcomputer.ai
 ssh my-box@agentcomputer.ai
 ```
 
+Use `computer ssh <handle> <ssh args>` when you want the CLI to resolve
+the machine and identity while still passing standard SSH tunnel flags through
+to the underlying client. Long-running SSH sessions and forwarded tunnels stay
+on the same resilient path:
+
+```bash
+computer ssh my-box -N -L 3000:localhost:3000
+```
+
+`computer ssh` now launches through `autossh` by default. Nix installs package
+`ssh`, `scp`, and `autossh` together. Global npm installs on macOS and Linux
+provision Agent Computer's bundled `autossh` copy during postinstall and retry
+that install on first SSH use if npm scripts were skipped. npm users still need
+local OpenSSH client tools available.
+
+Use `computer ssh <handle> --tmux` when you want reconnects to reattach to the
+same remote shell session instead of dropping you into a fresh shell. The flag
+attaches to `tmux new-session -A -s agentcomputer`, so it is meant for
+interactive shells, not `-N` tunnels or other non-interactive SSH flows.
+
 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

package/dist/{chunk-5JYMQXKN.js → chunk-36BZXAAX.js}

@@ -6,235 +6,22 @@ import {
   listOwnedSessions,
   selectPreferredSession,
   terminateSession
-} from "./chunk-NN4GECN6.js";
+} from "./chunk-TPFE3CC6.js";
 import {
+  readMountHandleMeta,
   readMountStatusSnapshot,
   removeMountHandleState,
   writeMountHandleMeta,
   writeMountStatusSnapshot
 } from "./chunk-KXLTHWW3.js";
+import {
+  getConnectionInfo,
+  listComputers
+} from "./chunk-LOGK7YYJ.js";
 
 // src/lib/mount-reconcile.ts
 import { readdir, mkdir, rm } from "fs/promises";
-import { join as join2 } from "path";
-
-// src/lib/config.ts
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
-var CONFIG_DIR = join(homedir(), ".computer");
-var CONFIG_FILE = join(CONFIG_DIR, "config.json");
-function ensureConfigDir() {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  }
-}
-function readConfig() {
-  ensureConfigDir();
-  if (!existsSync(CONFIG_FILE)) {
-    return {};
-  }
-  try {
-    return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function writeConfig(config) {
-  ensureConfigDir();
-  const tempFile = `${CONFIG_FILE}.${process.pid}.tmp`;
-  writeFileSync(tempFile, JSON.stringify(config, null, 2), { mode: 384 });
-  renameSync(tempFile, CONFIG_FILE);
-}
-function getAPIKey() {
-  const envValue = process.env.COMPUTER_API_KEY ?? process.env.AGENTCOMPUTER_API_KEY;
-  if (envValue) {
-    return envValue.trim();
-  }
-  return getStoredAPIKey();
-}
-function getStoredAPIKey() {
-  return readConfig().auth?.apiKey?.trim() || null;
-}
-function hasEnvAPIKey() {
-  return Boolean(process.env.COMPUTER_API_KEY ?? process.env.AGENTCOMPUTER_API_KEY);
-}
-function setAPIKey(apiKey) {
-  const config = readConfig();
-  config.auth = { apiKey: apiKey.trim() };
-  writeConfig(config);
-}
-function clearAPIKey() {
-  const config = readConfig();
-  delete config.auth;
-  writeConfig(config);
-}
-
-// src/lib/api.ts
-var BASE_URL = process.env.COMPUTER_API_URL ?? process.env.AGENTCOMPUTER_API_URL ?? "https://api.computer.agentcomputer.ai";
-var WEB_URL = process.env.COMPUTER_WEB_URL ?? process.env.AGENTCOMPUTER_WEB_URL ?? resolveDefaultWebURL(BASE_URL);
-var ApiError = class extends Error {
-  constructor(status, message) {
-    super(message);
-    this.status = status;
-    this.name = "ApiError";
-  }
-};
-function getBaseURL() {
-  return BASE_URL;
-}
-function getWebURL() {
-  return WEB_URL;
-}
-async function api(path, options = {}) {
-  const apiKey = getAPIKey();
-  if (!apiKey) {
-    throw new ApiError(401, "not logged in; run 'computer login' first");
-  }
-  return requestWithKey(apiKey, path, options);
-}
-function resolveDefaultWebURL(apiURL) {
-  try {
-    const parsed = new URL(apiURL);
-    if (parsed.hostname === "api.computer.agentcomputer.ai") {
-      return "https://agentcomputer.ai";
-    }
-    if (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1") {
-      return `${parsed.protocol}//${parsed.hostname}:3000`;
-    }
-  } catch {
-    return "https://agentcomputer.ai";
-  }
-  return "https://agentcomputer.ai";
-}
-async function apiWithKey(apiKey, path, options = {}) {
-  return requestWithKey(apiKey, path, options);
-}
-async function requestWithKey(apiKey, path, options) {
-  const headers = {
-    Accept: "application/json",
-    ...options.headers ?? {}
-  };
-  if (options.body !== void 0) {
-    headers["Content-Type"] = "application/json";
-  }
-  if (apiKey) {
-    headers.Authorization = `Bearer ${apiKey}`;
-  }
-  const response = await fetch(`${BASE_URL}${path}`, {
-    ...options,
-    headers
-  });
-  if (!response.ok) {
-    throw new ApiError(response.status, await readErrorMessage(response));
-  }
-  if (response.status === 204) {
-    return void 0;
-  }
-  return await response.json();
-}
-async function readErrorMessage(response) {
-  const contentType = response.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    try {
-      const payload = await response.json();
-      if (payload.error) {
-        return payload.error;
-      }
-      return JSON.stringify(payload);
-    } catch {
-      return response.statusText || "request failed";
-    }
-  }
-  const body = await response.text();
-  return body || response.statusText || "request failed";
-}
-
-// src/lib/computers.ts
-async function listComputers(signal) {
-  const response = await api("/v1/computers", { signal });
-  return response.computers;
-}
-async function getComputerByID(id) {
-  return api(`/v1/computers/${id}`);
-}
-async function createComputer(input) {
-  return api("/v1/computers", {
-    method: "POST",
-    body: JSON.stringify(input)
-  });
-}
-async function deleteComputer(computerID) {
-  return api(`/v1/computers/${computerID}`, {
-    method: "DELETE"
-  });
-}
-async function getFilesystemSettings() {
-  return api("/v1/me/filesystem");
-}
-async function getConnectionInfo(computerID, signal) {
-  return api(`/v1/computers/${computerID}/connection`, {
-    signal
-  });
-}
-async function createBrowserAccess(computerID) {
-  return api(`/v1/computers/${computerID}/access/browser`, {
-    method: "POST"
-  });
-}
-async function listPublishedPorts(computerID) {
-  const response = await api(`/v1/computers/${computerID}/ports`);
-  return response.ports;
-}
-async function publishPort(computerID, input) {
-  return api(`/v1/computers/${computerID}/ports`, {
-    method: "POST",
-    body: JSON.stringify(input)
-  });
-}
-async function deletePublishedPort(computerID, targetPort) {
-  return api(`/v1/computers/${computerID}/ports/${targetPort}`, {
-    method: "DELETE"
-  });
-}
-async function resolveComputer(identifier) {
-  try {
-    return await getComputerByID(identifier);
-  } catch (error) {
-    if (!(error instanceof Error) || !("status" in error)) {
-      throw error;
-    }
-    const status = Reflect.get(error, "status");
-    if (status !== 404) {
-      throw error;
-    }
-  }
-  const computers = await listComputers();
-  const exact = computers.find(
-    (computer) => computer.handle === identifier || computer.id === identifier
-  );
-  if (exact) {
-    return exact;
-  }
-  throw new Error(`computer '${identifier}' not found`);
-}
-function webURL(computer) {
-  return `https://${computer.primary_web_host}${normalizePrimaryPath(computer.primary_path)}`;
-}
-function vncURL(computer) {
-  if (!computer.vnc_enabled) {
-    return null;
-  }
-  const domain = computer.primary_web_host.replace(/^[^.]+\./, "");
-  return `https://6080--${computer.handle}.${domain}`;
-}
-function normalizePrimaryPath(primaryPath) {
-  const trimmed = primaryPath?.trim();
-  if (!trimmed) {
-    return "/";
-  }
-  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-}
 
 // src/lib/computer-picker.ts
 import { select } from "@inquirer/prompts";
@@ -363,7 +150,7 @@ async function planMountReconcile(config, paths, signal) {
   const desired = [];
   const pending = [];
   for (const computer of computers.filter(isSSHSelectable)) {
-    const mountPath = join2(paths.rootPath, computer.handle);
+    const mountPath = join(paths.rootPath, computer.handle);
     try {
       const info = await getConnectionInfo(computer.id, signal);
       if (!info.connection.ssh_available) {
@@ -436,7 +223,7 @@ async function reconcileMounts(config, paths, controllerPid = process.pid, signa
           (candidate) => candidate.handle === entry.handle
         )
       );
-      const inspected = inspectSnapshotEntry(session, entry.mountPath);
+      const inspected = inspectSnapshotEntry(session, entry.mountPath, config.rootPath);
       mounts.push(inspected.snapshot);
       if (inspected.issue) {
         issues.push(inspected.issue);
@@ -466,7 +253,11 @@ async function reconcileMounts(config, paths, controllerPid = process.pid, signa
             (candidate) => candidate.handle === entry.handle
           )
         );
-        const inspected2 = inspectSnapshotEntry(createdSession, entry.mountPath);
+        const inspected2 = inspectSnapshotEntry(
+          createdSession,
+          entry.mountPath,
+          config.rootPath
+        );
         mounts.push(inspected2.snapshot);
         if (inspected2.issue) {
           issues.push(inspected2.issue);
@@ -474,7 +265,7 @@ async function reconcileMounts(config, paths, controllerPid = process.pid, signa
         continue;
       }
       const session = selectPreferredSession(entry.handle, sessions);
-      const inspected = inspectSnapshotEntry(session, entry.mountPath);
+      const inspected = inspectSnapshotEntry(session, entry.mountPath, config.rootPath);
       mounts.push(inspected.snapshot);
       if (inspected.issue) {
         issues.push(inspected.issue);
@@ -494,12 +285,13 @@ async function reconcileMounts(config, paths, controllerPid = process.pid, signa
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const previousSnapshot = readMountStatusSnapshot(config.rootPath);
   const healthy = mounts.every((mount) => mount.state === "mounted" || mount.state === "pending");
+  const startupInProgress = previousSnapshot?.startupPhase !== "ready" && mounts.some((mount) => mount.state === "syncing" || mount.state === "reconnecting");
   const snapshot = {
     updatedAt: now,
     controllerPid,
     running: true,
-    startupPhase: "ready",
-    startupMessage: void 0,
+    startupPhase: startupInProgress ? "syncing" : "ready",
+    startupMessage: startupInProgress ? createInitialSyncMessage(mounts) : void 0,
     lastHealthySyncAt: healthy ? now : previousSnapshot?.lastHealthySyncAt,
     lastSuccessfulSyncAt: healthy ? now : previousSnapshot?.lastSuccessfulSyncAt,
     lastIssueAt: issues.length > 0 ? now : previousSnapshot?.lastIssueAt,
@@ -540,8 +332,9 @@ async function ensureMountedHandle(entry, config, paths, signal) {
     config.rootPath
   );
 }
-function inspectSnapshotEntry(session, mountPath) {
+function inspectSnapshotEntry(session, mountPath, rootPath) {
   const status = (session.status ?? "").toLowerCase();
+  const progressDetails = buildSyncProgressDetails(session, rootPath);
   const problemParts = [];
   if (session.conflictCount > 0) {
     problemParts.push(
@@ -563,36 +356,137 @@ function inspectSnapshotEntry(session, mountPath) {
   if (!session.alphaConnected) {
     const message = session.lastError ?? "local sync endpoint disconnected";
     return {
-      snapshot: snapshotEntry(session.handle, mountPath, "error", message),
+      snapshot: snapshotEntry(session.handle, mountPath, "error", message, {
+        status: session.status,
+        progress: session.stagingProgress,
+        currentFile: session.currentFile
+      }),
       issue: `${session.handle}: ${message}`
     };
   }
   if (!session.betaConnected || status.includes("connecting") || status.includes("reconnect")) {
-    const message = session.lastError ?? "reconnecting to remote machine";
+    const message = session.lastError ?? progressDetails.message ?? "connecting to remote machine";
     return {
-      snapshot: snapshotEntry(session.handle, mountPath, "reconnecting", message),
-      issue: `${session.handle}: ${message}`
+      snapshot: snapshotEntry(session.handle, mountPath, "reconnecting", message, {
+        status: session.status,
+        progress: session.stagingProgress,
+        currentFile: session.currentFile,
+        etaSeconds: progressDetails.etaSeconds
+      })
+    };
+  }
+  if (isMutagenSyncInProgress(status)) {
+    return {
+      snapshot: snapshotEntry(
+        session.handle,
+        mountPath,
+        "syncing",
+        progressDetails.message ?? session.status ?? "initial sync in progress",
+        {
+          status: session.status,
+          progress: session.stagingProgress,
+          currentFile: session.currentFile,
+          etaSeconds: progressDetails.etaSeconds
+        }
+      )
     };
   }
   if (session.lastError && !status.includes("watching")) {
     return {
-      snapshot: snapshotEntry(session.handle, mountPath, "degraded", session.lastError),
+      snapshot: snapshotEntry(session.handle, mountPath, "degraded", session.lastError, {
+        status: session.status,
+        progress: session.stagingProgress,
+        currentFile: session.currentFile
+      }),
       issue: `${session.handle}: ${session.lastError}`
     };
   }
   return {
-    snapshot: snapshotEntry(session.handle, mountPath, "mounted")
+    snapshot: snapshotEntry(session.handle, mountPath, "mounted", void 0, {
+      status: session.status
+    })
   };
 }
-function snapshotEntry(handle, mountPath, state, message) {
+function snapshotEntry(handle, mountPath, state, message, extra = {}) {
   return {
     handle,
     mountPath,
     state,
     message,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...extra
   };
 }
+function isMutagenSyncInProgress(status) {
+  return [
+    "staging",
+    "scanning",
+    "reconciling",
+    "applying",
+    "saving",
+    "waiting"
+  ].some((phase) => status.includes(phase));
+}
+function buildSyncProgressDetails(session, rootPath) {
+  const details = [];
+  if (session.status) {
+    details.push(session.status);
+  }
+  if (session.stagingProgress) {
+    details.push(session.stagingProgress);
+  }
+  if (session.currentFile) {
+    details.push(session.currentFile);
+  }
+  const startedAt = readMountHandleMeta(session.handle, rootPath)?.lastStartedAt;
+  const etaSeconds = estimateEtaSeconds(startedAt, session.stagingProgress);
+  if (etaSeconds !== void 0) {
+    details.push(`eta ~${formatSeconds(etaSeconds)}`);
+  }
+  return {
+    message: details.length > 0 ? details.join("; ") : void 0,
+    etaSeconds
+  };
+}
+function estimateEtaSeconds(startedAt, stagingProgress) {
+  if (!startedAt || !stagingProgress) {
+    return void 0;
+  }
+  const match = stagingProgress.match(/(\d+)%/);
+  if (!match) {
+    return void 0;
+  }
+  const percent = Number.parseInt(match[1] ?? "", 10);
+  if (!Number.isFinite(percent) || percent <= 0 || percent >= 100) {
+    return void 0;
+  }
+  const elapsedSeconds = Math.max(
+    0,
+    (Date.now() - new Date(startedAt).getTime()) / 1e3
+  );
+  if (!Number.isFinite(elapsedSeconds) || elapsedSeconds < 1) {
+    return void 0;
+  }
+  return Math.max(1, Math.round(elapsedSeconds * (100 - percent) / percent));
+}
+function formatSeconds(seconds) {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainder = seconds % 60;
+  return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
+}
+function createInitialSyncMessage(mounts) {
+  const actionable = mounts.filter((mount) => mount.state !== "pending");
+  const readyCount = actionable.filter((mount) => mount.state === "mounted").length;
+  const active = actionable.find((mount) => mount.state === "syncing") ?? actionable.find((mount) => mount.state === "reconnecting");
+  if (!active) {
+    return "Waiting for initial sync...";
+  }
+  const progressPrefix = actionable.length > 0 ? `${readyCount}/${actionable.length} ready; ` : "";
+  return `Waiting for initial sync... ${progressPrefix}${active.handle}: ${active.message ?? active.state}`;
+}
 function sortSnapshots(mounts) {
   return mounts.slice().sort((left, right) => left.handle.localeCompare(right.handle));
 }
@@ -614,7 +508,7 @@ function terminateOwnedSessions(sessions, config, paths, signal) {
   ).then(() => void 0);
 }
 async function removeHandleFromRoot(handle, paths) {
-  await rm(join2(paths.rootPath, handle), { recursive: true, force: true });
+  await rm(join(paths.rootPath, handle), { recursive: true, force: true });
 }
 async function listRootHandleDirectories(rootPath) {
   try {
@@ -639,29 +533,6 @@ function throwIfAborted(signal) {
 }
 
 export {
-  getAPIKey,
-  getStoredAPIKey,
-  hasEnvAPIKey,
-  setAPIKey,
-  clearAPIKey,
-  ApiError,
-  getBaseURL,
-  getWebURL,
-  api,
-  apiWithKey,
-  listComputers,
-  getComputerByID,
-  createComputer,
-  deleteComputer,
-  getFilesystemSettings,
-  getConnectionInfo,
-  createBrowserAccess,
-  listPublishedPorts,
-  publishPort,
-  deletePublishedPort,
-  resolveComputer,
-  webURL,
-  vncURL,
   padEnd,
   timeAgo,
   formatStatus,