@routstr/cocod 0.0.16

package/src/cli-shared.ts

@@ -0,0 +1,164 @@
+import { program } from "commander";
+
+const CONFIG_DIR = `${process.env.HOME || process.env.USERPROFILE}/.cocod`;
+const SOCKET_PATH = process.env.COCOD_SOCKET || `${CONFIG_DIR}/cocod.sock`;
+
+export interface CommandResponse {
+  output?: unknown;
+  error?: string;
+}
+
+async function callDaemon(
+  path: string,
+  options: { method?: "GET" | "POST"; body?: object } = {},
+): Promise<CommandResponse> {
+  const { method = "GET", body } = options;
+
+  const init: RequestInit & { unix: string } = {
+    unix: SOCKET_PATH,
+    method,
+    headers: body ? { "Content-Type": "application/json" } : {},
+    body: body ? JSON.stringify(body) : undefined,
+  } as RequestInit & { unix: string };
+
+  const response = await fetch(`http://localhost${path}`, init);
+
+  if (!response.ok) {
+    const errorData = (await response.json()) as { error?: string };
+    throw new Error(errorData.error || `HTTP ${response.status}`);
+  }
+
+  return response.json() as Promise<CommandResponse>;
+}
+
+export async function isDaemonRunning(): Promise<boolean> {
+  try {
+    const response = await fetch(`http://localhost/ping`, {
+      unix: SOCKET_PATH,
+    } as RequestInit);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function startDaemonProcess(): Promise<void> {
+  const proc = Bun.spawn({
+    cmd: ["bun", "run", `${import.meta.dir}/index.ts`, "daemon"],
+    stdout: "ignore",
+    stderr: "ignore",
+    stdin: "ignore",
+  });
+  proc.unref();
+
+  for (let i = 0; i < 50; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    if (await isDaemonRunning()) {
+      return;
+    }
+  }
+
+  throw new Error("Daemon failed to start within 5 seconds");
+}
+
+export async function ensureDaemonRunning(): Promise<void> {
+  if (await isDaemonRunning()) {
+    return;
+  }
+
+  console.log("Starting daemon...");
+  await startDaemonProcess();
+}
+
+export async function handleDaemonCommand(
+  path: string,
+  options: { method?: "GET" | "POST"; body?: object } = {},
+): Promise<CommandResponse> {
+  try {
+    await ensureDaemonRunning();
+    const result = await callDaemon(path, options);
+
+    if (result.error) {
+      console.log(result.error);
+      process.exit(1);
+    }
+
+    if (result.output !== undefined) {
+      if (typeof result.output === "string") {
+        console.log(result.output);
+      } else {
+        try {
+          const formatted = JSON.stringify(result.output, null, 2);
+          console.log(formatted ?? String(result.output));
+        } catch {
+          console.log(String(result.output));
+        }
+      }
+    }
+
+    return result;
+  } catch (error) {
+    const message = (error as Error).message;
+    if (message?.includes("fetch failed") || message?.includes("Connection refused")) {
+      console.error("Daemon is not running and failed to auto-start");
+      process.exit(1);
+    }
+    console.error(message);
+    process.exit(1);
+  }
+}
+
+export async function callDaemonStream(
+  path: string,
+  onData: (data: unknown) => void,
+): Promise<void> {
+  await ensureDaemonRunning();
+
+  const init: RequestInit & { unix: string } = {
+    unix: SOCKET_PATH,
+    method: "GET",
+  } as RequestInit & { unix: string };
+
+  const response = await fetch(`http://localhost${path}`, init);
+
+  if (!response.ok) {
+    const errorData = (await response.json()) as { error?: string };
+    throw new Error(errorData.error || `HTTP ${response.status}`);
+  }
+
+  if (!response.body) {
+    throw new Error("No response body");
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const jsonStr = line.slice(6);
+          try {
+            const data = JSON.parse(jsonStr);
+            onData(data);
+          } catch {
+            // Skip malformed JSON
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+export { program, callDaemon };

package/src/cli.ts

@@ -0,0 +1,317 @@
+import { startDaemon } from "./daemon";
+import { program, handleDaemonCommand, callDaemonStream } from "./cli-shared";
+import {
+  DEFAULT_LOG_LINES,
+  followLogFile,
+  getLogFileSize,
+  parseLogLineCount,
+  readRecentLogText,
+} from "./logs";
+import { LOG_FILE } from "./utils/config";
+import packageJson from "../package.json" with { type: "json" };
+
+const cliVersion = packageJson.version;
+
+program
+  .name("cocod")
+  .description("Coco CLI - A Cashu wallet daemon")
+  .version(cliVersion, "--version", "output the version number");
+
+// Status - check daemon/wallet state
+program
+  .command("status")
+  .description("Check daemon and wallet status")
+  .action(async () => {
+    await handleDaemonCommand("/status");
+  });
+
+// Init - initialize wallet
+program
+  .command("init [mnemonic]")
+  .description("Initialize wallet with optional mnemonic (generates one if not provided)")
+  .option("--passphrase <passphrase>", "Encrypt wallet with passphrase")
+  .option("--mint-url <url>", "Default mint URL (default: https://mint.minibits.cash/Bitcoin)")
+  .action(
+    async (mnemonic: string | undefined, options: { passphrase?: string; mintUrl?: string }) => {
+      await handleDaemonCommand("/init", {
+        method: "POST",
+        body: {
+          mnemonic,
+          passphrase: options.passphrase,
+          mintUrl: options.mintUrl,
+        },
+      });
+    },
+  );
+
+// Unlock - unlock encrypted wallet
+program
+  .command("unlock <passphrase>")
+  .description("Unlock encrypted wallet with passphrase")
+  .action(async (passphrase: string) => {
+    await handleDaemonCommand("/unlock", {
+      method: "POST",
+      body: { passphrase },
+    });
+  });
+
+// Balance - simple GET command
+program
+  .command("balance")
+  .description("Get wallet balance")
+  .action(async () => {
+    await handleDaemonCommand("/balance");
+  });
+
+// Receive - nested subcommands
+const receiveCmd = program.command("receive").description("Receive operations");
+
+receiveCmd
+  .command("cashu <token>")
+  .description("Receive Cashu token")
+  .action(async (token: string) => {
+    await handleDaemonCommand("/receive/cashu", {
+      method: "POST",
+      body: { token },
+    });
+  });
+
+receiveCmd
+  .command("bolt11 <amount>")
+  .description("Create Lightning invoice to receive tokens")
+  .option("--mint-url <url>", "Mint URL to use (defaults to the mint URL configured during init)")
+  .action(async (amount: string, options: { mintUrl?: string }) => {
+    await handleDaemonCommand("/receive/bolt11", {
+      method: "POST",
+      body: { amount: parseInt(amount), mintUrl: options.mintUrl },
+    });
+  });
+
+// Send - nested subcommands
+const sendCmd = program.command("send").description("Send operations");
+
+sendCmd
+  .command("cashu <amount>")
+  .description("Create Cashu token to send")
+  .option("--mint-url <url>", "Mint URL to use (defaults to the mint URL configured during init)")
+  .action(async (amount: string, options: { mintUrl?: string }) => {
+    await handleDaemonCommand("/send/cashu", {
+      method: "POST",
+      body: { amount: parseInt(amount), mintUrl: options.mintUrl },
+    });
+  });
+
+sendCmd
+  .command("bolt11 <invoice>")
+  .description("Pay Lightning invoice")
+  .option("--mint-url <url>", "Mint URL to use (defaults to the mint URL configured during init)")
+  .action(async (invoice: string, options: { mintUrl?: string }) => {
+    await handleDaemonCommand("/send/bolt11", {
+      method: "POST",
+      body: { invoice, mintUrl: options.mintUrl },
+    });
+  });
+
+// Ping
+program
+  .command("ping")
+  .description("Test connection to the daemon")
+  .action(async () => {
+    await handleDaemonCommand("/ping");
+  });
+
+// Logs
+program
+  .command("logs")
+  .description("Show daemon logs")
+  .option("--follow", "Stream log updates")
+  .option("--lines <number>", "Number of recent lines to show", String(DEFAULT_LOG_LINES))
+  .option("--path", "Print the resolved log file path")
+  .action(async (options: { follow?: boolean; lines?: string; path?: boolean }) => {
+    try {
+      if (options.path) {
+        console.log(LOG_FILE);
+        return;
+      }
+
+      const lineCount = parseLogLineCount(options.lines ?? String(DEFAULT_LOG_LINES));
+      const fileExists = await Bun.file(LOG_FILE).exists();
+      const startPosition = fileExists ? await getLogFileSize(LOG_FILE) : 0;
+
+      if (!fileExists && !options.follow) {
+        throw new Error(`Log file not found: ${LOG_FILE}`);
+      }
+
+      if (fileExists) {
+        const recentLogs = await readRecentLogText(LOG_FILE, lineCount);
+
+        if (recentLogs.length > 0) {
+          process.stdout.write(recentLogs);
+        }
+      }
+
+      if (options.follow) {
+        await followLogFile(
+          LOG_FILE,
+          (chunk) => {
+            process.stdout.write(chunk);
+          },
+          { startPosition },
+        );
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(message);
+      process.exit(1);
+    }
+  });
+
+// Stop
+program
+  .command("stop")
+  .description("Stop the background daemon")
+  .action(async () => {
+    await handleDaemonCommand("/stop", { method: "POST" });
+  });
+
+// Mints - nested subcommands
+const mintsCmd = program.command("mints").description("Mints operations");
+
+mintsCmd
+  .command("add <url>")
+  .description("Add a mint URL")
+  .action(async (url: string) => {
+    await handleDaemonCommand("/mints/add", {
+      method: "POST",
+      body: { url },
+    });
+  });
+
+mintsCmd
+  .command("list")
+  .description("List configured mints")
+  .action(async () => {
+    await handleDaemonCommand("/mints/list");
+  });
+
+mintsCmd
+  .command("info <url>")
+  .description("Get mint info")
+  .action(async (url: string) => {
+    await handleDaemonCommand("/mints/info", {
+      method: "POST",
+      body: { url },
+    });
+  });
+
+// NPC - nested subcommands
+const npcCmd = program.command("npc").description("NPC operations");
+
+npcCmd
+  .command("address")
+  .description("Get NPC user address")
+  .action(async () => {
+    await handleDaemonCommand("/npc/address");
+  });
+
+npcCmd
+  .command("username <name>")
+  .description("Buy/set NPC username")
+  .option("--confirm", "Confirm payment to set username")
+  .action(async (name: string, options: { confirm?: boolean }) => {
+    await handleDaemonCommand("/npc/username", {
+      method: "POST",
+      body: {
+        username: name,
+        confirm: options.confirm,
+      },
+    });
+  });
+
+// x-cashu - nested subcommands
+const xCashuCmd = program.command("x-cashu").description("x-cashu operations");
+
+xCashuCmd
+  .command("parse <request>")
+  .description("Parse x-cashu request")
+  .action(async (request: string) => {
+    await handleDaemonCommand("/x-cashu/parse", {
+      method: "POST",
+      body: { request },
+    });
+  });
+
+xCashuCmd
+  .command("handle <request>")
+  .description("Handle x-cashu request. Returns a X-Cashu header")
+  .action(async (request: string) => {
+    await handleDaemonCommand("/x-cashu/handle", {
+      method: "POST",
+      body: { request },
+    });
+  });
+
+// History - with pagination and watch options
+program
+  .command("history")
+  .description("Wallet history operations")
+  .option("--offset <number>", "Pagination offset (cannot be combined with --watch)", "0")
+  .option("--limit <number>", "Number of entries to fetch (1-100, default: 20)", "20")
+  .option(
+    "--watch",
+    "Stream history updates in real-time after fetching (can be combined with --limit)",
+  )
+  .action(async (options: { offset?: string; limit?: string; watch?: boolean }) => {
+    const offset = parseInt(options.offset || "0", 10);
+    const limit = parseInt(options.limit || "20", 10);
+
+    // Validate: offset and watch cannot be combined
+    if (offset > 0 && options.watch) {
+      console.error("Error: --offset cannot be combined with --watch");
+      process.exit(1);
+    }
+
+    // Validate numbers
+    if (isNaN(offset) || offset < 0) {
+      console.error("Error: --offset must be a non-negative number");
+      process.exit(1);
+    }
+
+    if (isNaN(limit) || limit < 1 || limit > 100) {
+      console.error("Error: --limit must be between 1 and 100");
+      process.exit(1);
+    }
+
+    // Fetch paginated history first (pass params as query string, not body)
+    const queryParams = new URLSearchParams();
+    queryParams.set("offset", offset.toString());
+    queryParams.set("limit", limit.toString());
+    const path = `/history?${queryParams.toString()}`;
+
+    await handleDaemonCommand(path);
+
+    // If watch is enabled, continue streaming after initial fetch
+    if (options.watch) {
+      try {
+        await callDaemonStream("/events", (data) => {
+          console.log(JSON.stringify(data));
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+      }
+    }
+  });
+
+// Daemon command - special case, doesn't go through IPC
+program
+  .command("daemon")
+  .description("Start the background daemon")
+  .action(async () => {
+    await startDaemon();
+  });
+
+export function cli(args: string[]) {
+  program.parse(args);
+}

package/src/daemon.ts

@@ -0,0 +1,184 @@
+import { mnemonicToSeedSync } from "@scure/bip39";
+import { unlink } from "node:fs/promises";
+import { CONFIG_FILE, SOCKET_PATH, PID_FILE } from "./utils/config.js";
+import { createDaemonLogger, serializeError } from "./utils/logger.js";
+import { DaemonStateManager } from "./utils/state.js";
+import { initializeWallet } from "./utils/wallet.js";
+import { createRouteHandlers, buildRoutes } from "./routes.js";
+import type { WalletConfig } from "./utils/config.js";
+
+export async function startDaemon() {
+  const stateManager = new DaemonStateManager();
+  const logger = createDaemonLogger();
+
+  logger.info("daemon.start.requested", {
+    pidFile: PID_FILE,
+    socketPath: SOCKET_PATH,
+  });
+
+  try {
+    const testConn = await Bun.connect({
+      unix: SOCKET_PATH,
+      socket: {
+        data() {},
+        open() {},
+        close() {},
+        drain() {},
+      },
+    });
+    testConn.end();
+    logger.warn("daemon.start.skipped", {
+      reason: "already_running",
+      socketPath: SOCKET_PATH,
+    });
+    await logger.flush();
+    console.error(`Error: Daemon is already running on ${SOCKET_PATH}`);
+    process.exit(1);
+  } catch {
+    // Not running, safe to proceed
+  }
+
+  try {
+    await Bun.write(PID_FILE, "");
+    await unlink(PID_FILE);
+  } catch {
+    // Directory creation failed or file didn't exist
+  }
+
+  try {
+    await unlink(SOCKET_PATH);
+  } catch {
+    // File might not exist
+  }
+  try {
+    await unlink(PID_FILE);
+  } catch {
+    // File might not exist
+  }
+
+  await Bun.write(PID_FILE, process.pid.toString());
+
+  try {
+    const configExists = await Bun.file(CONFIG_FILE).exists();
+    if (configExists) {
+      const configText = await Bun.file(CONFIG_FILE).text();
+      const config: WalletConfig = JSON.parse(configText);
+
+      if (config.encrypted) {
+        stateManager.setLocked(config.mnemonic, config.mintUrl);
+        logger.info("wallet.config_loaded", {
+          encrypted: true,
+          mintUrl: config.mintUrl,
+          state: "LOCKED",
+        });
+      } else {
+        const manager = await initializeWallet(
+          config,
+          undefined,
+          logger.child({ component: "wallet" }),
+        );
+        const seed = mnemonicToSeedSync(config.mnemonic);
+        stateManager.setUnlocked(manager, config.mintUrl, seed);
+        logger.info("wallet.config_loaded", {
+          encrypted: false,
+          mintUrl: config.mintUrl,
+          state: "UNLOCKED",
+        });
+      }
+    } else {
+      logger.info("wallet.config_missing");
+    }
+  } catch (error) {
+    logger.warn("wallet.config_load_failed", { error: serializeError(error) });
+    stateManager.setError(String(error));
+  }
+
+  const routeHandlers = createRouteHandlers(stateManager, logger.child({ component: "wallet" }));
+  const routes = buildRoutes(
+    routeHandlers,
+    () => stateManager.getState(),
+    logger.child({
+      component: "http",
+    }),
+  );
+
+  let server: ReturnType<typeof Bun.serve> | undefined;
+  let isShuttingDown = false;
+
+  const cleanup = async (reason: string) => {
+    if (isShuttingDown) {
+      return;
+    }
+
+    isShuttingDown = true;
+    logger.info("daemon.shutdown.requested", { reason });
+
+    server?.stop();
+
+    try {
+      await unlink(PID_FILE);
+    } catch {
+      // File might not exist
+    }
+
+    logger.info("daemon.shutdown.completed", { reason });
+    await logger.flush();
+    process.exit(0);
+  };
+
+  server = Bun.serve({
+    unix: SOCKET_PATH,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const path = url.pathname;
+      const method = req.method;
+
+      // Stop endpoint (special daemon control)
+      if (path === "/stop" && method === "POST") {
+        logger.info("daemon.stop_requested", { reason: "http_stop" });
+        setTimeout(() => {
+          void cleanup("http_stop");
+        }, 100);
+        return Response.json({ output: "Daemon stopping" });
+      }
+
+      // Look up route in the built routes table
+      const route = routes[path];
+      if (route) {
+        const handler = method === "GET" ? route.GET : method === "POST" ? route.POST : undefined;
+        if (handler) {
+          return handler(req);
+        }
+      }
+
+      logger.warn("request.unknown_endpoint", {
+        method,
+        url: req.url,
+      });
+      return Response.json({ error: `Unknown endpoint: ${method} ${path}` }, { status: 404 });
+    },
+  });
+
+  logger.info("daemon.started", { socketPath: SOCKET_PATH });
+  if (stateManager.isUninitialized()) {
+    logger.info("wallet.uninitialized");
+  }
+
+  process.on("unhandledRejection", (error) => {
+    logger.error("daemon.unhandled_rejection", { error: serializeError(error) });
+  });
+
+  process.on("uncaughtException", (error) => {
+    logger.error("daemon.uncaught_exception", { error: serializeError(error) });
+    void logger.flush().finally(() => {
+      process.exit(1);
+    });
+  });
+
+  process.on("SIGINT", () => {
+    void cleanup("sigint");
+  });
+  process.on("SIGTERM", () => {
+    void cleanup("sigterm");
+  });
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { cli } from "./cli";
+
+cli(process.argv);