aicomputer 0.1.17 → 0.1.18

package/dist/chunk-F2U4SFJ4.js

@@ -0,0 +1,517 @@
+import {
+  MOUNT_SERVICE_LABEL,
+  ensureHandleDirectories,
+  ensureMountDirectories
+} from "./chunk-KXLTHWW3.js";
+
+// src/lib/mount-mutagen.ts
+import { chmodSync as chmodSync2, readFileSync, symlinkSync, unlinkSync, writeFileSync } from "fs";
+import { spawn, spawnSync as spawnSync2 } from "child_process";
+import { basename, join as join2, relative, resolve } from "path";
+
+// src/lib/mutagen-runtime.ts
+import { spawnSync } from "child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  renameSync,
+  rmSync
+} from "fs";
+import { writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var BUNDLED_MUTAGEN_VERSION = "0.18.1";
+var BUNDLED_MUTAGEN_DOWNLOAD_BASE = `https://github.com/mutagen-io/mutagen/releases/download/v${BUNDLED_MUTAGEN_VERSION}`;
+var AGENTCOMPUTER_MUTAGEN_PATH_ENV = "AGENTCOMPUTER_MUTAGEN_PATH";
+function getBundledMutagenAsset(platform = process.platform, arch = process.arch, homeDirectory = homedir()) {
+  if (!isSupportedPlatform(platform) || !isSupportedArch(arch)) {
+    return null;
+  }
+  const assetName = `mutagen_${platform}_${arch}_v${BUNDLED_MUTAGEN_VERSION}.tar.gz`;
+  const installDir = join(
+    homeDirectory,
+    ".agentcomputer",
+    "tools",
+    "mutagen",
+    `v${BUNDLED_MUTAGEN_VERSION}`,
+    `${platform}-${arch}`
+  );
+  return {
+    platform,
+    arch,
+    version: BUNDLED_MUTAGEN_VERSION,
+    assetName,
+    downloadUrl: `${BUNDLED_MUTAGEN_DOWNLOAD_BASE}/${assetName}`,
+    installDir,
+    executablePath: join(installDir, "mutagen")
+  };
+}
+function resolveSystemCommandPath(command) {
+  const result = spawnSync("which", [command], { encoding: "utf8" });
+  if (result.status !== 0) {
+    return null;
+  }
+  const resolved = result.stdout.trim();
+  return resolved.length > 0 ? resolved : null;
+}
+async function ensureMutagenCommandPath() {
+  const asset = getBundledMutagenAsset();
+  if (asset && existsSync(asset.executablePath)) {
+    return asset.executablePath;
+  }
+  const systemPath = resolveSystemCommandPath("mutagen");
+  if (!asset) {
+    if (systemPath) {
+      return systemPath;
+    }
+    throw new Error(
+      `Agent Computer does not ship bundled Mutagen for ${process.platform} ${process.arch}. Install Mutagen manually and rerun \`computer mount\`.`
+    );
+  }
+  try {
+    return await installBundledMutagen(asset);
+  } catch (error) {
+    if (systemPath) {
+      return systemPath;
+    }
+    const reason = error instanceof Error ? error.message : "unknown Mutagen install failure";
+    throw new Error(
+      `Failed to install Agent Computer's bundled Mutagen (${reason}). Check your network connection and rerun \`computer mount\`.`
+    );
+  }
+}
+async function ensureBundledMutagenInstalled() {
+  const asset = getBundledMutagenAsset();
+  if (!asset) {
+    throw new Error(
+      `Agent Computer does not ship bundled Mutagen for ${process.platform} ${process.arch}.`
+    );
+  }
+  return installBundledMutagen(asset);
+}
+function resolveMutagenCommandPath() {
+  const overridden = process.env[AGENTCOMPUTER_MUTAGEN_PATH_ENV]?.trim();
+  if (overridden) {
+    return overridden;
+  }
+  const asset = getBundledMutagenAsset();
+  if (asset && existsSync(asset.executablePath)) {
+    return asset.executablePath;
+  }
+  const systemPath = resolveSystemCommandPath("mutagen");
+  if (systemPath) {
+    return systemPath;
+  }
+  if (!asset) {
+    throw new Error(
+      `Agent Computer does not ship bundled Mutagen for ${process.platform} ${process.arch}. Install Mutagen manually and rerun \`computer mount\`.`
+    );
+  }
+  throw new Error(
+    "Mutagen is not installed yet. Re-run `computer mount` and Agent Computer will install its bundled copy."
+  );
+}
+async function installBundledMutagen(asset) {
+  if (existsSync(asset.executablePath)) {
+    return asset.executablePath;
+  }
+  mkdirSync(dirname(asset.installDir), { recursive: true });
+  const stagingDir = `${asset.installDir}.staging-${process.pid}-${Date.now()}`;
+  const archivePath = join(stagingDir, asset.assetName);
+  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}`);
+    }
+    await writeFile(archivePath, Buffer.from(await response.arrayBuffer()), {
+      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.assetName}`
+      );
+    }
+    if (!existsSync(join(stagingDir, "mutagen"))) {
+      throw new Error("archive did not contain the Mutagen executable");
+    }
+    chmodSync(join(stagingDir, "mutagen"), 493);
+    rmSync(archivePath, { force: true });
+    try {
+      renameSync(stagingDir, 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 isSupportedPlatform(platform) {
+  return platform === "darwin" || platform === "linux";
+}
+function isSupportedArch(arch) {
+  return arch === "arm64" || arch === "x64";
+}
+
+// src/lib/mount-mutagen.ts
+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 getDefaultMountIgnorePaths() {
+  return [...DEFAULT_IGNORE_PATHS];
+}
+function createHandleSession(handle, config, paths, signal) {
+  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);
+  }
+  return runMutagen(args, config, paths, handle, { signal }).then(async () => {
+    await runMutagen(
+      ["sync", "flush", sessionName, "--skip-wait"],
+      config,
+      paths,
+      handle,
+      { signal }
+    );
+  });
+}
+function terminateSession(session, config, paths, signal) {
+  return runMutagen(
+    ["sync", "terminate", session.identifier],
+    config,
+    paths,
+    session.handle,
+    { ignoreFailure: true, signal }
+  ).then(() => void 0);
+}
+function inspectHandleSession(handle, config, paths, signal) {
+  return listOwnedSessions(config, paths, signal).then((sessions) => {
+    const matching = sessions.filter((session) => session.handle === handle);
+    if (matching.length === 0) {
+      return null;
+    }
+    return selectPreferredSession(handle, matching);
+  });
+}
+async function listOwnedSessions(config, paths, signal) {
+  const result = await runMutagen(["sync", "list", "-l"], config, paths, "mount", {
+    ignoreFailure: true,
+    signal
+  });
+  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 isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+async function runMutagen(args, config, paths, handle, options = {}) {
+  if (options.signal?.aborted) {
+    throw createAbortError(handle);
+  }
+  return new Promise((resolve2, reject) => {
+    const child = spawn(resolveMutagenCommandPath(), args, {
+      env: {
+        ...process.env,
+        MUTAGEN_SSH_PATH: paths.sshToolsDir,
+        MUTAGEN_SSH_CONNECT_TIMEOUT: String(config.connectTimeoutSeconds)
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let killTimer = null;
+    const finish = (callback) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
+      options.signal?.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const onAbort = () => {
+      if (child.exitCode !== null) {
+        return;
+      }
+      child.kill("SIGTERM");
+      killTimer = setTimeout(() => {
+        if (child.exitCode === null) {
+          child.kill("SIGKILL");
+        }
+      }, 1e3);
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", (error) => {
+      finish(() => {
+        reject(options.signal?.aborted ? createAbortError(handle) : error);
+      });
+    });
+    child.once("close", (code) => {
+      const result = {
+        ok: code === 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        status: code
+      };
+      finish(() => {
+        if (options.signal?.aborted) {
+          reject(createAbortError(handle));
+          return;
+        }
+        if (code !== 0 && !options.ignoreFailure) {
+          reject(
+            new Error(result.stderr || result.stdout || `mutagen failed for ${handle}`)
+          );
+          return;
+        }
+        resolve2(result);
+      });
+    });
+  });
+}
+function createAbortError(handle) {
+  const error = new Error(`mutagen cancelled for ${handle}`);
+  error.name = "AbortError";
+  return error;
+}
+function resolveCommandPath(command) {
+  const result = spawnSync2("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)}" "$@"
+`;
+    writeFileSync(linkPath, script, { mode: 493 });
+    chmodSync2(linkPath, 493);
+    return;
+  }
+  try {
+    const stat = readFileSync(linkPath);
+    if (!stat) {
+      throw new Error("empty");
+    }
+  } catch {
+    const script = `#!/bin/sh
+exec "${escapeShell(target)}" "$@"
+`;
+    writeFileSync(linkPath, script, { mode: 493 });
+    chmodSync2(linkPath, 493);
+  }
+}
+function escapeShell(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("$", "\\$").replaceAll('"', '\\"');
+}
+
+export {
+  AGENTCOMPUTER_MUTAGEN_PATH_ENV,
+  ensureMutagenCommandPath,
+  ensureBundledMutagenInstalled,
+  ensureMutagenSshEnvironment,
+  getHandleSessionName,
+  getDefaultMountIgnorePaths,
+  createHandleSession,
+  terminateSession,
+  inspectHandleSession,
+  listOwnedSessions,
+  selectPreferredSession,
+  isAbortError
+};

package/dist/{chunk-OWK5N76S.js → chunk-JMRAYXUO.js}

@@ -3,7 +3,6 @@ import { spawnSync } from "child_process";
 function getMountHostValidationIssues() {
   return evaluateMountHostValidation({
     platform: process.platform,
-    hasMutagen: hasCommand("mutagen"),
     hasSsh: hasCommand("ssh"),
     hasScp: hasCommand("scp")
   });
@@ -13,10 +12,9 @@ function formatMountHostInstallGuidance(issues) {
   for (const issue of issues) {
     switch (issue.code) {
       case "unsupported-platform":
-        lines.push("Supported today: macOS and Linux terminals with Mutagen and OpenSSH installed.");
-        break;
-      case "missing-mutagen":
-        lines.push("Install Mutagen, then rerun `computer mount`.");
+        lines.push(
+          "Supported today: macOS and Linux terminals with bundled Mutagen plus OpenSSH client tools available."
+        );
         break;
       case "missing-ssh":
       case "missing-scp":
@@ -38,12 +36,6 @@ function evaluateMountHostValidation(input) {
     });
     return issues;
   }
-  if (!input.hasMutagen) {
-    issues.push({
-      code: "missing-mutagen",
-      message: "mutagen is not installed. Install Mutagen before using computer mount."
-    });
-  }
   if (!input.hasSsh) {
     issues.push({
       code: "missing-ssh",