aicomputer 0.1.14 → 0.1.15

package/README.md

@@ -91,13 +91,14 @@ computer codex-login
 computer whoami
 computer create my-box
 computer open my-box
-computer open my-box --terminal
 computer ssh
 computer ssh my-box
 computer ssh --setup
+computer mount
+computer mount status
 computer agent agents my-box
 computer agent sessions list my-box
-computer agent prompt my-box "inspect /home/node/workspace-my-box" --agent codex
+computer agent prompt my-box "inspect /home/node" --agent codex
 computer acp serve my-box --agent codex
 ```
 
@@ -116,6 +117,11 @@ ssh agentcomputer.ai
 ssh my-box@agentcomputer.ai
 ```
 
+Run `computer mount` to start a foreground controller that mirrors all SSH-ready
+machine homes under `~/agentcomputer/<handle>` while the command is running.
+This uses the same SSH setup as `computer ssh --setup` and requires Mutagen plus
+OpenSSH client tools (`ssh` and `scp`) to already be installed locally.
+
 Use `computer agent` to inspect agents on one machine and manage remote sessions. Use `computer acp serve` when you want to expose one remote session through a local ACP bridge.
 
 You can also run without a global install via `npx aicomputer <command>`.

package/dist/chunk-5JVJROSI.js

@@ -0,0 +1,186 @@
+// 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,
+    projectFilePath: join(stateDir, "mutagen.yml"),
+    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.rootPath,
+    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
+};