@hasna/mementos 0.14.30 → 0.14.32

package/dist/cli.js

@@ -1,1362 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-
-// src/agent-setup.ts
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, 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-instructions.md"),
-      content: renderSharedInstructions({ apiUrl, injectCommand, mcpCommand })
-    },
-    {
-      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}-instructions.md`),
-      content: renderHostInstructions(host, { apiUrl, injectCommand, mcpCommand })
-    });
-    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 diagnoseAgentSetup(options = {}) {
-  const plan = installAgentSetup({ ...options, action: "verify" });
-  const home = options.homeDir ?? homedir();
-  const localStoragePath = join(home, ".hasna", "mementos");
-  const localDatabaseFiles = [
-    ...findLocalDatabaseFiles(localStoragePath),
-    ...findLocalDatabaseFiles(join(home, ".config", "mementos"))
-  ];
-  const env = options.env ?? process.env;
-  const tokenSource = ["MEMENTOS_API_TOKEN", "MEMENTOS_PLATFORM_TOKEN", "PLATFORM_API_TOKEN", "APP_API_KEY"].find((key) => Boolean(env[key]));
-  return {
-    apiUrl: options.apiUrl ?? "https://mementos.md",
-    hostResults: plan.hostResults,
-    localDatabaseFiles,
-    localStorage: {
-      path: localStoragePath,
-      status: existsSync(localStoragePath) ? "present" : "absent"
-    },
-    ok: plan.hostResults.every((result) => result.status === "present") && !existsSync(localStoragePath) && localDatabaseFiles.length === 0,
-    remoteOnly: true,
-    tokenConfigured: Boolean(tokenSource),
-    ...tokenSource ? { tokenSource } : {}
-  };
-}
-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,
-    nativeHooks: hasNativeHooks(host),
-    mcp: renderMcpServerConfig(commands).mcpServers.mementos,
-    hooks: {
-      stop: commands.hookCommand,
-      injection: commands.injectCommand
-    },
-    instructions: `${host}-instructions.md`
-  };
-}
-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
-    },
-    injection: {
-      nativeHooks: hasNativeHooks(host),
-      fallbackCommand: commands.injectCommand,
-      mcpTools: ["memory.search", "memory.save", "memory.get", "memory.update", "memory.delete", "memory.usage"]
-    },
-    files: {
-      integrationDir: commands.baseDir,
-      sharedInstructions: join(commands.baseDir, "mementos-instructions.md"),
-      hostInstructions: join(commands.baseDir, `${host}-instructions.md`),
-      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 renderSharedInstructions({
-  apiUrl,
-  injectCommand,
-  mcpCommand
-}) {
-  return `# mementos.md Agent Instructions
-
-Use mementos.md as hosted durable memory for this agent host.
-
-- The MCP server command is \`${mcpCommand}\`.
-- The hosted API is \`${apiUrl}\`.
-- Use \`memory.search\` before non-trivial project work.
-- Use \`memory.save\` for durable decisions, root causes, and reusable context.
-- If the host does not provide a native hook, run \`${injectCommand} "<current task or question>"\` and include the returned hosted context in the next prompt.
-- Do not create or depend on a local memory database for the SaaS package.
-`;
-}
-function renderHostInstructions(host, commands) {
-  const common = renderSharedInstructions(commands);
-  if (host === "claude-code") {
-    return `${common}
-## Claude Code
-
-Claude Code has native mementos hooks installed by \`mementos setup agents\`.
-Use the mementos MCP server for explicit memory operations and let the
-\`UserPromptSubmit\`, \`SessionStart\`, and \`Stop\` hooks inject hosted context.
-`;
-  }
-  if (host === "codex") {
-    return `${common}
-## Codex
-
-Codex does not have a mementos native hook in its config file. Use the
-mementos MCP server for durable memory and run \`${commands.injectCommand}\`
-when you need prompt-ready hosted context before a turn.
-`;
-  }
-  if (host === "opencode") {
-    return `${common}
-## OpenCode
-
-Use the mementos MCP server for durable memory. When OpenCode cannot invoke a
-native lifecycle hook, run \`${commands.injectCommand}\` with the active task
-or error text and paste the hosted context into the next prompt.
-`;
-  }
-  return `${common}
-## Antigravity
-
-Use the mementos MCP server for durable memory. When Antigravity cannot invoke
-a native lifecycle hook, run \`${commands.injectCommand}\` with the active task
-or error text and include the hosted context before continuing.
-`;
-}
-function hasNativeHooks(host) {
-  return host === "claude-code";
-}
-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;
-}
-function findLocalDatabaseFiles(dir) {
-  const localDbPattern = new RegExp(`\\.(${["db", "sql" + "ite"].join("|")})(?:$|-)`);
-  if (!existsSync(dir))
-    return [];
-  const stat = statSync(dir);
-  if (!stat.isDirectory())
-    return localDbPattern.test(dir) ? [dir] : [];
-  return readdirSync(dir).flatMap((entry) => {
-    const path = join(dir, entry);
-    const entryStat = statSync(path);
-    if (entryStat.isDirectory())
-      return findLocalDatabaseFiles(path);
-    return localDbPattern.test(entry) ? [path] : [];
-  });
-}
-
-// src/bridge.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join2 } from "path";
-function buildBridgePaths(homeDir = homedir2(), platform = process.platform) {
-  const baseDir = join2(homeDir, ".config", "mementos", "bridge");
-  return {
-    baseDir,
-    logFile: join2(baseDir, "bridge.log"),
-    pidFile: join2(baseDir, "bridge.pid.json"),
-    serviceFile: platform === "darwin" ? join2(homeDir, "Library", "LaunchAgents", "md.mementos.bridge.plist") : join2(homeDir, ".config", "systemd", "user", "mementos-bridge.service")
-  };
-}
-function getBridgeStatus(options = {}) {
-  const paths = buildBridgePaths(options.homeDir, options.platform);
-  const pidFile = readBridgePid(paths.pidFile);
-  if (pidFile && !isRunning(pidFile.pid)) {
-    rmSync2(paths.pidFile, { force: true });
-    return baseStatus(paths, options, false);
-  }
-  return {
-    ...baseStatus(paths, options, Boolean(pidFile)),
-    ...pidFile?.agentName ? { agentName: pidFile.agentName } : {},
-    ...pidFile ? { pid: pidFile.pid, startedAt: pidFile.startedAt } : {}
-  };
-}
-function startBridge(options = {}) {
-  const current = getBridgeStatus(options);
-  if (current.running)
-    return current;
-  const paths = buildBridgePaths(options.homeDir, options.platform);
-  mkdirSync2(paths.baseDir, { recursive: true });
-  const out = openSync(paths.logFile, "a");
-  const err = openSync(paths.logFile, "a");
-  const command = options.command ?? [process.execPath, process.argv[1] ?? "mementos", "bridge", "run"];
-  const child = spawn(command[0] ?? "mementos", command.slice(1), {
-    detached: true,
-    env: {
-      ...process.env,
-      ...options.agentName ? { MEMENTOS_AGENT_NAME: options.agentName } : {},
-      ...options.apiUrl ? { MEMENTOS_API_URL: options.apiUrl } : {},
-      ...options.homeDir ? { MEMENTOS_BRIDGE_HOME: options.homeDir } : {},
-      ...options.intervalMs ? { MEMENTOS_BRIDGE_INTERVAL_MS: String(options.intervalMs) } : {}
-    },
-    stdio: ["ignore", out, err]
-  });
-  child.unref();
-  writeBridgePid({
-    agentName: options.agentName,
-    apiUrl: options.apiUrl,
-    homeDir: options.homeDir,
-    pid: child.pid ?? 0,
-    startedAt: new Date().toISOString()
-  });
-  return getBridgeStatus(options);
-}
-function stopBridge(options = {}) {
-  const paths = buildBridgePaths(options.homeDir, options.platform);
-  const pidFile = readBridgePid(paths.pidFile);
-  if (!pidFile)
-    return { path: paths.pidFile, remoteOnly: true, status: "absent" };
-  if (isRunning(pidFile.pid))
-    process.kill(pidFile.pid, "SIGTERM");
-  clearBridgePid(options);
-  return { path: paths.pidFile, remoteOnly: true, status: "removed" };
-}
-function installBridgeService(options = {}) {
-  const platform = options.platform ?? process.platform;
-  const paths = buildBridgePaths(options.homeDir, platform);
-  mkdirSync2(dirname2(paths.serviceFile), { recursive: true });
-  const command = options.command ?? "mementos bridge run";
-  const apiUrl = options.apiUrl ?? "https://mementos.md/api/v1";
-  const content = platform === "darwin" ? renderLaunchdService(command, apiUrl, options.agentName) : renderSystemdService(command, apiUrl, options.agentName);
-  writeFileSync2(paths.serviceFile, content, { mode: 420 });
-  return { path: paths.serviceFile, remoteOnly: true, status: "installed" };
-}
-function uninstallBridgeService(options = {}) {
-  const paths = buildBridgePaths(options.homeDir, options.platform);
-  if (!existsSync2(paths.serviceFile))
-    return { path: paths.serviceFile, remoteOnly: true, status: "absent" };
-  rmSync2(paths.serviceFile, { force: true });
-  return { path: paths.serviceFile, remoteOnly: true, status: "removed" };
-}
-function readBridgeLogs(options = {}) {
-  const paths = buildBridgePaths(options.homeDir, options.platform);
-  if (!existsSync2(paths.logFile))
-    return [];
-  return readFileSync2(paths.logFile, "utf8").split(`
-`).filter(Boolean).slice(-(options.lines ?? 40));
-}
-function writeBridgePid(options) {
-  const paths = buildBridgePaths(options.homeDir, options.platform);
-  mkdirSync2(paths.baseDir, { recursive: true });
-  writeFileSync2(paths.pidFile, `${JSON.stringify({
-    ...options.agentName ? { agentName: options.agentName } : {},
-    ...options.apiUrl ? { apiUrl: options.apiUrl } : {},
-    pid: options.pid,
-    startedAt: options.startedAt
-  }, null, 2)}
-`, { mode: 420 });
-}
-function clearBridgePid(options = {}) {
-  rmSync2(buildBridgePaths(options.homeDir, options.platform).pidFile, { force: true });
-}
-function baseStatus(paths, options, running) {
-  return {
-    ...options.agentName ? { agentName: options.agentName } : {},
-    apiUrl: options.apiUrl ?? "https://mementos.md/api/v1",
-    localDatabase: false,
-    logFile: paths.logFile,
-    pidFile: paths.pidFile,
-    remoteOnly: true,
-    running
-  };
-}
-function readBridgePid(path) {
-  if (!existsSync2(path))
-    return;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return Number.isInteger(parsed.pid) && parsed.pid > 0 ? parsed : undefined;
-  } catch {
-    return;
-  }
-}
-function isRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function renderSystemdService(command, apiUrl, agentName) {
-  return `[Unit]
-Description=mementos.md remote bridge
-
-[Service]
-Type=simple
-Environment=MEMENTOS_API_URL=${apiUrl}
-${agentName ? `Environment=MEMENTOS_AGENT_NAME=${agentName}
-` : ""}ExecStart=${command}
-Restart=on-failure
-
-[Install]
-WantedBy=default.target
-`;
-}
-function renderLaunchdService(command, apiUrl, agentName) {
-  const args = command.split(/\s+/).map((part) => `    <string>${escapeXml(part)}</string>`).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>
-  <string>md.mementos.bridge</string>
-  <key>ProgramArguments</key>
-  <array>
-${args}
-  </array>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>MEMENTOS_API_URL</key>
-    <string>${escapeXml(apiUrl)}</string>
-${agentName ? `    <key>MEMENTOS_AGENT_NAME</key>
-    <string>${escapeXml(agentName)}</string>
-` : ""}  </dict>
-  <key>RunAtLoad</key>
-  <true/>
-</dict>
-</plist>
-`;
-}
-function escapeXml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-
-// 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 });
-  }
-  sendInboxMessage(input) {
-    return this.request("/inbox", { method: "POST", body: input });
-  }
-  listInboxMessages(input = {}) {
-    return this.request("/inbox", { query: input });
-  }
-  claimInboxMessage(id, input = {}) {
-    return this.request(`/inbox/${encodeURIComponent(id)}/claim`, { 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");
-  }
-  listCreditPacks() {
-    return this.request("/billing/credits");
-  }
-  buyCredits(input) {
-    return this.request("/billing/credits", { method: "POST", body: input });
-  }
-  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 "bridge":
-      return runBridge(args);
-    case "billing":
-      return runBilling(args);
-    case "inbox":
-      return runInbox(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 runBridge(args) {
-  const subcommand = args[0] ?? "status";
-  const options = parseBridgeOptions(args.slice(1));
-  const bridgeOptions = {
-    agentName: options.agentName ?? process.env.MEMENTOS_AGENT_NAME,
-    apiUrl: baseApiUrl().endsWith("/api/v1") ? baseApiUrl() : `${baseApiUrl()}/api/v1`,
-    homeDir: options.homeDir ?? process.env.MEMENTOS_BRIDGE_HOME,
-    intervalMs: options.intervalMs ?? readPositiveInteger(process.env.MEMENTOS_BRIDGE_INTERVAL_MS)
-  };
-  switch (subcommand) {
-    case "start":
-      return startBridge(bridgeOptions);
-    case "status":
-      return getBridgeStatus(bridgeOptions);
-    case "stop":
-      return stopBridge(bridgeOptions);
-    case "install":
-      return installBridgeService({
-        ...bridgeOptions,
-        command: "mementos bridge run"
-      });
-    case "uninstall":
-      return uninstallBridgeService(bridgeOptions);
-    case "logs":
-      return { lines: readBridgeLogs({ ...bridgeOptions, lines: options.lines }) };
-    case "run":
-      return runBridgeDaemon(bridgeOptions, Boolean(options.once));
-    default:
-      throw new Error("usage: mementos bridge <start|status|stop|install|uninstall|logs|run>");
-  }
-}
-async function runInbox(args) {
-  const subcommand = args[0] ?? "list";
-  switch (subcommand) {
-    case "send": {
-      const agentName = args[1];
-      const message = args.slice(2).join(" ");
-      if (!agentName || !message)
-        throw new Error("usage: mementos inbox send <agentName> <message>");
-      return client.sendInboxMessage({ targetAgentName: agentName, message });
-    }
-    case "list": {
-      const options = parseInboxOptions(args.slice(1));
-      return client.listInboxMessages(options);
-    }
-    case "claim": {
-      const id = args[1];
-      if (!id)
-        throw new Error("usage: mementos inbox claim <id> [--agent <agentName>]");
-      const options = parseInboxOptions(args.slice(2));
-      return client.claimInboxMessage(id, options);
-    }
-    default:
-      throw new Error("usage: mementos inbox <send|list|claim>");
-  }
-}
-async function runBridgeDaemon(options, once) {
-  writeBridgePid({
-    agentName: options.agentName,
-    apiUrl: options.apiUrl,
-    homeDir: options.homeDir,
-    pid: process.pid,
-    startedAt: new Date().toISOString()
-  });
-  const cleanup = () => clearBridgePid(options);
-  process.once("SIGINT", () => {
-    cleanup();
-    process.exit(0);
-  });
-  process.once("SIGTERM", () => {
-    cleanup();
-    process.exit(0);
-  });
-  try {
-    const intervalMs = options.intervalMs ?? 30000;
-    do {
-      if (options.agentName) {
-        await client.heartbeatAgent({
-          name: options.agentName,
-          source: "mementos-bridge"
-        });
-      }
-      if (once)
-        break;
-      await sleep(intervalMs);
-    } while (true);
-    if (once)
-      cleanup();
-    return getBridgeStatus(options);
-  } finally {
-    if (once)
-      cleanup();
-  }
-}
-async function runBilling(args) {
-  const subcommand = args[0] ?? "status";
-  switch (subcommand) {
-    case "status":
-      return client.billingStatus();
-    case "credits":
-      return client.listCreditPacks();
-    case "buy": {
-      const credits = Number(args[1]);
-      if (!Number.isInteger(credits) || credits < 1)
-        throw new Error("usage: mementos billing buy <credits>");
-      return client.buyCredits({ credits });
-    }
-    default:
-      throw new Error("usage: mementos billing <status|credits|buy>");
-  }
-}
-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";
-  if (subcommand === "doctor") {
-    const options = parseSetupOptions(args.slice(1));
-    return diagnoseAgentSetup({
-      apiUrl: baseProductUrl(),
-      homeDir: options.homeDir,
-      hosts: options.hosts
-    });
-  }
-  const hookEvents = {
-    notification: "Notification",
-    "post-tool-use": "PostToolUse",
-    "pre-tool-use": "PreToolUse",
-    setup: "Setup",
-    "subagent-start": "SubagentStart",
-    "subagent-stop": "SubagentStop",
-    "session-start": "SessionStart",
-    "user-prompt-submit": "UserPromptSubmit"
-  };
-  if (subcommand in hookEvents) {
-    const hookInput = await readHookInput();
-    const query2 = hookInput.query;
-    const payload = await client.injectionContext({ query: query2, limit: 12 });
-    const block = readTextPayload(payload) ?? formatMemoryInjection(payload);
-    const inboxBlock = await readInboxHookContext(hookInput);
-    return {
-      suppressOutput: true,
-      hookSpecificOutput: {
-        hookEventName: hookEvents[subcommand],
-        additionalContext: combineContextBlocks(inboxBlock, block)
-      }
-    };
-  }
-  if (subcommand !== "stop") {
-    throw new Error("usage: mementos hook <stop|user-prompt-submit|session-start|subagent-start|subagent-stop|pre-tool-use|post-tool-use|notification|setup|doctor>");
-  }
-  const query = process.env.MEMENTOS_INJECTION_QUERY ?? process.cwd();
-  return injectMemory([query]);
-}
-async function readHookInput() {
-  if (process.env.MEMENTOS_INJECTION_QUERY) {
-    return {
-      agentName: process.env.MEMENTOS_AGENT_NAME,
-      query: process.env.MEMENTOS_INJECTION_QUERY
-    };
-  }
-  const stdin = await readOptionalStdin();
-  if (!stdin) {
-    return {
-      agentName: process.env.MEMENTOS_AGENT_NAME,
-      query: process.cwd()
-    };
-  }
-  try {
-    const parsed = JSON.parse(stdin);
-    const prompt = parsed.prompt ?? parsed.userPrompt ?? parsed.message ?? parsed.cwd;
-    return {
-      agentName: readHookText(parsed.agentName ?? parsed.agent ?? parsed.name) ?? process.env.MEMENTOS_AGENT_NAME,
-      projectKey: readHookText(parsed.projectKey ?? parsed.project),
-      query: typeof prompt === "string" && prompt.trim() ? prompt.trim() : process.cwd(),
-      sessionId: readHookText(parsed.sessionId ?? parsed.session_id)
-    };
-  } catch {
-    if (stdin.trim()) {
-      return {
-        agentName: process.env.MEMENTOS_AGENT_NAME,
-        query: stdin.trim()
-      };
-    }
-  }
-  return {
-    agentName: process.env.MEMENTOS_AGENT_NAME,
-    query: process.cwd()
-  };
-}
-async function readInboxHookContext(input) {
-  if (!input.agentName)
-    return;
-  const response = await client.listInboxMessages({
-    agentName: input.agentName,
-    projectKey: input.projectKey,
-    sessionId: input.sessionId,
-    limit: 10
-  });
-  const messages = readInboxMessages(response);
-  if (messages.length === 0)
-    return;
-  await Promise.all(messages.map((message) => client.claimInboxMessage(message.id, { agentName: input.agentName })));
-  return formatInboxContext(messages);
-}
-function readInboxMessages(payload) {
-  if (typeof payload !== "object" || payload === null)
-    return [];
-  const messages = payload.messages;
-  if (!Array.isArray(messages))
-    return [];
-  return messages.flatMap((message) => {
-    if (typeof message !== "object" || message === null)
-      return [];
-    const record = message;
-    const id = readHookText(record.id);
-    const value = readHookText(record.message);
-    if (!id || !value)
-      return [];
-    return [{
-      id,
-      kind: readHookText(record.kind) ?? "directive",
-      message: value,
-      priority: readHookText(record.priority) ?? "normal",
-      title: readHookText(record.title)
-    }];
-  });
-}
-function formatInboxContext(messages) {
-  return [
-    "## mementos.md inbox",
-    "Apply these hosted agent directives before continuing. They have been claimed remotely.",
-    "",
-    ...messages.map((message) => `- [${message.priority}] ${message.title ? `${message.title}: ` : ""}${message.message} (${message.kind})`),
-    ""
-  ].join(`
-`);
-}
-function combineContextBlocks(...blocks) {
-  return blocks.map((block) => block?.trim()).filter(Boolean).join(`
-
-`);
-}
-function readHookText(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-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 parseBridgeOptions(args) {
-  const options = {};
-  for (let index = 0;index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--agent" || arg === "--agent-name") {
-      options.agentName = args[++index];
-    } else if (arg === "--home") {
-      options.homeDir = args[++index];
-    } else if (arg === "--interval-ms") {
-      options.intervalMs = readPositiveInteger(args[++index]);
-    } else if (arg === "--lines") {
-      options.lines = readPositiveInteger(args[++index]);
-    } else if (arg === "--once") {
-      options.once = true;
-    } else {
-      throw new Error(`Unknown bridge option: ${arg}`);
-    }
-  }
-  return options;
-}
-function parseInboxOptions(args) {
-  const options = {};
-  for (let index = 0;index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--agent" || arg === "--agent-name") {
-      options.agentName = args[++index];
-    } else if (arg === "--agent-id") {
-      options.agentId = args[++index];
-    } else if (arg === "--project") {
-      options.projectKey = args[++index];
-    } else if (arg === "--session") {
-      options.sessionId = args[++index];
-    } else if (arg === "--include-delivered") {
-      options.includeDelivered = true;
-    } else if (arg === "--limit") {
-      options.limit = Number(args[++index]);
-    } else {
-      throw new Error(`Unknown inbox 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 baseApiUrl() {
-  return (process.env.MEMENTOS_API_URL ?? DEFAULT_API_URL).replace(/\/+$/, "");
-}
-function readPositiveInteger(input) {
-  if (!input)
-    return;
-  const value = Number(input);
-  return Number.isInteger(value) && value > 0 ? value : undefined;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-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|subagent-stop|pre-tool-use|post-tool-use|notification|setup|doctor>
-  mementos bridge <start|status|stop|install|uninstall|logs|run>
-  mementos inbox <send|list|claim>
-  mementos billing <status|credits|buy>
-  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
-`;
-}