@hasna/mementos 0.14.21 → 0.14.23

package/dist/cli.js

@@ -0,0 +1,792 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/agent-setup.ts
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var SUPPORTED_AGENT_HOSTS = ["claude-code", "codex", "opencode", "antigravity"];
+function buildAgentSetupPlan(options = {}) {
+  const home = options.homeDir ?? homedir();
+  const baseDir = join(home, ".config", "mementos", "agent-integrations");
+  const hosts = uniqueHosts(options.hosts ?? [...SUPPORTED_AGENT_HOSTS]);
+  const apiUrl = options.apiUrl ?? "https://mementos.md";
+  const mcpCommand = "mementos-mcp";
+  const hookCommand = "mementos hook stop";
+  const injectCommand = "mementos inject";
+  const files = [
+    {
+      path: join(baseDir, "mementos-injection.md"),
+      content: renderInjectionInstructions({ apiUrl, injectCommand })
+    },
+    {
+      path: join(baseDir, "mementos-stop-hook.sh"),
+      executable: true,
+      content: renderHookScript(hookCommand)
+    },
+    {
+      path: join(baseDir, "mcp-server.json"),
+      content: `${JSON.stringify(renderMcpServerConfig({ apiUrl, mcpCommand }), null, 2)}
+`
+    }
+  ];
+  for (const host of hosts) {
+    files.push({
+      path: join(baseDir, `${host}.json`),
+      content: `${JSON.stringify(renderHostConfig(host, { apiUrl, hookCommand, injectCommand, mcpCommand }), null, 2)}
+`
+    });
+    files.push({
+      path: hostManagedConfigPath(home, host),
+      content: `${JSON.stringify(renderManagedHostConfig(host, { apiUrl, baseDir, hookCommand, injectCommand, mcpCommand }), null, 2)}
+`
+    });
+  }
+  return {
+    baseDir,
+    files,
+    hostResults: hosts.map((host) => ({ host, path: hostNativeConfigPath(home, host), status: "planned" })),
+    hosts,
+    mcpCommand
+  };
+}
+function installAgentSetup(options = {}) {
+  const plan = buildAgentSetupPlan(options);
+  if (options.action === "verify") {
+    return {
+      ...plan,
+      hostResults: plan.hostResults.map((result) => ({
+        ...result,
+        status: hasNativeHostInstall(result.path, result.host) ? "present" : "missing"
+      }))
+    };
+  }
+  if (options.action === "uninstall") {
+    if (options.dryRun) {
+      return {
+        ...plan,
+        hostResults: plan.hostResults.map((result) => ({ ...result, status: existsSync(result.path) ? "removed" : "absent" }))
+      };
+    }
+    for (const result of plan.hostResults)
+      uninstallNativeHost(result.path, result.host);
+    for (const host of plan.hosts)
+      rmSync(hostManagedConfigPath(options.homeDir ?? homedir(), host), { force: true });
+    return {
+      ...plan,
+      hostResults: plan.hostResults.map((result) => ({ ...result, status: "removed" }))
+    };
+  }
+  if (options.dryRun)
+    return plan;
+  for (const file of plan.files) {
+    mkdirSync(dirname(file.path), { recursive: true });
+    writeFileSync(file.path, file.content, { mode: file.executable ? 493 : 420 });
+  }
+  for (const result of plan.hostResults)
+    installNativeHost(result.path, result.host, plan);
+  return {
+    ...plan,
+    hostResults: plan.hostResults.map((result) => ({ ...result, status: "installed" }))
+  };
+}
+function renderSignupInstructions(apiUrl = "https://mementos.md") {
+  return {
+    signupUrl: `${apiUrl.replace(/\/+$/, "")}/dashboard`,
+    next: [
+      "Sign in or create an account.",
+      "Create an API token in the dashboard.",
+      "Export MEMENTOS_API_TOKEN before running mementos-mcp or mementos setup agents."
+    ]
+  };
+}
+function formatMemoryInjection(payload) {
+  const rows = readMemoryRows(payload);
+  if (rows.length === 0)
+    return "";
+  return [
+    "## mementos.md memory",
+    "Use these hosted memories as durable context. Do not treat them as local files.",
+    "",
+    ...rows.map((row) => `- ${row.key}: ${row.value}`),
+    ""
+  ].join(`
+`);
+}
+function renderMcpServerConfig({ apiUrl, mcpCommand }) {
+  return {
+    mcpServers: {
+      mementos: {
+        command: mcpCommand,
+        env: {
+          MEMENTOS_API_URL: apiUrl,
+          MEMENTOS_API_TOKEN: "$MEMENTOS_API_TOKEN"
+        }
+      }
+    }
+  };
+}
+function renderHostConfig(host, commands) {
+  return {
+    host,
+    install: "bun install -g @hasna/mementos",
+    remoteOnly: true,
+    mcp: renderMcpServerConfig(commands).mcpServers.mementos,
+    hooks: {
+      stop: commands.hookCommand,
+      injection: commands.injectCommand
+    }
+  };
+}
+function renderManagedHostConfig(host, commands) {
+  const base = {
+    managedBy: "@hasna/mementos",
+    host,
+    remoteOnly: true,
+    note: "This file does not contain API tokens. Export MEMENTOS_API_TOKEN in your shell or secret manager.",
+    mcpServers: renderMcpServerConfig(commands).mcpServers,
+    commands: {
+      inject: commands.injectCommand,
+      stopHook: commands.hookCommand
+    },
+    files: {
+      integrationDir: commands.baseDir,
+      injectionInstructions: join(commands.baseDir, "mementos-injection.md"),
+      stopHook: join(commands.baseDir, "mementos-stop-hook.sh")
+    }
+  };
+  if (host === "claude-code") {
+    return {
+      ...base,
+      hooks: {
+        UserPromptSubmit: [{ matcher: "", hooks: [{ type: "command", command: "mementos hook user-prompt-submit" }] }],
+        SessionStart: [{ matcher: "", hooks: [{ type: "command", command: "mementos hook session-start" }] }],
+        Stop: [{ matcher: "", hooks: [{ type: "command", command: commands.hookCommand }] }]
+      }
+    };
+  }
+  if (host === "codex") {
+    return {
+      ...base,
+      mcp_servers: {
+        mementos: {
+          command: commands.mcpCommand,
+          env: { MEMENTOS_API_URL: commands.apiUrl, MEMENTOS_API_TOKEN: "$MEMENTOS_API_TOKEN" }
+        }
+      }
+    };
+  }
+  return base;
+}
+function hostManagedConfigPath(home, host) {
+  switch (host) {
+    case "claude-code":
+      return join(home, ".claude", "mementos.managed.json");
+    case "codex":
+      return join(home, ".codex", "mementos.managed.json");
+    case "opencode":
+      return join(home, ".config", "opencode", "mementos.managed.json");
+    case "antigravity":
+      return join(home, ".config", "antigravity", "mementos.managed.json");
+  }
+}
+function hostNativeConfigPath(home, host) {
+  switch (host) {
+    case "claude-code":
+      return join(home, ".claude", "settings.json");
+    case "codex":
+      return join(home, ".codex", "config.toml");
+    case "opencode":
+      return join(home, ".config", "opencode", "opencode.json");
+    case "antigravity":
+      return join(home, ".antigravity", "mcp.json");
+  }
+}
+function installNativeHost(path, host, plan) {
+  mkdirSync(dirname(path), { recursive: true });
+  if (host === "codex") {
+    writeFileSync(path, installCodexToml(readTextFile(path), plan), { mode: 420 });
+    return;
+  }
+  const config = readJsonObject(path);
+  if (host === "claude-code") {
+    writeJsonObject(path, installClaudeConfig(config, plan));
+    return;
+  }
+  if (host === "opencode") {
+    writeJsonObject(path, installOpenCodeConfig(config, plan));
+    return;
+  }
+  writeJsonObject(path, installAntigravityConfig(config, plan));
+}
+function uninstallNativeHost(path, host) {
+  if (!existsSync(path))
+    return;
+  if (host === "codex") {
+    writeFileSync(path, uninstallCodexToml(readTextFile(path)), { mode: 420 });
+    return;
+  }
+  const config = readJsonObject(path);
+  if (host === "claude-code")
+    writeJsonObject(path, uninstallClaudeConfig(config));
+  if (host === "opencode")
+    writeJsonObject(path, uninstallOpenCodeConfig(config));
+  if (host === "antigravity")
+    writeJsonObject(path, uninstallMcpServersConfig(config));
+}
+function hasNativeHostInstall(path, host) {
+  if (!existsSync(path))
+    return false;
+  if (host === "codex")
+    return /\[mcp_servers\.mementos\]/.test(readTextFile(path));
+  const config = readJsonObject(path);
+  if (host === "opencode")
+    return isRecord(config.mcp) && isRecord(config.mcp.mementos);
+  return isRecord(config.mcpServers) && isRecord(config.mcpServers.mementos);
+}
+function installClaudeConfig(config, plan) {
+  return {
+    ...config,
+    mcpServers: {
+      ...recordValue(config.mcpServers),
+      mementos: stdioMcpServer(plan, true)
+    },
+    hooks: mergeAgentHooks(recordValue(config.hooks), {
+      UserPromptSubmit: "mementos hook user-prompt-submit",
+      SessionStart: "mementos hook session-start",
+      Stop: "mementos hook stop"
+    })
+  };
+}
+function uninstallClaudeConfig(config) {
+  return {
+    ...config,
+    mcpServers: omitKey(recordValue(config.mcpServers), "mementos"),
+    hooks: removeAgentHooks(recordValue(config.hooks), [
+      "mementos hook user-prompt-submit",
+      "mementos hook session-start",
+      "mementos hook stop"
+    ])
+  };
+}
+function installOpenCodeConfig(config, plan) {
+  return {
+    ...config,
+    mcp: {
+      ...recordValue(config.mcp),
+      mementos: {
+        type: "local",
+        command: [plan.mcpCommand],
+        enabled: true,
+        environment: remoteEnv(baseApiUrlFromPlan(plan))
+      }
+    }
+  };
+}
+function uninstallOpenCodeConfig(config) {
+  return {
+    ...config,
+    mcp: omitKey(recordValue(config.mcp), "mementos")
+  };
+}
+function installAntigravityConfig(config, plan) {
+  return {
+    ...config,
+    mcpServers: {
+      ...recordValue(config.mcpServers),
+      mementos: stdioMcpServer(plan, false)
+    }
+  };
+}
+function uninstallMcpServersConfig(config) {
+  return {
+    ...config,
+    mcpServers: omitKey(recordValue(config.mcpServers), "mementos")
+  };
+}
+function installCodexToml(current, plan) {
+  const withoutExisting = removeTomlTable(removeManagedCodexBlock(current), "mcp_servers.mementos");
+  const block = [
+    "# BEGIN @hasna/mementos",
+    "[mcp_servers.mementos]",
+    `command = ${JSON.stringify(plan.mcpCommand)}`,
+    "[mcp_servers.mementos.env]",
+    `MEMENTOS_API_URL = ${JSON.stringify(baseApiUrlFromPlan(plan))}`,
+    'MEMENTOS_API_TOKEN = "$MEMENTOS_API_TOKEN"',
+    "# END @hasna/mementos",
+    ""
+  ].join(`
+`);
+  return `${withoutExisting.trimEnd()}
+
+${block}`;
+}
+function uninstallCodexToml(current) {
+  return `${removeTomlTable(removeManagedCodexBlock(current), "mcp_servers.mementos").trimEnd()}
+`;
+}
+function mergeAgentHooks(hooks, commands) {
+  const next = { ...hooks };
+  for (const [event, command] of Object.entries(commands)) {
+    const current = next[event];
+    const entries = Array.isArray(current) ? [...current] : [];
+    if (!entries.some((entry) => JSON.stringify(entry).includes(command))) {
+      entries.push({ matcher: "", hooks: [{ type: "command", command }] });
+    }
+    next[event] = entries;
+  }
+  return next;
+}
+function removeAgentHooks(hooks, commands) {
+  const next = { ...hooks };
+  for (const [event, entries] of Object.entries(next)) {
+    if (!Array.isArray(entries))
+      continue;
+    next[event] = entries.filter((entry) => !commands.some((command) => JSON.stringify(entry).includes(command)));
+  }
+  return next;
+}
+function stdioMcpServer(plan, includeType) {
+  return {
+    ...includeType ? { type: "stdio" } : {},
+    command: plan.mcpCommand,
+    env: remoteEnv(baseApiUrlFromPlan(plan))
+  };
+}
+function remoteEnv(apiUrl) {
+  return {
+    MEMENTOS_API_URL: apiUrl,
+    MEMENTOS_API_TOKEN: "$MEMENTOS_API_TOKEN"
+  };
+}
+function baseApiUrlFromPlan(plan) {
+  const mcpFile = plan.files.find((file) => file.path.endsWith("mcp-server.json"));
+  if (!mcpFile)
+    return "https://mementos.md";
+  try {
+    const parsed = JSON.parse(mcpFile.content);
+    return parsed.mcpServers?.mementos?.env?.MEMENTOS_API_URL ?? "https://mementos.md";
+  } catch {
+    return "https://mementos.md";
+  }
+}
+function removeManagedCodexBlock(value) {
+  return value.replace(/\n?# BEGIN @hasna\/mementos\n[\s\S]*?# END @hasna\/mementos\n?/g, `
+`);
+}
+function removeTomlTable(value, table) {
+  const tablePattern = table.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const lines = value.split(`
+`);
+  const output = [];
+  let skipping = false;
+  for (const line of lines) {
+    if (new RegExp(`^\\[${tablePattern}(?:\\.|\\])`).test(line.trim())) {
+      skipping = true;
+      continue;
+    }
+    if (skipping && /^\[[^\]]+\]/.test(line.trim()))
+      skipping = false;
+    if (!skipping)
+      output.push(line);
+  }
+  return output.join(`
+`);
+}
+function readTextFile(path) {
+  return existsSync(path) ? readFileSync(path, "utf8") : "";
+}
+function readJsonObject(path) {
+  if (!existsSync(path))
+    return {};
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  if (!isRecord(parsed))
+    throw new Error(`${path} must contain a JSON object`);
+  return parsed;
+}
+function writeJsonObject(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, { mode: 420 });
+}
+function recordValue(value) {
+  return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function omitKey(record, key) {
+  const { [key]: _removed, ...rest } = record;
+  return rest;
+}
+function renderInjectionInstructions({ apiUrl, injectCommand }) {
+  return `# mementos.md Memory Injection
+
+Run this before or after an agent turn when it needs durable project context:
+
+\`\`\`bash
+MEMENTOS_API_URL=${apiUrl} MEMENTOS_API_TOKEN=$MEMENTOS_API_TOKEN ${injectCommand} "$MEMENTOS_INJECTION_QUERY"
+\`\`\`
+
+This command reads hosted memory through the mementos.md API and prints a prompt-ready block.
+`;
+}
+function renderHookScript(command) {
+  return `#!/usr/bin/env bash
+set -euo pipefail
+
+${command}
+`;
+}
+function uniqueHosts(hosts) {
+  const allowed = new Set(SUPPORTED_AGENT_HOSTS);
+  return [...new Set(hosts)].filter((host) => allowed.has(host));
+}
+function readMemoryRows(payload) {
+  if (typeof payload !== "object" || payload === null)
+    return [];
+  const maybeRows = "memories" in payload ? payload.memories : payload;
+  if (!Array.isArray(maybeRows))
+    return [];
+  return maybeRows.flatMap((row) => {
+    if (typeof row !== "object" || row === null)
+      return [];
+    const key = readText(row.key);
+    const value = readText(row.value ?? row.content);
+    return key && value ? [{ key, value }] : [];
+  });
+}
+function readText(input) {
+  return typeof input === "string" && input.trim() ? input.trim() : undefined;
+}
+
+// src/remote-client.ts
+var DEFAULT_API_URL = "https://mementos.md/api/v1";
+
+class MementosRemoteError extends Error {
+  status;
+  response;
+  constructor(message, status, response) {
+    super(message);
+    this.name = "MementosRemoteError";
+    this.status = status;
+    this.response = response;
+  }
+}
+
+class MementosRemoteClient {
+  apiUrl;
+  token;
+  fetchImpl;
+  constructor(config = {}) {
+    this.apiUrl = normalizeApiUrl(config.apiUrl ?? DEFAULT_API_URL);
+    this.token = config.token;
+    this.fetchImpl = config.fetch ?? fetch;
+  }
+  listCapabilities() {
+    return this.request("/capabilities", { requiresAuth: false });
+  }
+  listAgents() {
+    return this.request("/agents");
+  }
+  registerAgent(input) {
+    return this.request("/agents/register", { method: "POST", body: input });
+  }
+  heartbeatAgent(input) {
+    return this.request("/agents/heartbeat", { method: "POST", body: input });
+  }
+  saveMemory(input) {
+    return this.request("/memories", { method: "POST", body: input });
+  }
+  searchMemories(input = {}) {
+    return this.request("/memories", { query: input });
+  }
+  injectionContext(input = {}) {
+    return this.request("/injections/context", { method: "POST", body: input });
+  }
+  getMemory(id) {
+    return this.request(`/memories/${encodeURIComponent(id)}`);
+  }
+  updateMemory(id, input) {
+    return this.request(`/memories/${encodeURIComponent(id)}`, { method: "PATCH", body: input });
+  }
+  deleteMemory(id) {
+    return this.request(`/memories/${encodeURIComponent(id)}`, { method: "DELETE" });
+  }
+  memoryUsage() {
+    return this.request("/usage");
+  }
+  listRuns(input = {}) {
+    return this.request("/runs", { query: input });
+  }
+  createRun(slug, input = {}) {
+    return this.request(`/runs/${encodeURIComponent(slug)}`, { method: "POST", body: input });
+  }
+  getRun(id) {
+    return this.request(`/runs/${encodeURIComponent(id)}`);
+  }
+  listApprovals() {
+    return this.request("/approvals");
+  }
+  billingStatus() {
+    return this.request("/billing/status");
+  }
+  async request(path, options = {}) {
+    const method = options.method ?? "GET";
+    const requiresAuth = options.requiresAuth !== false;
+    if (requiresAuth && !this.token) {
+      throw new MementosRemoteError("MEMENTOS_API_TOKEN is required for hosted mementos.md requests", 401, null);
+    }
+    const url = new URL(`${this.apiUrl}${path.startsWith("/") ? path : `/${path}`}`);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+      if (value === undefined || value === null || value === "")
+        continue;
+      url.searchParams.set(key, String(value));
+    }
+    const headers = new Headers({ accept: "application/json" });
+    if (requiresAuth)
+      headers.set("authorization", `Bearer ${this.token}`);
+    if (options.body !== undefined)
+      headers.set("content-type", "application/json");
+    const response = await this.fetchImpl(url, {
+      method,
+      headers,
+      body: options.body === undefined ? undefined : JSON.stringify(options.body)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new MementosRemoteError(readErrorMessage(payload, response.status), response.status, payload);
+    }
+    return payload;
+  }
+}
+function createRemoteClientFromEnv(env = process.env) {
+  return new MementosRemoteClient({
+    apiUrl: env.MEMENTOS_API_URL,
+    token: env.MEMENTOS_API_TOKEN ?? env.MEMENTOS_PLATFORM_TOKEN ?? env.PLATFORM_API_TOKEN ?? env.APP_API_KEY
+  });
+}
+function normalizeApiUrl(input) {
+  const trimmed = input.trim().replace(/\/+$/, "");
+  if (!trimmed)
+    return DEFAULT_API_URL;
+  return trimmed.endsWith("/api/v1") ? trimmed : `${trimmed}/api/v1`;
+}
+async function readPayload(response) {
+  const text = await response.text();
+  if (!text)
+    return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function readErrorMessage(payload, status) {
+  if (typeof payload === "object" && payload !== null && "error" in payload) {
+    const value = payload.error;
+    if (typeof value === "string" && value.trim())
+      return value;
+  }
+  return `mementos.md request failed with status ${status}`;
+}
+
+// src/cli.ts
+var command = process.argv[2] ?? "help";
+var client = createRemoteClientFromEnv();
+try {
+  const result = await run(command, process.argv.slice(3));
+  if (result !== undefined) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  }
+} catch (error) {
+  if (error instanceof MementosRemoteError) {
+    process.stderr.write(`${error.message}
+`);
+    process.exit(error.status === 401 || error.status === 403 ? 2 : 1);
+  }
+  process.stderr.write(`${error.message}
+`);
+  process.exit(1);
+}
+async function run(name, args) {
+  switch (name) {
+    case "help":
+    case "--help":
+    case "-h":
+      process.stdout.write(helpText());
+      return;
+    case "auth":
+      return runAuth(args);
+    case "setup":
+      return runSetup(args);
+    case "inject":
+      return injectMemory(args);
+    case "hook":
+      return runHook(args);
+    case "capabilities":
+      return client.listCapabilities();
+    case "agents":
+      return client.listAgents();
+    case "usage":
+      return client.memoryUsage();
+    case "search":
+      return client.searchMemories({ q: args.join(" ").trim() });
+    case "save": {
+      const key = args[0];
+      const value = args.slice(1).join(" ");
+      if (!key || !value)
+        throw new Error("usage: mementos save <key> <value>");
+      return client.saveMemory({ key, value });
+    }
+    default:
+      throw new Error(`Unknown command: ${name}
+
+${helpText()}`);
+  }
+}
+async function runAuth(args) {
+  const subcommand = args[0] ?? "help";
+  if (subcommand !== "signup" && subcommand !== "login") {
+    throw new Error("usage: mementos auth signup");
+  }
+  return renderSignupInstructions(baseProductUrl());
+}
+async function runSetup(args) {
+  const subcommand = args[0] ?? "help";
+  if (subcommand !== "agents") {
+    throw new Error("usage: mementos setup agents [--dry-run] [--home <path>] [--hosts <list>]");
+  }
+  const options = parseSetupOptions(args.slice(1));
+  const plan = installAgentSetup({
+    action: options.action,
+    apiUrl: baseProductUrl(),
+    dryRun: options.dryRun,
+    homeDir: options.homeDir,
+    hosts: options.hosts
+  });
+  return {
+    installed: !options.dryRun,
+    action: options.action ?? "install",
+    baseDir: plan.baseDir,
+    hosts: plan.hosts,
+    files: plan.files.map((file) => file.path),
+    hostResults: plan.hostResults,
+    mcpCommand: plan.mcpCommand
+  };
+}
+async function injectMemory(args) {
+  const query = args.filter((arg) => !arg.startsWith("--")).join(" ").trim();
+  const payload = await client.injectionContext({ query, limit: 12 });
+  const block = readTextPayload(payload) ?? formatMemoryInjection(payload);
+  if (block) {
+    process.stdout.write(block);
+    return;
+  }
+  return { memories: 0 };
+}
+async function runHook(args) {
+  const subcommand = args[0] ?? "help";
+  const hookEvents = {
+    "user-prompt-submit": "UserPromptSubmit",
+    "session-start": "SessionStart",
+    "subagent-start": "SubagentStart",
+    setup: "Setup"
+  };
+  if (subcommand in hookEvents) {
+    const query2 = await readHookQuery();
+    const payload = await client.injectionContext({ query: query2, limit: 12 });
+    const block = readTextPayload(payload) ?? formatMemoryInjection(payload);
+    return {
+      suppressOutput: true,
+      hookSpecificOutput: {
+        hookEventName: hookEvents[subcommand],
+        additionalContext: block
+      }
+    };
+  }
+  if (subcommand !== "stop") {
+    throw new Error("usage: mementos hook <stop|user-prompt-submit|session-start|subagent-start|setup>");
+  }
+  const query = process.env.MEMENTOS_INJECTION_QUERY ?? process.cwd();
+  return injectMemory([query]);
+}
+async function readHookQuery() {
+  if (process.env.MEMENTOS_INJECTION_QUERY)
+    return process.env.MEMENTOS_INJECTION_QUERY;
+  const stdin = await readOptionalStdin();
+  if (!stdin)
+    return process.cwd();
+  try {
+    const parsed = JSON.parse(stdin);
+    const prompt = parsed.prompt ?? parsed.userPrompt ?? parsed.message ?? parsed.cwd;
+    if (typeof prompt === "string" && prompt.trim())
+      return prompt.trim();
+  } catch {
+    if (stdin.trim())
+      return stdin.trim();
+  }
+  return process.cwd();
+}
+async function readOptionalStdin() {
+  if (process.stdin.isTTY)
+    return "";
+  return new Response(Bun.stdin.stream()).text();
+}
+function parseSetupOptions(args) {
+  const options = {};
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+    } else if (arg === "--verify") {
+      options.action = "verify";
+    } else if (arg === "--uninstall") {
+      options.action = "uninstall";
+    } else if (arg === "--home") {
+      options.homeDir = args[++index];
+    } else if (arg === "--hosts") {
+      options.hosts = parseHosts(args[++index] ?? "");
+    } else {
+      throw new Error(`Unknown setup option: ${arg}`);
+    }
+  }
+  return options;
+}
+function parseHosts(input) {
+  const requested = input.split(",").map((host) => host.trim()).filter(Boolean);
+  const unknown = requested.filter((host) => !SUPPORTED_AGENT_HOSTS.includes(host));
+  if (unknown.length > 0)
+    throw new Error(`Unknown agent host: ${unknown.join(", ")}`);
+  return requested;
+}
+function baseProductUrl() {
+  return (process.env.MEMENTOS_API_URL ?? DEFAULT_API_URL).replace(/\/api\/v1\/?$/, "").replace(/\/+$/, "");
+}
+function readTextPayload(payload) {
+  if (typeof payload !== "object" || payload === null)
+    return;
+  const text = payload.text;
+  return typeof text === "string" && text.trim() ? text : undefined;
+}
+function helpText() {
+  return `mementos remote-only SaaS client
+
+Usage:
+  mementos auth signup
+  mementos setup agents [--dry-run|--verify|--uninstall]
+  mementos inject <query>
+  mementos hook <stop|user-prompt-submit|session-start|subagent-start|setup>
+  mementos capabilities
+  mementos agents
+  mementos usage
+  mementos search <query>
+  mementos save <key> <value>
+  MEMENTOS_API_TOKEN=<token> mementos-mcp
+
+Environment:
+  MEMENTOS_API_URL     Defaults to https://mementos.md/api/v1
+  MEMENTOS_API_TOKEN   Required for hosted private operations
+`;
+}