aicomputer 0.1.14 → 0.1.16

package/dist/chunk-KXLTHWW3.js

@@ -0,0 +1,184 @@
+// 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-OWK5N76S.js

@@ -0,0 +1,70 @@
+// src/lib/mount-host.ts
+import { spawnSync } from "child_process";
+function getMountHostValidationIssues() {
+  return evaluateMountHostValidation({
+    platform: process.platform,
+    hasMutagen: hasCommand("mutagen"),
+    hasSsh: hasCommand("ssh"),
+    hasScp: hasCommand("scp")
+  });
+}
+function formatMountHostInstallGuidance(issues) {
+  const lines = [];
+  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`.");
+        break;
+      case "missing-ssh":
+      case "missing-scp":
+        lines.push("Install OpenSSH client tools so both `ssh` and `scp` are available on PATH.");
+        break;
+      default:
+        lines.push(issue.message);
+        break;
+    }
+  }
+  return lines;
+}
+function evaluateMountHostValidation(input) {
+  const issues = [];
+  if (!["darwin", "linux"].includes(input.platform)) {
+    issues.push({
+      code: "unsupported-platform",
+      message: "computer mount currently supports macOS and Linux terminals only"
+    });
+    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",
+      message: "`ssh` is not installed or not available on PATH."
+    });
+  }
+  if (!input.hasScp) {
+    issues.push({
+      code: "missing-scp",
+      message: "`scp` is not installed or not available on PATH."
+    });
+  }
+  return issues;
+}
+function hasCommand(command) {
+  const result = spawnSync("which", [command], { stdio: "ignore" });
+  return result.status === 0;
+}
+
+export {
+  getMountHostValidationIssues,
+  formatMountHostInstallGuidance,
+  evaluateMountHostValidation
+};