blackriver-gateway 3.8.46

package/bin/cli/commands/logs.mjs

@@ -0,0 +1,183 @@
+import { writeFileSync, appendFileSync, existsSync, unlinkSync } from "node:fs";
+import { t } from "../i18n.mjs";
+import { getBaseUrl, buildHeaders } from "../api.mjs";
+
+export function registerLogs(program) {
+  program
+    .command("logs")
+    .description(t("logs.description"))
+    .option("--follow", t("logs.follow"))
+    .option("--filter <level>", t("logs.filter"))
+    .option("--lines <n>", t("logs.lines"), "100")
+    .option("--timeout <ms>", t("logs.timeout"), "30000")
+    .option("--base-url <url>", t("logs.baseUrl"))
+    .option("--request-id <id>", t("logs.requestId"))
+    .option("--api-key <key>", t("logs.apiKey"))
+    .option("--combo <name>", t("logs.combo"))
+    .option("--status <code>", t("logs.status"))
+    .option("--duration-min <ms>", t("logs.durationMin"), parseInt)
+    .option("--duration-max <ms>", t("logs.durationMax"), parseInt)
+    .option("--export <path>", t("logs.export"))
+    .action(async (opts, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      // `--context` and `--output` are global options, so forward them explicitly:
+      // runLogsCommand resolves the base URL via getBaseUrl({ context }), and without
+      // this a user's `--context` would be silently dropped.
+      const exitCode = await runLogsCommand({
+        ...opts,
+        context: globalOpts.context,
+        output: globalOpts.output,
+      });
+      if (exitCode !== 0) process.exit(exitCode);
+    });
+}
+
+function buildLogFilter(opts) {
+  const levelFilters = opts.filter ? opts.filter.split(",").map((f) => f.trim()) : [];
+  const requestId = opts.requestId;
+  const apiKey = opts.apiKey;
+  const combo = opts.combo;
+  const statusFilter = opts.status != null ? String(opts.status) : null;
+  const durationMin = opts.durationMin != null ? Number(opts.durationMin) : null;
+  const durationMax = opts.durationMax != null ? Number(opts.durationMax) : null;
+
+  return function matchesLog(parsed) {
+    if (levelFilters.length > 0) {
+      const level = String(parsed.level || "info").toLowerCase();
+      if (!levelFilters.includes(level)) return false;
+    }
+    if (requestId) {
+      const rid = String(parsed.requestId || parsed.request_id || "");
+      if (!rid.includes(requestId)) return false;
+    }
+    if (apiKey) {
+      const key = String(parsed.apiKey || parsed.api_key || parsed.key || "");
+      if (!key.includes(apiKey)) return false;
+    }
+    if (combo) {
+      const c = String(parsed.combo || parsed.comboName || parsed.combo_name || "");
+      if (!c.includes(combo)) return false;
+    }
+    if (statusFilter) {
+      const s = String(parsed.status || parsed.statusCode || parsed.status_code || "");
+      if (!s.startsWith(statusFilter)) return false;
+    }
+    if (durationMin != null) {
+      const d = Number(parsed.duration || parsed.durationMs || parsed.latency || 0);
+      if (d < durationMin) return false;
+    }
+    if (durationMax != null) {
+      const d = Number(parsed.duration || parsed.durationMs || parsed.latency || 0);
+      if (d > durationMax) return false;
+    }
+    return true;
+  };
+}
+
+export async function runLogsCommand(opts = {}) {
+  // Resolve the base URL the same way every other CLI command does: an explicit
+  // --base-url wins, otherwise fall back to the active context / env / localhost.
+  // Without this, `logs` always hit localhost and ignored a connected remote.
+  const baseUrl = opts.baseUrl || opts["base-url"] || getBaseUrl({ context: opts.context });
+  const follow = opts.follow ?? false;
+  const timeout = parseInt(String(opts.timeout || "30000"), 10);
+  const isJson = opts.output === "json";
+  const exportPath = opts.export;
+
+  // Prepare export file
+  if (exportPath && existsSync(exportPath)) {
+    unlinkSync(exportPath);
+  }
+
+  const matchesLog = buildLogFilter(opts);
+  // Pass only level filters to the stream (server-side); other filters are client-side
+  const levelFilters = opts.filter ? opts.filter.split(",").map((f) => f.trim()) : [];
+
+  // Authenticate the log stream. The /api/cli-tools/logs endpoint requires the
+  // management token; build the same headers (scoped context token + CLI token)
+  // that apiFetch uses, so `logs` works against authenticated/remote servers.
+  // NOTE: --api-key here is a client-side log *filter* (see buildLogFilter), not
+  // an auth credential, so it is deliberately not forwarded to buildHeaders.
+  const headers = await buildHeaders({ baseUrl, context: opts.context });
+
+  const { createLogStream } = await import("../../../src/lib/cli-helper/log-streamer.js");
+  const { stream, stop } = createLogStream({
+    baseUrl,
+    filters: levelFilters,
+    follow,
+    timeout,
+    headers,
+  });
+
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  const processLine = (line) => {
+    if (!line.trim()) return;
+    let parsed = null;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      // Non-JSON line: only include if no structured filters active
+      if (
+        opts.requestId ||
+        opts.apiKey ||
+        opts.combo ||
+        opts.status ||
+        opts.durationMin != null ||
+        opts.durationMax != null
+      )
+        return;
+      if (exportPath) appendFileSync(exportPath, line + "\n", "utf8");
+      else console.log(line);
+      return;
+    }
+
+    if (!matchesLog(parsed)) return;
+
+    if (exportPath) {
+      appendFileSync(exportPath, JSON.stringify(parsed) + "\n", "utf8");
+      return;
+    }
+
+    if (isJson) {
+      console.log(JSON.stringify(parsed));
+      return;
+    }
+
+    const level = parsed.level || "info";
+    const ts = parsed.timestamp || new Date().toISOString();
+    const msg = parsed.message || JSON.stringify(parsed);
+    const prefix =
+      { error: "\x1b[31m[ERR]", warn: "\x1b[33m[WRN]", info: "\x1b[36m[INF]" }[level] || "[INF]";
+    console.log(`${prefix}\x1b[0m ${ts} ${msg}`);
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split("\n");
+      buffer = parts.pop() || "";
+      for (const line of parts) processLine(line);
+    }
+    if (buffer) processLine(buffer);
+    if (exportPath) console.log(t("logs.exported", { path: exportPath }));
+  } catch (err) {
+    if (err.name === "AbortError") {
+      console.log(t("logs.stopped"));
+    } else {
+      console.error(
+        t("logs.streamError", {
+          message: (err instanceof Error ? err.message : String(err)).slice(0, 100),
+        })
+      );
+    }
+  } finally {
+    stop();
+  }
+
+  return 0;
+}

package/bin/cli/commands/mcp.mjs

@@ -0,0 +1,273 @@
+import { readFileSync } from "node:fs";
+import { apiFetch, isServerUp } from "../api.mjs";
+import { emit } from "../output.mjs";
+import { t } from "../i18n.mjs";
+
+function truncate(v, len = 60) {
+  if (v == null) return "-";
+  const s = String(v);
+  return s.length > len ? s.slice(0, len - 1) + "…" : s;
+}
+
+const mcpToolSchema = [
+  { key: "name", header: "Tool", width: 36 },
+  {
+    key: "scopes",
+    header: "Scopes",
+    formatter: (v) => (Array.isArray(v) ? v.join(",") : (v ?? "-")),
+  },
+  { key: "auditLevel", header: "Audit", width: 10 },
+  { key: "phase", header: "Phase", width: 6 },
+  { key: "description", header: "Description", formatter: truncate },
+];
+
+export function registerMcp(program) {
+  const mcp = program.command("mcp").description(t("mcp.title"));
+
+  mcp
+    .command("status")
+    .description("Show MCP server status")
+    .option("--json", "Output as JSON")
+    .action(async (opts, cmd) => {
+      const globalOpts = cmd.parent.optsWithGlobals();
+      const exitCode = await runMcpStatusCommand({ ...opts, output: globalOpts.output });
+      if (exitCode !== 0) process.exit(exitCode);
+    });
+
+  mcp
+    .command("restart")
+    .description("Restart the MCP server")
+    .action(async (opts, cmd) => {
+      const globalOpts = cmd.parent.optsWithGlobals();
+      const exitCode = await runMcpRestartCommand({ ...opts, output: globalOpts.output });
+      if (exitCode !== 0) process.exit(exitCode);
+    });
+
+  // 5.1 — mcp call + mcp scopes
+  mcp
+    .command("call <tool> [argsJson]")
+    .description(t("mcp.call.description"))
+    .option("--args <json>", t("mcp.call.args"))
+    .option("--args-file <path>", t("mcp.call.args_file"))
+    .option("--stream", t("mcp.call.stream"))
+    .option("--scope <s>", t("mcp.call.scope"), (v, prev = []) => [...prev, v], [])
+    .action(async (tool, argsPositional, opts, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const args = opts.args
+        ? JSON.parse(opts.args)
+        : opts.argsFile
+          ? JSON.parse(readFileSync(opts.argsFile, "utf8"))
+          : argsPositional
+            ? JSON.parse(argsPositional)
+            : {};
+
+      if (opts.stream) {
+        await runMcpStream(tool, args, globalOpts);
+        return;
+      }
+
+      const extraHeaders = opts.scope?.length ? { "X-MCP-Scopes": opts.scope.join(",") } : {};
+      const res = await apiFetch("/api/mcp/tools/call", {
+        method: "POST",
+        body: { name: tool, arguments: args },
+        headers: extraHeaders,
+      });
+      if (res.status === 403) {
+        process.stderr.write("Scope denied\n");
+        process.exit(4);
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      emit(data, globalOpts);
+    });
+
+  mcp
+    .command("scopes")
+    .description(t("mcp.scopes.description"))
+    .option("--tool <name>", t("mcp.scopes.tool"))
+    .action(async (opts, cmd) => {
+      const params = new URLSearchParams({ meta: "scopes" });
+      if (opts.tool) params.set("tool", opts.tool);
+      const res = await apiFetch(`/api/mcp/tools?${params}`);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      emit(data.scopes ?? data, cmd.optsWithGlobals());
+    });
+
+  // 5.2 — mcp tools + mcp audit
+  const tools = mcp.command("tools").description(t("mcp.tools.description"));
+
+  tools
+    .command("list")
+    .description(t("mcp.tools.list.description"))
+    .option("--scope <s>", t("mcp.tools.list.scope"))
+    .action(async (opts, cmd) => {
+      const params = new URLSearchParams();
+      if (opts.scope) params.set("scope", opts.scope);
+      const res = await apiFetch(`/api/mcp/tools?${params}`);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      emit(data.tools ?? data, cmd.optsWithGlobals(), mcpToolSchema);
+    });
+
+  tools
+    .command("info <name>")
+    .description(t("mcp.tools.info.description"))
+    .action(async (name, opts, cmd) => {
+      const res = await apiFetch(`/api/mcp/tools?name=${encodeURIComponent(name)}`);
+      if (!res.ok) {
+        process.stderr.write(`Not found: ${name}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+
+  tools
+    .command("schema <name>")
+    .description(t("mcp.tools.schema.description"))
+    .option("--io <kind>", t("mcp.tools.schema.io"), "input")
+    .action(async (name, opts, cmd) => {
+      const res = await apiFetch(`/api/mcp/tools?name=${encodeURIComponent(name)}&io=${opts.io}`);
+      if (!res.ok) {
+        process.stderr.write(`Not found: ${name}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      const globalOpts = cmd.optsWithGlobals();
+      if (globalOpts.output === "json") {
+        process.stdout.write(JSON.stringify(data.schema ?? data, null, 2) + "\n");
+      } else {
+        emit(data.schema ?? data, globalOpts);
+      }
+    });
+
+  const audit = mcp.command("audit").description(t("mcp.audit.description"));
+
+  audit
+    .command("tail")
+    .option("--follow", t("audit.tail.follow"))
+    .option("--limit <n>", t("audit.tail.limit"), parseInt, 100)
+    .action(async (opts, cmd) => {
+      const { runAuditTail } = await import("./audit.mjs");
+      await runAuditTail({ ...opts, source: "mcp" }, cmd);
+    });
+
+  audit
+    .command("stats")
+    .option("--period <p>", t("audit.stats.period"), "7d")
+    .action(async (opts, cmd) => {
+      const res = await apiFetch(`/api/mcp/audit/stats?period=${opts.period}`);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+}
+
+async function runMcpStream(tool, args, globalOpts) {
+  const baseUrl = globalOpts.baseUrl ?? "http://localhost:20128";
+  const apiKey = globalOpts.apiKey ?? "";
+  const res = await fetch(`${baseUrl}/api/mcp/stream`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+    },
+    body: JSON.stringify({ name: tool, arguments: args }),
+  });
+  if (!res.ok) {
+    process.stderr.write(`HTTP ${res.status}\n`);
+    process.exit(1);
+  }
+  const reader = res.body.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    const lines = buf.split("\n");
+    buf = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        const raw = line.slice(6).trim();
+        if (raw && raw !== "[DONE]") process.stdout.write(raw + "\n");
+      }
+    }
+  }
+}
+
+export async function runMcpStatusCommand(opts = {}) {
+  const serverUp = await isServerUp();
+  if (!serverUp) {
+    console.error(t("common.serverOffline"));
+    return 1;
+  }
+
+  try {
+    const res = await apiFetch("/api/mcp/status", {
+      retry: false,
+      timeout: 5000,
+      acceptNotOk: true,
+    });
+    if (!res.ok) {
+      console.log(t("mcp.stopped"));
+      return 0;
+    }
+
+    const status = await res.json();
+
+    if (opts.json || opts.output === "json") {
+      console.log(JSON.stringify(status, null, 2));
+      return 0;
+    }
+
+    const transport = status.transport || "stdio";
+    console.log(status.running ? t("mcp.running", { transport }) : t("mcp.stopped"));
+    if (status.toolsCount !== undefined) console.log(`  Tools: ${status.toolsCount}`);
+    if (status.scopes?.length) {
+      console.log("  Scopes:");
+      for (const scope of status.scopes) console.log(`    - ${scope}`);
+    }
+    return 0;
+  } catch (err) {
+    console.error(t("common.error", { message: err instanceof Error ? err.message : String(err) }));
+    return 1;
+  }
+}
+
+export async function runMcpRestartCommand(opts = {}) {
+  const serverUp = await isServerUp();
+  if (!serverUp) {
+    console.error(t("common.serverOffline"));
+    return 1;
+  }
+
+  try {
+    const res = await apiFetch("/api/mcp/restart", {
+      method: "POST",
+      retry: false,
+      timeout: 10000,
+      acceptNotOk: true,
+    });
+    if (res.ok) {
+      console.log(t("mcp.restarted"));
+      return 0;
+    }
+    console.error(t("common.error", { message: `HTTP ${res.status}` }));
+    return 1;
+  } catch (err) {
+    console.error(t("common.error", { message: err instanceof Error ? err.message : String(err) }));
+    return 1;
+  }
+}

package/bin/cli/commands/memory.mjs

@@ -0,0 +1,244 @@
+import { readFileSync } from "node:fs";
+import { apiFetch } from "../api.mjs";
+import { emit } from "../output.mjs";
+import { t } from "../i18n.mjs";
+
+const VALID_TYPES = ["factual", "episodic", "procedural", "semantic"];
+
+const LEGACY_TYPE_MAP = {
+  user: "factual",
+  feedback: "factual",
+  project: "factual",
+  reference: "factual",
+};
+
+/**
+ * Plan 21 Bug#4/D17 fix: remap legacy types in ALL CLI subcommands
+ * (search/list/clear in addition to add), with a stderr warning on remap.
+ * Returns the canonical type, or the original value (which the backend will
+ * 400 on if invalid) — never throws.
+ */
+function applyLegacyTypeMap(type) {
+  if (!type) return type;
+  if (Object.prototype.hasOwnProperty.call(LEGACY_TYPE_MAP, type)) {
+    const mapped = LEGACY_TYPE_MAP[type];
+    process.stderr.write(
+      `Warning: legacy type '${type}' is deprecated; using '${mapped}'. Use --type factual|episodic|procedural|semantic.\n`
+    );
+    return mapped;
+  }
+  if (!VALID_TYPES.includes(type)) {
+    process.stderr.write(
+      `Warning: unknown type '${type}'. Valid types: factual, episodic, procedural, semantic.\n`
+    );
+  }
+  return type;
+}
+
+function truncate(v, len = 60) {
+  if (v == null) return "-";
+  const s = String(v);
+  return s.length > len ? s.slice(0, len - 1) + "…" : s;
+}
+
+function fmtTs(v) {
+  if (!v) return "-";
+  try {
+    return new Date(v).toLocaleString();
+  } catch {
+    return String(v);
+  }
+}
+
+const memorySchema = [
+  { key: "id", header: "ID", width: 14 },
+  { key: "type", header: "Type", width: 12 },
+  { key: "content", header: "Content", width: 60, formatter: truncate },
+  { key: "score", header: "Score", formatter: (v) => (v != null ? v.toFixed(3) : "-") },
+  { key: "createdAt", header: "Created", formatter: fmtTs },
+];
+
+function parseDuration(s) {
+  const m = String(s).match(/^(\d+)(d|m|y)$/i);
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  const unit = m[2].toLowerCase();
+  const now = Date.now();
+  if (unit === "d") return new Date(now - n * 86400000).toISOString();
+  if (unit === "m") return new Date(now - n * 30 * 86400000).toISOString();
+  if (unit === "y") return new Date(now - n * 365 * 86400000).toISOString();
+  return null;
+}
+
+async function confirm(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(`${question} (yes/no) `);
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (chunk) => {
+      resolve(chunk.toString().trim().toLowerCase().startsWith("y"));
+    });
+  });
+}
+
+export async function runMemorySearch(query, opts, cmd) {
+  const globalOpts = cmd.optsWithGlobals();
+  const params = new URLSearchParams({ q: query, limit: String(opts.limit ?? 20) });
+  const mappedSearchType = applyLegacyTypeMap(opts.type);
+  if (mappedSearchType) params.set("type", mappedSearchType);
+  if (opts.apiKey) params.set("apiKey", opts.apiKey);
+  if (opts.tokenBudget) params.set("tokenBudget", String(opts.tokenBudget));
+  const res = await apiFetch(`/api/memory?${params}`);
+  if (!res.ok) {
+    process.stderr.write(`Error: ${res.status}\n`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  emit(data.items ?? data, globalOpts, memorySchema);
+}
+
+export async function runMemoryAdd(opts, cmd) {
+  const globalOpts = cmd.optsWithGlobals();
+  const content = opts.content ?? (opts.file ? readFileSync(opts.file, "utf8") : null);
+  if (!content) {
+    process.stderr.write("--content or --file required\n");
+    process.exit(2);
+  }
+  const resolvedType = opts.type ? applyLegacyTypeMap(opts.type) : "factual";
+  const body = {
+    content,
+    type: resolvedType,
+    ...(opts.metadata ? { metadata: JSON.parse(opts.metadata) } : {}),
+    ...(opts.apiKey ? { apiKey: opts.apiKey } : {}),
+  };
+  const res = await apiFetch("/api/memory", { method: "POST", body });
+  if (!res.ok) {
+    process.stderr.write(`Error: ${res.status}\n`);
+    process.exit(1);
+  }
+  const created = await res.json();
+  emit(created, globalOpts, memorySchema);
+}
+
+export async function runMemoryClear(opts, cmd) {
+  const globalOpts = cmd.optsWithGlobals();
+  if (!opts.yes) {
+    const ok = await confirm("This will delete memories. Continue?");
+    if (!ok) process.exit(0);
+  }
+  const params = new URLSearchParams();
+  const mappedClearType = applyLegacyTypeMap(opts.type);
+  if (mappedClearType) params.set("type", mappedClearType);
+  if (opts.olderThan) {
+    const iso = parseDuration(opts.olderThan);
+    if (!iso) {
+      process.stderr.write(`Invalid --older-than value: ${opts.olderThan}\n`);
+      process.exit(2);
+    }
+    params.set("olderThan", iso);
+  }
+  if (opts.apiKey) params.set("apiKey", opts.apiKey);
+  const res = await apiFetch(`/api/memory?${params}`, { method: "DELETE" });
+  const data = await res.json();
+  emit(data, globalOpts);
+}
+
+export async function runMemoryList(opts, cmd) {
+  const globalOpts = cmd.optsWithGlobals();
+  const params = new URLSearchParams({ limit: String(opts.limit ?? 100) });
+  const mappedListType = applyLegacyTypeMap(opts.type);
+  if (mappedListType) params.set("type", mappedListType);
+  if (opts.apiKey) params.set("apiKey", opts.apiKey);
+  const res = await apiFetch(`/api/memory?${params}`);
+  if (!res.ok) {
+    process.stderr.write(`Error: ${res.status}\n`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  emit(data.items ?? data, globalOpts, memorySchema);
+}
+
+export async function runMemoryGet(id, opts, cmd) {
+  const globalOpts = cmd.optsWithGlobals();
+  const res = await apiFetch(`/api/memory/${id}`);
+  if (!res.ok) {
+    process.stderr.write(`Not found: ${id}\n`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  emit(data, globalOpts, memorySchema);
+}
+
+export async function runMemoryDelete(id, opts, cmd) {
+  const globalOpts = cmd.optsWithGlobals();
+  if (!opts.yes) {
+    const ok = await confirm(`Delete memory ${id}?`);
+    if (!ok) process.exit(0);
+  }
+  const res = await apiFetch(`/api/memory/${id}`, { method: "DELETE" });
+  if (!res.ok) {
+    process.stderr.write(`Error: ${res.status}\n`);
+    process.exit(1);
+  }
+  process.stdout.write(`Deleted: ${id}\n`);
+}
+
+export async function runMemoryHealth(opts, cmd) {
+  const globalOpts = cmd.optsWithGlobals();
+  const res = await apiFetch("/api/memory/health");
+  if (!res.ok) {
+    process.stderr.write(`Error: ${res.status}\n`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  emit(data, globalOpts);
+}
+
+export function registerMemory(program) {
+  const memory = program.command("memory").description(t("memory.description"));
+
+  memory
+    .command("search <query>")
+    .description(t("memory.search.description"))
+    .option("--type <type>", t("memory.search.type"))
+    .option("--limit <n>", t("memory.search.limit"), parseInt, 20)
+    .option("--api-key <key>", t("memory.search.api_key"))
+    .option("--token-budget <n>", t("memory.search.token_budget"), parseInt)
+    .action(runMemorySearch);
+
+  memory
+    .command("add")
+    .description(t("memory.add.description"))
+    .option("--content <text>", t("memory.add.content"))
+    .option("--file <path>", t("memory.add.file"))
+    .option("--type <type>", t("memory.add.type"))
+    .option("--metadata <json>", t("memory.add.metadata"))
+    .option("--api-key <key>", t("memory.add.api_key"))
+    .action(runMemoryAdd);
+
+  memory
+    .command("clear")
+    .description(t("memory.clear.description"))
+    .option("--type <type>", t("memory.clear.type"))
+    .option("--older-than <duration>", t("memory.clear.older"))
+    .option("--api-key <key>", t("memory.clear.api_key"))
+    .option("--yes", t("memory.clear.yes"))
+    .action(runMemoryClear);
+
+  memory
+    .command("list")
+    .description(t("memory.list.description"))
+    .option("--type <type>", t("memory.list.type"))
+    .option("--limit <n>", t("memory.list.limit"), parseInt, 100)
+    .option("--api-key <key>", t("memory.list.api_key"))
+    .action(runMemoryList);
+
+  memory.command("get <id>").description(t("memory.get.description")).action(runMemoryGet);
+
+  memory
+    .command("delete <id>")
+    .description(t("memory.delete.description"))
+    .option("--yes", t("memory.delete.yes"))
+    .action(runMemoryDelete);
+
+  memory.command("health").description(t("memory.health.description")).action(runMemoryHealth);
+}