cmdr-mcp 0.1.0

package/plugins/cmdr/dist/cli.mjs

@@ -0,0 +1,485 @@
+#!/usr/bin/env -S node --experimental-sqlite --disable-warning=ExperimentalWarning
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// src/cli/main.ts
+import { readFileSync, existsSync } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { execFileSync } from "node:child_process";
+import { parseArgs } from "node:util";
+
+// src/shared/client.ts
+import { connect } from "node:net";
+import { spawn } from "node:child_process";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdirSync as mkdirSync2, rmSync, statSync } from "node:fs";
+
+// src/shared/paths.ts
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { mkdirSync, chmodSync } from "node:fs";
+import { createHash } from "node:crypto";
+
+// src/shared/ids.ts
+var safeSid = (sid) => Buffer.from(sid).toString("base64url");
+
+// src/shared/paths.ts
+function paths(home = process.env.CMDR_HOME || join(homedir(), ".cmdr")) {
+  home = resolve(home);
+  let socket = join(home, "cmdr.sock");
+  if (Buffer.byteLength(socket) > 100)
+    socket = join(
+      tmpdir(),
+      `cmdr-${createHash("sha256").update(`${process.getuid?.()}:${home}`).digest("hex").slice(0, 20)}.sock`
+    );
+  return {
+    home,
+    socket,
+    db: join(home, "cmdr.db"),
+    lock: join(home, "daemon.lock"),
+    spawn: join(home, "spawn.lock"),
+    info: join(home, "daemon.json"),
+    flags: join(home, "flags"),
+    log: join(home, "logs/daemon.log"),
+    config: join(home, "config.json"),
+    flag: (sid) => join(home, "flags", safeSid(sid))
+  };
+}
+function prepare(p2) {
+  for (const dir of [p2.home, p2.flags, join(p2.home, "logs")]) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    chmodSync(dir, 448);
+  }
+}
+
+// src/shared/rpc.ts
+import { EventEmitter } from "node:events";
+
+// src/shared/protocol.ts
+var LIMITS = {
+  maxWaitSec: 300,
+  maxBody: 32768,
+  maxData: 65536,
+  maxFrame: 2 * 1024 * 1024
+};
+var CmdrError = class extends Error {
+  constructor(code, message = code) {
+    super(message);
+    this.code = code;
+  }
+};
+
+// src/shared/rpc.ts
+var Rpc = class extends EventEmitter {
+  constructor(socket) {
+    super();
+    this.socket = socket;
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      this.buffer += chunk;
+      if (Buffer.byteLength(this.buffer) > LIMITS.maxFrame) {
+        socket.destroy();
+        return;
+      }
+      let at;
+      while ((at = this.buffer.indexOf("\n")) >= 0) {
+        const line = this.buffer.slice(0, at);
+        this.buffer = this.buffer.slice(at + 1);
+        if (line.trim()) void this.receive(line);
+      }
+    });
+    socket.on("error", () => {
+    });
+    socket.on("close", () => {
+      for (const p2 of this.pending.values()) {
+        clearTimeout(p2.timer);
+        p2.cleanup();
+        p2.reject(new CmdrError("DAEMON_UNAVAILABLE"));
+      }
+      this.pending.clear();
+      for (const c of this.active.values()) c.abort();
+      this.active.clear();
+      this.emit("close");
+    });
+  }
+  buffer = "";
+  next = 1;
+  pending = /* @__PURE__ */ new Map();
+  active = /* @__PURE__ */ new Map();
+  handler;
+  async receive(line) {
+    let m;
+    try {
+      m = JSON.parse(line);
+      if (!m || m.jsonrpc !== "2.0" || Array.isArray(m)) throw new Error();
+    } catch {
+      this.send({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: "Invalid JSON-RPC frame" }
+      });
+      return;
+    }
+    if (typeof m.method === "string") {
+      if (m.id === void 0) {
+        if (m.method === "rpc.cancel") this.active.get(m.params?.id)?.abort();
+        else this.emit("notification", m.method, m.params);
+        return;
+      }
+      const controller = new AbortController();
+      this.active.set(m.id, controller);
+      try {
+        const result = await this.handler?.(m.method, m.params || {}, controller.signal);
+        this.send({ jsonrpc: "2.0", id: m.id, result: result ?? null });
+      } catch (e) {
+        this.send({
+          jsonrpc: "2.0",
+          id: m.id,
+          error: {
+            code: e instanceof CmdrError ? -32e3 : -32603,
+            message: e instanceof CmdrError ? e.message : "Internal daemon error",
+            data: { code: e instanceof CmdrError ? e.code : "INTERNAL_ERROR" }
+          }
+        });
+      } finally {
+        this.active.delete(m.id);
+      }
+    } else if (this.pending.has(m.id)) {
+      const p2 = this.pending.get(m.id);
+      this.pending.delete(m.id);
+      clearTimeout(p2.timer);
+      p2.cleanup();
+      if (m.error) p2.reject(new CmdrError(m.error.data?.code || "RPC_ERROR", m.error.message));
+      else p2.resolve(m.result);
+    }
+  }
+  send(value) {
+    if (!this.socket.destroyed && this.socket.writable)
+      this.socket.write(JSON.stringify(value) + "\n");
+  }
+  request(method, params = {}, timeout = 5e3, signal) {
+    if (this.socket.destroyed) return Promise.reject(new CmdrError("DAEMON_UNAVAILABLE"));
+    if (signal?.aborted) return Promise.reject(new CmdrError("REQUEST_CANCELLED"));
+    return new Promise((resolve2, reject) => {
+      const id = this.next++;
+      const cancel = (code) => {
+        const p2 = this.pending.get(id);
+        if (!p2) return;
+        this.pending.delete(id);
+        clearTimeout(p2.timer);
+        p2.cleanup();
+        this.notify("rpc.cancel", { id });
+        reject(new CmdrError(code));
+      };
+      const abort = () => cancel("REQUEST_CANCELLED");
+      const timer = setTimeout(() => cancel("DAEMON_UNAVAILABLE"), timeout);
+      this.pending.set(id, {
+        resolve: resolve2,
+        reject,
+        timer,
+        cleanup: () => signal?.removeEventListener("abort", abort)
+      });
+      signal?.addEventListener("abort", abort, { once: true });
+      this.send({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+  notify(method, params) {
+    this.send({ jsonrpc: "2.0", method, params });
+  }
+  close() {
+    this.socket.destroy();
+  }
+};
+
+// src/shared/version.ts
+var VERSION = true ? "0.1.0" : "0.1.0";
+var PROTOCOL = 1;
+function newer(a, b) {
+  const x = a.split(".").map(Number), y = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (x[i] !== y[i]) return x[i] > y[i];
+  }
+  return false;
+}
+
+// src/shared/client.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function dial(p2, timeout = 1e3) {
+  return new Promise((resolve2, reject) => {
+    const socket = connect(p2.socket);
+    const timer = setTimeout(() => socket.destroy(new Error("connect timeout")), timeout);
+    socket.once("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    socket.once("connect", () => {
+      clearTimeout(timer);
+      resolve2(new Rpc(socket));
+    });
+  });
+}
+async function daemonConnection(options = {}) {
+  const p2 = paths(options.home), timeout = options.timeout || 1e3;
+  if (options.start) prepare(p2);
+  let owner = false, spawned = false;
+  try {
+    for (let attempt = 0; attempt < (options.start ? 65 : 1); attempt++) {
+      let rpc;
+      try {
+        rpc = await dial(p2, timeout);
+        const hello = await rpc.request(
+          "hello",
+          { client: "cmdr", version: VERSION, protocol: PROTOCOL },
+          timeout
+        );
+        if (options.upgrade && newer(VERSION, hello.version)) {
+          await rpc.request("admin.shutdown", { reason: "upgrade" }, timeout);
+          rpc.close();
+          await sleep(100);
+          continue;
+        }
+        return rpc;
+      } catch (e) {
+        rpc?.close();
+        if (e.code === "PROTOCOL_MISMATCH" || !options.start) throw e;
+      }
+      if (!owner) {
+        try {
+          mkdirSync2(p2.spawn, { mode: 448 });
+          owner = true;
+        } catch {
+          try {
+            if (Date.now() - statSync(p2.spawn).mtimeMs > 1e4)
+              rmSync(p2.spawn, { recursive: true, force: true });
+          } catch {
+          }
+        }
+      }
+      if (owner) {
+        if (attempt === 0 || !spawned) {
+          const child = spawn(
+            process.execPath,
+            ["--experimental-sqlite", join2(dirname(fileURLToPath(import.meta.url)), "daemon.mjs")],
+            { detached: true, stdio: "ignore", env: { ...process.env, CMDR_HOME: p2.home } }
+          );
+          child.on("error", () => {
+          });
+          child.unref();
+          spawned = true;
+        }
+      }
+      await sleep(50);
+    }
+  } finally {
+    if (owner) rmSync(p2.spawn, { recursive: true, force: true });
+    spawned = false;
+  }
+  throw new CmdrError("DAEMON_UNAVAILABLE", "Cannot start cmdr daemon. Run cmdr doctor.");
+}
+async function quickCall(method, params = {}, options = {}) {
+  const rpc = await daemonConnection({ ...options, upgrade: !!options.start });
+  try {
+    if (options.kind !== "hook")
+      await rpc.request("session.register", { kind: "cli" }, options.timeout || 5e3);
+    return await rpc.request(method, params, options.timeout || 5e3);
+  } finally {
+    rpc.close();
+  }
+}
+
+// src/cli/main.ts
+var { values: v, positionals: args } = parseArgs({
+  allowPositionals: true,
+  options: {
+    agent: { type: "string" },
+    all: { type: "boolean" },
+    squad: { type: "string" },
+    to: { type: "string" },
+    type: { type: "string" },
+    "reply-to": { type: "string" },
+    session: { type: "string" },
+    peek: { type: "boolean" },
+    follow: { type: "boolean" },
+    full: { type: "boolean" },
+    json: { type: "boolean" },
+    help: { type: "boolean" }
+  }
+});
+var p = paths();
+var cmd = args[0] || "status";
+var print = (value) => process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+var call = (method, params = {}, start = false) => quickCall(method, params, { start });
+var pause = (ms) => new Promise((r) => setTimeout(r, ms));
+async function doctor() {
+  const checks = {
+    node: process.version,
+    node_path: process.execPath,
+    cmdr: VERSION,
+    home: p.home
+  };
+  const root = dirname2(dirname2(fileURLToPath2(import.meta.url)));
+  checks.bundles = Object.fromEntries(
+    ["daemon", "mcp", "hook", "cli"].map((n) => [n, existsSync(join3(root, "dist", `${n}.mjs`))])
+  );
+  for (const host of ["claude", "codex"]) {
+    try {
+      checks[host] = execFileSync(host, ["--version"], { encoding: "utf8", timeout: 3e3 }).trim();
+    } catch {
+      checks[host] = "CLI not available in PATH";
+    }
+  }
+  try {
+    checks.daemon = await call("admin.status");
+  } catch {
+    checks.daemon = "not running";
+  }
+  try {
+    const conf = readFileSync(
+      join3(process.env.CODEX_HOME || join3(homedir2(), ".codex"), "config.toml"),
+      "utf8"
+    );
+    checks.codex_hooks = /(?:^|\n)\s*hooks\s*=\s*false/.test(conf) ? "disabled" : "not explicitly disabled; verify features.hooks in Codex";
+    checks.codex_hook_trust = "Verify all five cmdr hooks in the Codex trust UI (storage format is host-specific).";
+    if (/cmdr/.test(conf)) {
+      const listing = execFileSync("codex", ["mcp", "list"], {
+        encoding: "utf8",
+        timeout: 5e3,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      checks.codex_mcp_registered = /\bcmdr\b/.test(listing);
+    } else
+      checks.codex_mcp_registered = "No cmdr entry found in config; run codex mcp list after installing.";
+  } catch {
+    checks.codex_hooks = "Codex configuration unavailable";
+  }
+  const zcodeRoot = "/Applications/ZCode.app/Contents";
+  if (existsSync(join3(zcodeRoot, "Info.plist"))) {
+    try {
+      checks.zcode = {
+        app_version: execFileSync(
+          "/usr/libexec/PlistBuddy",
+          ["-c", "Print :CFBundleShortVersionString", join3(zcodeRoot, "Info.plist")],
+          { encoding: "utf8", timeout: 1e3 }
+        ).trim(),
+        runtime: join3(zcodeRoot, "Resources/glm/zcode.cjs")
+      };
+    } catch {
+      checks.zcode = "Installed";
+    }
+  } else
+    checks.zcode = "Desktop app not found in /Applications; generic MCP configuration is available.";
+  try {
+    const zconfig = JSON.parse(readFileSync(join3(homedir2(), ".zcode/cli/config.json"), "utf8"));
+    checks.zcode_user_hooks = zconfig.hooks?.enabled === true;
+  } catch {
+    checks.zcode_user_hooks = "No user hook config; installed plugin hooks follow plugin enablement.";
+  }
+  print(checks);
+}
+try {
+  if (v.help)
+    process.stdout.write(
+      "cmdr status | list [--all] [--squad ID] | tail [--follow] [--full] | send --squad ID [--to MEMBER] [--type command|info|answer] TEXT | read --session SID [--peek] | daemon start|stop|restart|status|logs | config [--agent HOST] [--session ID] | doctor | purge [--all]\n"
+    );
+  else if (cmd === "config") {
+    const agent = v.agent || "generic";
+    if (!/^[a-z][a-z0-9_-]{0,63}$/.test(agent))
+      throw new Error("Invalid --agent: use lowercase letters, digits, underscores or hyphens.");
+    const root = dirname2(dirname2(fileURLToPath2(import.meta.url)));
+    const server = {
+      command: join3(root, "bin/cmdr-mcp"),
+      env: {
+        CMDR_AGENT: agent,
+        ...v.session ? { CMDR_SESSION_ID: v.session } : {},
+        ...agent === "zcode" ? { CMDR_TOOL_TIMEOUT_SEC: "600" } : {}
+      },
+      ...agent === "zcode" ? { timeoutMs: 6e5 } : {}
+    };
+    print(
+      agent === "zcode" ? { mcp: { servers: { cmdr: server } } } : { mcpServers: { cmdr: server } }
+    );
+  } else if (cmd === "doctor") await doctor();
+  else if (cmd === "status") print(await call("admin.status"));
+  else if (cmd === "list") {
+    const result = await call("session.list", { scope: v.all ? "all" : void 0, squad: v.squad });
+    if (v.json) print(result);
+    else {
+      console.table(
+        result.sessions.map((s) => ({
+          sid: s.short,
+          agent: s.agent,
+          name: s.name,
+          title: s.title,
+          role: s.role,
+          squad: s.squad,
+          presence: s.presence,
+          activity: s.activity,
+          pending: s.pending,
+          cwd: s.cwd,
+          terminal: s.terminal?.program
+        }))
+      );
+      console.table(
+        result.squads.map((s) => ({
+          id: s.id,
+          name: s.name,
+          status: s.status,
+          commander: s.commander_sid
+        }))
+      );
+    }
+  } else if (cmd === "send")
+    print(
+      await call(
+        "msg.send",
+        {
+          squad: v.squad,
+          to: v.to || "all",
+          type: v.type || "command",
+          reply_to: v["reply-to"],
+          message: args.slice(1).join(" ")
+        },
+        true
+      )
+    );
+  else if (cmd === "read") {
+    if (!v.session) throw new Error("--session SID is required");
+    print(await call("admin.read", { sid: v.session, options: { peek: !!v.peek } }));
+  } else if (cmd === "purge") print(await call("admin.purge", { all: !!v.all }));
+  else if (cmd === "tail") {
+    const rpc = await daemonConnection();
+    await rpc.request("session.register", { kind: "cli" });
+    if (v.follow) {
+      rpc.on("notification", (method, value) => {
+        if (method === "msg.event") print(value);
+      });
+      await rpc.request("admin.tail", { squad: v.squad, full: !!v.full });
+    }
+    print(await rpc.request("admin.recent", { squad: v.squad, full: !!v.full }));
+    if (!v.follow) rpc.close();
+    else process.on("SIGINT", () => rpc.close());
+  } else if (cmd === "daemon") {
+    const action = args[1] || "status";
+    if (action === "logs")
+      process.stdout.write(existsSync(p.log) ? readFileSync(p.log, "utf8") : "No daemon logs.\n");
+    else if (action === "status") print(await call("admin.status"));
+    else if (action === "stop" || action === "restart") {
+      try {
+        print(await call("admin.shutdown", { reason: action }));
+      } catch (e) {
+        if (action === "stop") throw e;
+      }
+      if (action === "restart") {
+        for (let n = 0; n < 60 && existsSync(p.socket); n++) await pause(50);
+        print(await call("admin.status", {}, true));
+      }
+    } else if (action === "start") print(await call("admin.status", {}, true));
+    else throw new Error(`Unknown daemon action: ${action}`);
+  } else throw new Error(`Unknown command: ${cmd}`);
+} catch (e) {
+  process.stderr.write(`cmdr: ${e.code || "ERROR"}: ${e.message}
+`);
+  process.exitCode = 1;
+}