aicomputer 0.1.22 → 0.2.1

package/dist/chunk-KXLTHWW3.js

@@ -1,184 +0,0 @@
-// src/lib/mount-config.ts
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeFileSync
-} from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var MOUNT_SERVICE_LABEL = "ai.agentcomputer.mount";
-function getDefaultMountRoot() {
-  return join(homedir(), "agentcomputer");
-}
-function getMountStateDir() {
-  return join(homedir(), ".computer", "mount");
-}
-function getMountPaths(rootPath = getDefaultMountRoot()) {
-  const stateDir = getMountStateDir();
-  return {
-    stateDir,
-    rootPath,
-    configPath: join(stateDir, "config.json"),
-    statusPath: join(stateDir, "status.json"),
-    socketPath: join(stateDir, "control.sock"),
-    controllerLockPath: join(stateDir, "controller.lock.json"),
-    handlesDir: join(stateDir, "handles"),
-    sshToolsDir: join(stateDir, "ssh-tools"),
-    staleDir: join(stateDir, "stale")
-  };
-}
-function getMountHandlePaths(handle, rootPath = getDefaultMountRoot()) {
-  const paths = getMountPaths(rootPath);
-  const stateDir = join(paths.handlesDir, handle);
-  return {
-    stateDir,
-    metaPath: join(stateDir, "meta.json"),
-    sshToolsDir: join(stateDir, "ssh-tools")
-  };
-}
-function defaultMountServiceConfig() {
-  return {
-    alias: "agentcomputer.ai",
-    host: "ssh.agentcomputer.ai",
-    port: 443,
-    rootPath: getDefaultMountRoot(),
-    pollIntervalMs: 5e3,
-    connectTimeoutSeconds: 5
-  };
-}
-function ensureMountDirectories(paths) {
-  for (const directory of [
-    paths.stateDir,
-    paths.handlesDir,
-    paths.sshToolsDir,
-    paths.staleDir
-  ]) {
-    if (!existsSync(directory)) {
-      mkdirSync(directory, { recursive: true, mode: 448 });
-    }
-  }
-}
-function ensureHandleDirectories(handle, rootPath) {
-  const handlePaths = getMountHandlePaths(handle, rootPath);
-  for (const directory of [handlePaths.stateDir, handlePaths.sshToolsDir]) {
-    if (!existsSync(directory)) {
-      mkdirSync(directory, { recursive: true, mode: 448 });
-    }
-  }
-  return handlePaths;
-}
-function readMountConfig() {
-  const defaults = defaultMountServiceConfig();
-  const paths = getMountPaths(defaults.rootPath);
-  if (!existsSync(paths.configPath)) {
-    return null;
-  }
-  try {
-    const raw = JSON.parse(readFileSync(paths.configPath, "utf8"));
-    return {
-      alias: typeof raw.alias === "string" && raw.alias.trim() ? raw.alias.trim() : defaults.alias,
-      host: typeof raw.host === "string" && raw.host.trim() ? raw.host.trim() : defaults.host,
-      port: typeof raw.port === "number" ? raw.port : defaults.port,
-      rootPath: typeof raw.rootPath === "string" && raw.rootPath.trim() ? raw.rootPath.trim() : defaults.rootPath,
-      pollIntervalMs: typeof raw.pollIntervalMs === "number" && raw.pollIntervalMs > 0 ? raw.pollIntervalMs : defaults.pollIntervalMs,
-      connectTimeoutSeconds: typeof raw.connectTimeoutSeconds === "number" && raw.connectTimeoutSeconds > 0 ? raw.connectTimeoutSeconds : defaults.connectTimeoutSeconds
-    };
-  } catch {
-    return null;
-  }
-}
-function writeMountConfig(config) {
-  const paths = getMountPaths(config.rootPath);
-  ensureMountDirectories(paths);
-  writeJSONFile(paths.configPath, config);
-}
-function readMountStatusSnapshot(rootPath = getDefaultMountRoot()) {
-  const paths = getMountPaths(rootPath);
-  if (!existsSync(paths.statusPath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync(paths.statusPath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function writeMountStatusSnapshot(snapshot, rootPath = getDefaultMountRoot()) {
-  const paths = getMountPaths(rootPath);
-  ensureMountDirectories(paths);
-  writeJSONFile(paths.statusPath, snapshot);
-}
-function readMountControllerLock(rootPath = getDefaultMountRoot()) {
-  const paths = getMountPaths(rootPath);
-  if (!existsSync(paths.controllerLockPath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync(paths.controllerLockPath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function writeMountControllerLock(lock, rootPath = getDefaultMountRoot()) {
-  const paths = getMountPaths(rootPath);
-  ensureMountDirectories(paths);
-  writeJSONFile(paths.controllerLockPath, lock);
-}
-function removeMountControllerLock(rootPath = getDefaultMountRoot()) {
-  const paths = getMountPaths(rootPath);
-  try {
-    rmSync(paths.controllerLockPath, { force: true });
-  } catch {
-  }
-}
-function readMountHandleMeta(handle, rootPath = getDefaultMountRoot()) {
-  const paths = getMountHandlePaths(handle, rootPath);
-  if (!existsSync(paths.metaPath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync(paths.metaPath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function writeMountHandleMeta(handle, meta, rootPath = getDefaultMountRoot()) {
-  const paths = ensureHandleDirectories(handle, rootPath);
-  writeJSONFile(paths.metaPath, meta);
-}
-function removeMountHandleState(handle, rootPath = getDefaultMountRoot()) {
-  const paths = getMountHandlePaths(handle, rootPath);
-  try {
-    rmSync(paths.stateDir, { recursive: true, force: true });
-  } catch {
-  }
-}
-function writeJSONFile(path, value) {
-  const tempFile = `${path}.${process.pid}.tmp`;
-  writeFileSync(tempFile, JSON.stringify(value, null, 2), { mode: 384 });
-  renameSync(tempFile, path);
-}
-
-export {
-  MOUNT_SERVICE_LABEL,
-  getDefaultMountRoot,
-  getMountStateDir,
-  getMountPaths,
-  getMountHandlePaths,
-  defaultMountServiceConfig,
-  ensureMountDirectories,
-  ensureHandleDirectories,
-  readMountConfig,
-  writeMountConfig,
-  readMountStatusSnapshot,
-  writeMountStatusSnapshot,
-  readMountControllerLock,
-  writeMountControllerLock,
-  removeMountControllerLock,
-  readMountHandleMeta,
-  writeMountHandleMeta,
-  removeMountHandleState
-};

package/dist/chunk-LGJN26BQ.js

@@ -1,242 +0,0 @@
-import {
-  AUTOSSH_SSH_PATH_ENV,
-  ensureAutosshCommandPath,
-  resolveAutosshSSHCommandPath
-} from "./chunk-3ZF7JRBW.js";
-import {
-  api,
-  getConnectionInfo,
-  resolveComputer
-} from "./chunk-E7QD4MHI.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
-};