routstrd 0.1.0

package/src/daemon/index.ts

@@ -0,0 +1,151 @@
+import { createServer } from "http";
+import { existsSync } from "fs";
+import {
+  ModelManager,
+  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,
+  parseBalances,
+  runWalletCommand,
+} from "./wallet";
+import { createModelService } from "./models";
+import { createDaemonRequestHandler } from "./http";
+
+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);
+  const { ensureProvidersBootstrapped, getRoutstr21Models } =
+    createModelService(modelManager);
+
+  const walletAdapter = await createWalletAdapter();
+
+  const server = createServer();
+  server.on(
+    "request",
+    createDaemonRequestHandler({
+      provider,
+      server,
+      store,
+      walletAdapter,
+      storageAdapter,
+      providerRegistry,
+      discoveryAdapter,
+      modelManager,
+      ensureProvidersBootstrapped,
+      getRoutstr21Models,
+      runWalletCommand,
+      parseBalances,
+      mode: config.mode || "apikeys",
+      usageTrackingDriver,
+    }),
+  );
+
+  Bun.write(PID_FILE, String(process.pid));
+
+  try {
+    if (existsSync(SOCKET_PATH)) {
+      Bun.spawn(["rm", SOCKET_PATH]);
+    }
+  } catch {
+    // Ignore
+  }
+
+  const REFRESH_INTERVAL_MS = 3.5 * 60 * 60 * 1000; // 3.5 hours
+
+  // 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.");
+      } 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.");
+    }
+  };
+
+  server.on("close", () => {
+    stopModelRefreshJob();
+  });
+
+  server.listen(port, async () => {
+    logger.log(`Routstr daemon listening on http://localhost:${port}`);
+
+    // Start the recurring model refresh job after initial bootstrap
+    void ensureProvidersBootstrapped()
+      .then(() => {
+        startModelRefreshJob();
+        // Run an immediate refresh to populate models right away
+        logger.log("Running initial model refresh...");
+        return getRoutstr21Models(true);
+      })
+      .then(() => {
+        logger.log("Initial model refresh completed.");
+      })
+      .catch((error) => {
+        logger.error("Initial model refresh failed:", error);
+        // Still start the job even if initial refresh fails
+        startModelRefreshJob();
+      });
+  });
+}
+
+if (import.meta.main) {
+  main().catch((error) => {
+    logger.error("Failed to start Routstr daemon:", error);
+    process.exit(1);
+  });
+}

package/src/daemon/models.ts

@@ -0,0 +1,49 @@
+import { ModelManager } from "@routstr/sdk";
+import type { ExposedModel } from "./types";
+import { logger } from "../utils/logger";
+
+export function createModelService(modelManager: ModelManager) {
+  let providerBootstrapPromise: Promise<void> | null = null;
+
+  const ensureProvidersBootstrapped = (): Promise<void> => {
+    if (!providerBootstrapPromise) {
+      providerBootstrapPromise = (async () => {
+        logger.log("Bootstrapping providers...");
+        const providers = await modelManager.bootstrapProviders(false);
+        logger.log(`Bootstrapped ${providers.length} providers`);
+        await modelManager.fetchModels(providers);
+        logger.log("Provider bootstrap complete.");
+      })().catch((error) => {
+        logger.error("Provider bootstrap failed:", error);
+        throw error;
+      });
+    }
+    return providerBootstrapPromise;
+  };
+
+  const getRoutstr21Models = async (
+    forceRefresh = false,
+  ): Promise<ExposedModel[]> => {
+    await ensureProvidersBootstrapped();
+
+    const routstr21ModelIds = Array.from(
+      new Set(await modelManager.fetchRoutstr21Models(forceRefresh)),
+    ).slice(0, 21);
+    const baseUrls = modelManager.getBaseUrls();
+    const discoveredModels = await modelManager.fetchModels(
+      baseUrls,
+      forceRefresh,
+    );
+    const modelsById = new Map(discoveredModels.map((model) => [model.id, model]));
+
+    return routstr21ModelIds.map((modelId) => {
+      const model = modelsById.get(modelId);
+      return model || { id: modelId, name: modelId };
+    });
+  };
+
+  return {
+    ensureProvidersBootstrapped,
+    getRoutstr21Models,
+  };
+}

package/src/daemon/sse.ts

@@ -0,0 +1,98 @@
+import { Transform } from "stream";
+import type { UsageData } from "./types";
+
+export function createSSEParserTransform(
+  onUsage: (usage: UsageData) => void,
+  onResponseId?: (responseId: string) => void,
+): Transform {
+  let buffer = "";
+
+  const maybeCaptureUsageFromJson = (jsonText: string): void => {
+    try {
+      const data = JSON.parse(jsonText) as any;
+      const responseId = data.id;
+      if (typeof responseId === "string" && responseId.trim().length > 0) {
+        onResponseId?.(responseId.trim());
+      }
+
+      if (data.usage) {
+        const usageCost = data.usage.cost;
+        const cost =
+          typeof usageCost === "number"
+            ? usageCost
+            : usageCost?.total_usd ??
+              data.metadata?.routstr?.cost?.total_usd ??
+              0;
+        const msats =
+          data.metadata?.routstr?.cost?.total_msats ??
+          (typeof data.usage.cost_sats === "number"
+            ? data.usage.cost_sats * 1000
+            : 0);
+        onUsage({
+          promptTokens: data.usage.prompt_tokens ?? 0,
+          completionTokens: data.usage.completion_tokens ?? 0,
+          totalTokens: data.usage.total_tokens ?? 0,
+          cost,
+          satsCost: msats / 1000,
+        });
+      }
+    } catch {
+      // Ignore non-JSON lines/events.
+    }
+  };
+
+  const processLine = (self: Transform, line: string): void => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return;
+    }
+
+    if (trimmed === "data: [DONE]" || trimmed === "[DONE]") {
+      self.push("data: [DONE]\n\n");
+      return;
+    }
+
+    if (trimmed.startsWith("data:")) {
+      const dataStr = trimmed.startsWith("data: ")
+        ? trimmed.slice(6)
+        : trimmed.slice(5).trimStart();
+      if (dataStr === "[DONE]") {
+        self.push("data: [DONE]\n\n");
+        return;
+      }
+      maybeCaptureUsageFromJson(dataStr);
+      self.push(`data: ${dataStr}\n\n`);
+      return;
+    }
+
+    if (trimmed.startsWith("{")) {
+      maybeCaptureUsageFromJson(trimmed);
+      self.push(`data: ${trimmed}\n\n`);
+      return;
+    }
+
+    self.push(line + "\n");
+  };
+
+  return new Transform({
+    transform(chunk, encoding, callback) {
+      buffer += chunk.toString();
+
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        processLine(this, line);
+      }
+
+      callback();
+    },
+    flush(callback) {
+      if (buffer.trim()) {
+        processLine(this, buffer);
+      }
+      buffer = "";
+      callback();
+    },
+  });
+}

package/src/daemon/types.ts

@@ -0,0 +1,25 @@
+export type ExposedModel = {
+  id: string;
+  name?: string;
+  description?: string;
+  context_length?: number;
+};
+
+export type UsageData = {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  cost: number;
+  satsCost: number;
+};
+
+export type UsageTrackingEntry = UsageData & {
+  id: string;
+  timestamp: number;
+  modelId: string;
+  baseUrl: string;
+  requestId: string;
+  client?: string;
+  sessionId?: string;
+  tags?: string[];
+};

package/src/daemon/wallet/index.ts

@@ -0,0 +1,207 @@
+import { spawn } from "child_process";
+import { getDecodedToken } from "@cashu/cashu-ts";
+import { logger } from "../../utils/logger";
+
+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 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.
+  }
+
+  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;
+}
+
+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),
+    );
+}
+
+export function pickTokenLine(output: string): string {
+  const lines = output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return lines[lines.length - 1] || "";
+}
+
+export async function createWalletAdapter() {
+  let activeMintUrl: string | null = null;
+  let mintUnits: Record<string, "sat" | "msat"> = {};
+
+  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;
+    },
+    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 {
+          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;
+        } 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 {
+        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 };
+      } 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 };
+      }
+    },
+    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;
+  } catch (error) {
+    logger.error("Failed to read mints from wallet:", error);
+  }
+
+  return walletAdapter;
+}

package/src/daemon.ts

@@ -0,0 +1 @@
+export * from "./daemon/index";

package/src/index.ts

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

package/src/integrations/index.ts

@@ -0,0 +1,67 @@
+import type { RoutstrdConfig } from "../utils/config";
+import { logger } from "../utils/logger";
+import { installOpencodeIntegration } from "./opencode";
+import { installOpenClawIntegration } from "./openclaw";
+import { installPiIntegration } from "./pi";
+import type { SdkStore } from "@routstr/sdk";
+
+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 <= 4) {
+    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. Skip for now");
+
+  const answer = await ask("Select integration [1]: ");
+  const choice = parseChoice(answer);
+
+  if (choice === 1) {
+    await installOpencodeIntegration(config, store);
+    return;
+  }
+
+  if (choice === 2) {
+    await installOpenClawIntegration(config, store);
+    return;
+  }
+
+  if (choice === 3) {
+    await installPiIntegration(config, store);
+    return;
+  }
+
+  logger.log("Skipping integration setup.");
+}