@gajae-gateway/cli 0.1.0

package/dist/main.js

@@ -0,0 +1,792 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/main.ts
+import { copyFile, stat } from "fs/promises";
+import { isAbsolute, join as join2 } from "path";
+import { LOOPBACK_ORIGIN, originKey as originKey2, parseOriginKey } from "@gajae-gateway/protocol";
+import { GajaewayClient } from "@gajae-gateway/sdk";
+
+// src/list.ts
+import { originKey } from "@gajae-gateway/protocol";
+var MAX_CELL_WIDTH = 40;
+function columnNames(columns) {
+  return columns.map((column) => column.name);
+}
+function positiveInteger(flag, raw) {
+  const value = Number(raw);
+  if (raw === undefined || raw === "" || !Number.isInteger(value) || value < 0)
+    throw new Error(`${flag} expects a non-negative integer, got: ${raw ?? "(missing)"}`);
+  return value;
+}
+function parseListOptions(args, columns) {
+  const valid = columnNames(columns);
+  let json = false;
+  let fields;
+  let limit;
+  let offset = 0;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--json")
+      json = true;
+    else if (arg === "--fields") {
+      const raw = args[++i];
+      if (!raw)
+        throw new Error(`--fields expects a comma-separated column list (valid: ${valid.join(", ")})`);
+      fields = raw.split(",").map((field) => field.trim()).filter((field) => field.length > 0);
+      if (fields.length === 0)
+        throw new Error(`--fields expects a comma-separated column list (valid: ${valid.join(", ")})`);
+      const unknown = fields.filter((field) => !valid.includes(field));
+      if (unknown.length > 0)
+        throw new Error(`unknown field(s): ${unknown.join(", ")} (valid: ${valid.join(", ")})`);
+    } else if (arg === "--limit")
+      limit = positiveInteger("--limit", args[++i]);
+    else if (arg === "--offset")
+      offset = positiveInteger("--offset", args[++i]);
+    else
+      throw new Error(`unknown option: ${arg}`);
+  }
+  return { json, ...fields ? { fields } : {}, ...limit === undefined ? {} : { limit }, offset };
+}
+function selectColumns(columns, fields) {
+  if (!fields)
+    return [...columns];
+  return fields.map((field) => columns.find((column) => column.name === field));
+}
+function pageRows(rows, options) {
+  const entries = rows.map((row, index) => ({ row, index }));
+  const start = Math.min(options.offset, entries.length);
+  return options.limit === undefined ? entries.slice(start) : entries.slice(start, start + options.limit);
+}
+function headerLabel(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+}
+function formatCell(value) {
+  if (value === null || value === undefined)
+    return "-";
+  const text = Array.isArray(value) ? value.length === 0 ? "-" : value.join(",") : String(value);
+  if (text === "")
+    return "-";
+  return text.length > MAX_CELL_WIDTH ? `${text.slice(0, MAX_CELL_WIDTH - 1)}\u2026` : text;
+}
+function renderTable(columns, entries) {
+  if (columns.length === 0)
+    return ["(no columns)"];
+  const header = columns.map((column) => headerLabel(column.name));
+  const body = entries.map((entry) => columns.map((column) => formatCell(column.value(entry.row, entry.index))));
+  if (body.length === 0)
+    return [header.join("  "), "(none)"];
+  const widths = header.map((cell, index) => Math.max(cell.length, ...body.map((row) => row[index].length)));
+  const line = (cells) => cells.map((cell, index) => index === cells.length - 1 ? cell : cell.padEnd(widths[index])).join("  ").trimEnd();
+  return [line(header), ...body.map(line)];
+}
+function projectRows(columns, entries) {
+  return entries.map((entry) => Object.fromEntries(columns.map((column) => [column.name, column.value(entry.row, entry.index)])));
+}
+function triggerSummary(monitor) {
+  const trigger = monitor.trigger;
+  switch (trigger.kind) {
+    case "cron":
+      return trigger.schedule;
+    case "webhook":
+      return `webhook:${trigger.route}`;
+    case "watcher":
+      return `watch:${trigger.root}`;
+    case "script":
+      return `script:${trigger.intervalMs}ms`;
+  }
+}
+var MONITOR_COLUMNS = [
+  { name: "id", value: (monitor) => monitor.monitorId.slice(0, 8) },
+  { name: "name", value: (monitor) => monitor.name },
+  { name: "schedule", value: triggerSummary },
+  { name: "events", value: (monitor) => [...monitor.eventTypes] },
+  { name: "target", value: (monitor) => monitor.channelTarget ? originKey(monitor.channelTarget.origin) : null },
+  { name: "enabled", value: (monitor) => monitor.enabled }
+];
+var SESSION_COLUMNS = [
+  { name: "index", value: (_session, index) => index },
+  { name: "origin", value: (session) => originKey(session.origin) },
+  { name: "epoch", value: (session) => session.epoch },
+  {
+    name: "bootstrap",
+    value: (session) => session.bootstrap.pending ? "pending" : `${session.bootstrap.byteCount}B${session.bootstrap.truncated ? "/trunc" : ""}`
+  },
+  { name: "createdAt", value: (session) => session.createdAt },
+  { name: "lastActivityAt", value: (session) => session.lastActivityAt }
+];
+function renderList(columns, rows, options, envelope) {
+  const entries = pageRows(rows, options);
+  const selected = selectColumns(columns, options.fields);
+  if (!options.json)
+    return renderTable(selected, entries);
+  if (!options.fields && options.limit === undefined && options.offset === 0)
+    return [JSON.stringify(envelope.result)];
+  const projected = options.fields ? projectRows(selected, entries) : entries.map((entry) => entry.row);
+  return [JSON.stringify({ ...envelope.result, [envelope.key]: projected })];
+}
+
+// src/services.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { parseRuntimeConfig, RuntimeConfigError } from "@gajae-gateway/protocol";
+var CONFIG_SCHEMA_VERSION = 1;
+var FALLBACK_PATH_DIRS = ["/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
+var LOGIN_PATH_COMMAND = 'printf %s "$PATH"';
+var SERVICE_SPECS = [
+  { id: "gateway", label: "dev.gajaeway.gateway", binary: "gajaeway-gateway", args: ["daemon"] },
+  {
+    id: "adapter-discord",
+    label: "dev.gajaeway.adapter-discord",
+    binary: "gajaeway-discord",
+    args: []
+  },
+  {
+    id: "adapter-slack",
+    label: "dev.gajaeway.adapter-slack",
+    binary: "gajaeway-slack",
+    args: []
+  },
+  { id: "admin", label: "dev.gajaeway.admin", binary: "gajaeway-admin", args: ["serve"] }
+];
+function homeForEnvironment(env) {
+  return env.GAJAEWAY_HOME || join(env.HOME || homedir(), ".gajaeway");
+}
+function expandHome(value, home) {
+  return value.startsWith("~/") ? join(home, value.slice(2)) : value;
+}
+function normalizedEntries(entries, home) {
+  const seen = new Set;
+  const result = [];
+  for (const raw of entries) {
+    if (raw.length === 0)
+      continue;
+    const entry = expandHome(raw, home);
+    if (seen.has(entry))
+      continue;
+    seen.add(entry);
+    result.push(entry);
+  }
+  return result;
+}
+function mergePathEntries(binDir, userHome, loginPath) {
+  return normalizedEntries([
+    expandHome(binDir, userHome),
+    join(userHome, "bin"),
+    join(userHome, ".local", "bin"),
+    join(userHome, ".bun", "bin"),
+    ...loginPath.replace(/(?:\r\n|\n)+$/, "").split(":"),
+    ...FALLBACK_PATH_DIRS
+  ], userHome);
+}
+async function defaultLoginPathRunner(command) {
+  let child;
+  try {
+    child = Bun.spawn([...command], { stdout: "pipe", stderr: "pipe" });
+  } catch (error) {
+    throw new Error(`could not run login shell: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!(child.stdout instanceof ReadableStream))
+    throw new Error("login shell stdout was not piped");
+  const stdout = await new Response(child.stdout).text();
+  const exitCode = await child.exited;
+  if (exitCode !== 0)
+    throw new Error(`login shell exited with status ${exitCode}`);
+  return stdout;
+}
+async function discoverLoginPath(env = process.env, runner = defaultLoginPathRunner) {
+  const shell = env.SHELL || "/bin/zsh";
+  return await runner([shell, "-lc", LOGIN_PATH_COMMAND]);
+}
+async function resolvePath(options) {
+  const runtime = options.runtime;
+  const env = options.env;
+  const shellEnv = env ?? process.env;
+  const userHome = options.home;
+  let loginPath = "";
+  if (runtime?.path !== undefined)
+    loginPath = runtime.path.join(":");
+  else if (runtime?.inheritLoginPath !== false)
+    loginPath = options.loginPath ?? await discoverLoginPath(shellEnv, options.loginPathRunner ?? defaultLoginPathRunner);
+  return mergePathEntries(options.binDir, userHome, loginPath).join(":");
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function plistString(value) {
+  return `<string>${escapeXml(value)}</string>`;
+}
+function renderLaunchAgent(spec, binDir, home, path) {
+  const program = join(binDir, spec.binary);
+  const argumentsXml = [program, ...spec.args].map(plistString).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key>${plistString(spec.label)}
+  <key>ProgramArguments</key><array>${argumentsXml}</array>
+  <key>WorkingDirectory</key>${plistString(binDir)}
+  <key>EnvironmentVariables</key><dict>
+    <key>GAJAEWAY_HOME</key>${plistString(home)}
+    <key>PATH</key>${plistString(path)}
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key>${plistString(join(home, `${spec.id}.stdout.log`))}
+  <key>StandardErrorPath</key>${plistString(join(home, `${spec.id}.stderr.log`))}
+</dict></plist>
+`;
+}
+async function readRuntime(home) {
+  const configPath = join(home, "config.json");
+  let raw;
+  try {
+    raw = await readFile(configPath, "utf8");
+  } catch (error) {
+    throw new Error(`could not read ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`could not parse ${configPath}: malformed JSON`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    throw new Error(`invalid configuration ${configPath}: config must be an object`);
+  const input = parsed;
+  if (input.schemaVersion !== CONFIG_SCHEMA_VERSION)
+    throw new Error(`invalid configuration ${configPath}: schemaVersion must be ${CONFIG_SCHEMA_VERSION}`);
+  try {
+    return parseRuntimeConfig(input.runtime);
+  } catch (error) {
+    const message = error instanceof RuntimeConfigError ? error.message : String(error);
+    throw new Error(`invalid runtime configuration ${configPath}: ${message}`);
+  }
+}
+async function installServices(options) {
+  if (options.binDir.length === 0)
+    throw new Error("services requires a non-empty --bin-dir DIR");
+  const env = options.env ?? process.env;
+  const userHome = env.HOME || homedir();
+  const home = homeForEnvironment(env);
+  const binDir = expandHome(options.binDir, userHome);
+  const launchAgentsDir = expandHome(options.launchAgentsDir ?? join(userHome, "Library", "LaunchAgents"), userHome);
+  const runtime = await readRuntime(home);
+  const path = await resolvePath({
+    binDir,
+    home: userHome,
+    runtime,
+    env,
+    loginPathRunner: options.loginPathRunner
+  });
+  await mkdir(launchAgentsDir, { recursive: true, mode: 448 });
+  const plists = SERVICE_SPECS.map((spec) => ({
+    path: join(launchAgentsDir, `dev.gajaeway.${spec.id}.plist`),
+    contents: renderLaunchAgent(spec, binDir, home, path)
+  }));
+  const write = options.writeFile;
+  for (const plist of plists) {
+    if (write)
+      await write(plist.path, plist.contents);
+    else {
+      await writeFile(plist.path, plist.contents, { encoding: "utf8", mode: 384 });
+      await chmod(plist.path, 384);
+    }
+  }
+  return plists.map((plist) => plist.path);
+}
+function serviceUsage() {
+  return "usage: gajaeway services install|repair --bin-dir DIR [--launch-agents-dir DIR]";
+}
+
+// src/main.ts
+function socketPath(home = process.env.GAJAEWAY_HOME) {
+  return `${home ?? `${process.env.HOME ?? "~"}/.gajaeway`}/gateway.sock`;
+}
+var COMMANDS = [
+  "status",
+  "shutdown",
+  "chat",
+  "daemon",
+  "sessions",
+  "ops",
+  "memory",
+  "monitors",
+  "work",
+  "services"
+];
+var CLI_USAGE = "usage: gajaeway [--socket PATH] status|shutdown|chat|daemon run|sessions list [--json] [--fields a,b,c] [--limit N] [--offset N]|sessions inspect <originKey-or-index>|memory audit|memory search <query>|monitors ...|work run|start <name> [--cwd DIR] [--resume] [--model ID|--preset NAME] [--notify originKey (start only)] <text>|work status <name>|work steer <name> <text>|work retire <name>|work jobs|ops backup <path>|ops cycle [--json]|ops integrity|ops restore <backupPath>|services install|repair --bin-dir DIR [--launch-agents-dir DIR] (work run waits for a response; caller timeout does not end the attempt)";
+var USAGE_EXIT_CODE = 2;
+function usageFor(command) {
+  return command !== undefined && COMMANDS.includes(command) ? undefined : CLI_USAGE;
+}
+function parseArgs(args) {
+  let socket = socketPath();
+  const rest = [];
+  for (let i = 0;i < args.length; i++) {
+    if (args[i] === "--socket")
+      socket = args[++i] ?? socket;
+    else
+      rest.push(args[i]);
+  }
+  return { command: rest[0], rest: rest.slice(1), socket };
+}
+function gatewayHome() {
+  return process.env.GAJAEWAY_HOME ?? `${process.env.HOME ?? "~"}/.gajaeway`;
+}
+function parseServicesArgs(args) {
+  const action = args[0];
+  if (action !== "install" && action !== "repair")
+    throw new Error(serviceUsage());
+  let binDir;
+  let launchAgentsDir;
+  for (let i = 1;i < args.length; i++) {
+    const flag = args[i];
+    if (flag === "--bin-dir" || flag === "--launch-agents-dir") {
+      const value = args[++i];
+      if (value === undefined || value.length === 0 || value.startsWith("--"))
+        throw new Error(`${flag} expects a non-empty DIR`);
+      if (flag === "--bin-dir")
+        binDir = value;
+      else
+        launchAgentsDir = value;
+    } else
+      throw new Error(`unknown option: ${flag}`);
+  }
+  if (binDir === undefined)
+    throw new Error("services requires --bin-dir DIR");
+  return { action, binDir, ...launchAgentsDir === undefined ? {} : { launchAgentsDir } };
+}
+function renderCycle(cycle) {
+  const lines = [];
+  lines.push(`phase: ${cycle.phase}`);
+  if (cycle.gates.length > 0)
+    lines.push(`gates: ${cycle.gates.join(", ")}`);
+  else
+    lines.push("gates: none");
+  lines.push(`generatedAt: ${cycle.generatedAt}`);
+  lines.push(`instance: ${cycle.instanceId}`);
+  lines.push(`inbound: pending=${cycle.pendingInbound} inflight=${cycle.inFlightInbound}`);
+  lines.push(`context: unread=${cycle.contextDiff.unread} expired=${cycle.contextDiff.expired} truncated=${cycle.contextDiff.truncated} omitted_oldest=${cycle.contextDiff.omittedOldestAt ?? "-"} omitted_newest=${cycle.contextDiff.omittedNewestAt ?? "-"}`);
+  lines.push(`deliveries: pending=${cycle.deliveries.pending} inflight=${cycle.deliveries.inflight} confirmed=${cycle.deliveries.confirmed} failed_ambiguous=${cycle.deliveries.failedAmbiguous} expired=${cycle.deliveries.expired}`);
+  lines.push(`memory: queued=${cycle.memoryIntents.queued} written=${cycle.memoryIntents.written} committed=${cycle.memoryIntents.committed} receipted=${cycle.memoryIntents.receipted} quarantined=${cycle.memoryIntents.quarantined}${cycle.memoryClosing ? " (closing)" : ""}`);
+  lines.push(`monitors: ${cycle.monitorEvents.length ? cycle.monitorEvents.map((m) => `${m.stage}=${m.count}`).join(" ") : "none"}`);
+  if (cycle.sessions.length > 0) {
+    lines.push("sessions:");
+    lines.push("INDEX  ORIGIN                                      EPOCH  SESSION      PENDING  UNSETTLED  OLDEST");
+    for (const [index, session] of cycle.sessions.entries()) {
+      const sessionId = session.sessionId === "" ? "(rebinding)" : session.sessionId.slice(0, 11);
+      const oldest = session.oldestUnsettledAgeMs === null ? "-" : `${Math.round(session.oldestUnsettledAgeMs / 1000)}s`;
+      lines.push(`${String(index).padEnd(6)} ${session.originKey.padEnd(43)} ${String(session.epoch).padEnd(6)} ${sessionId.padEnd(12)} ${String(session.pendingInbound).padEnd(8)} ${String(session.unsettledDeliveries).padEnd(10)} ${oldest}`);
+    }
+  }
+  return lines;
+}
+function cycleExitCode(cycle) {
+  return cycle.gates.length > 0 ? 1 : 0;
+}
+async function restoreDatabase(socket, backupPath) {
+  if (!isAbsolute(backupPath))
+    throw new Error("ops restore requires an absolute backup path");
+  try {
+    await stat(socket);
+    throw new Error(`Refusing restore: gateway socket ${socket} exists. Stop the daemon before restoring.`);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Refusing restore:"))
+      throw error;
+    if (error.code !== "ENOENT")
+      throw new Error(`Cannot verify gateway socket ${socket}; refusing restore.`);
+  }
+  let header;
+  try {
+    header = new Uint8Array(await Bun.file(backupPath).slice(0, 16).arrayBuffer());
+  } catch {
+    throw new Error(`Backup is not readable: ${backupPath}`);
+  }
+  if (new TextDecoder().decode(header) !== "SQLite format 3\x00")
+    throw new Error(`Backup is not a SQLite database: ${backupPath}`);
+  const databasePath = join2(gatewayHome(), "gateway.db");
+  const preservedPath = `${databasePath}.pre-restore-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+  await copyFile(databasePath, preservedPath);
+  await copyFile(backupPath, databasePath);
+  console.log(`Validated SQLite backup: ${backupPath}`);
+  console.log(`Copied current database to: ${preservedPath}`);
+  console.log(`Restored backup to: ${databasePath}`);
+}
+async function chat(socket) {
+  let client;
+  try {
+    client = await GajaewayClient.connectSocket(socket);
+  } catch {
+    console.error(`Unable to connect to gateway socket ${socket}. Start the daemon out-of-band first.`);
+    process.exitCode = 1;
+    return;
+  }
+  const turnWaiters = new Map;
+  client.onChatMessage((message) => {
+    console.log(message.text);
+    if (message.final)
+      turnWaiters.get(message.turnId)?.();
+  });
+  const sendAndWait = async (text) => {
+    const { turnId } = await client.chatSend(LOOPBACK_ORIGIN, text);
+    if (turnId === null) {
+      console.error("(message was not engaged)");
+      return;
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        turnWaiters.delete(turnId);
+        console.error("(turn timed out after 120s)");
+        resolve();
+      }, 120000);
+      turnWaiters.set(turnId, () => {
+        clearTimeout(timer);
+        turnWaiters.delete(turnId);
+        resolve();
+      });
+    });
+  };
+  const reader = Bun.stdin.stream().getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  process.stdout.write("> ");
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line === "/quit")
+          return;
+        if (line.trim())
+          await sendAndWait(line);
+        process.stdout.write("> ");
+      }
+    }
+  } finally {
+    await client.close();
+  }
+}
+async function main(args = process.argv.slice(2), options = {}) {
+  const parsed = parseArgs(args);
+  const usage = usageFor(parsed.command);
+  if (usage !== undefined) {
+    console.error(usage);
+    process.exit(USAGE_EXIT_CODE);
+  }
+  try {
+    switch (parsed.command) {
+      case "status": {
+        const client = await GajaewayClient.connectSocket(parsed.socket);
+        try {
+          console.log(JSON.stringify(await client.status()));
+        } finally {
+          await client.close();
+        }
+        break;
+      }
+      case "shutdown": {
+        const client = await GajaewayClient.connectSocket(parsed.socket);
+        try {
+          await client.shutdown();
+        } finally {
+          await client.close();
+        }
+        break;
+      }
+      case "chat":
+        await chat(parsed.socket);
+        break;
+      case "daemon":
+        if (parsed.rest[0] === "run")
+          console.log("Launch the gateway out-of-band with: bun packages/gateway/src/main.ts daemon");
+        else
+          throw new Error("usage: gajaeway daemon run");
+        break;
+      case "sessions": {
+        const listOptions = parsed.rest[0] === "list" ? parseListOptions(parsed.rest.slice(1), SESSION_COLUMNS) : undefined;
+        const client = await GajaewayClient.connectSocket(parsed.socket);
+        try {
+          const result = await client.request("session.list");
+          const [command, selector] = parsed.rest;
+          if (command === "list") {
+            const options2 = listOptions;
+            for (const line of renderList(SESSION_COLUMNS, result.sessions, options2, {
+              key: "sessions",
+              result
+            }))
+              console.log(line);
+          } else if (command === "inspect" && selector) {
+            const index = Number(selector);
+            const session = Number.isInteger(index) ? result.sessions[index] : result.sessions.find((candidate) => originKey2(candidate.origin) === selector);
+            if (!session)
+              throw new Error(`Unknown session: ${selector}`);
+            console.log(`origin: ${originKey2(session.origin)}`);
+            console.log(`epoch: ${session.epoch}`);
+            console.log(`createdAt: ${session.createdAt}`);
+            console.log(`lastActivityAt: ${session.lastActivityAt ?? "-"}`);
+            console.log(`bootstrapEpoch: ${session.bootstrap.epoch}`);
+            console.log(`bootstrapPending: ${session.bootstrap.pending}`);
+            console.log(`bootstrapAppliedAt: ${session.bootstrap.appliedAt ?? "-"}`);
+            console.log(`bootstrapSections: ${session.bootstrap.includedSections.join(", ") || "-"}`);
+            console.log(`bootstrapBytes: ${session.bootstrap.byteCount}`);
+            console.log(`bootstrapTruncated: ${session.bootstrap.truncated}`);
+            console.log(`bootstrapDiagnostics: ${session.bootstrap.diagnostics.join(", ") || "-"}`);
+          } else
+            throw new Error(`usage: gajaeway sessions list [--json] [--fields ${columnNames(SESSION_COLUMNS).join(",")}] [--limit N] [--offset N]|inspect <originKey-or-index>`);
+        } finally {
+          await client.close();
+        }
+        break;
+      }
+      case "ops": {
+        const [command, path] = parsed.rest;
+        if (command === "restore" && path) {
+          await restoreDatabase(parsed.socket, path);
+          break;
+        }
+        const client = await GajaewayClient.connectSocket(parsed.socket);
+        try {
+          if (command === "backup" && path)
+            console.log(JSON.stringify(await client.request("ops.backup", { path })));
+          else if (command === "integrity")
+            console.log(JSON.stringify(await client.request("ops.integrity")));
+          else if (command === "cycle") {
+            const cycle = await client.opsCycle();
+            if (parsed.rest[1] === "--json")
+              console.log(JSON.stringify(cycle));
+            else if (parsed.rest[1])
+              throw new Error("usage: gajaeway ops cycle [--json]");
+            else
+              for (const line of renderCycle(cycle))
+                console.log(line);
+            process.exitCode = cycleExitCode(cycle);
+          } else
+            throw new Error("usage: gajaeway ops backup <path>|cycle [--json]|integrity|restore <backupPath>");
+        } finally {
+          await client.close();
+        }
+        break;
+      }
+      case "memory": {
+        const usage2 = "usage: gajaeway memory audit|memory autolink|memory search <query>";
+        if ((parsed.rest[0] === "audit" || parsed.rest[0] === "autolink") && parsed.rest.length > 1)
+          throw new Error(`${usage2} (unknown argument: ${parsed.rest[1]})`);
+        const client = await GajaewayClient.connectSocket(parsed.socket);
+        try {
+          if (parsed.rest[0] === "audit") {
+            const result = await client.request("memory.audit");
+            console.log(JSON.stringify(result.issues));
+            if (!result.ok)
+              process.exitCode = 1;
+          } else if (parsed.rest[0] === "autolink") {
+            console.log(JSON.stringify(await client.request("memory.autolink")));
+          } else if (parsed.rest[0] === "search" && parsed.rest.slice(1).join(" ")) {
+            console.log(JSON.stringify(await client.request("memory.search", { query: parsed.rest.slice(1).join(" ") })));
+          } else
+            throw new Error(usage2);
+        } finally {
+          await client.close();
+        }
+        break;
+      }
+      case "monitors": {
+        const listOptions = parsed.rest[0] === "list" ? parseListOptions(parsed.rest.slice(1), MONITOR_COLUMNS) : undefined;
+        const client = await GajaewayClient.connectSocket(parsed.socket);
+        try {
+          const [command, ...args2] = parsed.rest;
+          if (command === "add" && args2[0] === "--json" && args2[1])
+            console.log(JSON.stringify(await client.request("monitor.add", JSON.parse(args2[1]))));
+          else if (command === "list") {
+            const options2 = listOptions;
+            const result = await client.request("monitor.list");
+            for (const line of renderList(MONITOR_COLUMNS, result.monitors, options2, {
+              key: "monitors",
+              result
+            }))
+              console.log(line);
+          } else if (command === "inspect" && args2[0])
+            console.log(JSON.stringify(await client.request("monitor.inspect", { monitorId: args2[0] })));
+          else if (command === "remove" && args2[0])
+            console.log(JSON.stringify(await client.request("monitor.remove", { monitorId: args2[0] })));
+          else if (command === "test" && args2[0]) {
+            let eventType;
+            let payload = {};
+            for (let i = 1;i < args2.length; i++) {
+              if (args2[i] === "--type")
+                eventType = args2[++i];
+              else if (args2[i] === "--payload")
+                payload = JSON.parse(args2[++i] ?? "");
+            }
+            console.log(JSON.stringify(await client.request("monitor.test", {
+              monitorId: args2[0],
+              ...eventType ? { eventType } : {},
+              payload
+            })));
+          } else
+            throw new Error(`usage: gajaeway monitors add --json '<MonitorSpec json>'|list [--json] [--fields ${columnNames(MONITOR_COLUMNS).join(",")}] [--limit N] [--offset N]|inspect <id>|remove <id>|test <id> [--type T] [--payload J]`);
+        } finally {
+          await client.close();
+        }
+        break;
+      }
+      case "work": {
+        const [command, ...args2] = parsed.rest;
+        const usage2 = 'usage: gajaeway work run|start <name> [--cwd DIR] [--resume] [--model ID|--preset NAME] [--notify originKey (start only)] "<task text>"|status <name>|steer <name> <text>|retire <name>|jobs';
+        if (command === "status" || command === "steer") {
+          const name2 = args2[0];
+          const text2 = args2.slice(1).join(" ").trim();
+          if (!name2 || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name2) || (command === "status" ? args2.length !== 1 : !text2 || args2.slice(1).some((arg) => arg.startsWith("--"))))
+            throw new Error(usage2);
+          const client2 = await GajaewayClient.connectSocket(parsed.socket);
+          try {
+            if (command === "status") {
+              console.log(JSON.stringify(await client2.request("work.status", { name: name2 })));
+            } else {
+              const result = await client2.request("work.steer", { name: name2, text: text2 });
+              console.log(result.steered ? `steered: ${result.clientRef}` : `not steered: ${result.reason}`);
+              if (!result.steered)
+                process.exitCode = 1;
+            }
+          } finally {
+            await client2.close();
+          }
+          break;
+        }
+        if (command === "retire" || command === "jobs") {
+          if (command === "retire" ? args2.length !== 1 || !args2[0] || args2[0].startsWith("--") : args2.length !== 0)
+            throw new Error(usage2);
+          const client2 = await GajaewayClient.connectSocket(parsed.socket);
+          try {
+            if (command === "retire") {
+              const result = await client2.request("work.retire", { name: args2[0] });
+              console.log(result.retired ? `retired: ${result.sessionKey} session=${result.sessionId} closed=${result.closed}` : `not retired: ${result.reason}`);
+            } else {
+              const result = await client2.request("work.jobs");
+              for (const job of result.jobs) {
+                const name2 = job.lane_key.startsWith("work-") ? job.lane_key.slice("work-".length) : job.lane_key;
+                const state = job.quarantined ? `HELD: quarantined reason=${job.reason} historical_state=${job.state}` : job.state;
+                console.log(`${name2} ${state} session=${job.session_id || "-"} last=${job.last_activity_at || "-"} ${job.worktree_path}`);
+              }
+            }
+          } finally {
+            await client2.close();
+          }
+          break;
+        }
+        if (command !== "run" && command !== "start")
+          throw new Error(usage2);
+        const name = args2[0];
+        let cwd;
+        let resume = false;
+        let model;
+        let notify;
+        const textParts = [];
+        for (let i = 1;i < args2.length; i++) {
+          const arg = args2[i];
+          if (arg === "--cwd" || arg === "--model" || arg === "--preset" || arg === "--notify") {
+            const value = args2[++i];
+            if (!value?.trim() || value.startsWith("--"))
+              throw new Error(usage2);
+            if (arg === "--cwd") {
+              if (cwd !== undefined || !isAbsolute(value))
+                throw new Error(usage2);
+              cwd = value;
+            } else if (arg === "--notify") {
+              if (command !== "start" || notify !== undefined)
+                throw new Error(usage2);
+              try {
+                notify = parseOriginKey(value);
+              } catch {
+                throw new Error(`${usage2}
+invalid --notify originKey`);
+              }
+            } else {
+              if (model !== undefined)
+                throw new Error(`${usage2}
+--model and --preset are mutually exclusive`);
+              model = arg === "--preset" ? { preset: value } : value;
+            }
+          } else if (arg === "--resume")
+            resume = true;
+          else if (arg?.startsWith("--"))
+            throw new Error(usage2);
+          else
+            textParts.push(arg);
+        }
+        const text = textParts.join(" ").trim();
+        if (!name || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name) || !text)
+          throw new Error(usage2);
+        const client = await GajaewayClient.connectSocket(parsed.socket, {
+          requestTimeoutMs: command === "run" ? 3600000 : 120000
+        });
+        try {
+          const params = {
+            name,
+            text,
+            ...cwd ? { cwd } : {},
+            ...resume ? { resume: true } : {},
+            ...model === undefined ? {} : { model },
+            ...notify === undefined ? {} : { notify }
+          };
+          if (command === "start") {
+            const result = await client.request("work.start", params);
+            if (result.started) {
+              console.log(`started: ${result.sessionKey} session=${result.sessionId} job=${result.jobId} op=${result.opRef}`);
+            } else {
+              console.log(`HELD: ${result.reason}
+job: ${result.jobId} state: ${result.state}`);
+              process.exitCode = 1;
+            }
+          } else {
+            const result = await client.request("work.run", params);
+            if (result.held) {
+              console.log(`HELD: ${result.reason}
+job: ${result.jobId} state: ${result.state}`);
+              process.exitCode = 1;
+            } else
+              console.log(result.text);
+          }
+        } finally {
+          await client.close();
+        }
+        break;
+      }
+      case "services": {
+        const service = parseServicesArgs(parsed.rest);
+        const written = await installServices({
+          binDir: service.binDir,
+          ...service.launchAgentsDir === undefined ? {} : { launchAgentsDir: service.launchAgentsDir },
+          env: process.env,
+          ...options.services
+        });
+        console.log(`services ${service.action}: wrote ${written.length} LaunchAgent plists`);
+        break;
+      }
+      default:
+        throw new Error(CLI_USAGE);
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}
+if (import.meta.main)
+  await main();
+export {
+  CLI_USAGE,
+  COMMANDS,
+  USAGE_EXIT_CODE,
+  cycleExitCode,
+  main,
+  parseArgs,
+  parseServicesArgs,
+  renderCycle,
+  restoreDatabase,
+  socketPath,
+  usageFor
+};