routstrd 0.1.0 → 0.1.3

package/src/daemon/index.ts

@@ -2,6 +2,7 @@ import { createServer } from "http";
 import { existsSync } from "fs";
 import {
   ModelManager,
+  ProviderManager,
   createDiscoveryAdapterFromStore,
   createProviderRegistryFromStore,
   createStorageAdapterFromStore,
@@ -10,22 +11,17 @@ import {
 import { DB_PATH, SOCKET_PATH, PID_FILE } from "../utils/config";
 import { logger } from "../utils/logger";
 import { parseArgs } from "./args";
-import {
-  ensureDirs,
-  loadDaemonConfig,
-  saveDaemonConfig,
-} from "./config-store";
+import { ensureDirs, loadDaemonConfig, saveDaemonConfig } from "./config-store";
 import {
   createBunSqliteDriver,
   createBunSqliteUsageTrackingDriver,
 } from "@routstr/sdk/storage";
-import {
-  createWalletAdapter,
-  parseBalances,
-  runWalletCommand,
-} from "./wallet";
+import { createWalletAdapter } from "./wallet";
+import { createCocodClient } from "./wallet/cocod-client";
 import { createModelService } from "./models";
 import { createDaemonRequestHandler } from "./http";
+import { runIntegrationsForClients } from "../integrations";
+import { RoutstrClient } from "@routstr/sdk";
 
 async function main(): Promise<void> {
   const args = parseArgs(process.argv);
@@ -52,10 +48,16 @@ async function main(): Promise<void> {
   const providerRegistry = createProviderRegistryFromStore(store);
   const storageAdapter = createStorageAdapterFromStore(store);
   const modelManager = new ModelManager(discoveryAdapter);
+  // Create shared ProviderManager for consistent failure tracking across all requests
+  const providerManager = new ProviderManager(providerRegistry, store);
   const { ensureProvidersBootstrapped, getRoutstr21Models } =
     createModelService(modelManager);
 
-  const walletAdapter = await createWalletAdapter();
+  const walletClient = createCocodClient({ cocodPath: config.cocodPath });
+  const walletAdapter = await createWalletAdapter({
+    cocodPath: config.cocodPath,
+    walletClient,
+  });
 
   const server = createServer();
   server.on(
@@ -64,6 +66,7 @@ async function main(): Promise<void> {
       provider,
       server,
       store,
+      walletClient,
       walletAdapter,
       storageAdapter,
       providerRegistry,
@@ -71,10 +74,9 @@ async function main(): Promise<void> {
       modelManager,
       ensureProvidersBootstrapped,
       getRoutstr21Models,
-      runWalletCommand,
-      parseBalances,
       mode: config.mode || "apikeys",
       usageTrackingDriver,
+      providerManager,
     }),
   );
 
@@ -88,7 +90,7 @@ async function main(): Promise<void> {
     // Ignore
   }
 
-  const REFRESH_INTERVAL_MS = 3.5 * 60 * 60 * 1000; // 3.5 hours
+  const REFRESH_INTERVAL_MS = 21 * 60 * 1000; // 21 mins
 
   // Recurring job to refresh routstr21 models
   let refreshInterval: ReturnType<typeof setInterval> | null = null;
@@ -103,6 +105,15 @@ async function main(): Promise<void> {
       try {
         await getRoutstr21Models(true);
         logger.log("Scheduled model refresh completed successfully.");
+
+        // Refresh integrations for all registered clients
+        const state = store.getState();
+        const clientIds = state.clientIds || [];
+        if (clientIds.length > 0) {
+          logger.log(`Refreshing ${clientIds.length} client integration(s)...`);
+          await runIntegrationsForClients(clientIds, updatedConfig, store);
+          logger.log("Client integrations refreshed.");
+        }
       } catch (error) {
         logger.error("Scheduled model refresh failed:", error);
       }
@@ -117,8 +128,77 @@ async function main(): Promise<void> {
     }
   };
 
+  // Recurring job to refund pending tokens every 10 minutes
+  const REFUND_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
+  let refundInterval: ReturnType<typeof setInterval> | null = null;
+
+  const startRefundJob = async () => {
+    logger.log(
+      `Starting recurring refund job (every ${REFUND_INTERVAL_MS / 1000 / 60} minutes)`,
+    );
+
+    refundInterval = setInterval(async () => {
+      logger.log("Running scheduled refund...");
+      try {
+        const state = store.getState() as any;
+        const pendingDistribution = (state.cachedTokens || []).map(
+          (t: { baseUrl: string; balance?: number }) => ({
+            baseUrl: t.baseUrl,
+            amount: t.balance || 0,
+          }),
+        );
+        const apiKeysStored = (state.apiKeys || []).map(
+          (k: { baseUrl: string; balance?: number }) => ({
+            baseUrl: k.baseUrl,
+            amount: k.balance || 0,
+          }),
+        );
+
+        if (pendingDistribution.length === 0 && apiKeysStored.length === 0) {
+          logger.log("No pending tokens to refund.");
+          return;
+        }
+
+        const mintUrl = walletAdapter.getActiveMintUrl();
+        if (!mintUrl) {
+          logger.log("No active mint URL for refund.");
+          return;
+        }
+
+        const client = new RoutstrClient(
+          walletAdapter,
+          storageAdapter,
+          providerRegistry,
+          "min",
+          "apikeys",
+        );
+
+        const spender = client.getCashuSpender();
+        const results = await spender.refundProviders(mintUrl);
+
+        const successCount = results.filter(
+          (r: { success: boolean }) => r.success,
+        ).length;
+        logger.log(
+          `Scheduled refund completed: ${successCount}/${results.length} providers refunded.`,
+        );
+      } catch (error) {
+        logger.error("Scheduled refund failed:", error);
+      }
+    }, REFUND_INTERVAL_MS);
+  };
+
+  const stopRefundJob = () => {
+    if (refundInterval) {
+      clearInterval(refundInterval);
+      refundInterval = null;
+      logger.log("Stopped recurring refund job.");
+    }
+  };
+
   server.on("close", () => {
     stopModelRefreshJob();
+    stopRefundJob();
   });
 
   server.listen(port, async () => {
@@ -128,17 +208,27 @@ async function main(): Promise<void> {
     void ensureProvidersBootstrapped()
       .then(() => {
         startModelRefreshJob();
+        // startRefundJob(); DISABLING refund job for now.
         // Run an immediate refresh to populate models right away
         logger.log("Running initial model refresh...");
         return getRoutstr21Models(true);
       })
-      .then(() => {
+      .then(async () => {
         logger.log("Initial model refresh completed.");
+        // Refresh integrations for all registered clients after initial bootstrap
+        const state = store.getState();
+        const clientIds = state.clientIds || [];
+        if (clientIds.length > 0) {
+          logger.log(`Refreshing ${clientIds.length} client integration(s)...`);
+          await runIntegrationsForClients(clientIds, updatedConfig, store);
+          logger.log("Client integrations refreshed.");
+        }
       })
       .catch((error) => {
         logger.error("Initial model refresh failed:", error);
-        // Still start the job even if initial refresh fails
+        // Still start the jobs even if initial refresh fails
         startModelRefreshJob();
+        // startRefundJob(); DISABLING refund job for now.
       });
   });
 }

package/src/daemon/wallet/cocod-client.ts

@@ -0,0 +1,340 @@
+import { existsSync } from "fs";
+import { createHash } from "crypto";
+import { logger } from "../../utils/logger";
+
+const DEFAULT_CONFIG_DIR = `${process.env.HOME || process.env.USERPROFILE || ""}/.cocod`;
+const DEFAULT_SOCKET_PATH =
+  process.env.COCOD_SOCKET || `${DEFAULT_CONFIG_DIR}/cocod.sock`;
+
+type UnixRequestInit = RequestInit & { unix: string };
+
+type CommandResponse<T> = {
+  output?: T;
+  error?: string;
+};
+
+type CocodFetch = (
+  input: string | URL | Request,
+  init?: UnixRequestInit,
+) => Promise<Response>;
+
+type SpawnedProcess = {
+  exited: Promise<number>;
+  unref?: () => void;
+};
+
+type SpawnDaemon = (
+  args: string[],
+  env: Record<string, string>,
+) => SpawnedProcess;
+
+export type CocodState = "UNINITIALIZED" | "LOCKED" | "UNLOCKED" | "ERROR";
+
+export type CocodBalanceOutput = Record<string, { sats?: number } | number>;
+
+export class CocodHttpError extends Error {
+  status: number;
+
+  constructor(status: number, message: string) {
+    super(message);
+    this.name = "CocodHttpError";
+    this.status = status;
+  }
+}
+
+export interface CocodClient {
+  ping(): Promise<boolean>;
+  getStatus(): Promise<CocodState>;
+  unlock(passphrase: string): Promise<string>;
+  getBalances(): Promise<Record<string, number>>;
+  receiveCashu(token: string): Promise<string>;
+  receiveBolt11(amount: number, mintUrl?: string): Promise<string>;
+  sendCashu(amount: number, mintUrl?: string): Promise<string>;
+  sendBolt11(invoice: string, mintUrl?: string): Promise<string>;
+  listMints(): Promise<string[]>;
+  addMint(url: string): Promise<string>;
+  getMintInfo(url: string): Promise<unknown>;
+}
+
+export function resolveCocodExecutable(cocodPath?: string | null): string {
+  const trimmed = cocodPath?.trim();
+  return trimmed || "cocod";
+}
+
+export async function isCocodInstalled(
+  cocodPath?: string | null,
+): Promise<boolean> {
+  const executable = resolveCocodExecutable(cocodPath);
+
+  if (executable.includes("/")) {
+    return existsSync(executable);
+  }
+
+  try {
+    const proc = Bun.spawn({
+      cmd: ["which", executable],
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    return (await proc.exited) === 0;
+  } catch {
+    return false;
+  }
+}
+
+export function normalizeBalances(
+  output: CocodBalanceOutput | undefined,
+): Record<string, number> {
+  if (!output) return {};
+
+  return Object.fromEntries(
+    Object.entries(output).map(([mintUrl, value]) => {
+      if (typeof value === "number") {
+        return [mintUrl, value];
+      }
+      return [mintUrl, Number(value?.sats ?? 0)];
+    }),
+  );
+}
+
+function parseMintList(output: string | undefined): string[] {
+  return (output || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function toErrorText(value: unknown): string {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (value === null || value === undefined) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function tokenFingerprint(token: string): string {
+  return createHash("sha256").update(token).digest("hex").slice(0, 12);
+}
+
+export function createCocodClient(
+  options: {
+    cocodPath?: string | null;
+    socketPath?: string;
+    fetchImpl?: CocodFetch;
+    spawnDaemon?: SpawnDaemon;
+    pollIntervalMs?: number;
+    startupTimeoutMs?: number;
+  } = {},
+): CocodClient {
+  const executable = resolveCocodExecutable(options.cocodPath);
+  const socketPath = options.socketPath || DEFAULT_SOCKET_PATH;
+  const fetchImpl = options.fetchImpl || (fetch as CocodFetch);
+  const pollIntervalMs = options.pollIntervalMs ?? 100;
+  const startupTimeoutMs = options.startupTimeoutMs ?? 5000;
+
+  const spawnDaemon: SpawnDaemon =
+    options.spawnDaemon ||
+    ((args, env) => {
+      const proc = Bun.spawn(args, {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore",
+        detached: true,
+        env,
+      });
+      proc.unref();
+      return proc;
+    });
+
+  let startPromise: Promise<void> | null = null;
+
+  async function fetchJson<T>(
+    path: string,
+    init: Omit<UnixRequestInit, "unix"> = {},
+  ): Promise<CommandResponse<T>> {
+    const method = init.method || "GET";
+    const requestInit: UnixRequestInit = {
+      ...init,
+      unix: socketPath,
+    };
+
+    const response = await fetchImpl(`http://localhost${path}`, requestInit);
+    const rawText = await response.text();
+    // logger.debug(
+    //   `[fetchJson] ${method} ${path} status=${response.status} body=${rawText}`,
+    // );
+
+    if (!rawText.trim()) {
+      throw new CocodHttpError(
+        response.ok ? 502 : response.status,
+        `Empty response from cocod for ${method} ${path}`,
+      );
+    }
+
+    let data: CommandResponse<T>;
+    try {
+      data = JSON.parse(rawText) as CommandResponse<T>;
+    } catch {
+      throw new CocodHttpError(
+        response.ok ? 502 : response.status,
+        `Invalid JSON response from cocod for ${method} ${path}`,
+      );
+    }
+
+    if (!data || typeof data !== "object") {
+      throw new CocodHttpError(
+        response.ok ? 502 : response.status,
+        `Unexpected response shape from cocod for ${method} ${path}`,
+      );
+    }
+
+    const errorMessage = toErrorText((data as CommandResponse<T>).error);
+    if (errorMessage) {
+      throw new CocodHttpError(
+        response.ok ? 400 : response.status,
+        errorMessage,
+      );
+    }
+
+    if (!response.ok) {
+      throw new CocodHttpError(
+        response.status,
+        data.error || response.statusText || `HTTP ${response.status}`,
+      );
+    }
+
+    return data;
+  }
+
+  async function pingInternal(): Promise<boolean> {
+    try {
+      await fetchJson<string>("/ping");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async function startDaemon(): Promise<void> {
+    const env = { ...process.env, COCOD_SOCKET: socketPath };
+    const proc = spawnDaemon([executable, "daemon"], env);
+    const maxPolls = Math.ceil(startupTimeoutMs / pollIntervalMs);
+    let exitCode: number | null = null;
+
+    void proc.exited.then((code) => {
+      exitCode = code;
+    });
+
+    for (let i = 0; i < maxPolls; i++) {
+      await delay(pollIntervalMs);
+
+      if (exitCode !== null) {
+        throw new Error(`cocod daemon exited early with code ${exitCode}`);
+      }
+
+      if (await pingInternal()) {
+        logger.debug(`Connected to cocod daemon on ${socketPath}`);
+        return;
+      }
+    }
+
+    throw new Error(
+      `cocod daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds`,
+    );
+  }
+
+  async function ensureDaemonRunning(): Promise<void> {
+    if (await pingInternal()) {
+      return;
+    }
+
+    if (!startPromise) {
+      logger.debug(`Starting cocod daemon via ${executable}...`);
+      startPromise = startDaemon().finally(() => {
+        startPromise = null;
+      });
+    }
+
+    await startPromise;
+  }
+
+  async function callDaemon<T>(
+    path: string,
+    init: Omit<UnixRequestInit, "unix"> = {},
+  ): Promise<T> {
+    await ensureDaemonRunning();
+    const response = await fetchJson<T>(path, init);
+    return response.output as T;
+  }
+
+  function post<T>(path: string, body: Record<string, unknown>): Promise<T> {
+    return callDaemon<T>(path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+  }
+
+  return {
+    async ping(): Promise<boolean> {
+      return pingInternal();
+    },
+    async getStatus(): Promise<CocodState> {
+      return callDaemon<CocodState>("/status");
+    },
+    async unlock(passphrase: string): Promise<string> {
+      return post<string>("/unlock", { passphrase });
+    },
+    async getBalances(): Promise<Record<string, number>> {
+      const output = await callDaemon<CocodBalanceOutput>("/balance");
+      return normalizeBalances(output);
+    },
+    async receiveCashu(token: string): Promise<string> {
+      logger.debug(
+        `[receiveCashu] Receiving Cashu token ${tokenFingerprint(token)}`,
+      );
+      const message = await callDaemon<string>("/receive/cashu", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token }),
+      });
+      if (typeof message !== "string" || !message.trim()) {
+        throw new CocodHttpError(
+          502,
+          "Unexpected response from cocod while receiving Cashu token.",
+        );
+      }
+      logger.debug(`[receiveCashu] Full response.output:`, message);
+      return message;
+    },
+    async receiveBolt11(amount: number, mintUrl?: string): Promise<string> {
+      return post<string>("/receive/bolt11", { amount, mintUrl });
+    },
+    async sendCashu(amount: number, mintUrl?: string): Promise<string> {
+      return post<string>("/send/cashu", { amount, mintUrl });
+    },
+    async sendBolt11(invoice: string, mintUrl?: string): Promise<string> {
+      return post<string>("/send/bolt11", { invoice, mintUrl });
+    },
+    async listMints(): Promise<string[]> {
+      const output = await callDaemon<string>("/mints/list");
+      return parseMintList(output);
+    },
+    async addMint(url: string): Promise<string> {
+      return post<string>("/mints/add", { url });
+    },
+    async getMintInfo(url: string): Promise<unknown> {
+      return post<unknown>("/mints/info", { url });
+    },
+  };
+}