routstrd 0.2.6 → 0.2.9

package/src/daemon/wallet/cocod-client.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "fs";
 import { createHash } from "crypto";
 import { logger } from "../../utils/logger";
+import { withCrossProcessLock } from "../../utils/process-lock";
 
 const DEFAULT_CONFIG_DIR =
   process.env.COCOD_DIR || `${process.env.HOME || process.env.USERPROFILE || ""}/.cocod`;
@@ -139,6 +140,7 @@ export function createCocodClient(
 ): CocodClient {
   const executable = resolveCocodExecutable(options.cocodPath);
   const socketPath = options.socketPath || DEFAULT_SOCKET_PATH;
+  const startupLockPath = `${socketPath}.startup.lock`;
   const fetchImpl = options.fetchImpl || (fetch as CocodFetch);
   const pollIntervalMs = options.pollIntervalMs ?? 100;
   const startupTimeoutMs = options.startupTimeoutMs ?? 5000;
@@ -228,7 +230,7 @@ export function createCocodClient(
 
   async function startDaemon(): Promise<void> {
     const env = { ...process.env, COCOD_SOCKET: socketPath };
-    const proc = spawnDaemon([executable, "daemon"], env);
+    const proc = spawnDaemon([executable, "init"], env);
     const maxPolls = Math.ceil(startupTimeoutMs / pollIntervalMs);
     let exitCode: number | null = null;
 
@@ -239,8 +241,8 @@ export function createCocodClient(
     for (let i = 0; i < maxPolls; i++) {
       await delay(pollIntervalMs);
 
-      if (exitCode !== null) {
-        throw new Error(`cocod daemon exited early with code ${exitCode}`);
+      if (exitCode !== null && exitCode !== 0) {
+        throw new Error(`cocod init exited early with code ${exitCode}`);
       }
 
       if (await pingInternal()) {
@@ -250,7 +252,7 @@ export function createCocodClient(
     }
 
     throw new Error(
-      `cocod daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds`,
+      `cocod failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds`,
     );
   }
 
@@ -260,8 +262,22 @@ export function createCocodClient(
     }
 
     if (!startPromise) {
-      logger.debug(`Starting cocod daemon via ${executable}...`);
-      startPromise = startDaemon().finally(() => {
+      startPromise = withCrossProcessLock(
+        startupLockPath,
+        async () => {
+          if (await pingInternal()) {
+            return;
+          }
+
+          logger.debug(`Starting cocod daemon via ${executable} init...`);
+          await startDaemon();
+        },
+        {
+          acquireTimeoutMs: startupTimeoutMs + 30_000,
+          staleAfterMs: startupTimeoutMs + 30_000,
+          log: (message) => logger.debug(message),
+        },
+      ).finally(() => {
         startPromise = null;
       });
     }

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/start-daemon.ts

@@ -1,6 +1,9 @@
 import { logger } from "./utils/logger";
 import { existsSync } from "fs";
-import { LOGS_DIR } from "./utils/config";
+import { CONFIG_DIR, LOGS_DIR } from "./utils/config";
+import { withCrossProcessLock } from "./utils/process-lock";
+
+const DAEMON_STARTUP_LOCK_PATH = `${CONFIG_DIR}/routstrd-startup.lock`;
 
 function getTodayLogFile(): string {
   const now = new Date();
@@ -10,27 +13,32 @@ function getTodayLogFile(): string {
   return `${LOGS_DIR}/${year}-${month}-${day}.log`;
 }
 
-export async function startDaemon(
-  options: { port?: string; provider?: string } = {},
+async function isDaemonHealthy(port: string): Promise<boolean> {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 2000);
+  try {
+    const existing = await fetch(`http://localhost:${port}/health`, {
+      signal: controller.signal,
+    });
+    return existing.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+async function startDaemonUnlocked(
+  options: { port?: string; provider?: string },
 ): Promise<void> {
   const args: string[] = [];
   const port = options.port || "8008";
   const pollIntervalMs = 250;
   const startupTimeoutMs = 10 * 60 * 1000;
 
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 2000);
-    const existing = await fetch(`http://localhost:${port}/health`, {
-      signal: controller.signal,
-    });
-    clearTimeout(timeoutId);
-    if (existing.ok) {
-      logger.log(`Routstr daemon already running on http://localhost:${port}/v1`);
-      return;
-    }
-  } catch {
-    // Daemon is not running yet; continue with startup.
+  if (await isDaemonHealthy(port)) {
+    logger.log(`Routstr daemon already running on http://localhost:${port}/v1`);
+    return;
   }
 
   if (options.port) {
@@ -47,7 +55,7 @@ export async function startDaemon(
 
   const daemonScript = new URL("./daemon/index.js", import.meta.url).pathname;
   const todayLogFile = getTodayLogFile();
-  const shellCmd = `bun run "${daemonScript}" ${args.map(a => `'${a}'`).join(" ")} >> "${todayLogFile}" 2>&1`;
+  const shellCmd = `bun run "${daemonScript}" ${args.map((a) => `'${a}'`).join(" ")} >> "${todayLogFile}" 2>&1`;
 
   const proc = Bun.spawn(["sh", "-c", shellCmd], {
     stdout: "inherit",
@@ -73,19 +81,9 @@ export async function startDaemon(
       );
     }
 
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 2000);
-      const res = await fetch(`http://localhost:${port}/health`, {
-        signal: controller.signal,
-      });
-      clearTimeout(timeoutId);
-      if (res.ok) {
-        logger.log(`Routstr daemon started (PID: ${proc.pid}).`);
-        return;
-      }
-    } catch {
-      // Not ready yet
+    if (await isDaemonHealthy(port)) {
+      logger.log(`Routstr daemon started (PID: ${proc.pid}).`);
+      return;
     }
   }
 
@@ -93,3 +91,27 @@ export async function startDaemon(
     `Daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds. Check logs in ${LOGS_DIR}`,
   );
 }
+
+export async function startDaemon(
+  options: { port?: string; provider?: string } = {},
+): Promise<void> {
+  const port = options.port || "8008";
+  const startupTimeoutMs = 10 * 60 * 1000;
+
+  if (await isDaemonHealthy(port)) {
+    logger.log(`Routstr daemon already running on http://localhost:${port}/v1`);
+    return;
+  }
+
+  await withCrossProcessLock(
+    DAEMON_STARTUP_LOCK_PATH,
+    async () => {
+      await startDaemonUnlocked(options);
+    },
+    {
+      acquireTimeoutMs: startupTimeoutMs + 30_000,
+      staleAfterMs: startupTimeoutMs + 30_000,
+      log: (message) => logger.debug(message),
+    },
+  );
+}

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,