routstrd 0.1.1 → 0.1.3

package/src/daemon/wallet/index.ts

@@ -1,119 +1,54 @@
-import { spawn } from "child_process";
 import { getDecodedToken } from "@cashu/cashu-ts";
 import { logger } from "../../utils/logger";
+import { createCocodClient, type CocodClient } from "./cocod-client";
 
-export async function runWalletCommand(args: string[]): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const child = spawn("cocod", args, {
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (error) => reject(error));
-    child.on("close", (code) => {
-      if (code && code !== 0) {
-        reject(
-          new Error(stderr.trim() || stdout.trim() || "Wallet CLI failed"),
-        );
-        return;
-      }
-      resolve(stdout.trim());
-    });
-  });
+export function decodeCashuTokenAmount(token: string): {
+  amount: number;
+  unit: "sat" | "msat";
+} {
+  const decoded = getDecodedToken(token);
+  const amount =
+    decoded?.proofs?.reduce((sum, proof) => sum + proof.amount, 0) ?? 0;
+  const unit = decoded?.unit === "msat" ? "msat" : "sat";
+  return { amount, unit };
 }
 
-export function parseBalances(output: string): Record<string, number> {
-  const trimmed = output.trim();
-  if (!trimmed) return {};
-
-  try {
-    const parsed = JSON.parse(trimmed) as Record<
-      string,
-      { sats?: number } | number
-    >;
-    if (parsed && typeof parsed === "object") {
-      return Object.fromEntries(
-        Object.entries(parsed).map(([mintUrl, value]) => {
-          if (typeof value === "number") {
-            return [mintUrl, value];
-          }
-          if (value && typeof value === "object" && "sats" in value) {
-            return [mintUrl, Number(value.sats ?? 0)];
-          }
-          return [mintUrl, 0];
-        }),
-      );
-    }
-  } catch {
-    // Fall back to line parsing.
-  }
+export async function createWalletAdapter(
+  options: {
+    cocodPath?: string | null;
+    walletClient?: CocodClient;
+  } = {},
+) {
+  const client =
+    options.walletClient || createCocodClient({ cocodPath: options.cocodPath });
+  let activeMintUrl: string | null = null;
+  let mintUnits: Record<string, "sat" | "msat"> = {};
 
-  const balances: Record<string, number> = {};
-  trimmed
-    .split("\n")
-    .map((line) => line.trim())
-    .forEach((line) => {
-      const match = line.match(/^(\S+):\s+(\d+)\s+s$/);
-      const mintUrl = match?.[1];
-      const amount = match?.[2];
-      if (mintUrl && amount) {
-        balances[mintUrl] = Number.parseInt(amount, 10);
-      }
-    });
-  return balances;
-}
+  async function syncMintState(
+    balances?: Record<string, number>,
+  ): Promise<Record<string, number>> {
+    const nextBalances = balances || (await client.getBalances());
 
-export function parseMints(
-  output: string,
-): Array<{ url: string; trusted: boolean }> {
-  return output
-    .split("\n")
-    .map((line) => line.trim())
-    .map((line) => {
-      const urlMatch = line.match(/https?:\/\/\S+/i);
-      if (!urlMatch) return null;
-      const trustedMatch = line.match(/trusted:\s*(true|false)/i);
-      const trustedValue = trustedMatch?.[1];
-      return {
-        url: urlMatch[0],
-        trusted: trustedMatch ? trustedValue?.toLowerCase() === "true" : false,
-      };
-    })
-    .filter((entry): entry is { url: string; trusted: boolean } =>
-      Boolean(entry),
+    mintUnits = Object.fromEntries(
+      Object.keys(nextBalances).map((mintUrl) => [mintUrl, "sat"]),
     );
-}
 
-export function pickTokenLine(output: string): string {
-  const lines = output
-    .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean);
-  return lines[lines.length - 1] || "";
-}
+    try {
+      const mints = await client.listMints();
+      activeMintUrl = mints[0] || Object.keys(nextBalances)[0] || null;
+    } catch (error) {
+      logger.error("Failed to list cocod mints:", error);
+      if (!activeMintUrl) {
+        activeMintUrl = Object.keys(nextBalances)[0] || null;
+      }
+    }
 
-export async function createWalletAdapter() {
-  let activeMintUrl: string | null = null;
-  let mintUnits: Record<string, "sat" | "msat"> = {};
+    return nextBalances;
+  }
 
   const walletAdapter = {
     async getBalances(): Promise<Record<string, number>> {
-      const output = await runWalletCommand(["balance"]);
-      const balances = parseBalances(output);
-      mintUnits = Object.fromEntries(
-        Object.keys(balances).map((mintUrl) => [mintUrl, "sat"]),
-      );
-      if (!activeMintUrl) {
-        activeMintUrl = Object.keys(balances)[0] || null;
-      }
-      return balances;
+      return syncMintState();
     },
     getMintUnits(): Record<string, "sat" | "msat"> {
       return mintUnits;
@@ -128,33 +63,19 @@ export async function createWalletAdapter() {
 
       for (let attempt = 0; attempt <= maxRetries; attempt++) {
         try {
-          const output = await runWalletCommand([
-            "send",
-            "cashu",
-            String(amount),
-            "--mint-url",
-            mintUrl,
-          ]);
-          const token = pickTokenLine(output);
-          if (!token) {
-            throw new Error("Wallet CLI did not return a token.");
-          }
-          return token;
+          return await client.sendCashu(amount, mintUrl);
         } catch (error) {
           const errorMessage =
             error instanceof Error ? error.message : String(error);
 
           const shouldRetry =
-            attempt < maxRetries &&
-            errorMessage.includes(retryErrorPattern);
+            attempt < maxRetries && errorMessage.includes(retryErrorPattern);
 
           if (shouldRetry) {
             logger.log(
               `sendToken attempt ${attempt + 1} failed with reserved proof error, retrying in ${retryDelayMs / 1000}s...`,
             );
-            await new Promise((resolve) =>
-              setTimeout(resolve, retryDelayMs),
-            );
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
             continue;
           }
 
@@ -162,6 +83,7 @@ export async function createWalletAdapter() {
           throw error;
         }
       }
+
       throw new Error("sendToken failed after max retries");
     },
     async receiveToken(token: string): Promise<{
@@ -171,36 +93,29 @@ export async function createWalletAdapter() {
       message?: string;
     }> {
       try {
-        await runWalletCommand(["receive", "cashu", token]);
-        const decoded = getDecodedToken(token);
-        const amount = decoded?.proofs?.reduce(
-          (sum, proof) => sum + proof.amount,
-          0,
-        );
-        const unit = decoded?.unit === "msat" ? "msat" : "sat";
-        return { success: true, amount: amount ?? 0, unit };
+        const message = await client.receiveCashu(token);
+        const { amount, unit } = decodeCashuTokenAmount(token);
+        return { success: true, amount, unit, message };
       } catch (error) {
-        console.log("Eerro in receive", error);
         const errorMessage =
           error instanceof Error ? error.message : String(error);
-        const message = errorMessage.includes("Failed to fetch mint")
-          ? errorMessage
-          : undefined;
-        return { success: false, amount: 0, unit: "sat", message };
+        logger.error("Error in walletAdapter receiveToken:", error);
+        return { success: false, amount: 0, unit: "sat", message: errorMessage };
       }
     },
-    isUsingNip60(): boolean {
-      return false;
-    },
   };
 
   try {
-    const mintsOutput = await runWalletCommand(["mints", "list"]);
-    const mints = parseMints(mintsOutput);
-    activeMintUrl =
-      mints.find((mint) => mint.trusted)?.url || mints[0]?.url || null;
+    const [balances, mints] = await Promise.all([
+      client.getBalances(),
+      client.listMints().catch(() => []),
+    ]);
+    mintUnits = Object.fromEntries(
+      Object.keys(balances).map((mintUrl) => [mintUrl, "sat"]),
+    );
+    activeMintUrl = mints[0] || Object.keys(balances)[0] || null;
   } catch (error) {
-    logger.error("Failed to read mints from wallet:", error);
+    logger.error("Failed to initialize wallet adapter state:", error);
   }
 
   return walletAdapter;

package/src/integrations/index.ts

@@ -4,6 +4,8 @@ import { installOpencodeIntegration } from "./opencode";
 import { installOpenClawIntegration } from "./openclaw";
 import { installPiIntegration } from "./pi";
 import type { SdkStore } from "@routstr/sdk";
+import { CLIENT_CONFIGS } from "./registry";
+export { CLIENT_INTEGRATIONS, CLIENT_CONFIGS, runIntegrationsForClients } from "./registry";
 
 function ask(question: string): Promise<string> {
   process.stdout.write(question);
@@ -49,17 +51,17 @@ export async function setupIntegration(
   const choice = parseChoice(answer);
 
   if (choice === 1) {
-    await installOpencodeIntegration(config, store);
+    await installOpencodeIntegration(config, store, CLIENT_CONFIGS.opencode!);
     return;
   }
 
   if (choice === 2) {
-    await installOpenClawIntegration(config, store);
+    await installOpenClawIntegration(config, store, CLIENT_CONFIGS.openclaw!);
     return;
   }
 
   if (choice === 3) {
-    await installPiIntegration(config, store);
+    await installPiIntegration(config, store, CLIENT_CONFIGS["pi-agent"]!);
     return;
   }
 

package/src/integrations/openclaw.ts

@@ -1,23 +1,15 @@
-import { randomBytes } from "crypto";
 import { existsSync, mkdirSync } from "fs";
 import { readFile, writeFile } from "fs/promises";
-import { dirname, join } from "path";
+import { dirname } from "path";
 import type { RoutstrdConfig } from "../utils/config";
 import { logger } from "../utils/logger";
 import type { SdkStore } from "@routstr/sdk";
+import type { IntegrationConfig, RoutstrModel } from "./registry";
+import { generateApiKey } from "./registry";
 
-const OPENCLAW_CONFIG_PATH = join(process.env.HOME || "", ".openclaw/openclaw.json");
 const OPENCLAW_PROVIDER_ID = "routstr";
-const OPENCLAW_API_BASE = "http://localhost:8008/v1";
 const OPENCLAW_DEFAULT_PRIMARY_MODEL = "routstr/minimax-m2.5";
 const OPENCLAW_DEFAULT_FALLBACK_MODEL = "routstr/kimi-k2.5";
-const OPENCLAW_CLIENT_ID = "openclaw";
-const OPENCLAW_NAME = "OpenClaw";
-
-type RoutstrModel = {
-  id: string;
-  name?: string;
-};
 
 type OpenClawModelEntry = {
   id: string;
@@ -58,15 +50,13 @@ function toAlias(modelId: string): string {
   return modelId;
 }
 
-function generateApiKey(): string {
-  const bytes = randomBytes(24);
-  return `sk-${bytes.toString("hex")}`;
-}
-
 export async function installOpenClawIntegration(
   config: RoutstrdConfig,
   store: SdkStore,
+  integrationConfig: IntegrationConfig,
 ): Promise<void> {
+  const { clientId, name, configPath } = integrationConfig;
+
   logger.log("\nInstalling routstr models in openclaw.json...");
 
   const port = config.port || 8008;
@@ -74,33 +64,33 @@ export async function installOpenClawIntegration(
   // Get or create clientId entry for OpenClaw
   const state = store.getState();
   const existingClient = (state.clientIds || []).find(
-    (c: { clientId: string }) => c.clientId === OPENCLAW_CLIENT_ID,
+    (c: { clientId: string }) => c.clientId === clientId,
   );
 
   let apiKey: string;
   if (existingClient) {
     apiKey = existingClient.apiKey;
-    logger.log(`Using existing API key for ${OPENCLAW_NAME}`);
+    logger.log(`Using existing API key for ${name}`);
   } else {
     apiKey = generateApiKey();
     // Add new clientId entry using proper store action
     store.getState().setClientIds((prev) => [
       ...(prev || []),
       {
-        clientId: OPENCLAW_CLIENT_ID,
-        name: OPENCLAW_NAME,
+        clientId,
+        name,
         apiKey,
         createdAt: Date.now(),
       },
     ]);
-    logger.log(`Created new API key for ${OPENCLAW_NAME}`);
+    logger.log(`Created new API key for ${name}`);
   }
 
   let openclawConfig: OpenClawConfig = {};
 
   try {
-    if (existsSync(OPENCLAW_CONFIG_PATH)) {
-      const content = await readFile(OPENCLAW_CONFIG_PATH, "utf-8");
+    if (existsSync(configPath)) {
+      const content = await readFile(configPath, "utf-8");
       openclawConfig = JSON.parse(content) as OpenClawConfig;
     }
   } catch {
@@ -121,7 +111,7 @@ export async function installOpenClawIntegration(
   }
 
   try {
-    mkdirSync(dirname(OPENCLAW_CONFIG_PATH), { recursive: true });
+    mkdirSync(dirname(configPath), { recursive: true });
 
     const response = await fetch(`http://localhost:${port}/models`);
     const data = await response.json() as { output?: { models: RoutstrModel[] } };
@@ -139,7 +129,7 @@ export async function installOpenClawIntegration(
     }));
 
     openclawConfig.models.providers[OPENCLAW_PROVIDER_ID] = {
-      baseUrl: OPENCLAW_API_BASE,
+      baseUrl: `http://localhost:${port}/v1`,
       apiKey,
       api: "openai-completions",
       models: providerModels,
@@ -169,7 +159,7 @@ export async function installOpenClawIntegration(
     // }
     // openclawConfig.agents.defaults.models = aliasMap;
 
-    await writeFile(OPENCLAW_CONFIG_PATH, JSON.stringify(openclawConfig, null, 2));
+    await writeFile(configPath, JSON.stringify(openclawConfig, null, 2));
     logger.log(`Added "${OPENCLAW_PROVIDER_ID}" provider with ${models.length} models to openclaw.json`);
   } catch (error) {
     logger.error("Failed to install models in openclaw.json:", error);

package/src/integrations/opencode.ts

@@ -1,30 +1,21 @@
-import { randomBytes } from "crypto";
 import { existsSync, mkdirSync } from "fs";
 import { readFile, writeFile } from "fs/promises";
-import { dirname, join } from "path";
+import { dirname } from "path";
 import type { RoutstrdConfig } from "../utils/config";
 import { logger } from "../utils/logger";
 import type { SdkStore } from "@routstr/sdk";
+import type { IntegrationConfig, RoutstrModel } from "./registry";
+import { generateApiKey } from "./registry";
 
-const OPENCODE_CONFIG_PATH = join(process.env.HOME || "", ".config/opencode/opencode.json");
 const OPENCODE_SMALL_MODEL = "routstr/minimax-m2.5";
-const OPENCODE_CLIENT_ID = "opencode";
-const OPENCODE_NAME = "OpenCode";
-
-type RoutstrModel = {
-  id: string;
-  name?: string;
-};
-
-function generateApiKey(): string {
-  const bytes = randomBytes(24);
-  return `sk-${bytes.toString("hex")}`;
-}
 
 export async function installOpencodeIntegration(
   config: RoutstrdConfig,
   store: SdkStore,
+  integrationConfig: IntegrationConfig,
 ): Promise<void> {
+  const { clientId, name, configPath } = integrationConfig;
+
   logger.log("\nInstalling routstr models in opencode.json...");
 
   const port = config.port || 8008;
@@ -32,26 +23,26 @@ export async function installOpencodeIntegration(
   // Get or create clientId entry for OpenCode
   const state = store.getState();
   const existingClient = (state.clientIds || []).find(
-    (c: { clientId: string }) => c.clientId === OPENCODE_CLIENT_ID,
+    (c: { clientId: string }) => c.clientId === clientId,
   );
 
   let apiKey: string;
   if (existingClient) {
     apiKey = existingClient.apiKey;
-    logger.log(`Using existing API key for ${OPENCODE_NAME}`);
+    logger.log(`Using existing API key for ${name}`);
   } else {
     apiKey = generateApiKey();
     // Add new clientId entry using proper store action
     store.getState().setClientIds((prev) => [
       ...(prev || []),
       {
-        clientId: OPENCODE_CLIENT_ID,
-        name: OPENCODE_NAME,
+        clientId,
+        name,
         apiKey,
         createdAt: Date.now(),
       },
     ]);
-    logger.log(`Created new API key for ${OPENCODE_NAME}`);
+    logger.log(`Created new API key for ${name}`);
   }
 
   let opencodeConfig: {
@@ -69,8 +60,8 @@ export async function installOpencodeIntegration(
   };
 
   try {
-    if (existsSync(OPENCODE_CONFIG_PATH)) {
-      const content = await readFile(OPENCODE_CONFIG_PATH, "utf-8");
+    if (existsSync(configPath)) {
+      const content = await readFile(configPath, "utf-8");
       opencodeConfig = JSON.parse(content);
     } else {
       opencodeConfig = { provider: {} };
@@ -84,7 +75,7 @@ export async function installOpencodeIntegration(
   }
 
   try {
-    mkdirSync(dirname(OPENCODE_CONFIG_PATH), { recursive: true });
+    mkdirSync(dirname(configPath), { recursive: true });
 
     const response = await fetch(`http://localhost:${port}/models`);
     const data = await response.json() as { output?: { models: RoutstrModel[] } };
@@ -112,7 +103,7 @@ export async function installOpencodeIntegration(
     };
     opencodeConfig.small_model = OPENCODE_SMALL_MODEL;
 
-    await writeFile(OPENCODE_CONFIG_PATH, JSON.stringify(opencodeConfig, null, 2));
+    await writeFile(configPath, JSON.stringify(opencodeConfig, null, 2));
     logger.log(`Added "routstr" provider with ${models.length} models to opencode.json`);
   } catch (error) {
     logger.error("Failed to install models in opencode.json:", error);

package/src/integrations/pi.ts

@@ -1,19 +1,11 @@
-import { randomBytes } from "crypto";
 import { existsSync, mkdirSync } from "fs";
 import { readFile, writeFile } from "fs/promises";
-import { dirname, join } from "path";
+import { dirname } from "path";
 import type { RoutstrdConfig } from "../utils/config";
 import { logger } from "../utils/logger";
 import type { SdkStore } from "@routstr/sdk";
-
-const PI_CONFIG_PATH = join(process.env.HOME || "", ".pi/agent/models.json");
-const PI_CLIENT_ID = "pi-agent";
-const PI_NAME = "Pi Agent";
-
-type RoutstrModel = {
-  id: string;
-  name?: string;
-};
+import type { IntegrationConfig, RoutstrModel } from "./registry";
+import { generateApiKey } from "./registry";
 
 type PiModelEntry = {
   id: string;
@@ -30,15 +22,13 @@ type PiConfig = {
   providers?: Record<string, PiProviderConfig>;
 };
 
-function generateApiKey(): string {
-  const bytes = randomBytes(24);
-  return `sk-${bytes.toString("hex")}`;
-}
-
 export async function installPiIntegration(
   config: RoutstrdConfig,
   store: SdkStore,
+  integrationConfig: IntegrationConfig,
 ): Promise<void> {
+  const { clientId, name, configPath } = integrationConfig;
+
   logger.log("\nInstalling routstr models in pi models.json...");
 
   const port = config.port || 8008;
@@ -47,33 +37,33 @@ export async function installPiIntegration(
   // Get or create clientId entry for Pi Agent
   const state = store.getState();
   const existingClient = (state.clientIds || []).find(
-    (c: { clientId: string }) => c.clientId === PI_CLIENT_ID,
+    (c: { clientId: string }) => c.clientId === clientId,
   );
 
   let apiKey: string;
   if (existingClient) {
     apiKey = existingClient.apiKey;
-    logger.log(`Using existing API key for ${PI_NAME}`);
+    logger.log(`Using existing API key for ${name}`);
   } else {
     apiKey = generateApiKey();
     // Add new clientId entry using proper store action
     store.getState().setClientIds((prev) => [
       ...(prev || []),
       {
-        clientId: PI_CLIENT_ID,
-        name: PI_NAME,
+        clientId,
+        name,
         apiKey,
         createdAt: Date.now(),
       },
     ]);
-    logger.log(`Created new API key for ${PI_NAME}`);
+    logger.log(`Created new API key for ${name}`);
   }
 
   let piConfig: PiConfig = {};
 
   try {
-    if (existsSync(PI_CONFIG_PATH)) {
-      const content = await readFile(PI_CONFIG_PATH, "utf-8");
+    if (existsSync(configPath)) {
+      const content = await readFile(configPath, "utf-8");
       piConfig = JSON.parse(content) as PiConfig;
     }
   } catch {
@@ -86,7 +76,7 @@ export async function installPiIntegration(
 
   try {
     // Ensure directory exists
-    mkdirSync(dirname(PI_CONFIG_PATH), { recursive: true });
+    mkdirSync(dirname(configPath), { recursive: true });
 
     const response = await fetch(`http://localhost:${port}/models`);
     const data = await response.json() as { output?: { models: RoutstrModel[] } };
@@ -108,7 +98,7 @@ export async function installPiIntegration(
       models: providerModels,
     };
 
-    await writeFile(PI_CONFIG_PATH, JSON.stringify(piConfig, null, 2));
+    await writeFile(configPath, JSON.stringify(piConfig, null, 2));
     logger.log(`Added "routstr" provider with ${models.length} models to pi models.json`);
   } catch (error) {
     logger.error("Failed to install models in pi models.json:", error);

package/src/integrations/registry.ts

@@ -0,0 +1,71 @@
+import { randomBytes } from "crypto";
+import { join } from "path";
+import type { RoutstrdConfig } from "../utils/config";
+import type { SdkStore } from "@routstr/sdk";
+import { installOpencodeIntegration } from "./opencode";
+import { installPiIntegration } from "./pi";
+import { installOpenClawIntegration } from "./openclaw";
+
+export interface IntegrationConfig {
+  clientId: string;
+  name: string;
+  configPath: string;
+}
+
+export type RoutstrModel = {
+  id: string;
+  name?: string;
+};
+
+export function generateApiKey(): string {
+  const bytes = randomBytes(24);
+  return `sk-${bytes.toString("hex")}`;
+}
+
+export type IntegrationFn = (
+  config: RoutstrdConfig,
+  store: SdkStore,
+  integrationConfig: IntegrationConfig,
+) => Promise<void>;
+
+export const CLIENT_CONFIGS: Record<string, IntegrationConfig> = {
+  opencode: {
+    clientId: "opencode",
+    name: "OpenCode",
+    configPath: join(process.env.HOME || "", ".config/opencode/opencode.json"),
+  },
+  "pi-agent": {
+    clientId: "pi-agent",
+    name: "Pi Agent",
+    configPath: join(process.env.HOME || "", ".pi/agent/models.json"),
+  },
+  openclaw: {
+    clientId: "openclaw",
+    name: "OpenClaw",
+    configPath: join(process.env.HOME || "", ".openclaw/openclaw.json"),
+  },
+};
+
+export const CLIENT_INTEGRATIONS: Record<string, IntegrationFn> = {
+  opencode: installOpencodeIntegration,
+  "pi-agent": installPiIntegration,
+  openclaw: installOpenClawIntegration,
+};
+
+export async function runIntegrationsForClients(
+  clientIds: Array<{ clientId: string }>,
+  config: RoutstrdConfig,
+  store: SdkStore,
+): Promise<void> {
+  for (const client of clientIds) {
+    const integrationFn = CLIENT_INTEGRATIONS[client.clientId];
+    const integrationConfig = CLIENT_CONFIGS[client.clientId];
+    if (integrationFn && integrationConfig) {
+      try {
+        await integrationFn(config, store, integrationConfig);
+      } catch (error) {
+        console.error(`Integration failed for ${client.clientId}:`, error);
+      }
+    }
+  }
+}