moneyswitch 0.5.0

package/dist/cli.js

@@ -0,0 +1,523 @@
+#!/usr/bin/env node
+
+// ../connect/dist/lib/args.js
+function parseArgs(argv) {
+  let command = "connect";
+  const rest = [...argv];
+  if (rest[0] === "status" || rest[0] === "remove") {
+    command = rest.shift();
+  }
+  let server;
+  let key;
+  let apply = false;
+  let json = false;
+  let help = false;
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--server") {
+      server = rest[++i];
+      if (server === void 0)
+        return { error: "--server requires a value" };
+    } else if (arg === "--key") {
+      key = rest[++i];
+      if (key === void 0)
+        return { error: "--key requires a value" };
+    } else if (arg === "--apply") {
+      apply = true;
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else {
+      return { error: `unknown argument: ${arg}` };
+    }
+  }
+  if (!help && (command === "connect" || command === "status")) {
+    if (!server)
+      return { error: "--server is required" };
+    if (!key)
+      return { error: "--key is required" };
+  }
+  return { command, server, key, apply, json, help };
+}
+
+// ../connect/dist/lib/status.js
+async function fetchStatus(server, key, fetchImpl = fetch) {
+  const base = server.replace(/\/+$/, "");
+  const res = await fetchImpl(`${base}/v1/status`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${key}` }
+  });
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+    body = null;
+  }
+  return { ok: res.ok, httpStatus: res.status, body };
+}
+
+// ../connect/dist/lib/detect.js
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function detectClaude(runner) {
+  const res = runner.run("claude", ["--version"]);
+  return res.ok;
+}
+function codexHomeDir(env = process.env) {
+  if (env.CODEX_HOME)
+    return env.CODEX_HOME;
+  return path.join(os.homedir(), ".codex");
+}
+function codexConfigPath(env = process.env) {
+  return path.join(codexHomeDir(env), "config.toml");
+}
+function detectCodex(runner, env = process.env) {
+  const inPath = runner.run("codex", ["--version"]).ok;
+  const dirExists = fs.existsSync(codexHomeDir(env));
+  return inPath || dirExists;
+}
+
+// ../connect/dist/lib/claude.js
+var SERVER_NAME = "moneyswitch";
+function applyClaude(runner, server, key, mcpCommand) {
+  const removed = runner.run("claude", ["mcp", "remove", SERVER_NAME, "-s", "user"]);
+  const added = runner.run("claude", [
+    "mcp",
+    "add",
+    SERVER_NAME,
+    "-s",
+    "user",
+    "-e",
+    `MONEY_API_BASE=${server}`,
+    "-e",
+    `MONEY_API_KEY=${key}`,
+    "--",
+    mcpCommand.command,
+    ...mcpCommand.args
+  ]);
+  return { removed, added };
+}
+function removeClaude(runner) {
+  return runner.run("claude", ["mcp", "remove", SERVER_NAME, "-s", "user"]);
+}
+
+// ../connect/dist/lib/codex.js
+import fs2 from "node:fs";
+import path2 from "node:path";
+var TABLE = "mcp_servers.moneyswitch";
+function tomlEscape(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildMcpSection(server, key, mcpCommand) {
+  const argsToml = mcpCommand.args.map((a) => `"${tomlEscape(a)}"`).join(", ");
+  return [
+    `[${TABLE}]`,
+    `command = "${tomlEscape(mcpCommand.command)}"`,
+    `args = [${argsToml}]`,
+    "",
+    `[${TABLE}.env]`,
+    `MONEY_API_BASE = "${tomlEscape(server)}"`,
+    `MONEY_API_KEY = "${tomlEscape(key)}"`
+  ].join("\n");
+}
+function hasMoneySwitchSection(text) {
+  const headerRe = /^\[([^\]]+)\]$/;
+  return text.split(/\r?\n/).some((line) => {
+    const m = headerRe.exec(line.trim());
+    if (!m)
+      return false;
+    const name = m[1];
+    return name === TABLE || name.startsWith(`${TABLE}.`);
+  });
+}
+function removeMoneySwitchSection(text) {
+  const lines = text.split(/\r?\n/);
+  const headerRe = /^\[([^\]]+)\]$/;
+  const out = [];
+  let skipping = false;
+  for (const line of lines) {
+    const m = headerRe.exec(line.trim());
+    if (m) {
+      const name = m[1];
+      skipping = name === TABLE || name.startsWith(`${TABLE}.`);
+    }
+    if (!skipping)
+      out.push(line);
+  }
+  return out.join("\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "").replace(/\s+$/, "");
+}
+function applyCodexConfig(configPath, server, key, mcpCommand) {
+  fs2.mkdirSync(path2.dirname(configPath), { recursive: true });
+  const existed = fs2.existsSync(configPath);
+  const original = existed ? fs2.readFileSync(configPath, "utf8") : "";
+  let backupPath = null;
+  if (existed) {
+    backupPath = `${configPath}.bak-${Date.now()}`;
+    fs2.writeFileSync(backupPath, original, "utf8");
+  }
+  const withoutSection = removeMoneySwitchSection(original);
+  const section = buildMcpSection(server, key, mcpCommand);
+  const combined = withoutSection.length > 0 ? `${withoutSection}
+
+${section}
+` : `${section}
+`;
+  fs2.writeFileSync(configPath, combined, "utf8");
+  return { configPath, existed, backupPath };
+}
+function removeCodexConfig(configPath) {
+  if (!fs2.existsSync(configPath)) {
+    return { configPath, removed: false, backupPath: null };
+  }
+  const original = fs2.readFileSync(configPath, "utf8");
+  if (!hasMoneySwitchSection(original)) {
+    return { configPath, removed: false, backupPath: null };
+  }
+  const stripped = removeMoneySwitchSection(original);
+  const backupPath = `${configPath}.bak-${Date.now()}`;
+  fs2.writeFileSync(backupPath, original, "utf8");
+  fs2.writeFileSync(configPath, stripped.length > 0 ? `${stripped}
+` : "", "utf8");
+  return { configPath, removed: true, backupPath };
+}
+
+// ../connect/dist/lib/mcp-entry.js
+import { createRequire } from "node:module";
+function resolveMcpCommand(fromUrl = import.meta.url) {
+  const require2 = createRequire(fromUrl);
+  try {
+    const entry = require2.resolve("@moneyswitch/mcp");
+    return { command: "node", args: [entry] };
+  } catch {
+    return { command: "npx", args: ["-y", "moneyswitch", "mcp"] };
+  }
+}
+function isNpmRegistryFallback(cmd) {
+  return cmd.command === "npx" && cmd.args.length === 3 && cmd.args[0] === "-y" && cmd.args[1] === "moneyswitch" && cmd.args[2] === "mcp";
+}
+async function resolvePortableMcpCommand(server, fetchImpl = fetch) {
+  const base = server.replace(/\/+$/, "");
+  const tarballUrl = `${base}/dl/moneyswitch.tgz`;
+  try {
+    const res = await fetchImpl(tarballUrl, { method: "HEAD" });
+    if (res.ok)
+      return { command: "npx", args: ["-y", `--package=${tarballUrl}`, "moneyswitch", "mcp"] };
+  } catch {
+  }
+  return { command: "npx", args: ["-y", "moneyswitch", "mcp"] };
+}
+
+// ../connect/dist/lib/runner.js
+import { spawnSync } from "node:child_process";
+function quoteWinArg(arg) {
+  if (arg.length > 0 && !/[\s"&|<>^%()!,;=]/.test(arg))
+    return arg;
+  return `"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1")}"`;
+}
+var RealCommandRunner = class {
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  run(cmd, args) {
+    const win = process.platform === "win32";
+    try {
+      const res = win ? spawnSync([cmd, ...args].map(quoteWinArg).join(" "), {
+        encoding: "utf8",
+        shell: true,
+        env: this.opts.env ?? process.env,
+        cwd: this.opts.cwd,
+        timeout: this.opts.timeoutMs
+      }) : spawnSync(cmd, args, {
+        encoding: "utf8",
+        env: this.opts.env ?? process.env,
+        cwd: this.opts.cwd,
+        timeout: this.opts.timeoutMs
+      });
+      if (res.error) {
+        return { ok: false, code: null, stdout: "", stderr: String(res.error.message ?? res.error) };
+      }
+      return {
+        ok: (res.status ?? 1) === 0,
+        code: res.status,
+        stdout: res.stdout ?? "",
+        stderr: res.stderr ?? ""
+      };
+    } catch (e) {
+      return { ok: false, code: null, stdout: "", stderr: e.message };
+    }
+  }
+};
+
+// ../connect/dist/lib/cli.js
+function maskKey(key) {
+  if (key.length <= 12)
+    return `${key}\u2022\u2022\u2022\u2022`;
+  return `${key.slice(0, 12)}\u2022\u2022\u2022\u2022`;
+}
+var HELP_TEXT = `moneyswitch-connect - one-command local Agent setup for MoneySwitch (SPEC-v0.3-employee.md \xA7B)
+
+Usage:
+  moneyswitch-connect --server <url> --key <mk_live_...> [--apply] [--json]
+  moneyswitch-connect status --server <url> --key <mk_live_...> [--json]
+  moneyswitch-connect remove [--apply] [--json]
+
+Without --apply, changes are only listed (dry-run). Exit codes: 0 ok, 1 failure, 2 bad args.`;
+async function runCli(argv, deps = {}) {
+  const stdout = deps.stdout ?? ((line) => process.stdout.write(line + "\n"));
+  const stderr = deps.stderr ?? ((line) => process.stderr.write(line + "\n"));
+  const env = deps.env ?? process.env;
+  const runner = deps.runner ?? new RealCommandRunner();
+  const fetchImpl = deps.fetchImpl;
+  const isTTY = deps.isTTY ?? Boolean(process.stdout.isTTY);
+  const jsonMode = argv.includes("--json") || !isTTY;
+  const parsed = parseArgs(argv);
+  if ("error" in parsed) {
+    if (jsonMode)
+      stdout(JSON.stringify({ ok: false, error: parsed.error }));
+    else
+      stderr(`error: ${parsed.error}
+
+${HELP_TEXT}`);
+    return 2;
+  }
+  if (parsed.help) {
+    if (jsonMode)
+      stdout(JSON.stringify({ ok: true, help: HELP_TEXT }));
+    else
+      stdout(HELP_TEXT);
+    return 0;
+  }
+  let mcpCommand = deps.mcpCommand ?? resolveMcpCommand();
+  if (parsed.command === "status") {
+    const server2 = parsed.server;
+    const key2 = parsed.key;
+    let result;
+    try {
+      result = await fetchStatus(server2, key2, fetchImpl);
+    } catch (e) {
+      const msg = e.message;
+      if (jsonMode)
+        stdout(JSON.stringify({ ok: false, error: "REQUEST_FAILED", message: msg }));
+      else
+        stderr(`failed to reach ${server2}: ${msg}`);
+      return 1;
+    }
+    if (!result.ok) {
+      if (jsonMode)
+        stdout(JSON.stringify({ ok: false, http_status: result.httpStatus, body: result.body }));
+      else
+        stderr(`GET /v1/status -> ${result.httpStatus}: ${JSON.stringify(result.body)}`);
+      return 1;
+    }
+    if (jsonMode)
+      stdout(JSON.stringify({ ok: true, http_status: result.httpStatus, status: result.body }));
+    else {
+      const body = result.body;
+      stdout(`Key: ${body.key_name ?? "(unnamed)"} (${body.key_prefix ?? maskKey(key2)})`);
+      stdout(`Remaining today: ${body.remaining_today} / ${body.daily_budget} ${body.currency}`);
+      stdout(`Remaining total: ${body.remaining_total} / ${body.total_budget} ${body.currency}`);
+      stdout(`Network: ${body.network}`);
+    }
+    return 0;
+  }
+  if (parsed.command === "remove") {
+    const agents2 = [];
+    const claudePresent2 = detectClaude(runner);
+    if (parsed.apply) {
+      const res = removeClaude(runner);
+      agents2.push({ name: "claude", detected: claudePresent2, action: res.ok ? "removed" : "remove_failed", detail: res });
+    } else {
+      agents2.push({ name: "claude", detected: claudePresent2, action: claudePresent2 ? "would_remove" : "skip" });
+    }
+    const cfgPath2 = codexConfigPath(env);
+    if (parsed.apply) {
+      const res = removeCodexConfig(cfgPath2);
+      agents2.push({ name: "codex", detected: res.removed, action: res.removed ? "removed" : "skip", detail: res });
+    } else {
+      agents2.push({ name: "codex", detected: null, action: "would_remove", detail: { configPath: cfgPath2 } });
+    }
+    if (jsonMode) {
+      stdout(JSON.stringify({ ok: true, applied: parsed.apply, agents: agents2 }));
+    } else {
+      stdout(parsed.apply ? "Removed MoneySwitch MCP configuration:" : "Would remove MoneySwitch MCP configuration (dry-run, pass --apply):");
+      for (const a of agents2)
+        stdout(`  - ${a.name}: ${a.action}`);
+    }
+    return 0;
+  }
+  const server = parsed.server;
+  const key = parsed.key;
+  let statusResult;
+  try {
+    statusResult = await fetchStatus(server, key, fetchImpl);
+  } catch (e) {
+    const msg = e.message;
+    if (jsonMode)
+      stdout(JSON.stringify({ ok: false, error: "REQUEST_FAILED", message: msg }));
+    else
+      stderr(`failed to reach ${server}: ${msg}`);
+    return 1;
+  }
+  if (!statusResult.ok) {
+    if (jsonMode)
+      stdout(JSON.stringify({ ok: false, http_status: statusResult.httpStatus, body: statusResult.body }));
+    else
+      stderr(`key rejected by ${server}: HTTP ${statusResult.httpStatus}: ${JSON.stringify(statusResult.body)}`);
+    return 1;
+  }
+  const statusBody = statusResult.body;
+  if (!deps.mcpCommand && isNpmRegistryFallback(mcpCommand)) {
+    mcpCommand = await resolvePortableMcpCommand(server, fetchImpl);
+  }
+  if (!jsonMode) {
+    stdout(`Key: ${statusBody.key_name ?? "(unnamed)"} (${statusBody.key_prefix ?? maskKey(key)})`);
+    stdout(`Remaining today: ${statusBody.remaining_today} ${statusBody.currency}`);
+    stdout(`Network: ${statusBody.network}`);
+  }
+  const claudePresent = detectClaude(runner);
+  const codexPresent = detectCodex(runner, env);
+  const cfgPath = codexConfigPath(env);
+  const agents = [];
+  if (parsed.apply) {
+    if (claudePresent) {
+      const res = applyClaude(runner, server, key, mcpCommand);
+      agents.push({
+        name: "claude",
+        detected: true,
+        action: res.added.ok ? "added" : "add_failed",
+        detail: res
+      });
+    } else {
+      agents.push({ name: "claude", detected: false, action: "not_found" });
+    }
+    if (codexPresent) {
+      const res = applyCodexConfig(cfgPath, server, key, mcpCommand);
+      agents.push({ name: "codex", detected: true, action: "added", detail: res });
+    } else {
+      agents.push({ name: "codex", detected: false, action: "not_found" });
+    }
+  } else {
+    const mcpCommandStr = [mcpCommand.command, ...mcpCommand.args].join(" ");
+    agents.push({
+      name: "claude",
+      detected: claudePresent,
+      action: claudePresent ? `would run: claude mcp add moneyswitch -s user -e MONEY_API_BASE=${server} -e MONEY_API_KEY=**** -- ${mcpCommandStr}` : "not_found"
+    });
+    agents.push({
+      name: "codex",
+      detected: codexPresent,
+      action: codexPresent ? `would write [mcp_servers.moneyswitch] to ${cfgPath} (backing up existing file)` : "not_found"
+    });
+  }
+  agents.push({
+    name: "cherry_studio",
+    detected: null,
+    action: `manual: set Base URL = ${server}/v1, API Key = <your key>`
+  });
+  agents.push({
+    name: "open_webui",
+    detected: null,
+    action: `manual: set Base URL = ${server}/v1, API Key = <your key>`
+  });
+  const revoke = "moneyswitch-connect remove --apply";
+  if (jsonMode) {
+    stdout(JSON.stringify({
+      ok: true,
+      applied: parsed.apply,
+      server,
+      key_prefix: statusBody.key_prefix ?? maskKey(key),
+      status: statusBody,
+      agents,
+      revoke
+    }));
+  } else {
+    stdout(parsed.apply ? "\nApplied:" : "\nDry-run (pass --apply to make these changes):");
+    for (const a of agents)
+      stdout(`  - ${a.name}: ${a.action}`);
+    stdout(`
+To revoke later: ${revoke}`);
+  }
+  const failed = agents.some((a) => a.action === "add_failed");
+  return failed ? 1 : 0;
+}
+
+// src/cli.ts
+import { pathToFileURL } from "node:url";
+var TOP_HELP = `moneyswitch - client CLI for MoneySwitch (x402 + USDC on Monad)
+
+Usage:
+  moneyswitch connect --server <url> --key <mk_live_...> [--apply] [--json]
+  moneyswitch status --server <url> --key <mk_live_...> [--json]
+  moneyswitch remove [--apply] [--json]
+  moneyswitch ui [--port 4318] [--no-open]
+  moneyswitch sell --upstream <url> --pay-to <0x\u2026> [--price 0.01] [--route "POST /path=0.01"]...
+  moneyswitch mcp
+
+"sell" puts a toll booth in front of your own API: AI agents pay USDC per call
+(x402) straight to your PUBLIC receiving address; no MoneySwitch server needed.
+Run "moneyswitch sell --help" for all options.
+"ui" opens the local desktop console (127.0.0.1 only): give each agent a
+model key and a MoneyKey, preview the config diff, then enable.
+Without --apply, "connect"/"remove" only print planned changes (dry-run).
+"mcp" starts a stdio MCP server; it reads MONEY_API_BASE and MONEY_API_KEY
+from the environment and never touches this process's argv/stdout for
+anything other than the MCP protocol itself.
+
+Exit codes: 0 ok, 1 failure, 2 bad args.`;
+function parseTopArgv(argv) {
+  const [sub, ...rest] = argv;
+  if (sub === "mcp") return { kind: "mcp" };
+  if (sub === "ui") return { kind: "ui", args: rest };
+  if (sub === "sell") return { kind: "sell", args: rest };
+  if (sub === "connect") return { kind: "connect-lib", args: rest };
+  if (sub === "status" || sub === "remove") return { kind: "connect-lib", args: argv };
+  if (sub === void 0 || sub === "--help" || sub === "-h") return { kind: "help" };
+  return { kind: "unknown", command: sub };
+}
+async function main() {
+  const dispatch = parseTopArgv(process.argv.slice(2));
+  if (dispatch.kind === "mcp") {
+    await import("./mcp.js");
+    return;
+  }
+  if (dispatch.kind === "ui") {
+    const { runUi } = await import("./desktop.js");
+    process.exit(await runUi(dispatch.args));
+    return;
+  }
+  if (dispatch.kind === "sell") {
+    const { runSell } = await import("./sell.js");
+    process.exit(await runSell(dispatch.args));
+    return;
+  }
+  if (dispatch.kind === "connect-lib") {
+    const code = await runCli(dispatch.args);
+    process.exit(code);
+    return;
+  }
+  if (dispatch.kind === "help") {
+    process.stdout.write(TOP_HELP + "\n");
+    process.exit(0);
+    return;
+  }
+  process.stderr.write(`moneyswitch: unknown command "${dispatch.command}"
+
+${TOP_HELP}
+`);
+  process.exit(2);
+}
+var isMain = Boolean(process.argv[1]) && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMain) {
+  main().catch((err) => {
+    process.stderr.write(`moneyswitch: unexpected error: ${err?.message ?? err}
+`);
+    process.exit(1);
+  });
+}
+export {
+  TOP_HELP,
+  parseTopArgv
+};