agent-office-cli 0.0.1

package/src/index.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+
+try {
+  process.loadEnvFile?.();
+} catch {}
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { createAppServer } = require("./server");
+const {
+  createSessionStore,
+  printClaudeHooksConfig,
+  DEFAULT_LAN_HOST,
+  DEFAULT_PORT,
+  DEFAULT_SERVER_URL
+} = require("./core");
+const {
+  createPtyManager,
+  defaultTransportForProvider,
+  ensureNodePtySpawnHelper,
+  listSessionRecords,
+  removeSessionRecord,
+  applyClaudeHookConfig,
+  commandExists,
+  hasClaudeHookConfig,
+  networkUrls,
+  resolveCommand,
+  listAgentOfficeSessions,
+  killSession,
+  tmuxPath
+} = require("./runtime");
+const { createTunnelClient } = require("./tunnel");
+
+const DEFAULT_RELAY_URL = "https://agentoffice.top";
+
+function readEnvValue(name) {
+  const value = process.env[name];
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function resolveHostedOptions(options) {
+  const optionKey = typeof options.key === "string" ? options.key.trim() : "";
+  const optionRelay = typeof options.relay === "string" ? options.relay.trim() : "";
+
+  return {
+    key: optionKey || readEnvValue("AGENTOFFICE_API_KEY"),
+    relayUrl: optionRelay || readEnvValue("AGENTOFFICE_RELAY_URL") || DEFAULT_RELAY_URL,
+    keySource: optionKey ? "--key" : readEnvValue("AGENTOFFICE_API_KEY") ? "AGENTOFFICE_API_KEY" : null,
+    relaySource: optionRelay ? "--relay" : readEnvValue("AGENTOFFICE_RELAY_URL") ? "AGENTOFFICE_RELAY_URL" : "default"
+  };
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const action = args.shift() || "start";
+  let subaction = null;
+  const options = {};
+  const commandParts = [];
+  let commandMode = false;
+
+  if (args[0] && !args[0].startsWith("-") && args[0] !== "--") {
+    subaction = args.shift();
+  }
+
+  while (args.length > 0) {
+    const token = args.shift();
+    if (commandMode) {
+      commandParts.push(token);
+      continue;
+    }
+    if (token === "--") {
+      if (action !== "run") {
+        continue;
+      }
+      commandMode = true;
+      continue;
+    }
+    if (token === "-t") {
+      options.title = args.shift();
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const key = token.slice(2);
+      const next = args[0];
+      if (!next || next.startsWith("--")) {
+        options[key] = true;
+      } else {
+        options[key] = args.shift();
+      }
+      continue;
+    }
+    commandParts.push(token);
+  }
+
+  return { action, subaction, options, command: commandParts.join(" ").trim() };
+}
+
+async function postJson(url, payload) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(text || response.statusText);
+  }
+  return response.json();
+}
+
+async function resolveAttachTarget({ target, server }) {
+  if (!target) {
+    return null;
+  }
+
+  if (target.startsWith("agentoffice_")) {
+    return target;
+  }
+
+  const record = listSessionRecords().find((entry) => entry.sessionId === target);
+  if (record && record.meta && record.meta.tmuxSession) {
+    return record.meta.tmuxSession;
+  }
+
+  try {
+    const response = await fetch(`${server}/api/sessions/${encodeURIComponent(target)}`);
+    if (response.ok) {
+      const session = await response.json();
+      if (session && session.meta && session.meta.tmuxSession) {
+        return session.meta.tmuxSession;
+      }
+    }
+  } catch {
+    // Ignore server lookup failures and fall back to local registry only.
+  }
+
+  return null;
+}
+
+async function main() {
+  const { action, subaction, options, command } = parseArgs(process.argv);
+
+  if (action === "start") {
+    const nodePtySetup = ensureNodePtySpawnHelper();
+    if (nodePtySetup.changed.length > 0) {
+      console.log(`AgentOffice repaired node-pty spawn-helper permissions for ${nodePtySetup.changed.join(", ")}`);
+    }
+
+    const host = options.host || DEFAULT_LAN_HOST;
+    const port = Number(options.port || DEFAULT_PORT);
+    const localServerUrl = `http://127.0.0.1:${port}`;
+    const handlerPath = path.resolve(__dirname, "index.js");
+
+    console.log("AgentOffice preflight");
+    console.log(`- tmux: ${commandExists("tmux") ? resolveCommand("tmux") : "missing"}`);
+    console.log(`- claude: ${commandExists("claude") ? resolveCommand("claude") : "missing"}`);
+    console.log(`- codex: ${commandExists("codex") ? resolveCommand("codex") : "missing"}`);
+
+    if (!hasClaudeHookConfig({ serverUrl: localServerUrl, handlerPath })) {
+      const settingsPath = applyClaudeHookConfig({ serverUrl: localServerUrl, handlerPath });
+      console.log(`- claude hooks: installed into ${settingsPath}`);
+    } else {
+      console.log("- claude hooks: configured");
+    }
+
+    if (!commandExists("tmux")) {
+      throw new Error("tmux is required for AgentOffice local sessions. Install it first, for example with `brew install tmux`.");
+    }
+
+    const store = createSessionStore();
+    const ptyManager = createPtyManager({ store });
+    const restored = ptyManager.restoreManagedSessions();
+    createAppServer({ host, port, store, ptyManager });
+    console.log(`AgentOffice restored ${restored.length} session(s).`);
+    console.log("AgentOffice URLs");
+    for (const url of networkUrls({ host, port })) {
+      console.log(`- ${url}`);
+    }
+    console.log("");
+
+    // --- Hosted mode: connect tunnel to relay ---
+    const hosted = resolveHostedOptions(options);
+    if (hosted.key) {
+      const localServerUrl = `http://127.0.0.1:${port}`;
+      const tunnel = createTunnelClient({
+        key: hosted.key,
+        relayUrl: hosted.relayUrl,
+        localServerUrl
+      });
+      console.log(`AgentOffice tunnel connecting to relay: ${hosted.relayUrl}`);
+      console.log(`- hosted auth: key from ${hosted.keySource}, relay from ${hosted.relaySource}`);
+      tunnel.sendStatusSummary(store.listSessionSummaries());
+
+      let statusDebounceTimer = null;
+      function scheduleStatusSummary() {
+        if (statusDebounceTimer) return;
+        statusDebounceTimer = setTimeout(() => {
+          statusDebounceTimer = null;
+          tunnel.sendStatusSummary(store.listSessionSummaries());
+        }, 500);
+      }
+
+      store.emitter.on("session:update", scheduleStatusSummary);
+      store.emitter.on("session:remove", scheduleStatusSummary);
+    }
+
+    return;
+  }
+
+  if (action === "attach") {
+    if (!commandExists("tmux")) {
+      throw new Error("tmux is required to attach to an AgentOffice worker.");
+    }
+
+    const target = subaction || command || options.session || options.id;
+    const server = options.server || DEFAULT_SERVER_URL;
+    const tmuxSession = await resolveAttachTarget({ target, server });
+    if (!tmuxSession) {
+      throw new Error(`unable to find a tmux worker for ${target || "<missing-session-id>"}`);
+    }
+
+    console.log(`Attaching local terminal to ${tmuxSession}`);
+    const attached = spawnSync(tmuxPath(), ["attach-session", "-t", tmuxSession], {
+      stdio: "inherit"
+    });
+    if (attached.status !== 0) {
+      throw new Error((attached.stderr || attached.stdout || "tmux attach failed").toString().trim());
+    }
+    return;
+  }
+
+  if (action === "codex" || action === "claude") {
+    const provider = action;
+    const binary = options.bin || resolveCommand(provider) || provider;
+    const server = options.server || DEFAULT_SERVER_URL;
+    const transport = options.transport || "tmux";
+    const sessionCommand = command || binary;
+    const result = await postJson(`${server}/api/sessions/launch`, {
+      provider,
+      title: options.title || `${provider[0].toUpperCase()}${provider.slice(1)} Session`,
+      cwd: options.cwd || process.cwd(),
+      command: sessionCommand,
+      transport
+    });
+    if (transport === "tmux") {
+      console.log(`Attaching local terminal to ${result.session.meta.tmuxSession}`);
+      const attached = spawnSync(tmuxPath(), ["attach-session", "-t", result.session.meta.tmuxSession], {
+        stdio: "inherit"
+      });
+      if (attached.status !== 0) {
+        throw new Error((attached.stderr || attached.stdout || "tmux attach failed").toString().trim());
+      }
+      return;
+    }
+    console.log(JSON.stringify(result.session, null, 2));
+    return;
+  }
+
+  if (action === "cleanup") {
+    if (!commandExists("tmux")) {
+      console.log("No cleanup needed: tmux is not installed.");
+      return;
+    }
+    const sessions = listAgentOfficeSessions();
+    const records = listSessionRecords();
+    if (sessions.length === 0) {
+      for (const record of records) {
+        removeSessionRecord(record.sessionId);
+      }
+      console.log(records.length > 0 ? `Removed ${records.length} stale AgentOffice record(s).` : "No AgentOffice tmux sessions found.");
+      return;
+    }
+    for (const sessionName of sessions) {
+      killSession(sessionName);
+      console.log(`Removed ${sessionName}`);
+    }
+    for (const record of records) {
+      removeSessionRecord(record.sessionId);
+    }
+    console.log(`Cleanup complete. Removed ${sessions.length} AgentOffice session(s).`);
+    return;
+  }
+
+  if (action === "run") {
+    if (!command) {
+      throw new Error("missing command after --");
+    }
+    const server = options.server || DEFAULT_SERVER_URL;
+    const transport = options.transport || defaultTransportForProvider(options.provider || "generic");
+    const result = await postJson(`${server}/api/sessions/launch`, {
+      provider: options.provider || "generic",
+      title: options.title || command,
+      cwd: options.cwd || process.cwd(),
+      command,
+      transport
+    });
+    if (options.attach) {
+      if (result.session.transport !== "tmux" || !result.session.meta || !result.session.meta.tmuxSession) {
+        throw new Error("--attach currently requires transport=tmux");
+      }
+      console.log(`Attaching local terminal to ${result.session.meta.tmuxSession}`);
+      const attached = spawnSync(tmuxPath(), ["attach-session", "-t", result.session.meta.tmuxSession], {
+        stdio: "inherit"
+      });
+      if (attached.status !== 0) {
+        throw new Error((attached.stderr || attached.stdout || "tmux attach failed").toString().trim());
+      }
+      return;
+    }
+    console.log(JSON.stringify(result.session, null, 2));
+    return;
+  }
+
+  if (action === "claude-hook") {
+    const server = options.server || DEFAULT_SERVER_URL;
+    try {
+      const input = fs.readFileSync(0, "utf8");
+      if (input.trim()) {
+        await postJson(`${server}/api/providers/claude/hook`, JSON.parse(input));
+      }
+    } catch (error) {
+      console.error(`AgentOffice claude-hook ignored error: ${error.message}`);
+    }
+    return;
+  }
+
+  if (action === "print-claude-hooks") {
+    const server = options.server || DEFAULT_SERVER_URL;
+    const settings = printClaudeHooksConfig({
+      serverUrl: server,
+      handlerPath: path.resolve(__dirname, "index.js")
+    });
+    console.log(JSON.stringify(settings, null, 2));
+    return;
+  }
+
+  throw new Error(`unknown action: ${action}`);
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/src/runtime/cli-helpers.js

@@ -0,0 +1,90 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { printClaudeHooksConfig } = require("../core");
+
+function commandExists(command) {
+  const result = spawnSync("/usr/bin/env", ["bash", "-lc", `command -v ${JSON.stringify(command)} >/dev/null 2>&1`]);
+  return result.status === 0;
+}
+
+function resolveCommand(command) {
+  const result = spawnSync("/usr/bin/env", ["bash", "-lc", `command -v ${JSON.stringify(command)}`], { encoding: "utf8" });
+  if (result.status !== 0) {
+    return null;
+  }
+  return (result.stdout || "").trim() || null;
+}
+
+function networkUrls({ host, port }) {
+  const urls = [];
+  if (host === "0.0.0.0") {
+    urls.push(`http://127.0.0.1:${port}`);
+    const interfaces = os.networkInterfaces();
+    for (const entries of Object.values(interfaces)) {
+      for (const entry of entries || []) {
+        if (!entry || entry.family !== "IPv4" || entry.internal) {
+          continue;
+        }
+        urls.push(`http://${entry.address}:${port}`);
+      }
+    }
+  } else {
+    urls.push(`http://${host}:${port}`);
+  }
+  return [...new Set(urls)];
+}
+
+function claudeSettingsPath() {
+  return path.join(os.homedir(), ".claude", "settings.json");
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function hasClaudeHookConfig({ serverUrl, handlerPath }) {
+  const settings = readJson(claudeSettingsPath());
+  if (!settings || !settings.hooks) {
+    return false;
+  }
+  const expected = printClaudeHooksConfig({ serverUrl, handlerPath });
+  const hookEvent = expected.hooks && expected.hooks.SessionStart;
+  const actualEvent = settings.hooks && settings.hooks.SessionStart;
+  if (!hookEvent || !actualEvent) {
+    return false;
+  }
+  const expectedCommand = hookEvent[0] && hookEvent[0].hooks && hookEvent[0].hooks[0] && hookEvent[0].hooks[0].command;
+  const actualCommand = actualEvent[0] && actualEvent[0].hooks && actualEvent[0].hooks[0] && actualEvent[0].hooks[0].command;
+  return Boolean(expectedCommand && actualCommand && expectedCommand === actualCommand);
+}
+
+function applyClaudeHookConfig({ serverUrl, handlerPath }) {
+  const filePath = claudeSettingsPath();
+  const nextHooks = printClaudeHooksConfig({ serverUrl, handlerPath }).hooks;
+  const current = readJson(filePath) || {};
+  const next = {
+    ...current,
+    hooks: {
+      ...(current.hooks || {}),
+      ...nextHooks
+    }
+  };
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return filePath;
+}
+
+module.exports = {
+  applyClaudeHookConfig,
+  claudeSettingsPath,
+  commandExists,
+  hasClaudeHookConfig,
+  networkUrls,
+  resolveCommand
+};

package/src/runtime/ensure-node-pty.js

@@ -0,0 +1,49 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function ensureExecutable(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    const mode = stats.mode & 0o777;
+    if ((mode & 0o111) === 0o111) {
+      return false;
+    }
+    fs.chmodSync(filePath, mode | 0o755);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ensureNodePtySpawnHelper() {
+  let packageJsonPath;
+  try {
+    packageJsonPath = require.resolve("node-pty/package.json");
+  } catch {
+    return { changed: [], checked: [] };
+  }
+
+  const packageRoot = path.dirname(packageJsonPath);
+  const targets = [
+    path.join(packageRoot, "prebuilds", "darwin-arm64", "spawn-helper"),
+    path.join(packageRoot, "prebuilds", "darwin-x64", "spawn-helper")
+  ];
+
+  const checked = [];
+  const changed = [];
+  for (const target of targets) {
+    checked.push(target);
+    if (!fs.existsSync(target)) {
+      continue;
+    }
+    if (ensureExecutable(target)) {
+      changed.push(target);
+    }
+  }
+
+  return { changed, checked };
+}
+
+module.exports = {
+  ensureNodePtySpawnHelper
+};

package/src/runtime/index.js

@@ -0,0 +1,54 @@
+const { createPtyManager, defaultTransportForProvider } = require("./pty-manager");
+const {
+  AGENTOFFICE_TMUX_PREFIX,
+  attachClient,
+  capturePane,
+  createTmuxSession,
+  describePane,
+  killSession,
+  listAgentOfficeSessions,
+  localAttachCommand,
+  sessionExists,
+  tmuxPath
+} = require("./tmux");
+const {
+  REGISTRY_DIR,
+  listSessionRecords,
+  persistSessionRecord,
+  removeSessionRecord
+} = require("./session-registry");
+const { ensureNodePtySpawnHelper } = require("./ensure-node-pty");
+const {
+  applyClaudeHookConfig,
+  claudeSettingsPath,
+  commandExists,
+  hasClaudeHookConfig,
+  networkUrls,
+  resolveCommand
+} = require("./cli-helpers");
+
+module.exports = {
+  createPtyManager,
+  defaultTransportForProvider,
+  AGENTOFFICE_TMUX_PREFIX,
+  attachClient,
+  capturePane,
+  createTmuxSession,
+  describePane,
+  killSession,
+  listAgentOfficeSessions,
+  localAttachCommand,
+  sessionExists,
+  tmuxPath,
+  REGISTRY_DIR,
+  listSessionRecords,
+  persistSessionRecord,
+  removeSessionRecord,
+  ensureNodePtySpawnHelper,
+  applyClaudeHookConfig,
+  claudeSettingsPath,
+  commandExists,
+  hasClaudeHookConfig,
+  networkUrls,
+  resolveCommand
+};