imsg-mcp 1.0.0

package/dist/cli.js

@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Command } from "commander";
+import { c as checkLocalAccess, f as formatAccessReport, q as installShutdownHandlers, r as registerCleanup } from "./shutdown-B9ClCyco.js";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { A as APP_VERSION } from "./meta-D3NoTAjA.js";
+function distRoot() {
+  return dirname(fileURLToPath(import.meta.url));
+}
+class LocalMcpClient {
+  constructor(onStderr) {
+    this.onStderr = onStderr;
+    const entry = join(distRoot(), "cli.js");
+    if (!existsSync(entry)) {
+      throw new Error("dist/cli.js not found. Run `pnpm build` first.");
+    }
+    this.proc = spawn(process.execPath, [entry, "mcp"], {
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.proc.stderr.on("data", (chunk) => {
+      this.onStderr?.(chunk.toString("utf8"));
+    });
+    this.proc.stdout.on("data", (chunk) => {
+      this.outBuf += chunk.toString("utf8");
+      const lines = this.outBuf.split("\n");
+      this.outBuf = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const message = JSON.parse(line);
+          if (message.id != null && this.pending.has(message.id)) {
+            const pending = this.pending.get(message.id);
+            this.pending.delete(message.id);
+            pending?.resolve(message);
+          }
+        } catch {
+        }
+      }
+    });
+    this.proc.on("exit", (code) => {
+      if (this.closed) return;
+      for (const [, p] of this.pending) {
+        p.reject(new Error(`MCP child exited unexpectedly with code ${code}`));
+      }
+      this.pending.clear();
+    });
+  }
+  proc;
+  requestId = 0;
+  pending = /* @__PURE__ */ new Map();
+  outBuf = "";
+  closed = false;
+  async start() {
+    const response = await this.call("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "imsg", version: "1.0.0" }
+    });
+    if (response.result) {
+      this.proc.stdin.write(
+        `${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} })}
+`
+      );
+    }
+  }
+  async callTool(name, args, timeoutMs = 3e4) {
+    const response = await this.call("tools/call", { name, arguments: args }, timeoutMs);
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.result ?? {};
+  }
+  async listTools(timeoutMs = 15e3) {
+    const response = await this.call("tools/list", {}, timeoutMs);
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.result?.tools ?? [];
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.proc.stdin.end();
+    const killTimer = setTimeout(() => {
+      if (!this.proc.killed) {
+        this.proc.kill("SIGKILL");
+      }
+    }, 2e3);
+    killTimer.unref();
+    this.proc.on("exit", () => clearTimeout(killTimer));
+    this.proc.kill("SIGTERM");
+    for (const [, p] of this.pending) {
+      p.reject(new Error("MCP client closed"));
+    }
+    this.pending.clear();
+  }
+  call(method, params, timeoutMs = 15e3) {
+    return new Promise((resolve, reject) => {
+      if (this.closed) {
+        reject(new Error("MCP client is closed"));
+        return;
+      }
+      const id = ++this.requestId;
+      this.pending.set(id, { resolve, reject });
+      this.proc.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+      const timer = setTimeout(() => {
+        if (!this.pending.has(id)) return;
+        this.pending.delete(id);
+        reject(new Error(`Request timeout after ${timeoutMs}ms.`));
+      }, timeoutMs);
+      timer.unref();
+      const original = this.pending.get(id);
+      if (!original) return;
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          original.resolve(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          original.reject(error);
+        }
+      });
+    });
+  }
+}
+const color = {
+  dim: (v) => `\x1B[2m${v}\x1B[0m`,
+  cyan: (v) => `\x1B[36m${v}\x1B[0m`,
+  green: (v) => `\x1B[32m${v}\x1B[0m`,
+  yellow: (v) => `\x1B[33m${v}\x1B[0m`,
+  red: (v) => `\x1B[31m${v}\x1B[0m`
+};
+function log(message, style = "dim") {
+  const fn = style === "ok" ? color.green : style === "warn" ? color.yellow : style === "err" ? color.red : color.dim;
+  console.log(fn(message));
+}
+function looksLikeThreadSlug(value) {
+  return Boolean(value?.includes("~"));
+}
+async function withClient(run) {
+  const client = new LocalMcpClient((line) => process.stderr.write(color.dim(`[server] ${line}`)));
+  try {
+    await client.start();
+    return await run(client);
+  } finally {
+    client.close();
+  }
+}
+async function printToolResult(client, name, args, timeoutMs) {
+  const result = await client.callTool(name, args, timeoutMs);
+  const text = result.content?.[0]?.text ?? JSON.stringify(result, null, 2);
+  if (result.isError) throw new Error(text);
+  console.log(text);
+}
+function parseConsoleInput(line) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  for (const char of line) {
+    if ((char === '"' || char === "'") && quote == null) {
+      quote = char;
+      continue;
+    }
+    if (char === quote) {
+      quote = null;
+      continue;
+    }
+    if (char === " " && quote == null) {
+      if (current) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) parts.push(current);
+  return { cmd: parts[0]?.toLowerCase() ?? "", args: parts.slice(1) };
+}
+async function runConsoleCommand(cmd, args, client) {
+  switch (cmd) {
+    case "conversations":
+    case "list":
+      await printToolResult(client, "list_conversations", { limit: Number(args[0] ?? 20) });
+      return;
+    case "messages":
+    case "msg": {
+      const first = args[0];
+      const firstIsLimit = first != null && /^\d+$/.test(first);
+      const chatIdentifier = firstIsLimit ? void 0 : first;
+      const limit = Number(firstIsLimit ? first : args[1] ?? 20);
+      await printToolResult(client, "get_messages", {
+        ...chatIdentifier ? looksLikeThreadSlug(chatIdentifier) ? { threadSlug: chatIdentifier } : { chatIdentifier } : {},
+        limit
+      });
+      return;
+    }
+    case "unread":
+      await printToolResult(
+        client,
+        "get_unread_messages",
+        args[0] ? { limit: Number(args[0]) } : {}
+      );
+      return;
+    case "search":
+      if (!args[0]) throw new Error("Usage: search <query> [limit]");
+      await printToolResult(client, "search_messages", {
+        query: args[0],
+        limit: Number(args[1] ?? 20)
+      });
+      return;
+    case "wait":
+      if (!args[0]) throw new Error("Usage: wait <chat> [timeoutSeconds]");
+      await printToolResult(
+        client,
+        "wait_for_reply",
+        {
+          ...looksLikeThreadSlug(args[0]) ? { threadSlug: args[0] } : { chatIdentifier: args[0] },
+          timeoutSeconds: Number(args[1] ?? 60),
+          pollIntervalSeconds: 5
+        },
+        7e4
+      );
+      return;
+    case "send":
+      if (args.length < 2) throw new Error("Usage: send <target> <message>");
+      await printToolResult(client, "send_message", {
+        ...looksLikeThreadSlug(args[0]) ? { threadSlug: args[0] } : { recipient: args[0] },
+        message: args.slice(1).join(" ")
+      });
+      return;
+    case "logs":
+      await printToolResult(client, "get_logs", args[0] ? { tail: Number(args[0]) } : {});
+      return;
+    case "last-error":
+    case "lasterror":
+      await printToolResult(client, "get_last_send_error", {});
+      return;
+    case "tools":
+      for (const tool of await client.listTools()) {
+        console.log(`${tool.name}${tool.description ? ` - ${tool.description}` : ""}`);
+      }
+      return;
+    case "raw":
+      if (!args[0]) throw new Error("Usage: raw '<json>'");
+      {
+        const parsed = JSON.parse(args.join(" "));
+        if (!parsed.name)
+          throw new Error('Expected JSON like {"name":"tool_name","arguments":{...}}.');
+        await printToolResult(client, parsed.name, parsed.arguments ?? {});
+      }
+      return;
+    case "tui": {
+      const { runTui } = await import("./tui.js");
+      await runTui();
+      return;
+    }
+    case "help":
+    case "?":
+      console.log(CONSOLE_HELP);
+      return;
+    case "quit":
+    case "exit":
+      process.exit(0);
+      return;
+    default:
+      throw new Error(`Unknown command: ${cmd}. Type "help" for available commands.`);
+  }
+}
+const CONSOLE_HELP = `
+Available commands:
+  conversations [n]    List recent conversations (default 20)
+  messages [chat] [n]  Show recent messages
+  unread [n]           Show unread messages
+  search <query> [n]   Search messages
+  wait <chat> [secs]   Wait for a reply (default 60s)
+  send <target> <msg>  Send a message
+  logs [tail]          Show server debug logs
+  last-error           Show last send failure
+  tools                List available MCP tools
+  raw <json>           Send raw JSON-RPC to tools/call
+  tui                  Launch the read-only TUI
+  help                 Show this help
+  quit                 Exit
+`.trim();
+async function runInteractiveConsole() {
+  log("Starting local MCP server...", "dim");
+  const client = new LocalMcpClient((line) => process.stderr.write(color.dim(`[server] ${line}`)));
+  await client.start();
+  log("Console ready.\n", "ok");
+  console.log(CONSOLE_HELP);
+  console.log("");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = () => rl.question(color.cyan("imsg> "), async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      prompt();
+      return;
+    }
+    const { cmd, args } = parseConsoleInput(trimmed);
+    try {
+      await runConsoleCommand(cmd, args, client);
+    } catch (error) {
+      log(error instanceof Error ? error.message : String(error), "err");
+    }
+    console.log("");
+    prompt();
+  });
+  prompt();
+  installShutdownHandlers();
+  registerCleanup(() => client.close());
+}
+function normalizeFormat(raw) {
+  const v = raw.toLowerCase();
+  if (v === "md" || v === "markdown") return "markdown";
+  if (v === "csv") return "csv";
+  if (v === "json") return "json";
+  if (v === "ndjson") return "ndjson";
+  throw new Error(`Unknown format: ${raw}. Expected md, csv, json, or ndjson.`);
+}
+function extForFormat(fmt) {
+  return fmt === "markdown" ? "md" : fmt;
+}
+function sanitizeForFilename(s) {
+  return s.replace(/[^A-Za-z0-9._~-]+/g, "_").replace(/^_+|_+$/g, "") || "chat";
+}
+async function runExportCommand(target, opts) {
+  const { existsSync: existsSync2, mkdirSync, copyFileSync, statSync } = await import("node:fs");
+  const { homedir } = await import("node:os");
+  const { dirname: dirname2, join: join2, isAbsolute, resolve } = await import("node:path");
+  const { getContactsDbPaths, getImsgDbPath, getSlugsDbPath } = await import("./shutdown-B9ClCyco.js").then((n) => n.K);
+  const { IMessageDB } = await import("./imessage-db-BVDtx0Sn.js").then((n) => n.i);
+  const { streamExport } = await import("./exportStream-BaheQ6M4.js");
+  const { parseUserDate } = await import("./dateParse-DJXMfq3a.js");
+  const format = normalizeFormat(opts.format ?? "md");
+  const ext = extForFormat(format);
+  const pageSize = Number(opts.pageSize ?? "1000");
+  if (!Number.isFinite(pageSize) || pageSize < 100 || pageSize > 5e3) {
+    throw new Error("--page-size must be between 100 and 5000.");
+  }
+  const since = opts.since ? parseUserDate(opts.since) : null;
+  if (opts.since && !since) throw new Error(`Could not parse --since: ${opts.since}`);
+  const until = opts.until ? parseUserDate(opts.until) : null;
+  if (opts.until && !until) throw new Error(`Could not parse --until: ${opts.until}`);
+  const db = new IMessageDB(getImsgDbPath(), getContactsDbPaths(), getSlugsDbPath());
+  try {
+    let chatIdentifier = target;
+    let displayHandle = target;
+    if (looksLikeThreadSlug(target)) {
+      const rec = db.getSlugRecord(target);
+      if (!rec) throw new Error(`Unknown thread slug: ${target}`);
+      chatIdentifier = rec.chatIdentifier;
+      displayHandle = rec.slug;
+    }
+    let outputPath;
+    if (opts.output) {
+      outputPath = isAbsolute(opts.output) ? opts.output : resolve(opts.output);
+    } else {
+      const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      outputPath = join2(
+        homedir(),
+        `imsg-export-${sanitizeForFilename(displayHandle)}-${today}.${ext}`
+      );
+    }
+    const parent = dirname2(outputPath);
+    if (!existsSync2(parent)) mkdirSync(parent, { recursive: true });
+    log(`Exporting ${displayHandle} → ${outputPath} (${format})`, "dim");
+    const result = await streamExport({
+      db,
+      chatIdentifier,
+      format,
+      outputPath,
+      since,
+      until,
+      pageSize
+    });
+    let attachmentSummary = "";
+    if (opts.includeAttachments) {
+      const dir = opts.attachmentsDir ? isAbsolute(opts.attachmentsDir) ? opts.attachmentsDir : resolve(opts.attachmentsDir) : `${outputPath}.attachments`;
+      if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+      const filters = {
+        chatIdentifier,
+        limit: 0
+      };
+      if (since) filters.sinceMs = since.getTime();
+      if (until) filters.untilMs = until.getTime();
+      const attachments = db.searchAttachments(filters);
+      let copied = 0;
+      let totalBytes = 0;
+      const seen = /* @__PURE__ */ new Set();
+      for (const a of attachments) {
+        if (!a.filename) continue;
+        const src = a.filename.replace(/^~/, homedir());
+        if (!existsSync2(src)) continue;
+        const baseName = a.transferName || src.split("/").pop() || `att-${a.rowId}`;
+        let destName = `${a.rowId}-${sanitizeForFilename(baseName)}`;
+        if (seen.has(destName)) destName = `${a.rowId}-${Date.now()}-${baseName}`;
+        seen.add(destName);
+        const dest = join2(dir, destName);
+        try {
+          copyFileSync(src, dest);
+          copied++;
+          totalBytes += statSync(dest).size;
+        } catch (err) {
+          log(
+            `  warn: copy failed for ${src}: ${err instanceof Error ? err.message : String(err)}`,
+            "warn"
+          );
+        }
+      }
+      attachmentSummary = `
+Attachments: ${copied} file(s), ${(totalBytes / 1024).toFixed(1)} KB → ${dir}`;
+    }
+    log(
+      [
+        "",
+        `✓ Exported ${result.count} message(s) to ${result.savedTo}`,
+        `  Format: ${format}`,
+        `  Range: ${result.oldest?.toISOString() ?? "(none)"} → ${result.newest?.toISOString() ?? "(none)"}`,
+        `  Size: ${(result.sizeBytes / 1024).toFixed(1)} KB${attachmentSummary}`
+      ].join("\n"),
+      "ok"
+    );
+  } finally {
+    await db.close();
+  }
+}
+const program = new Command().name("imsg").version(APP_VERSION, "-v, --version").description("CLI for the imsg-mcp iMessage MCP server").addHelpText(
+  "after",
+  `
+Notes:
+  Use "imsg doctor" on a new machine.
+  Run the MCP stdio server with "imsg mcp".
+  Launch the read-only TUI with "imsg tui".`
+);
+program.command("mcp").description("Run the MCP stdio server").action(async () => {
+  const { runMcpServer } = await import("./index.js");
+  await runMcpServer();
+});
+program.command("cli").alias("console").description("Launch interactive console").action(runInteractiveConsole);
+program.command("doctor").description("Check local permissions and database access").action(async () => {
+  const report = await checkLocalAccess();
+  console.log(formatAccessReport(report));
+  process.exitCode = report.ok ? 0 : 1;
+});
+program.command("conversations").alias("list").description("List recent conversations").argument("[limit]", "Number of conversations", "20").action(async (limit) => {
+  await withClient((c) => printToolResult(c, "list_conversations", { limit: Number(limit) }));
+});
+program.command("messages").alias("msg").description("Show recent messages from a conversation").argument("[chat]", "Phone number, email, or thread slug").argument("[limit]", "Number of messages", "20").action(async (chat, limit) => {
+  const firstIsLimit = chat != null && /^\d+$/.test(chat);
+  const chatIdentifier = firstIsLimit ? void 0 : chat;
+  const finalLimit = Number(firstIsLimit ? chat : limit);
+  await withClient(
+    (c) => printToolResult(c, "get_messages", {
+      ...chatIdentifier ? looksLikeThreadSlug(chatIdentifier) ? { threadSlug: chatIdentifier } : { chatIdentifier } : {},
+      limit: finalLimit
+    })
+  );
+});
+program.command("unread").description("Show unread messages across all conversations").argument("[limit]", "Number of messages", "100").action(async (limit) => {
+  await withClient((c) => printToolResult(c, "get_unread_messages", { limit: Number(limit) }));
+});
+program.command("search").description("Search messages by text content").argument("<query>", "Search query").argument("[limit]", "Number of results", "20").action(async (query, limit) => {
+  await withClient((c) => printToolResult(c, "search_messages", { query, limit: Number(limit) }));
+});
+program.command("wait").description("Wait for a reply in a conversation").argument("<chat>", "Phone number, email, or thread slug").argument("[timeout]", "Timeout in seconds", "60").action(async (chat, timeout) => {
+  await withClient(
+    (c) => printToolResult(
+      c,
+      "wait_for_reply",
+      {
+        ...looksLikeThreadSlug(chat) ? { threadSlug: chat } : { chatIdentifier: chat },
+        timeoutSeconds: Number(timeout),
+        pollIntervalSeconds: 5
+      },
+      7e4
+    )
+  );
+});
+program.command("send").description("Send a message via Messages.app").argument("<target>", "Phone number, email, or thread slug").argument("<message...>", "Message text").action(async (target, messageParts) => {
+  await withClient(
+    (c) => printToolResult(c, "send_message", {
+      ...looksLikeThreadSlug(target) ? { threadSlug: target } : { recipient: target },
+      message: messageParts.join(" ")
+    })
+  );
+});
+program.command("logs").description("Show server debug logs").argument("[tail]", "Show only last N lines").action(async (tail) => {
+  await withClient((c) => printToolResult(c, "get_logs", tail ? { tail: Number(tail) } : {}));
+});
+program.command("last-error").description("Show last send_message failure details").action(async () => {
+  await withClient((c) => printToolResult(c, "get_last_send_error", {}));
+});
+program.command("tools").description("List available MCP tools").action(async () => {
+  await withClient(async (c) => {
+    for (const tool of await c.listTools()) {
+      console.log(`${tool.name}${tool.description ? ` - ${tool.description}` : ""}`);
+    }
+  });
+});
+program.command("raw").description("Send raw JSON-RPC params to tools/call").argument("<json>", 'JSON like {"name":"tool_name","arguments":{...}}').action(async (json) => {
+  const parsed = JSON.parse(json);
+  if (!parsed.name) throw new Error('Expected JSON like {"name":"tool_name","arguments":{...}}.');
+  await withClient((c) => printToolResult(c, parsed.name, parsed.arguments ?? {}));
+});
+program.command("tui").description("Launch the read-only terminal UI").option("--theme <theme>", 'TUI theme: "safe" or "powerline"').option("--accent <hex>", "TUI accent color as #RRGGBB").action(async () => {
+  const { runTui } = await import("./tui.js");
+  await runTui();
+});
+program.command("export <target>").description("Export a conversation to a file (md/csv/json/ndjson)").option("-f, --format <fmt>", "Output format: md (default), csv, json, ndjson", "md").option("--since <date>", "Earliest date (ISO or relative, e.g. '3 months ago')").option("--until <date>", "Latest date (ISO or relative)").option("-o, --output <path>", "Output path (default: ~/imsg-export-<target>-<YYYY-MM-DD>.<ext>)").option("--include-attachments", "Copy attachments next to the export").option("--attachments-dir <path>", "Where to copy attachments (default: <output>.attachments/)").option("--page-size <n>", "Messages per DB page (100-5000)", "1000").action(runExportCommand);
+program.command("setup").description("Autodetect DB paths and emit an MCP host config snippet").option("-w, --write <host>", 'Write into a host config: "claude" or "cursor"').option("-r, --runtime <runtime>", 'Runtime command: "npx" (default), "bunx", or "global"').option("--print-only", "Just print the snippet (default behaviour)").action(async (opts) => {
+  const { probeMachine, buildMcpSnippet, writeHostConfig } = await import("./setup-DMckHRnI.js");
+  const report = probeMachine();
+  if (!report.imsgDb.readable) {
+    log(`✗ Messages DB is not readable: ${report.imsgDb.path}`, "err");
+    log(`  ${report.imsgDb.error ?? ""}`, "err");
+    log(
+      "  Grant Full Disk Access to the running app: System Settings → Privacy & Security → Full Disk Access",
+      "warn"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  log(`✓ Messages DB readable: ${report.imsgDb.path}`, "ok");
+  log(
+    `✓ Address Book: ${report.contactsDbs.length} source(s), ${report.contactsDbs.filter((p) => p.readable).length} readable`,
+    "ok"
+  );
+  log(
+    `  slugs.db: ${report.slugsDb.path} ${report.slugsDb.exists ? "(exists)" : "(will be created on first run)"}`
+  );
+  const runtime = opts.runtime === "bunx" || opts.runtime === "global" ? opts.runtime : "npx";
+  const snippet = buildMcpSnippet(report, { runtime });
+  if (opts.write) {
+    if (opts.write !== "claude" && opts.write !== "cursor") {
+      log(`✗ unknown host: ${opts.write} (expected "claude" or "cursor")`, "err");
+      process.exitCode = 1;
+      return;
+    }
+    const result = writeHostConfig(opts.write, report, { runtime });
+    log(
+      `✓ wrote ${opts.write} config to ${result.path}${result.replaced ? " (replaced existing imessage entry)" : ""}`,
+      "ok"
+    );
+    log(`  backup of any prior file at ${result.path}.bak`);
+    return;
+  }
+  log("--- snippet ---", "dim");
+  process.stdout.write(snippet);
+});
+const configCmd = program.command("config").description("Manage TUI settings (theme, accent color)");
+configCmd.command("show").description("Print resolved TUI settings and where each value came from").action(async () => {
+  const { resolveTuiConfig, defaultTuiConfigPath } = await import("./tui-config-Crn6TZPg.js");
+  const cfg = resolveTuiConfig();
+  log(
+    `config file : ${cfg.configPath ?? `(none — defaults; would write to ${defaultTuiConfigPath()})`}`
+  );
+  log(`theme       : ${cfg.theme}  (from ${cfg.origin.theme})`);
+  log(`accentColor : ${cfg.accentColor}  (from ${cfg.origin.accentColor})`);
+  if (cfg.theme === "powerline") {
+    log("  — powerline theme requires a Nerd Font (https://www.nerdfonts.com)", "warn");
+  }
+  for (const w of cfg.warnings) log(w, "warn");
+});
+configCmd.command("edit").description("Open the TUI config file in $EDITOR (creates it if missing)").action(async () => {
+  const { defaultTuiConfigPath, findTuiConfigPath, writeTuiConfig, DEFAULT_TUI_CONFIG } = await import("./tui-config-Crn6TZPg.js");
+  const path = findTuiConfigPath() ?? defaultTuiConfigPath();
+  const { existsSync: existsSync2 } = await import("node:fs");
+  if (!existsSync2(path)) {
+    writeTuiConfig(DEFAULT_TUI_CONFIG, path);
+    log(`created ${path}`, "ok");
+  }
+  const editor = process.env.EDITOR ?? "vi";
+  const { spawn: spawn2 } = await import("node:child_process");
+  const child = spawn2(editor, [path], { stdio: "inherit" });
+  await new Promise((resolve, reject) => {
+    child.on(
+      "exit",
+      (code) => code === 0 ? resolve() : reject(new Error(`editor exited ${code}`))
+    );
+    child.on("error", reject);
+  });
+});
+program.action(() => {
+  program.outputHelp();
+});
+const invokedAsScript = (() => {
+  try {
+    const entry = process.argv[1];
+    if (!entry) return false;
+    return import.meta.url === pathToFileURL(entry).href;
+  } catch {
+    return false;
+  }
+})();
+if (invokedAsScript) {
+  program.parseAsync(process.argv).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+export {
+  runExportCommand
+};
+//# sourceMappingURL=cli.js.map