routstrd 0.2.6 → 0.2.8

package/src/daemon/index.ts

@@ -1,242 +0,0 @@
-import { createServer } from "http";
-import { existsSync } from "fs";
-import {
-  ModelManager,
-  ProviderManager,
-  createDiscoveryAdapterFromStore,
-  createProviderRegistryFromStore,
-  createStorageAdapterFromStore,
-  createSdkStore,
-} from "@routstr/sdk";
-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 {
-  createBunSqliteDriver,
-  createBunSqliteUsageTrackingDriver,
-} from "@routstr/sdk/storage";
-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);
-  const config = await loadDaemonConfig();
-
-  const port = args.port;
-  const provider = args.provider || config.provider;
-
-  await ensureDirs();
-
-  const updatedConfig = { ...config, port, provider };
-  saveDaemonConfig(updatedConfig);
-
-  const sqliteDriver = await createBunSqliteDriver(DB_PATH);
-  const { store } = await createSdkStore({ driver: sqliteDriver });
-  const { Database } = await import("bun:sqlite");
-  const usageTrackingDriver = createBunSqliteUsageTrackingDriver({
-    dbPath: DB_PATH,
-    sqlite: { Database },
-    legacyStorageDriver: sqliteDriver,
-  });
-
-  const discoveryAdapter = createDiscoveryAdapterFromStore(store);
-  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, getModelProviders } =
-    createModelService(modelManager);
-
-  const walletClient = createCocodClient({ cocodPath: config.cocodPath });
-  const walletAdapter = await createWalletAdapter({
-    cocodPath: config.cocodPath,
-    walletClient,
-  });
-
-  const server = createServer();
-  server.on(
-    "request",
-    createDaemonRequestHandler({
-      provider,
-      server,
-      store,
-      walletClient,
-      walletAdapter,
-      storageAdapter,
-      providerRegistry,
-      discoveryAdapter,
-      modelManager,
-      ensureProvidersBootstrapped,
-      getRoutstr21Models,
-      getModelProviders,
-      mode: config.mode || "apikeys",
-      usageTrackingDriver,
-      providerManager,
-    }),
-  );
-
-  Bun.write(PID_FILE, String(process.pid));
-
-  try {
-    if (existsSync(SOCKET_PATH)) {
-      Bun.spawn(["rm", SOCKET_PATH]);
-    }
-  } catch {
-    // Ignore
-  }
-
-  const REFRESH_INTERVAL_MS = 21 * 60 * 1000; // 21 mins
-
-  // Recurring job to refresh routstr21 models
-  let refreshInterval: ReturnType<typeof setInterval> | null = null;
-
-  const startModelRefreshJob = () => {
-    logger.log(
-      `Starting recurring model refresh job (every ${REFRESH_INTERVAL_MS / 1000 / 60 / 60} hours)`,
-    );
-
-    refreshInterval = setInterval(async () => {
-      logger.log("Running scheduled model refresh...");
-      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);
-      }
-    }, REFRESH_INTERVAL_MS);
-  };
-
-  const stopModelRefreshJob = () => {
-    if (refreshInterval) {
-      clearInterval(refreshInterval);
-      refreshInterval = null;
-      logger.log("Stopped recurring model refresh job.");
-    }
-  };
-
-  // Recurring job to refund pending tokens every 42 minutes
-  const REFUND_INTERVAL_MS = 42 * 60 * 1000; // 42 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 () => {
-    logger.log(`Routstr daemon listening on http://localhost:${port}/v1`);
-
-    // Start the recurring model refresh job after initial bootstrap
-    void ensureProvidersBootstrapped()
-      .then(() => {
-        startModelRefreshJob();
-        startRefundJob(); 
-        // Run an immediate refresh to populate models right away
-        logger.log("Running initial model refresh...");
-        return getRoutstr21Models(true);
-      })
-      .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 jobs even if initial refresh fails
-        startModelRefreshJob();
-        startRefundJob(); 
-      });
-  });
-}
-
-if (import.meta.main) {
-  main().catch((error) => {
-    logger.error("Failed to start Routstr daemon:", error);
-    process.exit(1);
-  });
-}

package/src/daemon/wallet/index.ts

@@ -1,122 +0,0 @@
-import { getDecodedToken } from "@cashu/cashu-ts";
-import { logger } from "../../utils/logger";
-import { createCocodClient, type CocodClient } from "./cocod-client";
-
-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 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"> = {};
-
-  async function syncMintState(
-    balances?: Record<string, number>,
-  ): Promise<Record<string, number>> {
-    const nextBalances = balances || (await client.getBalances());
-
-    mintUnits = Object.fromEntries(
-      Object.keys(nextBalances).map((mintUrl) => [mintUrl, "sat"]),
-    );
-
-    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;
-      }
-    }
-
-    return nextBalances;
-  }
-
-  const walletAdapter = {
-    async getBalances(): Promise<Record<string, number>> {
-      return syncMintState();
-    },
-    getMintUnits(): Record<string, "sat" | "msat"> {
-      return mintUnits;
-    },
-    getActiveMintUrl(): string | null {
-      return activeMintUrl;
-    },
-    async sendToken(mintUrl: string, amount: number): Promise<string> {
-      const maxRetries = 3;
-      const retryDelayMs = 5000;
-      const retryErrorPattern = "Proof already reserved by operation";
-
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-          return await client.sendCashu(amount, mintUrl);
-        } catch (error) {
-          const errorMessage =
-            error instanceof Error ? error.message : String(error);
-
-          const shouldRetry =
-            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));
-            continue;
-          }
-
-          logger.error("Error in walletAdapter sendToken:", error);
-          throw error;
-        }
-      }
-
-      throw new Error("sendToken failed after max retries");
-    },
-    async receiveToken(token: string): Promise<{
-      success: boolean;
-      amount: number;
-      unit: "sat" | "msat";
-      message?: string;
-    }> {
-      try {
-        const message = await client.receiveCashu(token);
-        const { amount, unit } = decodeCashuTokenAmount(token);
-        return { success: true, amount, unit, message };
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error ? error.message : String(error);
-        logger.error("Error in walletAdapter receiveToken:", errorMessage);
-        return { success: false, amount: 0, unit: "sat", message: errorMessage };
-      }
-    },
-  };
-
-  try {
-    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 initialize wallet adapter state:", error);
-  }
-
-  return walletAdapter;
-}

package/src/index.ts

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

package/src/integrations/index.ts

@@ -1,76 +0,0 @@
-import type { RoutstrdConfig } from "../utils/config";
-import { logger } from "../utils/logger";
-import { installOpencodeIntegration } from "./opencode";
-import { installOpenClawIntegration } from "./openclaw";
-import { installPiIntegration } from "./pi";
-import { installClaudeCodeIntegration } from "./claudecode";
-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);
-
-  if (!process.stdin.isTTY) {
-    return Promise.resolve("1");
-  }
-
-  return new Promise((resolve) => {
-    process.stdin.resume();
-    process.stdin.setEncoding("utf8");
-    process.stdin.once("data", (data) => {
-      process.stdin.pause();
-      resolve(data.toString().trim());
-    });
-  });
-}
-
-function parseChoice(input: string): number {
-  if (input === "") {
-    return 1;
-  }
-
-  const parsed = Number.parseInt(input, 10);
-  if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 5) {
-    return parsed;
-  }
-
-  return 1;
-}
-
-export async function setupIntegration(
-  config: RoutstrdConfig,
-  store: SdkStore,
-): Promise<void> {
-  logger.log("\nChoose an integration to set up:");
-  logger.log("1. OpenCode (default)");
-  logger.log("2. OpenClaw");
-  logger.log("3. Pi");
-  logger.log("4. Claude Code");
-  logger.log("5. Skip for now");
-
-  const answer = await ask("Select integration [1]: ");
-  const choice = parseChoice(answer);
-
-  if (choice === 1) {
-    await installOpencodeIntegration(config, store, CLIENT_CONFIGS.opencode!);
-    return;
-  }
-
-  if (choice === 2) {
-    await installOpenClawIntegration(config, store, CLIENT_CONFIGS.openclaw!);
-    return;
-  }
-
-  if (choice === 3) {
-    await installPiIntegration(config, store, CLIENT_CONFIGS["pi-agent"]!);
-    return;
-  }
-
-  if (choice === 4) {
-    await installClaudeCodeIntegration(config, store, CLIENT_CONFIGS["claude-code"]!);
-    return;
-  }
-
-  logger.log("Skipping integration setup.");
-}

package/src/tui/usage/index.ts

@@ -1 +0,0 @@
-export { runUsageTui } from "./app.ts";