aicomputer 0.1.13 → 0.1.15

package/dist/chunk-KQQUR2YX.js

@@ -0,0 +1,655 @@
+import {
+  ensureHandleDirectories,
+  ensureMountDirectories,
+  getMountHandlePaths,
+  readMountStatusSnapshot,
+  removeMountHandleState,
+  writeMountHandleMeta,
+  writeMountStatusSnapshot
+} from "./chunk-5JVJROSI.js";
+
+// src/lib/mount-reconcile.ts
+import { readdir, mkdir, rename, 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 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":
+      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, existsSync as existsSync2, readFileSync as readFileSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { spawnSync } from "child_process";
+import { basename, join as join2 } from "path";
+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 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 inspectHandleProject(handle, config, paths) {
+  const handlePaths = getMountHandlePaths(handle, config.rootPath);
+  if (!existsSync2(handlePaths.projectFilePath)) {
+    return {
+      ok: false,
+      stdout: "",
+      stderr: "project file missing"
+    };
+  }
+  return runMutagen(["project", "list", "-f", handlePaths.projectFilePath], config, paths, handle, true);
+}
+function cleanupKnownHandleProjects(config, paths, handles) {
+  for (const handle of handles) {
+    terminateHandleProject(handle, config, paths);
+  }
+}
+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
+  };
+}
+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 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);
+    } else {
+      toStart.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 entry of input.rootEntries) {
+    if (!desiredHandles.has(entry)) {
+      toStop.add(entry);
+    }
+  }
+  return {
+    toStart,
+    toCheck,
+    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 previousSnapshot = readMountStatusSnapshot(config.rootPath);
+  const rootEntries = await listRootHandleDirectories(paths.rootPath);
+  return computeMountPlan({
+    desired,
+    pending,
+    previousSnapshot,
+    rootEntries
+  });
+}
+async function reconcileMounts(config, paths, controllerPid = process.pid) {
+  ensureMutagenSshEnvironment(config, paths);
+  const plan = await planMountReconcile(config, paths);
+  const mounts = [];
+  const errors = [];
+  for (const handle of plan.toStop) {
+    try {
+      terminateHandleProject(handle, config, paths);
+      await moveHandleOutOfRoot(handle, paths);
+      removeMountHandleState(handle, config.rootPath);
+    } catch (error) {
+      errors.push(
+        error instanceof Error ? `${handle}: ${error.message}` : `${handle}: teardown failed`
+      );
+    }
+  }
+  for (const entry of plan.toCheck) {
+    try {
+      const inspection = inspectHandleProject(entry.handle, config, paths);
+      if (!inspection.ok) {
+        await ensureMountedHandle(entry, config, paths);
+      }
+      mounts.push(snapshotEntry(entry.handle, entry.mountPath, "mounted"));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "sync check failed";
+      mounts.push(snapshotEntry(entry.handle, entry.mountPath, "error", message));
+      errors.push(`${entry.handle}: ${message}`);
+    }
+  }
+  for (const entry of plan.toStart) {
+    try {
+      await ensureMountedHandle(entry, config, paths);
+      mounts.push(snapshotEntry(entry.handle, entry.mountPath, "mounted"));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "sync start failed";
+      mounts.push(snapshotEntry(entry.handle, entry.mountPath, "error", message));
+      errors.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 snapshot = {
+    updatedAt: now,
+    controllerPid,
+    running: true,
+    lastSuccessfulSyncAt: errors.length === 0 ? now : previousSnapshot?.lastSuccessfulSyncAt,
+    lastError: errors[0],
+    mounts: sortSnapshots(mounts)
+  };
+  writeMountStatusSnapshot(snapshot, config.rootPath);
+  return snapshot;
+}
+async function teardownManagedSessions(config, paths) {
+  const handles = await listKnownHandleStates(paths);
+  cleanupKnownHandleProjects(config, paths, handles);
+  for (const handle of handles) {
+    removeMountHandleState(handle, config.rootPath);
+  }
+}
+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);
+  writeMountHandleMeta(
+    entry.handle,
+    {
+      handle: 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 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));
+}
+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,
+  minuteSecondAgo,
+  formatStatus,
+  promptForSSHComputer,
+  computeMountPlan,
+  planMountReconcile,
+  reconcileMounts,
+  teardownManagedSessions
+};