aicomputer 0.1.18 → 0.1.20

package/dist/chunk-GD42GHW3.js

@@ -0,0 +1,183 @@
+import {
+  resolveSystemCommandPath
+} from "./chunk-5Y2NWK5I.js";
+
+// 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)) {
+    return null;
+  }
+  const assetArch = resolveMutagenAssetArch(arch);
+  if (!assetArch) {
+    return null;
+  }
+  const assetName = `mutagen_${platform}_${assetArch}_v${BUNDLED_MUTAGEN_VERSION}.tar.gz`;
+  const installDir = join(
+    homeDirectory,
+    ".agentcomputer",
+    "tools",
+    "mutagen",
+    `v${BUNDLED_MUTAGEN_VERSION}`,
+    `${platform}-${assetArch}`
+  );
+  return {
+    platform,
+    arch: assetArch,
+    version: BUNDLED_MUTAGEN_VERSION,
+    assetName,
+    downloadUrl: `${BUNDLED_MUTAGEN_DOWNLOAD_BASE}/${assetName}`,
+    installDir,
+    executablePath: join(installDir, "mutagen")
+  };
+}
+function hasBundledMutagen() {
+  const asset = getBundledMutagenAsset();
+  return asset ? existsSync(asset.executablePath) : false;
+}
+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 resolveMutagenAssetArch(arch) {
+  if (!isSupportedNodeArch(arch)) {
+    return null;
+  }
+  if (arch === "x64") {
+    return "amd64";
+  }
+  return arch;
+}
+function isSupportedNodeArch(arch) {
+  return arch === "arm64" || arch === "x64";
+}
+
+export {
+  AGENTCOMPUTER_MUTAGEN_PATH_ENV,
+  getBundledMutagenAsset,
+  hasBundledMutagen,
+  ensureMutagenCommandPath,
+  ensureBundledMutagenInstalled,
+  resolveMutagenCommandPath,
+  resolveMutagenAssetArch
+};

package/dist/chunk-GGBVVRLL.js

@@ -0,0 +1,32 @@
+// src/lib/upgrade-version.ts
+function normalizeVersion(version) {
+  return version.split("-")[0].split(".").map((part) => Number.parseInt(part, 10)).map((part) => Number.isNaN(part) ? 0 : part);
+}
+function compareVersions(a, b) {
+  const left = normalizeVersion(a);
+  const right = normalizeVersion(b);
+  const size = Math.max(left.length, right.length);
+  for (let index = 0; index < size; index += 1) {
+    const diff = (left[index] ?? 0) - (right[index] ?? 0);
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return 0;
+}
+function resolveLatestPublishedVersion(packument) {
+  const versions = Object.keys(packument.versions ?? {});
+  if (versions.length === 0) {
+    throw new Error("Registry response missing published versions");
+  }
+  const taggedLatest = packument["dist-tags"]?.latest;
+  if (taggedLatest && versions.includes(taggedLatest)) {
+    return taggedLatest;
+  }
+  return versions.sort((left, right) => compareVersions(right, left))[0];
+}
+
+export {
+  compareVersions,
+  resolveLatestPublishedVersion
+};

package/dist/chunk-LOGK7YYJ.js

@@ -0,0 +1,255 @@
+// 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(signal) {
+  const response = await api("/v1/computers", { signal });
+  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 powerOnComputer(computerID) {
+  return api(`/v1/computers/${computerID}/power-on`, {
+    method: "POST"
+  });
+}
+async function powerOffComputer(computerID) {
+  return api(`/v1/computers/${computerID}/power-off`, {
+    method: "POST"
+  });
+}
+async function getFilesystemSettings() {
+  return api("/v1/me/filesystem");
+}
+async function getConnectionInfo(computerID, signal) {
+  return api(`/v1/computers/${computerID}/connection`, {
+    signal
+  });
+}
+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}`;
+}
+
+export {
+  getAPIKey,
+  getStoredAPIKey,
+  hasEnvAPIKey,
+  setAPIKey,
+  clearAPIKey,
+  ApiError,
+  getBaseURL,
+  getWebURL,
+  api,
+  apiWithKey,
+  listComputers,
+  getComputerByID,
+  createComputer,
+  deleteComputer,
+  powerOnComputer,
+  powerOffComputer,
+  getFilesystemSettings,
+  getConnectionInfo,
+  createBrowserAccess,
+  listPublishedPorts,
+  publishPort,
+  deletePublishedPort,
+  resolveComputer,
+  webURL,
+  vncURL
+};