aicomputer 0.1.22 → 0.2.0

package/dist/chunk-HDZTFK4U.js

@@ -1,544 +0,0 @@
-import {
-  createHandleSession,
-  ensureMutagenSshEnvironment,
-  getHandleSessionName,
-  isAbortError,
-  listOwnedSessions,
-  selectPreferredSession,
-  terminateSession
-} from "./chunk-TPFE3CC6.js";
-import {
-  readMountHandleMeta,
-  readMountStatusSnapshot,
-  removeMountHandleState,
-  writeMountHandleMeta,
-  writeMountStatusSnapshot
-} from "./chunk-KXLTHWW3.js";
-import {
-  getConnectionInfo,
-  listComputers
-} from "./chunk-E7QD4MHI.js";
-
-// src/lib/mount-reconcile.ts
-import { readdir, mkdir, rm } from "fs/promises";
-import { join } from "path";
-
-// 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-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, signal) {
-  const computers = await listComputers(signal);
-  const desired = [];
-  const pending = [];
-  for (const computer of computers.filter(isSSHSelectable)) {
-    const mountPath = join(paths.rootPath, computer.handle);
-    try {
-      const info = await getConnectionInfo(computer.id, signal);
-      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
-    });
-  }
-  throwIfAborted(signal);
-  const ownedSessions = await listOwnedSessions(config, paths, signal);
-  const rootEntries = await listRootHandleDirectories(paths.rootPath);
-  return {
-    plan: computeMountPlan({
-      desired,
-      pending,
-      ownedSessions,
-      rootEntries
-    }),
-    ownedSessions
-  };
-}
-async function reconcileMounts(config, paths, controllerPid = process.pid, signal) {
-  ensureMutagenSshEnvironment(config, paths);
-  throwIfAborted(signal);
-  const { plan, ownedSessions } = await planMountReconcile(config, paths, signal);
-  const mounts = [];
-  const issues = [];
-  const ownedByHandle = groupSessionsByHandle(ownedSessions);
-  for (const handle of [...plan.toStop, ...plan.toReset]) {
-    throwIfAborted(signal);
-    const sessions = ownedByHandle.get(handle) ?? [];
-    try {
-      await terminateOwnedSessions(sessions, config, paths, signal);
-      await removeHandleFromRoot(handle, paths);
-      removeMountHandleState(handle, config.rootPath);
-    } catch (error) {
-      if (isAbortError(error)) {
-        throw error;
-      }
-      issues.push(
-        error instanceof Error ? `${handle}: ${error.message}` : `${handle}: teardown failed`
-      );
-    }
-  }
-  for (const entry of plan.toCreate) {
-    throwIfAborted(signal);
-    try {
-      await ensureMountedHandle(entry, config, paths, signal);
-      const session = selectPreferredSession(
-        entry.handle,
-        (await listOwnedSessions(config, paths, signal)).filter(
-          (candidate) => candidate.handle === entry.handle
-        )
-      );
-      const inspected = inspectSnapshotEntry(session, entry.mountPath, config.rootPath);
-      mounts.push(inspected.snapshot);
-      if (inspected.issue) {
-        issues.push(inspected.issue);
-      }
-    } catch (error) {
-      if (isAbortError(error)) {
-        throw error;
-      }
-      const message = error instanceof Error ? error.message : "sync start failed";
-      mounts.push(snapshotEntry(entry.handle, entry.mountPath, "error", message));
-      issues.push(`${entry.handle}: ${message}`);
-    }
-  }
-  throwIfAborted(signal);
-  const postCreateSessions = groupSessionsByHandle(
-    await listOwnedSessions(config, paths, signal)
-  );
-  for (const entry of plan.toInspect) {
-    throwIfAborted(signal);
-    try {
-      const sessions = postCreateSessions.get(entry.handle) ?? [];
-      if (sessions.length === 0) {
-        await ensureMountedHandle(entry, config, paths, signal);
-        const createdSession = selectPreferredSession(
-          entry.handle,
-          (await listOwnedSessions(config, paths, signal)).filter(
-            (candidate) => candidate.handle === entry.handle
-          )
-        );
-        const inspected2 = inspectSnapshotEntry(
-          createdSession,
-          entry.mountPath,
-          config.rootPath
-        );
-        mounts.push(inspected2.snapshot);
-        if (inspected2.issue) {
-          issues.push(inspected2.issue);
-        }
-        continue;
-      }
-      const session = selectPreferredSession(entry.handle, sessions);
-      const inspected = inspectSnapshotEntry(session, entry.mountPath, config.rootPath);
-      mounts.push(inspected.snapshot);
-      if (inspected.issue) {
-        issues.push(inspected.issue);
-      }
-    } catch (error) {
-      if (isAbortError(error)) {
-        throw error;
-      }
-      const message = error instanceof Error ? error.message : "sync inspection failed";
-      mounts.push(snapshotEntry(entry.handle, entry.mountPath, "error", message));
-      issues.push(`${entry.handle}: ${message}`);
-    }
-  }
-  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 startupInProgress = previousSnapshot?.startupPhase !== "ready" && mounts.some((mount) => mount.state === "syncing" || mount.state === "reconnecting");
-  const snapshot = {
-    updatedAt: now,
-    controllerPid,
-    running: true,
-    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,
-    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, signal) {
-  throwIfAborted(signal);
-  const ownedSessions = await listOwnedSessions(config, paths, signal);
-  await terminateOwnedSessions(ownedSessions, config, paths, signal);
-  const handles = new Set(ownedSessions.map((session) => session.handle));
-  for (const handle of await listKnownHandleStates(paths)) {
-    handles.add(handle);
-  }
-  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, signal) {
-  await mkdir(entry.mountPath, { recursive: true });
-  await createHandleSession(entry.handle, config, paths, signal);
-  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, rootPath) {
-  const status = (session.status ?? "").toLowerCase();
-  const progressDetails = buildSyncProgressDetails(session, rootPath);
-  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, {
-        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 ?? progressDetails.message ?? "connecting to remote machine";
-    return {
-      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, {
-        status: session.status,
-        progress: session.stagingProgress,
-        currentFile: session.currentFile
-      }),
-      issue: `${session.handle}: ${session.lastError}`
-    };
-  }
-  return {
-    snapshot: snapshotEntry(session.handle, mountPath, "mounted", void 0, {
-      status: session.status
-    })
-  };
-}
-function snapshotEntry(handle, mountPath, state, message, extra = {}) {
-  return {
-    handle,
-    mountPath,
-    state,
-    message,
-    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));
-}
-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, signal) {
-  return Promise.all(
-    sessions.map((session) => terminateSession(session, config, paths, signal))
-  ).then(() => void 0);
-}
-async function removeHandleFromRoot(handle, paths) {
-  await rm(join(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 [];
-  }
-}
-function throwIfAborted(signal) {
-  if (signal?.aborted) {
-    const error = new Error("mount operation cancelled");
-    error.name = "AbortError";
-    throw error;
-  }
-}
-
-export {
-  padEnd,
-  timeAgo,
-  formatStatus,
-  promptForSSHComputer,
-  computeMountPlan,
-  planMountReconcile,
-  reconcileMounts,
-  teardownManagedSessions
-};

package/dist/chunk-JMRAYXUO.js

@@ -1,62 +0,0 @@
-// src/lib/mount-host.ts
-import { spawnSync } from "child_process";
-function getMountHostValidationIssues() {
-  return evaluateMountHostValidation({
-    platform: process.platform,
-    hasSsh: hasCommand("ssh"),
-    hasScp: hasCommand("scp")
-  });
-}
-function formatMountHostInstallGuidance(issues) {
-  const lines = [];
-  for (const issue of issues) {
-    switch (issue.code) {
-      case "unsupported-platform":
-        lines.push(
-          "Supported today: macOS and Linux terminals with bundled Mutagen plus OpenSSH client tools available."
-        );
-        break;
-      case "missing-ssh":
-      case "missing-scp":
-        lines.push("Install OpenSSH client tools so both `ssh` and `scp` are available on PATH.");
-        break;
-      default:
-        lines.push(issue.message);
-        break;
-    }
-  }
-  return lines;
-}
-function evaluateMountHostValidation(input) {
-  const issues = [];
-  if (!["darwin", "linux"].includes(input.platform)) {
-    issues.push({
-      code: "unsupported-platform",
-      message: "computer mount currently supports macOS and Linux terminals only"
-    });
-    return issues;
-  }
-  if (!input.hasSsh) {
-    issues.push({
-      code: "missing-ssh",
-      message: "`ssh` is not installed or not available on PATH."
-    });
-  }
-  if (!input.hasScp) {
-    issues.push({
-      code: "missing-scp",
-      message: "`scp` is not installed or not available on PATH."
-    });
-  }
-  return issues;
-}
-function hasCommand(command) {
-  const result = spawnSync("which", [command], { stdio: "ignore" });
-  return result.status === 0;
-}
-
-export {
-  getMountHostValidationIssues,
-  formatMountHostInstallGuidance,
-  evaluateMountHostValidation
-};