aicomputer 0.1.14 → 0.1.16

package/dist/chunk-5IEWKH52.js

@@ -0,0 +1,883 @@
+import {
+  MOUNT_SERVICE_LABEL,
+  ensureHandleDirectories,
+  ensureMountDirectories,
+  readMountStatusSnapshot,
+  removeMountHandleState,
+  writeMountHandleMeta,
+  writeMountStatusSnapshot
+} from "./chunk-KXLTHWW3.js";
+
+// src/lib/mount-reconcile.ts
+import { readdir, mkdir, rm } from "fs/promises";
+import { join as join3 } 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() {
+  const response = await api("/v1/computers");
+  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) {
+  return api(`/v1/computers/${computerID}/connection`);
+}
+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";
+import chalk2 from "chalk";
+
+// src/lib/format.ts
+import chalk from "chalk";
+function padEnd(str, len) {
+  const visible = str.replace(/\u001b\[[0-9;]*m/g, "");
+  return str + " ".repeat(Math.max(0, len - visible.length));
+}
+function timeAgo(dateStr) {
+  const seconds = Math.floor((Date.now() - new Date(dateStr).getTime()) / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function formatStatus(status) {
+  switch (status) {
+    case "running":
+      return chalk.green(status);
+    case "pending":
+    case "provisioning":
+    case "starting":
+      return chalk.yellow(status);
+    case "stopping":
+    case "stopped":
+    case "deleted":
+      return chalk.gray(status);
+    case "error":
+      return chalk.red(status);
+    default:
+      return status;
+  }
+}
+
+// src/lib/computer-picker.ts
+async function promptForSSHComputer(computers, message) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("computer id or handle is required when not running interactively");
+  }
+  const available = computers.filter(isSSHSelectable);
+  if (available.length === 0) {
+    if (computers.length === 0) {
+      throw new Error("no computers found");
+    }
+    throw new Error("no running computers with SSH enabled");
+  }
+  const handleWidth = Math.max(6, ...available.map((computer) => computer.handle.length));
+  const selectedID = await select({
+    message,
+    pageSize: Math.min(available.length, 10),
+    choices: available.map((computer) => ({
+      name: `${padEnd(chalk2.white(computer.handle), handleWidth + 2)}${padEnd(formatStatus(computer.status), 12)}${chalk2.dim(describeSSHChoice(computer))}`,
+      value: computer.id
+    }))
+  });
+  return available.find((computer) => computer.id === selectedID) ?? available[0];
+}
+function isSSHSelectable(computer) {
+  return computer.ssh_enabled && computer.status === "running";
+}
+function describeSSHChoice(computer) {
+  const displayName = computer.display_name.trim();
+  if (displayName && displayName !== computer.handle) {
+    return `${displayName}  ${timeAgo(computer.updated_at)}`;
+  }
+  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));
+  const sessionGroups = /* @__PURE__ */ new Map();
+  for (const session of input.ownedSessions) {
+    const group = sessionGroups.get(session.handle);
+    if (group) {
+      group.push(session);
+    } else {
+      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 session of input.ownedSessions) {
+    if (!desiredHandles.has(session.handle)) {
+      toStop.add(session.handle);
+    }
+  }
+  for (const entry of input.rootEntries) {
+    if (!desiredHandles.has(entry)) {
+      toStop.add(entry);
+    }
+  }
+  for (const handle of toReset) {
+    toStop.delete(handle);
+  }
+  return {
+    toCreate,
+    toInspect,
+    toReset: Array.from(toReset).sort(),
+    toStop: Array.from(toStop).sort(),
+    pending: input.pending
+  };
+}
+async function planMountReconcile(config, paths) {
+  const computers = await listComputers();
+  const desired = [];
+  const pending = [];
+  for (const computer of computers.filter(isSSHSelectable)) {
+    const mountPath = join3(paths.rootPath, computer.handle);
+    try {
+      const info = await getConnectionInfo(computer.id);
+      if (!info.connection.ssh_available) {
+        pending.push({
+          handle: computer.handle,
+          mountPath,
+          ready: false,
+          message: "SSH is not ready yet"
+        });
+        continue;
+      }
+    } catch (error) {
+      pending.push({
+        handle: computer.handle,
+        mountPath,
+        ready: false,
+        message: error instanceof Error ? error.message : "Failed to confirm SSH readiness"
+      });
+      continue;
+    }
+    desired.push({
+      handle: computer.handle,
+      mountPath,
+      ready: true
+    });
+  }
+  const ownedSessions = listOwnedSessions(config, paths);
+  const rootEntries = await listRootHandleDirectories(paths.rootPath);
+  return {
+    plan: computeMountPlan({
+      desired,
+      pending,
+      ownedSessions,
+      rootEntries
+    }),
+    ownedSessions
+  };
+}
+async function reconcileMounts(config, paths, controllerPid = process.pid) {
+  ensureMutagenSshEnvironment(config, paths);
+  const { plan, ownedSessions } = await planMountReconcile(config, paths);
+  const mounts = [];
+  const issues = [];
+  const ownedByHandle = groupSessionsByHandle(ownedSessions);
+  for (const handle of [...plan.toStop, ...plan.toReset]) {
+    const sessions = ownedByHandle.get(handle) ?? [];
+    try {
+      terminateOwnedSessions(sessions, config, paths);
+      await removeHandleFromRoot(handle, paths);
+      removeMountHandleState(handle, config.rootPath);
+    } catch (error) {
+      issues.push(
+        error instanceof Error ? `${handle}: ${error.message}` : `${handle}: teardown failed`
+      );
+    }
+  }
+  for (const entry of plan.toCreate) {
+    try {
+      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);
+      }
+    } catch (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));
+  for (const entry of plan.toInspect) {
+    try {
+      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 inspection failed";
+      mounts.push(snapshotEntry(entry.handle, entry.mountPath, "error", message));
+      issues.push(`${entry.handle}: ${message}`);
+    }
+  }
+  for (const entry of plan.pending) {
+    mounts.push(snapshotEntry(entry.handle, entry.mountPath, "pending", entry.message));
+  }
+  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,
+    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 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 });
+  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
+  );
+}
+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 {
+    handle,
+    mountPath,
+    state,
+    message,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+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();
+  } catch {
+    return [];
+  }
+}
+async function listKnownHandleStates(paths) {
+  try {
+    return (await readdir(paths.handlesDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+
+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,
+  promptForSSHComputer,
+  computeMountPlan,
+  planMountReconcile,
+  reconcileMounts,
+  teardownManagedSessions
+};