cocod 0.0.1

package/src/cli-shared.ts

@@ -0,0 +1,163 @@
+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.error(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);
+    }
+    throw error;
+  }
+}
+
+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,188 @@
+import { startDaemon } from "./daemon";
+import { program, handleDaemonCommand, callDaemonStream } from "./cli-shared";
+
+program.name("cocod").description("Coco CLI - A Cashu wallet daemon");
+
+// 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")
+  .action(async (mnemonic: string | undefined, options: { passphrase?: string }) => {
+    await handleDaemonCommand("/init", {
+      method: "POST",
+      body: {
+        mnemonic,
+        passphrase: options.passphrase,
+      },
+    });
+  });
+
+// 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 - POST command with argument
+program
+  .command("receive <token>")
+  .description("Receive Cashu token")
+  .action(async (token: string) => {
+    await handleDaemonCommand("/receive", {
+      method: "POST",
+      body: { token },
+    });
+  });
+
+// Ping
+program
+  .command("ping")
+  .description("Test connection to the daemon")
+  .action(async () => {
+    await handleDaemonCommand("/ping");
+  });
+
+// 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 },
+    });
+  });
+
+mintsCmd
+  .command("bolt11 <amount>")
+  .description("Create Lightning invoice to mint tokens")
+  .action(async (amount: string) => {
+    await handleDaemonCommand("/mints/bolt11", {
+      method: "POST",
+      body: { amount: parseInt(amount) },
+    });
+  });
+
+// 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");
+  });
+
+// 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,115 @@
+import { mnemonicToSeedSync } from "@scure/bip39";
+import { CONFIG_FILE, SOCKET_PATH, PID_FILE } from "./utils/config.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();
+
+  try {
+    const testConn = await Bun.connect({
+      unix: SOCKET_PATH,
+      socket: {
+        data() {},
+        open() {},
+        close() {},
+        drain() {},
+      },
+    });
+    testConn.end();
+    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 Bun.file(PID_FILE).delete();
+  } catch {
+    // Directory creation failed or file didn't exist
+  }
+
+  try {
+    await Bun.file(SOCKET_PATH).delete();
+  } catch {
+    // File might not exist
+  }
+  try {
+    await Bun.file(PID_FILE).delete();
+  } 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);
+        console.log("Wallet locked. Run 'cocod unlock <passphrase>' to decrypt.");
+      } else {
+        const manager = await initializeWallet(config);
+        const seed = mnemonicToSeedSync(config.mnemonic);
+        stateManager.setUnlocked(manager, config.mintUrl, seed);
+        console.log("Wallet auto-initialized (unencrypted).");
+      }
+    }
+  } catch (error) {
+    console.warn("Failed to load existing config:", error);
+    stateManager.setError(String(error));
+  }
+
+  const routeHandlers = createRouteHandlers(stateManager);
+  const routes = buildRoutes(routeHandlers, () => stateManager.getState());
+
+  const server = Bun.serve({
+    unix: SOCKET_PATH,
+    routes: {
+      ...routes,
+      "/stop": {
+        POST: async () => {
+          console.log("\nShutting down daemon...");
+          setTimeout(async () => {
+            server.stop();
+            try {
+              await Bun.file(PID_FILE).delete();
+            } catch {
+              // File might not exist
+            }
+            process.exit(0);
+          }, 100);
+          return Response.json({ output: "Daemon stopping" });
+        },
+      },
+    },
+    async fetch(req) {
+      return Response.json({ error: `Unknown endpoint: ${req.url}` }, { status: 404 });
+    },
+  });
+
+  console.log(`Daemon listening on ${SOCKET_PATH}`);
+  if (stateManager.isUninitialized()) {
+    console.log("Wallet not initialized. Run 'cocod init [mnemonic]' to set up.");
+  }
+
+  const cleanup = async () => {
+    console.log("\nShutting down daemon...");
+    server.stop();
+    try {
+      await Bun.file(PID_FILE).delete();
+    } catch {
+      // File might not exist
+    }
+    process.exit(0);
+  };
+
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}

package/src/index.ts

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