aicomputer 0.1.18 → 0.1.20

package/dist/chunk-3ZF7JRBW.js

@@ -0,0 +1,270 @@
+import {
+  resolveSystemCommandPath
+} from "./chunk-5Y2NWK5I.js";
+
+// src/lib/autossh-runtime.ts
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  rmSync
+} from "fs";
+import { writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var BUNDLED_AUTOSSH_VERSION = "1.4f";
+var BUNDLED_AUTOSSH_DOWNLOAD_BASE = `https://github.com/Autossh/autossh/archive/refs/tags/v${BUNDLED_AUTOSSH_VERSION}.tar.gz`;
+var BUNDLED_AUTOSSH_ARCHIVE_SHA256 = "fce67ee6e8e032eb41eca984f7e16a6ea74f85c513d94f78e56656815c473604";
+var AGENTCOMPUTER_AUTOSSH_PATH_ENV = "AGENTCOMPUTER_AUTOSSH_PATH";
+var AUTOSSH_SSH_PATH_ENV = "AUTOSSH_PATH";
+function getBundledAutosshAsset(platform = process.platform, homeDirectory = homedir()) {
+  if (!isSupportedPlatform(platform)) {
+    return null;
+  }
+  const installDir = join(
+    homeDirectory,
+    ".agentcomputer",
+    "tools",
+    "autossh",
+    `v${BUNDLED_AUTOSSH_VERSION}`,
+    platform
+  );
+  return {
+    platform,
+    version: BUNDLED_AUTOSSH_VERSION,
+    archiveName: `autossh-v${BUNDLED_AUTOSSH_VERSION}.tar.gz`,
+    downloadUrl: BUNDLED_AUTOSSH_DOWNLOAD_BASE,
+    archiveSha256: BUNDLED_AUTOSSH_ARCHIVE_SHA256,
+    installDir,
+    executablePath: join(installDir, "bin", "autossh")
+  };
+}
+function hasBundledAutossh() {
+  const asset = getBundledAutosshAsset();
+  return asset ? existsSync(asset.executablePath) : false;
+}
+async function ensureAutosshCommandPath(env = process.env) {
+  const resolution = lookupAutosshCommandPath(env);
+  if (resolution.commandPath) {
+    return resolution.commandPath;
+  }
+  if (!resolution.asset) {
+    throw new Error(
+      `Agent Computer does not ship bundled autossh for ${process.platform}. Install autossh manually and rerun \`computer ssh\`.`
+    );
+  }
+  try {
+    return await installBundledAutossh(resolution.asset);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unknown autossh install failure";
+    throw new Error(
+      `Failed to install Agent Computer's bundled autossh (${reason}). Check your network connection and local build tools, then rerun \`computer ssh\`.`
+    );
+  }
+}
+async function ensureBundledAutosshInstalled() {
+  const asset = getBundledAutosshAsset();
+  if (!asset) {
+    throw new Error(
+      `Agent Computer does not ship bundled autossh for ${process.platform}.`
+    );
+  }
+  return installBundledAutossh(asset);
+}
+function resolveAutosshCommandPath(env = process.env) {
+  const resolution = lookupAutosshCommandPath(env);
+  if (resolution.commandPath) {
+    return resolution.commandPath;
+  }
+  if (!resolution.asset) {
+    throw new Error(
+      `Agent Computer does not ship bundled autossh for ${process.platform}. Install autossh manually and rerun \`computer ssh\`.`
+    );
+  }
+  throw new Error(
+    "autossh is not installed yet. Re-run `computer ssh` and Agent Computer will install its bundled copy."
+  );
+}
+function resolveAutosshSSHCommandPath(env = process.env) {
+  const overridden = env[AUTOSSH_SSH_PATH_ENV]?.trim();
+  if (overridden) {
+    return overridden;
+  }
+  const systemPath = resolveSystemCommandPath("ssh", env);
+  if (systemPath) {
+    return systemPath;
+  }
+  throw new Error(getMissingOpenSSHClientMessage());
+}
+function getMissingOpenSSHClientMessage(platform = process.platform) {
+  switch (platform) {
+    case "darwin":
+      return "OpenSSH client tools are required for `computer ssh`. Install the macOS command line tools or make sure `ssh` is available on PATH, then rerun the command.";
+    case "linux":
+      return "OpenSSH client tools are required for `computer ssh`. Install `ssh` and `scp` with your package manager, then rerun the command.";
+    default:
+      return "OpenSSH client tools are required for `computer ssh`. Install `ssh` and `scp`, then rerun the command.";
+  }
+}
+async function installBundledAutossh(asset) {
+  if (existsSync(asset.executablePath)) {
+    return asset.executablePath;
+  }
+  const sshPath = resolveSystemCommandPath("ssh");
+  if (!sshPath) {
+    throw new Error("OpenSSH client (`ssh`) is required before autossh can be provisioned");
+  }
+  if (!resolveSystemCommandPath("make")) {
+    throw new Error("`make` is required to build bundled autossh");
+  }
+  const ccPath = resolveSystemCommandPath("cc") ?? resolveSystemCommandPath("clang");
+  if (!ccPath) {
+    throw new Error("a C compiler is required to build bundled autossh");
+  }
+  if (!resolveSystemCommandPath("tar")) {
+    throw new Error("`tar` is required to extract bundled autossh");
+  }
+  mkdirSync(dirname(asset.installDir), { recursive: true });
+  const stagingDir = `${asset.installDir}.staging-${process.pid}-${Date.now()}`;
+  const archivePath = join(stagingDir, asset.archiveName);
+  const prefixDir = join(stagingDir, "prefix");
+  rmSync(stagingDir, { recursive: true, force: true });
+  if (existsSync(asset.installDir) && !existsSync(asset.executablePath)) {
+    rmSync(asset.installDir, { recursive: true, force: true });
+  }
+  mkdirSync(stagingDir, { recursive: true });
+  try {
+    const response = await fetch(asset.downloadUrl, {
+      headers: {
+        "User-Agent": "aicomputer-cli"
+      }
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(`download failed with status ${response.status}`);
+    }
+    const archiveBuffer = Buffer.from(await response.arrayBuffer());
+    verifyAutosshArchiveChecksum(asset, archiveBuffer);
+    await writeFile(archivePath, archiveBuffer, {
+      mode: 384
+    });
+    const extract = spawnSync("tar", ["-xzf", archivePath, "-C", stagingDir], {
+      encoding: "utf8"
+    });
+    if (extract.status !== 0) {
+      throw new Error(
+        extract.stderr.trim() || extract.stdout.trim() || `failed to extract ${asset.archiveName}`
+      );
+    }
+    const sourceDir = findExtractedSourceDir(stagingDir);
+    if (!sourceDir) {
+      throw new Error("downloaded autossh archive did not contain source files");
+    }
+    const configure = spawnSync(
+      "./configure",
+      [`--prefix=${prefixDir}`, `--with-ssh=${sshPath}`],
+      {
+        cwd: sourceDir,
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          CC: ccPath
+        }
+      }
+    );
+    if (configure.status !== 0) {
+      throw new Error(
+        configure.stderr.trim() || configure.stdout.trim() || "autossh configure failed"
+      );
+    }
+    const make = spawnSync("make", [], {
+      cwd: sourceDir,
+      encoding: "utf8",
+      env: {
+        ...process.env,
+        CC: ccPath
+      }
+    });
+    if (make.status !== 0) {
+      throw new Error(make.stderr.trim() || make.stdout.trim() || "autossh build failed");
+    }
+    const install = spawnSync("make", ["install"], {
+      cwd: sourceDir,
+      encoding: "utf8",
+      env: {
+        ...process.env,
+        CC: ccPath
+      }
+    });
+    if (install.status !== 0) {
+      throw new Error(
+        install.stderr.trim() || install.stdout.trim() || "autossh install failed"
+      );
+    }
+    if (!existsSync(join(prefixDir, "bin", "autossh"))) {
+      throw new Error("autossh install did not produce the executable");
+    }
+    chmodSync(join(prefixDir, "bin", "autossh"), 493);
+    rmSync(archivePath, { force: true });
+    try {
+      renameSync(prefixDir, asset.installDir);
+    } catch (error) {
+      if (!existsSync(asset.executablePath)) {
+        throw error;
+      }
+    }
+    rmSync(stagingDir, { recursive: true, force: true });
+    return asset.executablePath;
+  } catch (error) {
+    rmSync(stagingDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+function lookupAutosshCommandPath(env) {
+  const overridden = env[AGENTCOMPUTER_AUTOSSH_PATH_ENV]?.trim();
+  const asset = getBundledAutosshAsset();
+  if (overridden) {
+    return { asset, commandPath: overridden };
+  }
+  if (asset && existsSync(asset.executablePath)) {
+    return { asset, commandPath: asset.executablePath };
+  }
+  return {
+    asset,
+    commandPath: resolveSystemCommandPath("autossh", env)
+  };
+}
+function verifyAutosshArchiveChecksum(asset, archiveBuffer) {
+  const digest = createHash("sha256").update(archiveBuffer).digest("hex");
+  if (digest !== asset.archiveSha256) {
+    throw new Error(
+      `autossh archive checksum mismatch (expected ${asset.archiveSha256}, got ${digest})`
+    );
+  }
+}
+function findExtractedSourceDir(stagingDir) {
+  for (const entry of readdirSync(stagingDir, { withFileTypes: true })) {
+    if (entry.isDirectory() && entry.name !== "prefix") {
+      return join(stagingDir, entry.name);
+    }
+  }
+  return null;
+}
+function isSupportedPlatform(platform) {
+  return platform === "darwin" || platform === "linux";
+}
+
+export {
+  AGENTCOMPUTER_AUTOSSH_PATH_ENV,
+  AUTOSSH_SSH_PATH_ENV,
+  getBundledAutosshAsset,
+  hasBundledAutossh,
+  ensureAutosshCommandPath,
+  ensureBundledAutosshInstalled,
+  resolveAutosshCommandPath,
+  resolveAutosshSSHCommandPath,
+  getMissingOpenSSHClientMessage
+};

package/dist/chunk-4TE5XTYE.js

@@ -0,0 +1,242 @@
+import {
+  AUTOSSH_SSH_PATH_ENV,
+  ensureAutosshCommandPath,
+  resolveAutosshSSHCommandPath
+} from "./chunk-3ZF7JRBW.js";
+import {
+  api,
+  getConnectionInfo,
+  resolveComputer
+} from "./chunk-LOGK7YYJ.js";
+
+// src/lib/ssh-access.ts
+import { spawn } from "child_process";
+import { basename as basename2 } from "path";
+
+// src/lib/ssh-keys.ts
+import { basename } from "path";
+import { homedir } from "os";
+import { readFile, mkdir } from "fs/promises";
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+var DEFAULT_PUBLIC_KEY_PATHS = [
+  `${homedir()}/.ssh/id_ed25519.pub`,
+  `${homedir()}/.ssh/id_ecdsa.pub`,
+  `${homedir()}/.ssh/id_rsa.pub`
+];
+async function ensureDefaultSSHKeyRegistered() {
+  for (const path of DEFAULT_PUBLIC_KEY_PATHS) {
+    try {
+      const publicKey2 = (await readFile(path, "utf8")).trim();
+      if (!publicKey2) {
+        continue;
+      }
+      const key2 = await api("/v1/ssh-keys", {
+        method: "POST",
+        body: JSON.stringify({
+          name: basename(path),
+          public_key: publicKey2
+        })
+      });
+      return {
+        key: key2,
+        publicKeyPath: path,
+        privateKeyPath: path.replace(/\.pub$/, "")
+      };
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+  }
+  const generated = await generateSSHKey();
+  const publicKey = (await readFile(generated.publicKeyPath, "utf8")).trim();
+  const key = await api("/v1/ssh-keys", {
+    method: "POST",
+    body: JSON.stringify({
+      name: basename(generated.publicKeyPath),
+      public_key: publicKey
+    })
+  });
+  return {
+    key,
+    publicKeyPath: generated.publicKeyPath,
+    privateKeyPath: generated.privateKeyPath
+  };
+}
+async function generateSSHKey() {
+  const sshDir = `${homedir()}/.ssh`;
+  if (!existsSync(sshDir)) {
+    await mkdir(sshDir, { mode: 448 });
+  }
+  const privateKeyPath = `${sshDir}/id_ed25519`;
+  const publicKeyPath = `${privateKeyPath}.pub`;
+  console.log("No SSH key found \u2014 generating one at", publicKeyPath);
+  execFileSync("ssh-keygen", ["-t", "ed25519", "-f", privateKeyPath, "-N", ""], {
+    stdio: "inherit"
+  });
+  return { publicKeyPath, privateKeyPath };
+}
+
+// src/lib/ssh-access.ts
+var AUTOSSH_BINARY = "autossh";
+var AUTOSSH_MONITOR_PORT = "0";
+var TMUX_SESSION_NAME = "agentcomputer";
+var TMUX_INCOMPATIBLE_SSH_ARGS = /* @__PURE__ */ new Set(["-N", "-T", "-f"]);
+var SSH_SERVER_ALIVE_INTERVAL_SECONDS = 30;
+var SSH_SERVER_ALIVE_COUNT_MAX = 3;
+async function prepareSSHConnection(computer, options = {}) {
+  const registered = await ensureDefaultSSHKeyRegistered();
+  const info = await getConnectionInfo(computer.id);
+  if (!info.connection.ssh_available) {
+    throw new Error("SSH is not available for this computer");
+  }
+  const launchPlan = buildSSHLaunchPlan({
+    user: info.connection.ssh_user,
+    host: info.connection.ssh_host,
+    port: info.connection.ssh_port,
+    identityFilePath: registered.privateKeyPath,
+    commandPath: await ensureAutosshCommandPath(),
+    sshCommandPath: resolveAutosshSSHCommandPath(),
+    extraArgs: options.extraArgs,
+    tmux: options.tmux
+  });
+  return {
+    computer,
+    ...launchPlan
+  };
+}
+async function prepareSSHConnectionByIdentifier(identifier, options = {}) {
+  const computer = await resolveComputer(identifier);
+  return prepareSSHConnection(computer, options);
+}
+async function openSSHConnection(connection) {
+  await new Promise((resolve, reject) => {
+    const child = spawn(connection.commandPath, connection.args, {
+      env: {
+        ...process.env,
+        ...connection.env
+      },
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(
+        new Error(
+          `${basename2(connection.commandPath)} exited with code ${code ?? 1}`
+        )
+      );
+    });
+  });
+}
+function buildSSHLaunchPlan(input) {
+  const user = input.user.trim();
+  const host = input.host.trim();
+  const port = input.port;
+  const identityFilePath = input.identityFilePath.trim();
+  const extraArgs = [...input.extraArgs ?? []];
+  const tmux = input.tmux === true;
+  if (!user || !host) {
+    throw new Error("ssh is unavailable");
+  }
+  if (!identityFilePath) {
+    throw new Error("ssh identity file is required");
+  }
+  if (tmux) {
+    validateTmuxSSHArgs(extraArgs);
+  }
+  const commandPath = input.commandPath?.trim() || AUTOSSH_BINARY;
+  const env = {};
+  if (input.sshCommandPath?.trim()) {
+    env[AUTOSSH_SSH_PATH_ENV] = input.sshCommandPath.trim();
+  }
+  return {
+    commandPath,
+    command: formatSSHCommand(user, host, port, extraArgs, { tmux }),
+    args: [
+      "-M",
+      AUTOSSH_MONITOR_PORT,
+      ...getSSHResilienceOptionArgs(),
+      "-i",
+      identityFilePath,
+      "-p",
+      String(port),
+      ...tmux ? ["-t"] : [],
+      ...extraArgs,
+      `${user}@${host}`,
+      ...tmux ? getTmuxRemoteCommandArgs() : []
+    ],
+    env
+  };
+}
+function getSSHResilienceOptionArgs() {
+  return [
+    "-o",
+    `ServerAliveInterval=${SSH_SERVER_ALIVE_INTERVAL_SECONDS}`,
+    "-o",
+    `ServerAliveCountMax=${SSH_SERVER_ALIVE_COUNT_MAX}`,
+    "-o",
+    "ExitOnForwardFailure=yes"
+  ];
+}
+function getSSHResilienceConfigLines() {
+  return [
+    `ServerAliveInterval ${SSH_SERVER_ALIVE_INTERVAL_SECONDS}`,
+    `ServerAliveCountMax ${SSH_SERVER_ALIVE_COUNT_MAX}`,
+    "ExitOnForwardFailure yes"
+  ];
+}
+function formatSSHCommand(user, host, port, extraArgs = [], options = {}) {
+  if (!user.trim() || !host.trim()) {
+    return "ssh unavailable";
+  }
+  const parts = [AUTOSSH_BINARY, "-M", AUTOSSH_MONITOR_PORT];
+  if (port > 0 && port !== 22) {
+    parts.push("-p", String(port));
+  }
+  if (options.tmux) {
+    parts.push("-t");
+  }
+  parts.push(...extraArgs, `${user}@${host}`);
+  if (options.tmux) {
+    parts.push(...getTmuxRemoteCommandArgs());
+  }
+  return parts.map(formatShellDisplayArg).join(" ");
+}
+function getTmuxRemoteCommandArgs() {
+  return ["tmux", "new-session", "-A", "-s", TMUX_SESSION_NAME];
+}
+function validateTmuxSSHArgs(extraArgs) {
+  const incompatibleArg = extraArgs.find(
+    (arg) => TMUX_INCOMPATIBLE_SSH_ARGS.has(arg)
+  );
+  if (incompatibleArg) {
+    throw new Error(
+      `--tmux cannot be combined with ${incompatibleArg} because tmux attach mode requires an interactive shell.`
+    );
+  }
+}
+function formatShellDisplayArg(value) {
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+
+export {
+  ensureDefaultSSHKeyRegistered,
+  SSH_SERVER_ALIVE_INTERVAL_SECONDS,
+  SSH_SERVER_ALIVE_COUNT_MAX,
+  prepareSSHConnection,
+  prepareSSHConnectionByIdentifier,
+  openSSHConnection,
+  buildSSHLaunchPlan,
+  getSSHResilienceOptionArgs,
+  getSSHResilienceConfigLines,
+  formatSSHCommand
+};

package/dist/chunk-5Y2NWK5I.js

@@ -0,0 +1,14 @@
+// src/lib/system-tools.ts
+import { spawnSync } from "child_process";
+function resolveSystemCommandPath(command, env = process.env) {
+  const result = spawnSync("which", [command], { encoding: "utf8", env });
+  if (result.status !== 0) {
+    return null;
+  }
+  const resolved = result.stdout.trim();
+  return resolved.length > 0 ? resolved : null;
+}
+
+export {
+  resolveSystemCommandPath
+};

package/dist/chunk-D3SAFNSI.js

@@ -0,0 +1,75 @@
+import {
+  getSSHResilienceConfigLines
+} from "./chunk-4TE5XTYE.js";
+
+// src/lib/ssh-config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir, readFile, writeFile } from "fs/promises";
+var MANAGED_BLOCK_START = "# >>> agentcomputer ssh setup >>>";
+var MANAGED_BLOCK_END = "# <<< agentcomputer ssh setup <<<";
+async function ensureSSHAliasConfig(options) {
+  const sshDir = join(homedir(), ".ssh");
+  const configPath = join(sshDir, "config");
+  await mkdir(sshDir, { recursive: true, mode: 448 });
+  let existing = "";
+  try {
+    existing = await readFile(configPath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const nextBlock = renderManagedBlock(options);
+  const managedBlockPattern = new RegExp(
+    `${escapeRegex(MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegex(MANAGED_BLOCK_END)}\\n?`,
+    "m"
+  );
+  let nextContents;
+  if (managedBlockPattern.test(existing)) {
+    nextContents = existing.replace(managedBlockPattern, nextBlock);
+  } else {
+    const normalized = existing.length === 0 ? "" : existing.endsWith("\n") ? existing : `${existing}
+`;
+    nextContents = normalized.length === 0 ? nextBlock : `${normalized}
+${nextBlock}`;
+  }
+  const changed = nextContents !== existing;
+  if (changed) {
+    await writeFile(configPath, nextContents, { mode: 384 });
+  }
+  return {
+    configPath,
+    changed
+  };
+}
+function renderManagedBlock(options) {
+  const user = options.user?.trim() || "agentcomputer";
+  const identityFile = formatIdentityFilePath(options.identityFilePath);
+  const resilienceLines = getSSHResilienceConfigLines().map((line) => `  ${line}`).join("\n");
+  return `${MANAGED_BLOCK_START}
+Host ${options.alias}
+  HostName ${options.host}
+  Port ${options.port}
+  User ${user}
+  IdentityFile ${identityFile}
+  IdentitiesOnly yes
+${resilienceLines}
+${MANAGED_BLOCK_END}
+`;
+}
+function formatIdentityFilePath(path) {
+  const normalized = path.trim();
+  const homePath = `${homedir()}/`;
+  if (normalized.startsWith(homePath)) {
+    return `~/${normalized.slice(homePath.length)}`;
+  }
+  return normalized.replaceAll(" ", "\\ ");
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export {
+  ensureSSHAliasConfig
+};