routstrd 0.2.6 → 0.2.8

package/src/integrations/claudecode.ts

@@ -3,44 +3,20 @@ import { readFile, writeFile } from "fs/promises";
 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";
+import { callDaemon, getDaemonBaseUrl } from "../utils/daemon-client";
 
 export async function installClaudeCodeIntegration(
   config: RoutstrdConfig,
-  store: SdkStore,
+  apiKey: string,
   integrationConfig: IntegrationConfig,
 ): Promise<void> {
-  const { clientId, name, configPath } = integrationConfig;
+  const { name, configPath } = integrationConfig;
 
   logger.log(`\nInstalling routstr configuration in ${configPath}...`);
+  logger.log(`Using API key for ${name}`);
 
-  const port = config.port || 8008;
-
-  // Get or create clientId entry
-  const state = store.getState();
-  const existingClient = (state.clientIds || []).find(
-    (c: { clientId: string }) => c.clientId === clientId,
-  );
-
-  let apiKey: string;
-  if (existingClient) {
-    apiKey = existingClient.apiKey;
-    logger.log(`Using existing API key for ${name}`);
-  } else {
-    apiKey = generateApiKey();
-    store.getState().setClientIds((prev) => [
-      ...(prev || []),
-      {
-        clientId,
-        name,
-        apiKey,
-        createdAt: Date.now(),
-      },
-    ]);
-    logger.log(`Created new API key for ${name}`);
-  }
+  const baseUrl = getDaemonBaseUrl(config);
 
   let settings: {
     env?: Record<string, string>;
@@ -60,23 +36,26 @@ export async function installClaudeCodeIntegration(
   }
 
   settings.env["ANTHROPIC_AUTH_TOKEN"] = apiKey;
-  settings.env["ANTHROPIC_BASE_URL"] = `http://localhost:${port}`;
+  settings.env["ANTHROPIC_BASE_URL"] = baseUrl;
 
   try {
-    const response = await fetch(`http://localhost:${port}/models`);
-    const data = await response.json() as { output?: { models: RoutstrModel[] } };
-    const models = data.output?.models || [];
+    const data = await callDaemon("/models");
+    const models = (data.output as { models: RoutstrModel[] } | undefined)?.models || [];
 
     if (models.length >= 3) {
-      settings.env["ANTHROPIC_DEFAULT_OPUS_MODEL"] = models[0].id;
-      settings.env["ANTHROPIC_DEFAULT_SONNET_MODEL"] = models[1].id;
-      settings.env["ANTHROPIC_DEFAULT_HAIKU_MODEL"] = models[2].id;
-      logger.log(`Set Claude models: Opus=${models[0].id}, Sonnet=${models[1].id}, Haiku=${models[2].id}`);
+      const opus = models[0]!;
+      const sonnet = models[1]!;
+      const haiku = models[2]!;
+      settings.env["ANTHROPIC_DEFAULT_OPUS_MODEL"] = opus.id;
+      settings.env["ANTHROPIC_DEFAULT_SONNET_MODEL"] = sonnet.id;
+      settings.env["ANTHROPIC_DEFAULT_HAIKU_MODEL"] = haiku.id;
+      logger.log(`Set Claude models: Opus=${opus.id}, Sonnet=${sonnet.id}, Haiku=${haiku.id}`);
     } else if (models.length > 0) {
+      const model = models[0]!;
       logger.log(`Only ${models.length} models available, falling back to defaults.`);
-      settings.env["ANTHROPIC_DEFAULT_OPUS_MODEL"] = models[0].id;
-      settings.env["ANTHROPIC_DEFAULT_SONNET_MODEL"] = models[0].id;
-      settings.env["ANTHROPIC_DEFAULT_HAIKU_MODEL"] = models[0].id;
+      settings.env["ANTHROPIC_DEFAULT_OPUS_MODEL"] = model.id;
+      settings.env["ANTHROPIC_DEFAULT_SONNET_MODEL"] = model.id;
+      settings.env["ANTHROPIC_DEFAULT_HAIKU_MODEL"] = model.id;
     } else {
       logger.log("No models available from routstr daemon.");
     }

package/src/integrations/openclaw.ts

@@ -3,9 +3,8 @@ import { readFile, writeFile } from "fs/promises";
 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";
+import { callDaemon, getDaemonBaseUrl } from "../utils/daemon-client";
 
 const OPENCLAW_PROVIDER_ID = "routstr";
 const OPENCLAW_DEFAULT_PRIMARY_MODEL = "routstr/minimax-m2.5";
@@ -52,39 +51,15 @@ function toAlias(modelId: string): string {
 
 export async function installOpenClawIntegration(
   config: RoutstrdConfig,
-  store: SdkStore,
+  apiKey: string,
   integrationConfig: IntegrationConfig,
 ): Promise<void> {
-  const { clientId, name, configPath } = integrationConfig;
+  const { name, configPath } = integrationConfig;
 
   logger.log("\nInstalling routstr models in openclaw.json...");
+  logger.log(`Using API key for ${name}`);
 
-  const port = config.port || 8008;
-
-  // Get or create clientId entry for OpenClaw
-  const state = store.getState();
-  const existingClient = (state.clientIds || []).find(
-    (c: { clientId: string }) => c.clientId === clientId,
-  );
-
-  let apiKey: string;
-  if (existingClient) {
-    apiKey = existingClient.apiKey;
-    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,
-        name,
-        apiKey,
-        createdAt: Date.now(),
-      },
-    ]);
-    logger.log(`Created new API key for ${name}`);
-  }
+  const baseUrl = getDaemonBaseUrl(config);
 
   let openclawConfig: OpenClawConfig = {};
 
@@ -113,9 +88,8 @@ export async function installOpenClawIntegration(
   try {
     mkdirSync(dirname(configPath), { recursive: true });
 
-    const response = await fetch(`http://localhost:${port}/models`);
-    const data = await response.json() as { output?: { models: RoutstrModel[] } };
-    const models = data.output?.models || [];
+    const data = await callDaemon("/models");
+    const models = (data.output as { models: RoutstrModel[] } | undefined)?.models || [];
 
     if (models.length === 0) {
       logger.log("No models found from routstr daemon.");
@@ -129,7 +103,7 @@ export async function installOpenClawIntegration(
     }));
 
     openclawConfig.models.providers[OPENCLAW_PROVIDER_ID] = {
-      baseUrl: `http://localhost:${port}/v1`,
+      baseUrl: `${baseUrl}/v1`,
       apiKey,
       api: "openai-completions",
       models: providerModels,

package/src/integrations/opencode.ts

@@ -3,47 +3,22 @@ import { readFile, writeFile } from "fs/promises";
 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";
+import { callDaemon, getDaemonBaseUrl } from "../utils/daemon-client";
 
 const OPENCODE_SMALL_MODEL = "routstr/minimax-m2.5";
 
 export async function installOpencodeIntegration(
   config: RoutstrdConfig,
-  store: SdkStore,
+  apiKey: string,
   integrationConfig: IntegrationConfig,
 ): Promise<void> {
-  const { clientId, name, configPath } = integrationConfig;
+  const { name, configPath } = integrationConfig;
 
   logger.log("\nInstalling routstr models in opencode.json...");
+  logger.log(`Using API key for ${name}`);
 
-  const port = config.port || 8008;
-
-  // Get or create clientId entry for OpenCode
-  const state = store.getState();
-  const existingClient = (state.clientIds || []).find(
-    (c: { clientId: string }) => c.clientId === clientId,
-  );
-
-  let apiKey: string;
-  if (existingClient) {
-    apiKey = existingClient.apiKey;
-    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,
-        name,
-        apiKey,
-        createdAt: Date.now(),
-      },
-    ]);
-    logger.log(`Created new API key for ${name}`);
-  }
+  const baseUrl = getDaemonBaseUrl(config);
 
   let opencodeConfig: {
     provider?: Record<string, {
@@ -77,9 +52,8 @@ export async function installOpencodeIntegration(
   try {
     mkdirSync(dirname(configPath), { recursive: true });
 
-    const response = await fetch(`http://localhost:${port}/models`);
-    const data = await response.json() as { output?: { models: RoutstrModel[] } };
-    const models = data.output?.models || [];
+    const data = await callDaemon("/models");
+    const models = (data.output as { models: RoutstrModel[] } | undefined)?.models || [];
 
     if (models.length === 0) {
       logger.log("No models found from routstr daemon.");
@@ -95,7 +69,7 @@ export async function installOpencodeIntegration(
       npm: "@ai-sdk/openai-compatible",
       name: "routstr",
       options: {
-        baseURL: `http://localhost:${port}/`,
+        baseURL: `${baseUrl}/`,
         apiKey,
         includeUsage: true,
       },

package/src/integrations/pi.ts

@@ -3,9 +3,8 @@ import { readFile, writeFile } from "fs/promises";
 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";
+import { callDaemon, getDaemonBaseUrl } from "../utils/daemon-client";
 
 type PiModelEntry = {
   id: string;
@@ -24,40 +23,15 @@ type PiConfig = {
 
 export async function installPiIntegration(
   config: RoutstrdConfig,
-  store: SdkStore,
+  apiKey: string,
   integrationConfig: IntegrationConfig,
 ): Promise<void> {
-  const { clientId, name, configPath } = integrationConfig;
+  const { name, configPath } = integrationConfig;
 
   logger.log("\nInstalling routstr models in pi models.json...");
+  logger.log(`Using API key for ${name}`);
 
-  const port = config.port || 8008;
-  const baseUrl = `http://localhost:${port}/v1`;
-
-  // Get or create clientId entry for Pi Agent
-  const state = store.getState();
-  const existingClient = (state.clientIds || []).find(
-    (c: { clientId: string }) => c.clientId === clientId,
-  );
-
-  let apiKey: string;
-  if (existingClient) {
-    apiKey = existingClient.apiKey;
-    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,
-        name,
-        apiKey,
-        createdAt: Date.now(),
-      },
-    ]);
-    logger.log(`Created new API key for ${name}`);
-  }
+  const baseUrl = `${getDaemonBaseUrl(config)}/v1`;
 
   let piConfig: PiConfig = {};
 
@@ -78,9 +52,8 @@ export async function installPiIntegration(
     // Ensure directory exists
     mkdirSync(dirname(configPath), { recursive: true });
 
-    const response = await fetch(`http://localhost:${port}/models`);
-    const data = await response.json() as { output?: { models: RoutstrModel[] } };
-    const models = data.output?.models || [];
+    const data = await callDaemon("/models");
+    const models = (data.output as { models: RoutstrModel[] } | undefined)?.models || [];
 
     if (models.length === 0) {
       logger.log("No models found from routstr daemon.");

package/src/integrations/registry.ts

@@ -1,7 +1,5 @@
-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";
@@ -18,14 +16,9 @@ export type RoutstrModel = {
   name?: string;
 };
 
-export function generateApiKey(): string {
-  const bytes = randomBytes(24);
-  return `sk-${bytes.toString("hex")}`;
-}
-
 export type IntegrationFn = (
   config: RoutstrdConfig,
-  store: SdkStore,
+  apiKey: string,
   integrationConfig: IntegrationConfig,
 ) => Promise<void>;
 
@@ -60,16 +53,15 @@ export const CLIENT_INTEGRATIONS: Record<string, IntegrationFn> = {
 };
 
 export async function runIntegrationsForClients(
-  clientIds: Array<{ clientId: string }>,
+  clientIds: Array<{ clientId: string; apiKey?: 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) {
+    if (integrationFn && integrationConfig && client.apiKey) {
       try {
-        await integrationFn(config, store, integrationConfig);
+        await integrationFn(config, client.apiKey, integrationConfig);
       } catch (error) {
         console.error(`Integration failed for ${client.clientId}:`, error);
       }

package/src/tui/usage/data.ts

@@ -1,5 +1,5 @@
 import type { UsageTrackingEntry } from "../../daemon/types.ts";
-import { callDaemon, isDaemonRunning } from "../../utils/daemon-client.ts";
+import { callDaemon, getNpubSuffix, isDaemonRunning, loadConfig } from "../../utils/daemon-client.ts";
 import type { ClientStats, DayStats, ModelStats, ProviderStats, UsageStats } from "./types.ts";
 
 export interface BalanceKey {
@@ -82,12 +82,24 @@ export async function fetchUsage(limit = 10000): Promise<UsageStats | null> {
     const result = await callDaemon(`/usage?limit=${limit}`);
     if (result.error) return null;
 
-    // The daemon returns { output: [...] } where output is the entries array directly
+    // The daemon returns { output: [...] } where output is the entries array directly.
+    // In remote daemon mode, client IDs are suffixed with the last 7 chars of our npub.
+    // Fetch the full daemon result, but only display/aggregate entries for our clients.
     const entries = result.output as UsageTrackingEntry[] | undefined;
     const entriesArray = Array.isArray(entries) ? entries : [];
-
-    // Calculate totals from entries
-    const totals = entriesArray.reduce(
+    const suffix = getNpubSuffix(await loadConfig());
+    const suffixStr = suffix ? `-${suffix}` : null;
+    const visibleEntries = suffixStr
+      ? entriesArray
+        .filter((entry) => entry.client?.endsWith(suffixStr))
+        .map((entry) => ({
+          ...entry,
+          client: entry.client?.slice(0, -suffixStr.length),
+        }))
+      : entriesArray;
+
+    // Calculate totals from visible entries
+    const totals = visibleEntries.reduce(
       (acc, entry) => ({
         promptTokens: acc.promptTokens + entry.promptTokens,
         completionTokens: acc.completionTokens + entry.completionTokens,
@@ -98,8 +110,8 @@ export async function fetchUsage(limit = 10000): Promise<UsageStats | null> {
     );
 
     return {
-      entries: entriesArray,
-      totalEntries: entriesArray.length,
+      entries: visibleEntries,
+      totalEntries: visibleEntries.length,
       totalSatsCost: totals.satsCost,
       recentSatsCost: totals.satsCost, // For now, recent = total since we don't have time window
       limit,