routstrd 0.2.6 → 0.2.9

package/dist/daemon/index.js

@@ -62,9 +62,9 @@ var init__assert = () => {
 
 // node_modules/nostr-tools/node_modules/@noble/curves/node_modules/@noble/hashes/esm/cryptoNode.js
 import * as nc from "crypto";
-var crypto;
+var crypto2;
 var init_cryptoNode = __esm(() => {
-  crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : undefined;
+  crypto2 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : undefined;
 });
 
 // node_modules/nostr-tools/node_modules/@noble/curves/node_modules/@noble/hashes/esm/utils.js
@@ -106,8 +106,8 @@ function wrapConstructor(hashCons) {
   return hashC;
 }
 function randomBytes(bytesLength = 32) {
-  if (crypto && typeof crypto.getRandomValues === "function") {
-    return crypto.getRandomValues(new Uint8Array(bytesLength));
+  if (crypto2 && typeof crypto2.getRandomValues === "function") {
+    return crypto2.getRandomValues(new Uint8Array(bytesLength));
   }
   throw new Error("crypto.getRandomValues must be defined");
 }
@@ -1951,9 +1951,9 @@ var init_secp256k1 = __esm(() => {
 
 // node_modules/nostr-tools/node_modules/@noble/hashes/esm/cryptoNode.js
 import * as nc2 from "crypto";
-var crypto2;
+var crypto3;
 var init_cryptoNode2 = __esm(() => {
-  crypto2 = nc2 && typeof nc2 === "object" && "webcrypto" in nc2 ? nc2.webcrypto : undefined;
+  crypto3 = nc2 && typeof nc2 === "object" && "webcrypto" in nc2 ? nc2.webcrypto : undefined;
 });
 
 // node_modules/nostr-tools/node_modules/@noble/hashes/esm/utils.js
@@ -2021,8 +2021,8 @@ function wrapConstructor2(hashCons) {
   return hashC;
 }
 function randomBytes2(bytesLength = 32) {
-  if (crypto2 && typeof crypto2.getRandomValues === "function") {
-    return crypto2.getRandomValues(new Uint8Array(bytesLength));
+  if (crypto3 && typeof crypto3.getRandomValues === "function") {
+    return crypto3.getRandomValues(new Uint8Array(bytesLength));
   }
   throw new Error("crypto.getRandomValues must be defined");
 }
@@ -19631,14 +19631,14 @@ var init_observable = __esm(() => {
 var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
 
 // node_modules/nanoid/index.js
-import { webcrypto as crypto3 } from "crypto";
+import { webcrypto as crypto4 } from "crypto";
 function fillPool(bytes4) {
   if (!pool || pool.length < bytes4) {
     pool = Buffer.allocUnsafe(bytes4 * POOL_SIZE_MULTIPLIER);
-    crypto3.getRandomValues(pool);
+    crypto4.getRandomValues(pool);
     poolOffset = 0;
   } else if (poolOffset + bytes4 > pool.length) {
-    crypto3.getRandomValues(pool);
+    crypto4.getRandomValues(pool);
     poolOffset = 0;
   }
   poolOffset += bytes4;
@@ -34560,7 +34560,7 @@ var init_dist3 = __esm(() => {
 // src/daemon/index.ts
 init_dist3();
 import { createServer } from "http";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 
 // src/utils/config.ts
 var HOME = process.env.HOME || process.env.USERPROFILE || "";
@@ -34900,6 +34900,102 @@ init_cashu_ts_es();
 
 // src/daemon/wallet/cocod-client.ts
 import { createHash } from "crypto";
+
+// src/utils/process-lock.ts
+import { randomUUID } from "crypto";
+import { mkdir as mkdir3, readFile, rm, stat, writeFile } from "fs/promises";
+import { dirname } from "path";
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isProcessRunning(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code === "EPERM";
+  }
+}
+async function readLockOwner(lockDir) {
+  try {
+    const raw = await readFile(`${lockDir}/owner.json`, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid === "number" && typeof parsed.createdAt === "number") {
+      return {
+        pid: parsed.pid,
+        createdAt: parsed.createdAt,
+        token: typeof parsed.token === "string" ? parsed.token : undefined
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function isLockStale(lockDir, staleAfterMs) {
+  const owner = await readLockOwner(lockDir);
+  if (owner) {
+    return !isProcessRunning(owner.pid) || Date.now() - owner.createdAt > staleAfterMs;
+  }
+  try {
+    const info = await stat(lockDir);
+    return Date.now() - info.mtimeMs > staleAfterMs;
+  } catch {
+    return false;
+  }
+}
+async function acquireCrossProcessLock(lockDir, options = {}) {
+  const acquireTimeoutMs = options.acquireTimeoutMs ?? 120000;
+  const retryIntervalMs = options.retryIntervalMs ?? 100;
+  const staleAfterMs = options.staleAfterMs ?? 120000;
+  const deadline = Date.now() + acquireTimeoutMs;
+  await mkdir3(dirname(lockDir), { recursive: true });
+  while (true) {
+    try {
+      await mkdir3(lockDir);
+      const token = randomUUID();
+      const owner = { pid: process.pid, createdAt: Date.now(), token };
+      await writeFile(`${lockDir}/owner.json`, JSON.stringify(owner), "utf8");
+      let released = false;
+      return async () => {
+        if (released)
+          return;
+        released = true;
+        const currentOwner = await readLockOwner(lockDir);
+        if (currentOwner?.token === token) {
+          await rm(lockDir, { recursive: true, force: true });
+        }
+      };
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") {
+        throw error;
+      }
+      if (await isLockStale(lockDir, staleAfterMs)) {
+        options.log?.(`Removing stale lock at ${lockDir}`);
+        await rm(lockDir, { recursive: true, force: true });
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting to acquire lock ${lockDir}`);
+      }
+      await delay(retryIntervalMs);
+    }
+  }
+}
+async function withCrossProcessLock(lockDir, fn, options = {}) {
+  const release = await acquireCrossProcessLock(lockDir, options);
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+
+// src/daemon/wallet/cocod-client.ts
 var DEFAULT_CONFIG_DIR = process.env.COCOD_DIR || `${process.env.HOME || process.env.USERPROFILE || ""}/.cocod`;
 var DEFAULT_SOCKET_PATH = process.env.COCOD_SOCKET || `${DEFAULT_CONFIG_DIR}/cocod.sock`;
 
@@ -34929,7 +35025,7 @@ function parseMintList(output4) {
   return (output4 || "").split(`
 `).map((line) => line.trim()).filter(Boolean);
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function toErrorText(value) {
@@ -34951,6 +35047,7 @@ function tokenFingerprint(token) {
 function createCocodClient(options = {}) {
   const executable = resolveCocodExecutable(options.cocodPath);
   const socketPath = options.socketPath || DEFAULT_SOCKET_PATH;
+  const startupLockPath = `${socketPath}.startup.lock`;
   const fetchImpl = options.fetchImpl || fetch;
   const pollIntervalMs = options.pollIntervalMs ?? 100;
   const startupTimeoutMs = options.startupTimeoutMs ?? 5000;
@@ -35005,31 +35102,40 @@ function createCocodClient(options = {}) {
   }
   async function startDaemon() {
     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 = null;
     proc.exited.then((code) => {
       exitCode = code;
     });
     for (let i4 = 0;i4 < maxPolls; i4++) {
-      await delay(pollIntervalMs);
-      if (exitCode !== null) {
-        throw new Error(`cocod daemon exited early with code ${exitCode}`);
+      await delay2(pollIntervalMs);
+      if (exitCode !== null && exitCode !== 0) {
+        throw new Error(`cocod init exited early with code ${exitCode}`);
       }
       if (await pingInternal()) {
         logger3.debug(`Connected to cocod daemon on ${socketPath}`);
         return;
       }
     }
-    throw new Error(`cocod daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds`);
+    throw new Error(`cocod failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds`);
   }
   async function ensureDaemonRunning() {
     if (await pingInternal()) {
       return;
     }
     if (!startPromise) {
-      logger3.debug(`Starting cocod daemon via ${executable}...`);
-      startPromise = startDaemon().finally(() => {
+      startPromise = withCrossProcessLock(startupLockPath, async () => {
+        if (await pingInternal()) {
+          return;
+        }
+        logger3.debug(`Starting cocod daemon via ${executable} init...`);
+        await startDaemon();
+      }, {
+        acquireTimeoutMs: startupTimeoutMs + 30000,
+        staleAfterMs: startupTimeoutMs + 30000,
+        log: (message) => logger3.debug(message)
+      }).finally(() => {
         startPromise = null;
       });
     }
@@ -35253,6 +35359,439 @@ function createModelService(modelManager) {
 init_dist3();
 import { randomBytes as randomBytes5 } from "crypto";
 import { Readable } from "stream";
+
+// src/utils/daemon-client.ts
+import { existsSync as existsSync3 } from "fs";
+
+// src/start-daemon.ts
+var DAEMON_STARTUP_LOCK_PATH = `${CONFIG_DIR}/routstrd-startup.lock`;
+
+// src/utils/nip98.ts
+init_esm2();
+var NIP98_KIND = 27235;
+function hexToBytes6(hex3) {
+  const normalized = hex3.trim().toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(normalized)) {
+    throw new Error("Expected a 64-char hex private key or an nsec private key.");
+  }
+  const bytes4 = new Uint8Array(32);
+  for (let i4 = 0;i4 < bytes4.length; i4++) {
+    bytes4[i4] = Number.parseInt(normalized.slice(i4 * 2, i4 * 2 + 2), 16);
+  }
+  return bytes4;
+}
+function parseSecretKey(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("Missing Nostr private key.");
+  }
+  if (trimmed.toLowerCase().startsWith("nsec1")) {
+    const decoded = nip19_exports.decode(trimmed);
+    if (decoded.type !== "nsec" || !(decoded.data instanceof Uint8Array)) {
+      throw new Error("Invalid nsec private key.");
+    }
+    return decoded.data;
+  }
+  return hexToBytes6(trimmed);
+}
+async function sha256Hex(data) {
+  const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(data));
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function base64EncodeUtf8(value) {
+  return btoa(String.fromCharCode(...new TextEncoder().encode(value)));
+}
+function npubFromPubkey(pubkey) {
+  return nip19_exports.npubEncode(pubkey.toLowerCase());
+}
+function npubFromSecretKey(secretKey) {
+  return npubFromPubkey(getPublicKey2(secretKey));
+}
+async function createNIP98Authorization(secretKey, url2, method, body) {
+  const tags3 = [
+    ["u", url2],
+    ["method", method.toUpperCase()]
+  ];
+  if (body && body.byteLength > 0) {
+    tags3.push(["payload", await sha256Hex(body)]);
+  }
+  const template = {
+    kind: NIP98_KIND,
+    created_at: Math.round(Date.now() / 1000),
+    content: "",
+    tags: tags3
+  };
+  const signed = finalizeEvent2(template, secretKey);
+  return `Nostr ${base64EncodeUtf8(JSON.stringify(signed))}`;
+}
+
+// src/utils/daemon-client.ts
+async function loadConfig() {
+  try {
+    if (existsSync3(CONFIG_FILE)) {
+      const content2 = await Bun.file(CONFIG_FILE).text();
+      return { ...DEFAULT_CONFIG, ...JSON.parse(content2) };
+    }
+  } catch (error) {
+    console.error("Failed to load config:", error);
+  }
+  return DEFAULT_CONFIG;
+}
+function getDaemonBaseUrl(config) {
+  return config.daemonUrl?.replace(/\/$/, "") || `http://localhost:${config.port}`;
+}
+async function callDaemon(path, options = {}) {
+  const { method = "GET", body } = options;
+  const config = await loadConfig();
+  const baseUrl = getDaemonBaseUrl(config);
+  const url2 = `${baseUrl}${path}`;
+  const bodyString = body ? JSON.stringify(body) : undefined;
+  const bodyBytes = bodyString ? new TextEncoder().encode(bodyString) : undefined;
+  let authorization;
+  if (config.daemonUrl && config.nsec) {
+    const secretKey = parseSecretKey(config.nsec);
+    authorization = await createNIP98Authorization(secretKey, url2, method, bodyBytes);
+  }
+  const response = await fetch(url2, {
+    method,
+    headers: {
+      ...authorization ? { Authorization: authorization } : {},
+      ...bodyString ? { "Content-Type": "application/json" } : {}
+    },
+    body: bodyString
+  });
+  if (!response.ok) {
+    const errorData = await response.json();
+    throw new Error(errorData.error || `HTTP ${response.status}`);
+  }
+  return response.json();
+}
+
+// src/integrations/registry.ts
+import { join as join4 } from "path";
+
+// src/integrations/opencode.ts
+import { existsSync as existsSync4, mkdirSync } from "fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var OPENCODE_SMALL_MODEL = "routstr/minimax-m2.5";
+async function installOpencodeIntegration(config, apiKey, integrationConfig) {
+  const { name, configPath } = integrationConfig;
+  logger3.log(`
+Installing routstr models in opencode.json...`);
+  logger3.log(`Using API key for ${name}`);
+  const baseUrl = getDaemonBaseUrl(config);
+  let opencodeConfig;
+  try {
+    if (existsSync4(configPath)) {
+      const content2 = await readFile2(configPath, "utf-8");
+      opencodeConfig = JSON.parse(content2);
+    } else {
+      opencodeConfig = { provider: {} };
+    }
+  } catch {
+    opencodeConfig = { provider: {} };
+  }
+  if (!opencodeConfig.provider) {
+    opencodeConfig.provider = {};
+  }
+  try {
+    mkdirSync(dirname2(configPath), { recursive: true });
+    const data = await callDaemon("/models");
+    const models = data.output?.models || [];
+    if (models.length === 0) {
+      logger3.log("No models found from routstr daemon.");
+      return;
+    }
+    const modelsObj = {};
+    for (const model2 of models) {
+      modelsObj[model2.id] = { name: model2.name || model2.id };
+    }
+    opencodeConfig.provider["routstr"] = {
+      npm: "@ai-sdk/openai-compatible",
+      name: "routstr",
+      options: {
+        baseURL: `${baseUrl}/`,
+        apiKey,
+        includeUsage: true
+      },
+      models: modelsObj
+    };
+    opencodeConfig.small_model = OPENCODE_SMALL_MODEL;
+    await writeFile2(configPath, JSON.stringify(opencodeConfig, null, 2));
+    logger3.log(`Added "routstr" provider with ${models.length} models to opencode.json`);
+  } catch (error) {
+    logger3.error("Failed to install models in opencode.json:", error);
+  }
+}
+
+// src/integrations/pi.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+async function installPiIntegration(config, apiKey, integrationConfig) {
+  const { name, configPath } = integrationConfig;
+  logger3.log(`
+Installing routstr models in pi models.json...`);
+  logger3.log(`Using API key for ${name}`);
+  const baseUrl = `${getDaemonBaseUrl(config)}/v1`;
+  let piConfig = {};
+  try {
+    if (existsSync5(configPath)) {
+      const content2 = await readFile3(configPath, "utf-8");
+      piConfig = JSON.parse(content2);
+    }
+  } catch {
+    piConfig = {};
+  }
+  if (!piConfig.providers) {
+    piConfig.providers = {};
+  }
+  try {
+    mkdirSync2(dirname3(configPath), { recursive: true });
+    const data = await callDaemon("/models");
+    const models = data.output?.models || [];
+    if (models.length === 0) {
+      logger3.log("No models found from routstr daemon.");
+      return;
+    }
+    const providerModels = models.map((model2) => ({
+      id: model2.id
+    }));
+    piConfig.providers["routstr"] = {
+      baseUrl,
+      api: "openai-completions",
+      apiKey,
+      models: providerModels
+    };
+    await writeFile3(configPath, JSON.stringify(piConfig, null, 2));
+    logger3.log(`Added "routstr" provider with ${models.length} models to pi models.json`);
+  } catch (error) {
+    logger3.error("Failed to install models in pi models.json:", error);
+  }
+}
+
+// src/integrations/openclaw.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+var OPENCLAW_PROVIDER_ID = "routstr";
+var OPENCLAW_DEFAULT_PRIMARY_MODEL = "routstr/minimax-m2.5";
+var OPENCLAW_DEFAULT_FALLBACK_MODEL = "routstr/kimi-k2.5";
+async function installOpenClawIntegration(config, apiKey, integrationConfig) {
+  const { name, configPath } = integrationConfig;
+  logger3.log(`
+Installing routstr models in openclaw.json...`);
+  logger3.log(`Using API key for ${name}`);
+  const baseUrl = getDaemonBaseUrl(config);
+  let openclawConfig = {};
+  try {
+    if (existsSync6(configPath)) {
+      const content2 = await readFile4(configPath, "utf-8");
+      openclawConfig = JSON.parse(content2);
+    }
+  } catch {
+    openclawConfig = {};
+  }
+  if (!openclawConfig.models) {
+    openclawConfig.models = {};
+  }
+  if (!openclawConfig.models.providers) {
+    openclawConfig.models.providers = {};
+  }
+  if (!openclawConfig.agents) {
+    openclawConfig.agents = {};
+  }
+  if (!openclawConfig.agents.defaults) {
+    openclawConfig.agents.defaults = {};
+  }
+  try {
+    mkdirSync3(dirname4(configPath), { recursive: true });
+    const data = await callDaemon("/models");
+    const models = data.output?.models || [];
+    if (models.length === 0) {
+      logger3.log("No models found from routstr daemon.");
+      return;
+    }
+    const providerModels = models.map((model2) => ({
+      id: model2.id,
+      name: model2.name || model2.id,
+      reasoning: true
+    }));
+    openclawConfig.models.providers[OPENCLAW_PROVIDER_ID] = {
+      baseUrl: `${baseUrl}/v1`,
+      apiKey,
+      api: "openai-completions",
+      models: providerModels
+    };
+    const availableModelIds = new Set(providerModels.map((model2) => model2.id));
+    const primaryId = availableModelIds.has("gpt-5.3-codex") ? "gpt-5.3-codex" : providerModels[0]?.id;
+    const fallbackId = availableModelIds.has("minimax-m2.5") ? "minimax-m2.5" : providerModels.find((model2) => model2.id !== primaryId)?.id;
+    if (primaryId) {
+      openclawConfig.agents.defaults.model = {
+        primary: `${OPENCLAW_PROVIDER_ID}/${primaryId}`,
+        fallbacks: fallbackId ? [`${OPENCLAW_PROVIDER_ID}/${fallbackId}`] : []
+      };
+    } else {
+      openclawConfig.agents.defaults.model = {
+        primary: OPENCLAW_DEFAULT_PRIMARY_MODEL,
+        fallbacks: [OPENCLAW_DEFAULT_FALLBACK_MODEL]
+      };
+    }
+    await writeFile4(configPath, JSON.stringify(openclawConfig, null, 2));
+    logger3.log(`Added "${OPENCLAW_PROVIDER_ID}" provider with ${models.length} models to openclaw.json`);
+  } catch (error) {
+    logger3.error("Failed to install models in openclaw.json:", error);
+  }
+}
+
+// src/integrations/claudecode.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+async function installClaudeCodeIntegration(config, apiKey, integrationConfig) {
+  const { name, configPath } = integrationConfig;
+  logger3.log(`
+Installing routstr configuration in ${configPath}...`);
+  logger3.log(`Using API key for ${name}`);
+  const baseUrl = getDaemonBaseUrl(config);
+  let settings = {};
+  try {
+    if (existsSync7(configPath)) {
+      const content2 = await readFile5(configPath, "utf-8");
+      settings = JSON.parse(content2);
+    }
+  } catch (error) {
+    logger3.error(`Error reading ${configPath}, creating new one.`);
+  }
+  if (!settings.env) {
+    settings.env = {};
+  }
+  settings.env["ANTHROPIC_AUTH_TOKEN"] = apiKey;
+  settings.env["ANTHROPIC_BASE_URL"] = baseUrl;
+  try {
+    const data = await callDaemon("/models");
+    const models = data.output?.models || [];
+    if (models.length >= 3) {
+      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;
+      logger3.log(`Set Claude models: Opus=${opus.id}, Sonnet=${sonnet.id}, Haiku=${haiku.id}`);
+    } else if (models.length > 0) {
+      const model2 = models[0];
+      logger3.log(`Only ${models.length} models available, falling back to defaults.`);
+      settings.env["ANTHROPIC_DEFAULT_OPUS_MODEL"] = model2.id;
+      settings.env["ANTHROPIC_DEFAULT_SONNET_MODEL"] = model2.id;
+      settings.env["ANTHROPIC_DEFAULT_HAIKU_MODEL"] = model2.id;
+    } else {
+      logger3.log("No models available from routstr daemon.");
+    }
+  } catch (error) {
+    logger3.error("Failed to fetch models for Claude Code integration:", error);
+  }
+  try {
+    mkdirSync4(dirname5(configPath), { recursive: true });
+    await writeFile5(configPath, JSON.stringify(settings, null, 2));
+    logger3.log(`Successfully updated ${configPath} with routstr settings.`);
+  } catch (error) {
+    logger3.error(`Failed to write to ${configPath}:`, error);
+  }
+}
+
+// src/integrations/registry.ts
+var CLIENT_CONFIGS = {
+  opencode: {
+    clientId: "opencode",
+    name: "OpenCode",
+    configPath: join4(process.env.HOME || "", ".config/opencode/opencode.json")
+  },
+  "pi-agent": {
+    clientId: "pi-agent",
+    name: "Pi Agent",
+    configPath: join4(process.env.HOME || "", ".pi/agent/models.json")
+  },
+  openclaw: {
+    clientId: "openclaw",
+    name: "OpenClaw",
+    configPath: join4(process.env.HOME || "", ".openclaw/openclaw.json")
+  },
+  "claude-code": {
+    clientId: "claude-code",
+    name: "Claude Code",
+    configPath: join4(process.env.HOME || "", ".claude/settings.json")
+  }
+};
+var CLIENT_INTEGRATIONS = {
+  opencode: installOpencodeIntegration,
+  "pi-agent": installPiIntegration,
+  openclaw: installOpenClawIntegration,
+  "claude-code": installClaudeCodeIntegration
+};
+async function runIntegrationsForClients(clientIds, config) {
+  for (const client2 of clientIds) {
+    const integrationFn = CLIENT_INTEGRATIONS[client2.clientId];
+    const integrationConfig = CLIENT_CONFIGS[client2.clientId];
+    if (integrationFn && integrationConfig && client2.apiKey) {
+      try {
+        await integrationFn(config, client2.apiKey, integrationConfig);
+      } catch (error) {
+        console.error(`Integration failed for ${client2.clientId}:`, error);
+      }
+    }
+  }
+}
+
+// src/utils/clients.ts
+function getNpubSuffix(config) {
+  if (!config.daemonUrl || !config.nsec)
+    return null;
+  try {
+    const secretKey = parseSecretKey(config.nsec);
+    const npub = npubFromSecretKey(secretKey);
+    return npub.slice(-7);
+  } catch {
+    return null;
+  }
+}
+function removeSuffixFromId(id, suffix) {
+  const suffixStr = `-${suffix}`;
+  if (id.endsWith(suffixStr)) {
+    return id.slice(0, -suffixStr.length);
+  }
+  return id;
+}
+function getClientsFromStore(store) {
+  const state = store.getState();
+  const clientIds = state.clientIds || [];
+  return clientIds.map((c) => ({
+    clientId: c.clientId,
+    name: c.name,
+    apiKey: c.apiKey,
+    createdAt: c.createdAt,
+    lastUsed: c.lastUsed
+  }));
+}
+async function getClientsList() {
+  const config = await loadConfig();
+  const result = await callDaemon("/clients");
+  const clients = result.output?.clients;
+  if (!clients) {
+    return [];
+  }
+  const suffix = config.daemonUrl ? getNpubSuffix(config) : null;
+  return clients.filter((c) => !suffix || c.id.endsWith(`-${suffix}`)).map((c) => ({
+    clientId: suffix ? removeSuffixFromId(c.id, suffix) : c.id,
+    name: c.name,
+    apiKey: c.apiKey,
+    createdAt: c.createdAt,
+    lastUsed: c.lastUsed
+  }));
+}
+
+// src/daemon/http/index.ts
 function generateApiKey() {
   const bytes4 = randomBytes5(24);
   return `sk-${bytes4.toString("hex")}`;
@@ -35733,9 +36272,7 @@ function createDaemonRequestHandler(deps) {
     }
     if (req.method === "GET" && url2.pathname === "/clients") {
       try {
-        const state = deps.store.getState();
-        const clientIds = state.clientIds || [];
-        const clients = clientIds.map((c) => ({
+        const clients = getClientsFromStore(deps.store).map((c) => ({
           id: c.clientId,
           name: c.name,
           apiKey: c.apiKey,
@@ -35760,6 +36297,7 @@ function createDaemonRequestHandler(deps) {
         const bodyText = await readBody(req);
         const body = bodyText ? JSON.parse(bodyText) : {};
         const name = body.name;
+        const explicitId = body.id;
         if (!name || typeof name !== "string" || name.trim() === "") {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({
@@ -35767,16 +36305,23 @@ function createDaemonRequestHandler(deps) {
           }));
           return;
         }
-        const clientId = name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+        if (!explicitId || typeof explicitId !== "string" || explicitId.trim() === "") {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Missing required 'id' field (must be a non-empty string)."
+          }));
+          return;
+        }
+        const sanitizeId = (value) => value.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+        const clientId = sanitizeId(explicitId);
         if (!clientId) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({
-            error: "Invalid client name. Must contain alphanumeric characters."
+            error: "Invalid client id. Must contain alphanumeric characters."
           }));
           return;
         }
-        const state = deps.store.getState();
-        const existingClients = state.clientIds || [];
+        const existingClients = getClientsFromStore(deps.store);
         const existingClient = existingClients.find((c) => c.clientId === clientId);
         if (existingClient) {
           res.writeHead(409, { "Content-Type": "application/json" });
@@ -35826,8 +36371,7 @@ function createDaemonRequestHandler(deps) {
           }));
           return;
         }
-        const state = deps.store.getState();
-        const existingClients = state.clientIds || [];
+        const existingClients = getClientsFromStore(deps.store);
         const index = existingClients.findIndex((c) => c.clientId === id);
         if (index === -1) {
           res.writeHead(404, { "Content-Type": "application/json" });
@@ -36040,362 +36584,18 @@ function createDaemonRequestHandler(deps) {
   };
 }
 
-// src/integrations/opencode.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname4 } from "path";
-
-// src/integrations/registry.ts
-import { randomBytes as randomBytes6 } from "crypto";
-import { join as join4 } from "path";
-
-// src/integrations/pi.ts
-import { existsSync as existsSync3, mkdirSync } from "fs";
-import { readFile, writeFile } from "fs/promises";
-import { dirname } from "path";
-async function installPiIntegration(config, store, integrationConfig) {
-  const { clientId, name, configPath } = integrationConfig;
-  logger3.log(`
-Installing routstr models in pi models.json...`);
-  const port = config.port || 8008;
-  const baseUrl = `http://localhost:${port}/v1`;
-  const state = store.getState();
-  const existingClient = (state.clientIds || []).find((c) => c.clientId === clientId);
-  let apiKey;
-  if (existingClient) {
-    apiKey = existingClient.apiKey;
-    logger3.log(`Using existing API key for ${name}`);
-  } else {
-    apiKey = generateApiKey2();
-    store.getState().setClientIds((prev) => [
-      ...prev || [],
-      {
-        clientId,
-        name,
-        apiKey,
-        createdAt: Date.now()
-      }
-    ]);
-    logger3.log(`Created new API key for ${name}`);
-  }
-  let piConfig = {};
-  try {
-    if (existsSync3(configPath)) {
-      const content2 = await readFile(configPath, "utf-8");
-      piConfig = JSON.parse(content2);
-    }
-  } catch {
-    piConfig = {};
-  }
-  if (!piConfig.providers) {
-    piConfig.providers = {};
-  }
-  try {
-    mkdirSync(dirname(configPath), { recursive: true });
-    const response = await fetch(`http://localhost:${port}/models`);
-    const data = await response.json();
-    const models = data.output?.models || [];
-    if (models.length === 0) {
-      logger3.log("No models found from routstr daemon.");
-      return;
-    }
-    const providerModels = models.map((model2) => ({
-      id: model2.id
-    }));
-    piConfig.providers["routstr"] = {
-      baseUrl,
-      api: "openai-completions",
-      apiKey,
-      models: providerModels
-    };
-    await writeFile(configPath, JSON.stringify(piConfig, null, 2));
-    logger3.log(`Added "routstr" provider with ${models.length} models to pi models.json`);
-  } catch (error) {
-    logger3.error("Failed to install models in pi models.json:", error);
-  }
-}
-
-// src/integrations/openclaw.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
-var OPENCLAW_PROVIDER_ID = "routstr";
-var OPENCLAW_DEFAULT_PRIMARY_MODEL = "routstr/minimax-m2.5";
-var OPENCLAW_DEFAULT_FALLBACK_MODEL = "routstr/kimi-k2.5";
-async function installOpenClawIntegration(config, store, integrationConfig) {
-  const { clientId, name, configPath } = integrationConfig;
-  logger3.log(`
-Installing routstr models in openclaw.json...`);
-  const port = config.port || 8008;
-  const state = store.getState();
-  const existingClient = (state.clientIds || []).find((c) => c.clientId === clientId);
-  let apiKey;
-  if (existingClient) {
-    apiKey = existingClient.apiKey;
-    logger3.log(`Using existing API key for ${name}`);
-  } else {
-    apiKey = generateApiKey2();
-    store.getState().setClientIds((prev) => [
-      ...prev || [],
-      {
-        clientId,
-        name,
-        apiKey,
-        createdAt: Date.now()
-      }
-    ]);
-    logger3.log(`Created new API key for ${name}`);
-  }
-  let openclawConfig = {};
-  try {
-    if (existsSync4(configPath)) {
-      const content2 = await readFile2(configPath, "utf-8");
-      openclawConfig = JSON.parse(content2);
-    }
-  } catch {
-    openclawConfig = {};
-  }
-  if (!openclawConfig.models) {
-    openclawConfig.models = {};
-  }
-  if (!openclawConfig.models.providers) {
-    openclawConfig.models.providers = {};
-  }
-  if (!openclawConfig.agents) {
-    openclawConfig.agents = {};
-  }
-  if (!openclawConfig.agents.defaults) {
-    openclawConfig.agents.defaults = {};
-  }
-  try {
-    mkdirSync2(dirname2(configPath), { recursive: true });
-    const response = await fetch(`http://localhost:${port}/models`);
-    const data = await response.json();
-    const models = data.output?.models || [];
-    if (models.length === 0) {
-      logger3.log("No models found from routstr daemon.");
-      return;
-    }
-    const providerModels = models.map((model2) => ({
-      id: model2.id,
-      name: model2.name || model2.id,
-      reasoning: true
-    }));
-    openclawConfig.models.providers[OPENCLAW_PROVIDER_ID] = {
-      baseUrl: `http://localhost:${port}/v1`,
-      apiKey,
-      api: "openai-completions",
-      models: providerModels
-    };
-    const availableModelIds = new Set(providerModels.map((model2) => model2.id));
-    const primaryId = availableModelIds.has("gpt-5.3-codex") ? "gpt-5.3-codex" : providerModels[0]?.id;
-    const fallbackId = availableModelIds.has("minimax-m2.5") ? "minimax-m2.5" : providerModels.find((model2) => model2.id !== primaryId)?.id;
-    if (primaryId) {
-      openclawConfig.agents.defaults.model = {
-        primary: `${OPENCLAW_PROVIDER_ID}/${primaryId}`,
-        fallbacks: fallbackId ? [`${OPENCLAW_PROVIDER_ID}/${fallbackId}`] : []
-      };
-    } else {
-      openclawConfig.agents.defaults.model = {
-        primary: OPENCLAW_DEFAULT_PRIMARY_MODEL,
-        fallbacks: [OPENCLAW_DEFAULT_FALLBACK_MODEL]
-      };
-    }
-    await writeFile2(configPath, JSON.stringify(openclawConfig, null, 2));
-    logger3.log(`Added "${OPENCLAW_PROVIDER_ID}" provider with ${models.length} models to openclaw.json`);
-  } catch (error) {
-    logger3.error("Failed to install models in openclaw.json:", error);
-  }
-}
-
-// src/integrations/claudecode.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3 } from "path";
-async function installClaudeCodeIntegration(config, store, integrationConfig) {
-  const { clientId, name, configPath } = integrationConfig;
-  logger3.log(`
-Installing routstr configuration in ${configPath}...`);
-  const port = config.port || 8008;
-  const state = store.getState();
-  const existingClient = (state.clientIds || []).find((c) => c.clientId === clientId);
-  let apiKey;
-  if (existingClient) {
-    apiKey = existingClient.apiKey;
-    logger3.log(`Using existing API key for ${name}`);
-  } else {
-    apiKey = generateApiKey2();
-    store.getState().setClientIds((prev) => [
-      ...prev || [],
-      {
-        clientId,
-        name,
-        apiKey,
-        createdAt: Date.now()
-      }
-    ]);
-    logger3.log(`Created new API key for ${name}`);
-  }
-  let settings = {};
-  try {
-    if (existsSync5(configPath)) {
-      const content2 = await readFile3(configPath, "utf-8");
-      settings = JSON.parse(content2);
-    }
-  } catch (error) {
-    logger3.error(`Error reading ${configPath}, creating new one.`);
-  }
-  if (!settings.env) {
-    settings.env = {};
-  }
-  settings.env["ANTHROPIC_AUTH_TOKEN"] = apiKey;
-  settings.env["ANTHROPIC_BASE_URL"] = `http://localhost:${port}`;
-  try {
-    const response = await fetch(`http://localhost:${port}/models`);
-    const data = await response.json();
-    const models = data.output?.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;
-      logger3.log(`Set Claude models: Opus=${models[0].id}, Sonnet=${models[1].id}, Haiku=${models[2].id}`);
-    } else if (models.length > 0) {
-      logger3.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;
-    } else {
-      logger3.log("No models available from routstr daemon.");
-    }
-  } catch (error) {
-    logger3.error("Failed to fetch models for Claude Code integration:", error);
-  }
-  try {
-    mkdirSync3(dirname3(configPath), { recursive: true });
-    await writeFile3(configPath, JSON.stringify(settings, null, 2));
-    logger3.log(`Successfully updated ${configPath} with routstr settings.`);
-  } catch (error) {
-    logger3.error(`Failed to write to ${configPath}:`, error);
-  }
-}
-
-// src/integrations/registry.ts
-function generateApiKey2() {
-  const bytes4 = randomBytes6(24);
-  return `sk-${bytes4.toString("hex")}`;
-}
-var CLIENT_CONFIGS = {
-  opencode: {
-    clientId: "opencode",
-    name: "OpenCode",
-    configPath: join4(process.env.HOME || "", ".config/opencode/opencode.json")
-  },
-  "pi-agent": {
-    clientId: "pi-agent",
-    name: "Pi Agent",
-    configPath: join4(process.env.HOME || "", ".pi/agent/models.json")
-  },
-  openclaw: {
-    clientId: "openclaw",
-    name: "OpenClaw",
-    configPath: join4(process.env.HOME || "", ".openclaw/openclaw.json")
-  },
-  "claude-code": {
-    clientId: "claude-code",
-    name: "Claude Code",
-    configPath: join4(process.env.HOME || "", ".claude/settings.json")
-  }
-};
-var CLIENT_INTEGRATIONS = {
-  opencode: installOpencodeIntegration,
-  "pi-agent": installPiIntegration,
-  openclaw: installOpenClawIntegration,
-  "claude-code": installClaudeCodeIntegration
-};
-async function runIntegrationsForClients(clientIds, config, store) {
-  for (const client2 of clientIds) {
-    const integrationFn = CLIENT_INTEGRATIONS[client2.clientId];
-    const integrationConfig = CLIENT_CONFIGS[client2.clientId];
-    if (integrationFn && integrationConfig) {
-      try {
-        await integrationFn(config, store, integrationConfig);
-      } catch (error) {
-        console.error(`Integration failed for ${client2.clientId}:`, error);
-      }
-    }
+// src/integrations/index.ts
+async function refreshModelsAndIntegrations(getRoutstr21Models, config, label = "Scheduled") {
+  await getRoutstr21Models(true);
+  logger3.log(`${label} model refresh completed successfully.`);
+  const clientIds = await getClientsList();
+  if (clientIds.length > 0) {
+    logger3.log(`Refreshing ${clientIds.length} client integration(s)...`);
+    await runIntegrationsForClients(clientIds, config);
+    logger3.log("Client integrations refreshed.");
   }
 }
 
-// src/integrations/opencode.ts
-var OPENCODE_SMALL_MODEL = "routstr/minimax-m2.5";
-async function installOpencodeIntegration(config, store, integrationConfig) {
-  const { clientId, name, configPath } = integrationConfig;
-  logger3.log(`
-Installing routstr models in opencode.json...`);
-  const port = config.port || 8008;
-  const state = store.getState();
-  const existingClient = (state.clientIds || []).find((c) => c.clientId === clientId);
-  let apiKey;
-  if (existingClient) {
-    apiKey = existingClient.apiKey;
-    logger3.log(`Using existing API key for ${name}`);
-  } else {
-    apiKey = generateApiKey2();
-    store.getState().setClientIds((prev) => [
-      ...prev || [],
-      {
-        clientId,
-        name,
-        apiKey,
-        createdAt: Date.now()
-      }
-    ]);
-    logger3.log(`Created new API key for ${name}`);
-  }
-  let opencodeConfig;
-  try {
-    if (existsSync6(configPath)) {
-      const content2 = await readFile4(configPath, "utf-8");
-      opencodeConfig = JSON.parse(content2);
-    } else {
-      opencodeConfig = { provider: {} };
-    }
-  } catch {
-    opencodeConfig = { provider: {} };
-  }
-  if (!opencodeConfig.provider) {
-    opencodeConfig.provider = {};
-  }
-  try {
-    mkdirSync4(dirname4(configPath), { recursive: true });
-    const response = await fetch(`http://localhost:${port}/models`);
-    const data = await response.json();
-    const models = data.output?.models || [];
-    if (models.length === 0) {
-      logger3.log("No models found from routstr daemon.");
-      return;
-    }
-    const modelsObj = {};
-    for (const model2 of models) {
-      modelsObj[model2.id] = { name: model2.name || model2.id };
-    }
-    opencodeConfig.provider["routstr"] = {
-      npm: "@ai-sdk/openai-compatible",
-      name: "routstr",
-      options: {
-        baseURL: `http://localhost:${port}/`,
-        apiKey,
-        includeUsage: true
-      },
-      models: modelsObj
-    };
-    opencodeConfig.small_model = OPENCODE_SMALL_MODEL;
-    await writeFile4(configPath, JSON.stringify(opencodeConfig, null, 2));
-    logger3.log(`Added "routstr" provider with ${models.length} models to opencode.json`);
-  } catch (error) {
-    logger3.error("Failed to install models in opencode.json:", error);
-  }
-}
 // src/daemon/index.ts
 init_dist3();
 async function main() {
@@ -36407,7 +36607,8 @@ async function main() {
   const updatedConfig = { ...config, port, provider };
   saveDaemonConfig(updatedConfig);
   const sqliteDriver = await createBunSqliteDriver2(DB_PATH);
-  const { store } = await createSdkStore({ driver: sqliteDriver });
+  const { store, hydrate } = createSdkStore({ driver: sqliteDriver });
+  await hydrate;
   const { Database } = await import("bun:sqlite");
   const usageTrackingDriver = createBunSqliteUsageTrackingDriver2({
     dbPath: DB_PATH,
@@ -36445,7 +36646,7 @@ async function main() {
   }));
   Bun.write(PID_FILE, String(process.pid));
   try {
-    if (existsSync7(SOCKET_PATH)) {
+    if (existsSync8(SOCKET_PATH)) {
       Bun.spawn(["rm", SOCKET_PATH]);
     }
   } catch {
@@ -36457,15 +36658,7 @@ async function main() {
     refreshInterval = setInterval(async () => {
       logger3.log("Running scheduled model refresh...");
       try {
-        await getRoutstr21Models(true);
-        logger3.log("Scheduled model refresh completed successfully.");
-        const state = store.getState();
-        const clientIds = state.clientIds || [];
-        if (clientIds.length > 0) {
-          logger3.log(`Refreshing ${clientIds.length} client integration(s)...`);
-          await runIntegrationsForClients(clientIds, updatedConfig, store);
-          logger3.log("Client integrations refreshed.");
-        }
+        await refreshModelsAndIntegrations(getRoutstr21Models, updatedConfig, "Scheduled");
       } catch (error) {
         logger3.error("Scheduled model refresh failed:", error);
       }
@@ -36526,20 +36719,11 @@ async function main() {
   });
   server.listen(port, async () => {
     logger3.log(`Routstr daemon listening on http://localhost:${port}/v1`);
-    ensureProvidersBootstrapped().then(() => {
+    ensureProvidersBootstrapped().then(async () => {
       startModelRefreshJob();
       startRefundJob();
       logger3.log("Running initial model refresh...");
-      return getRoutstr21Models(true);
-    }).then(async () => {
-      logger3.log("Initial model refresh completed.");
-      const state = store.getState();
-      const clientIds = state.clientIds || [];
-      if (clientIds.length > 0) {
-        logger3.log(`Refreshing ${clientIds.length} client integration(s)...`);
-        await runIntegrationsForClients(clientIds, updatedConfig, store);
-        logger3.log("Client integrations refreshed.");
-      }
+      await refreshModelsAndIntegrations(getRoutstr21Models, updatedConfig, "Initial");
     }).catch((error) => {
       logger3.error("Initial model refresh failed:", error);
       startModelRefreshJob();