routstrd 0.2.15 → 0.2.17

package/src/daemon/models.ts

@@ -1,4 +1,4 @@
-import { ModelManager } from "@routstr/sdk";
+import { ModelManager, type SdkStore } from "@routstr/sdk";
 import type { ExposedModel } from "./types";
 import { logger } from "../utils/logger";
 
@@ -16,7 +16,7 @@ export type ModelWithProviders = ExposedModel & {
   providers: ModelProviderInfo[];
 };
 
-export function createModelService(modelManager: ModelManager) {
+export function createModelService(modelManager: ModelManager, store: SdkStore) {
   let providerBootstrapPromise: Promise<void> | null = null;
 
   const ensureProvidersBootstrapped = (): Promise<void> => {
@@ -26,6 +26,22 @@ export function createModelService(modelManager: ModelManager) {
         const providers = await modelManager.bootstrapProviders(false);
         logger.log(`Bootstrapped ${providers.length} providers`);
         await modelManager.fetchModels(providers);
+
+        // Sync discovered providers into the store so `providers list` reflects
+        // the same set that the model manager knows about.
+        const { baseUrlsList, setBaseUrlsList } = store.getState();
+        const existing = new Set(baseUrlsList);
+        const merged = [
+          ...baseUrlsList,
+          ...providers.filter((url) => !existing.has(url)),
+        ];
+        if (merged.length !== baseUrlsList.length) {
+          setBaseUrlsList(merged);
+          logger.log(
+            `Synced ${merged.length - baseUrlsList.length} new provider(s) into store`,
+          );
+        }
+
         logger.log("Provider bootstrap complete.");
       })().catch((error) => {
         logger.error("Provider bootstrap failed:", error);

package/src/integrations/hermes.ts

@@ -0,0 +1,87 @@
+import { existsSync, mkdirSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+import type { RoutstrdConfig } from "../utils/config";
+import { logger } from "../utils/logger";
+import type { IntegrationConfig, RoutstrModel } from "./registry";
+import { callDaemon, getDaemonBaseUrl } from "../utils/daemon-client";
+
+export async function installHermesIntegration(
+  config: RoutstrdConfig,
+  apiKey: string,
+  integrationConfig: IntegrationConfig,
+): Promise<void> {
+  const { name, configPath } = integrationConfig;
+
+  logger.log(`\nInstalling routstr configuration in ${configPath}...`);
+  logger.log(`Using API key for ${name}`);
+
+  const baseUrl = getDaemonBaseUrl(config);
+  const baseUrlV1 = `${baseUrl}/v1`;
+
+  let defaultModel = "minimax-m2.7";
+
+  try {
+    const data = await callDaemon("/models");
+    const models = (data.output as { models: RoutstrModel[] } | undefined)?.models || [];
+
+    if (models.length >= 3) {
+      defaultModel = models[2]!.id;
+      logger.log(`Set default model to 3rd available model: ${defaultModel}`);
+    } else if (models.length > 0) {
+      defaultModel = models[0]!.id;
+      logger.log(`Only ${models.length} models available, using ${defaultModel} as default.`);
+    } else {
+      logger.log("No models available from routstr daemon, using fallback default.");
+    }
+  } catch (error) {
+    logger.error("Failed to fetch models for Hermes integration:", error);
+    logger.log("Using fallback default model.");
+  }
+
+  let content = "";
+  try {
+    if (existsSync(configPath)) {
+      content = await readFile(configPath, "utf-8");
+    }
+  } catch (error) {
+    logger.error(`Error reading ${configPath}, creating new one.`);
+  }
+
+  // Remove existing model block
+  content = content.replace(/^model:\n(?:  .*\n)*/gm, "");
+  // Remove existing custom_providers block
+  content = content.replace(/^custom_providers:\n(?:- .*\n(?:  .*\n)*)*/gm, "");
+  // Clean up extra blank lines
+  content = content.replace(/\n{3,}/g, "\n\n").trim();
+
+  const urlDisplay = baseUrl.replace(/^https?:\/\//, "");
+
+  const modelBlock = `model:
+  default: ${defaultModel}
+  provider: custom
+  base_url: ${baseUrlV1}
+  api_key: ${apiKey}`;
+
+  const providerBlock = `custom_providers:
+- name: Routstr (${urlDisplay})
+  base_url: ${baseUrlV1}
+  api_key: ${apiKey}
+  model: ${defaultModel}`;
+
+  const parts: string[] = [modelBlock];
+  if (content) {
+    parts.push(content);
+  }
+  parts.push(providerBlock);
+
+  const newContent = parts.join("\n\n") + "\n";
+
+  try {
+    mkdirSync(dirname(configPath), { recursive: true });
+    await writeFile(configPath, newContent);
+    logger.log(`Successfully updated ${configPath} with routstr settings.`);
+  } catch (error) {
+    logger.error(`Failed to write to ${configPath}:`, error);
+  }
+}

package/src/integrations/registry.ts

@@ -4,6 +4,7 @@ import { installOpencodeIntegration } from "./opencode";
 import { installPiIntegration } from "./pi";
 import { installOpenClawIntegration } from "./openclaw";
 import { installClaudeCodeIntegration } from "./claudecode";
+import { installHermesIntegration } from "./hermes";
 
 export interface IntegrationConfig {
   clientId: string;
@@ -43,6 +44,11 @@ export const CLIENT_CONFIGS: Record<string, IntegrationConfig> = {
     name: "Claude Code",
     configPath: join(process.env.HOME || "", ".claude/settings.json"),
   },
+  hermes: {
+    clientId: "hermes",
+    name: "Hermes",
+    configPath: join(process.env.HOME || "", ".hermes/config.yaml"),
+  },
 };
 
 export const CLIENT_INTEGRATIONS: Record<string, IntegrationFn> = {
@@ -50,6 +56,7 @@ export const CLIENT_INTEGRATIONS: Record<string, IntegrationFn> = {
   "pi-agent": installPiIntegration,
   openclaw: installOpenClawIntegration,
   "claude-code": installClaudeCodeIntegration,
+  hermes: installHermesIntegration,
 };
 
 export async function runIntegrationsForClients(

package/src/tui/usage/render.ts

@@ -511,18 +511,21 @@ export function renderRecent(stats: UsageStats, width: number): string {
   const recentEntries = stats.entries.slice(0, 50);
   if (recentEntries.length === 0) return renderBox(["No recent entries"], width, "Recent Requests");
 
+  const clientCol = 10;
   const lines: string[] = [];
-  lines.push(`${COLORS.bold}${"TIME".padEnd(10)} ${"MODEL".padEnd(18)} ${"TOKENS".padEnd(10)} ${"COST".padEnd(12)} ${"PROVIDER".slice(0, Math.max(0, width - 60))}${COLORS.reset}`);
+  lines.push(`${COLORS.bold}${"TIME".padEnd(10)} ${"CLIENT".padEnd(clientCol)} ${"MODEL".padEnd(18)} ${"TOKENS".padEnd(10)} ${"COST".padEnd(12)} ${"PROVIDER".slice(0, Math.max(0, width - 70))}${COLORS.reset}`);
   lines.push(COLORS.dim + "─".repeat(width - 4) + COLORS.reset);
 
   for (const entry of recentEntries) {
     const time = formatTime(entry.timestamp).slice(0, 8);
+    const clientName = (entry.client || "unknown").slice(0, clientCol - 1).padEnd(clientCol);
+    const clientColor = CLIENT_COLORS[entry.client || "unknown"] || CLIENT_COLORS.default || COLORS.white;
     const model = entry.modelId.slice(0, 18).padEnd(18);
     const tokens = `${formatNumber(entry.totalTokens).padEnd(6)} (${formatNumber(entry.promptTokens)}+${formatNumber(entry.completionTokens)})`;
     const cost = `${formatCost(entry.satsCost).padEnd(8)} sats`;
-    const provider = (entry.baseUrl || "unknown").replace("https://", "").replace("http://", "").slice(0, Math.max(0, width - 60));
-    const color = MODEL_COLORS[entry.modelId] || MODEL_COLORS.default;
-    lines.push(`${COLORS.dim}${time}${COLORS.reset} ${color}${model}${COLORS.reset} ${tokens.padEnd(10)} ${COLORS.green}${cost}${COLORS.reset} ${COLORS.dim}${provider}${COLORS.reset}`);
+    const provider = (entry.baseUrl || "unknown").replace("https://", "").replace("http://", "").slice(0, Math.max(0, width - 70));
+    const modelColor = MODEL_COLORS[entry.modelId] || MODEL_COLORS.default;
+    lines.push(`${COLORS.dim}${time}${COLORS.reset} ${clientColor}${clientName}${COLORS.reset} ${modelColor}${model}${COLORS.reset} ${tokens.padEnd(10)} ${COLORS.green}${cost}${COLORS.reset} ${COLORS.dim}${provider}${COLORS.reset}`);
   }
 
   return renderBox(lines, width, `Recent Requests (${stats.entries.length} shown)`);

package/src/utils/clients.ts

@@ -187,6 +187,7 @@ export interface AddClientOptions {
   openclaw?: boolean;
   piAgent?: boolean;
   claudeCode?: boolean;
+  hermes?: boolean;
 }
 
 export async function addClientAction(options: AddClientOptions): Promise<void> {
@@ -198,6 +199,7 @@ export async function addClientAction(options: AddClientOptions): Promise<void>
   if (options.openclaw) integrationKeys.push("openclaw");
   if (options.piAgent) integrationKeys.push("pi-agent");
   if (options.claudeCode) integrationKeys.push("claude-code");
+  if (options.hermes) integrationKeys.push("hermes");
 
   if (integrationKeys.length > 0) {
     for (const key of integrationKeys) {
@@ -233,9 +235,14 @@ export async function addClientAction(options: AddClientOptions): Promise<void>
   }
 
   if (!options.name) {
-    console.error(
-      "error: required option '-n, --name <name>' not specified",
-    );
+    console.error("error: either provide a client name or specify an integration flag.\n");
+    console.error("Options:");
+    console.error("  -n, --name <name>    Client name");
+    console.error("  --opencode           Set up OpenCode integration");
+    console.error("  --openclaw           Set up OpenClaw integration");
+    console.error("  --pi-agent           Set up Pi Agent integration");
+    console.error("  --claude-code        Set up Claude Code integration");
+    console.error("  --hermes             Set up Hermes integration");
     process.exit(1);
   }
 

package/src/utils/daemon-client.ts

@@ -37,7 +37,7 @@ export function getDaemonBaseUrl(config: RoutstrdConfig): string {
 
 export async function callDaemon(
   path: string,
-  options: { method?: "GET" | "POST" | "DELETE"; body?: object } = {},
+  options: { method?: "GET" | "POST" | "PATCH" | "DELETE"; body?: object } = {},
 ): Promise<CommandResponse> {
   const { method = "GET", body } = options;
   const config = await loadConfig();