routstrd 0.2.8 → 0.2.10

package/README.md

@@ -23,44 +23,41 @@ curl -fsSL https://bun.com/install | bash
 
 ## Installation
 
-### From Source
+### Step 1: Install
 
+**Global with bun:**
 ```sh
+bun i -g routstrd
+```
+
+**OR - From source:**
+```sh
+git clone https://github.com/routstr/routstrd.git
 cd routstrd
 bun install
 bun link
-routstrd onboard
 ```
 
-## Usage
-
-### Initialize
-
-Initialize routstrd (creates config directory and sets up cocod):
+### Step 2: Setup & Fund
 
 ```sh
 routstrd onboard
+routstrd receive <cashu>       # receive a Cashu token
+routstrd receive 2100         # to top up 2100 sats with lightning
 ```
 
-This will:
-- Create `~/.routstrd/` directory
-- Create config file at `~/.routstrd/config.json`
-- Run `cocod init` to set up the wallet
-
+### Step 3: Integrate with Claude Code
 
-Then fund with Cashu/Lightning:
 ```sh
-cocod receive cashu <token>
-```
-or 
-```sh
-cocod receive bolt11 <amount>
+routstrd clients add --claude-code  # or --pi-agent / --opencode
 ```
 
-### That's it! You can start using it on http://localhost:8008
+## Use Routstrd Skill
+
+> **Tip:** You can also install the [routstrd skill](https://github.com/Routstr/routstrd/blob/main/SKILL.md) so the agent can manage routstrd for you.
 
 ## More Commands
-###Start Daemon
+### Start Daemon
 
 Start the background daemon:
 

package/SKILL.md

@@ -111,6 +111,7 @@ List and manage API clients (subcommand required).
 
 List all registered clients with their ID, name, API key, and creation date.
 
+
 #### `routstrd clients add`
 
 Add a new client or set up a client integration.
@@ -123,28 +124,53 @@ Add a new client or set up a client integration.
 | `--pi-agent` | Set up Pi Agent integration |
 | `--claude-code` | Set up Claude Code integration |
 
-Set up a specific client integration (creates API key and writes config to the client's config file):
-
 ```sh
-routstrd clients add --opencode
-routstrd clients add --claude-code
-routstrd clients add --pi-agent
-routstrd clients add --openclaw
+routstrd clients add --opencode --pi-agent --claude-code  # multiple integrations
+routstrd clients add -n "My App"                            # generic client
 ```
 
-You can also set up multiple integrations at once:
+Returns the client ID and API key for use with the OpenAI-compatible API.
 
-```sh
-routstrd clients add --opencode --pi-agent --claude-code
-```
+#### `routstrd clients delete <id>`
+
+Delete a registered client by its ID.
+
+### `routstrd npubs`
 
-Add a generic client manually:
+
+Manage admin npubs (subcommand required).
+
+| Command | Description |
+|---------|-------------|
+| `routstrd npubs list` | List configured admin npubs |
+| `routstrd npubs add <npub>` | Add an admin npub (accepts hex or npub1...) |
+| `routstrd npubs delete <npub>` | Delete an admin npub |
+
+### `routstrd remote <url>`
+
+Configure a remote daemon URL. Generates a Nostr identity (nsec/npub) for NIP-98 authentication automatically.
 
 ```sh
-routstrd clients add -n "My App"
+routstrd remote https://your-remote-daemon.com
 ```
 
-Returns the client ID and API key for use with the OpenAI-compatible API.
+### `routstrd refresh`
+
+Refresh routstr21 models from Nostr and re-run integrations for all registered clients.
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `port` | number | 8008 | Daemon HTTP port |
+| `provider` | string\|null | null | Default provider URL |
+| `daemonUrl` | string\|null | null | Remote daemon URL |
+| `nsec` | string\|null | null | Nostr secret key for NIP-98 auth |
+| `cocodPath` | string\|null | null | Custom path to cocod executable |
+| `mode` | string | `"apikeys"` | Client mode (`apikeys` or `xcashu`) |
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `ROUTSTRD_DIR` | `~/.routstrd` | Config directory |
+| `COCOD_DIR` | `~/.cocod` | Wallet config directory |
 
 ### `routstrd mode`
 
@@ -266,6 +292,13 @@ Config file: `~/.routstrd/config.json`
 | `ROUTSTRD_SOCKET` | `~/.routstrd/routstrd.sock` | IPC socket path |
 | `ROUTSTRD_PID` | `~/.routstrd/routstrd.pid` | PID file path |
 
+## Remote Mode
+
+When `daemonUrl` is configured, commands connect to a remote daemon instead of a local one:
+- Client names are suffixed with the last 7 chars of your npub
+- All requests are automatically NIP-98 signed using your local nsec
+- Local-only commands (`onboard`, `start`, `restart`, `mode`, `logs`, `service`) are disabled
+
 ## Pi Integration
 
 When `routstrd onboard` runs, it automatically configures a `routstr` provider in `pi`'s `models.json` with an OpenAI-compatible base URL and API key. This allows pi (the AI coding agent) to use Routstr providers seamlessly.

package/dist/daemon/index.js

@@ -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;
       });
     }
@@ -35257,6 +35363,9 @@ 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;
@@ -35363,8 +35472,8 @@ import { join as join4 } from "path";
 
 // src/integrations/opencode.ts
 import { existsSync as existsSync4, mkdirSync } from "fs";
-import { readFile, writeFile } from "fs/promises";
-import { dirname } from "path";
+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;
@@ -35375,7 +35484,7 @@ Installing routstr models in opencode.json...`);
   let opencodeConfig;
   try {
     if (existsSync4(configPath)) {
-      const content2 = await readFile(configPath, "utf-8");
+      const content2 = await readFile2(configPath, "utf-8");
       opencodeConfig = JSON.parse(content2);
     } else {
       opencodeConfig = { provider: {} };
@@ -35387,7 +35496,7 @@ Installing routstr models in opencode.json...`);
     opencodeConfig.provider = {};
   }
   try {
-    mkdirSync(dirname(configPath), { recursive: true });
+    mkdirSync(dirname2(configPath), { recursive: true });
     const data = await callDaemon("/models");
     const models = data.output?.models || [];
     if (models.length === 0) {
@@ -35409,7 +35518,7 @@ Installing routstr models in opencode.json...`);
       models: modelsObj
     };
     opencodeConfig.small_model = OPENCODE_SMALL_MODEL;
-    await writeFile(configPath, JSON.stringify(opencodeConfig, null, 2));
+    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);
@@ -35418,8 +35527,8 @@ Installing routstr models in opencode.json...`);
 
 // src/integrations/pi.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
+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(`
@@ -35429,7 +35538,7 @@ Installing routstr models in pi models.json...`);
   let piConfig = {};
   try {
     if (existsSync5(configPath)) {
-      const content2 = await readFile2(configPath, "utf-8");
+      const content2 = await readFile3(configPath, "utf-8");
       piConfig = JSON.parse(content2);
     }
   } catch {
@@ -35439,7 +35548,7 @@ Installing routstr models in pi models.json...`);
     piConfig.providers = {};
   }
   try {
-    mkdirSync2(dirname2(configPath), { recursive: true });
+    mkdirSync2(dirname3(configPath), { recursive: true });
     const data = await callDaemon("/models");
     const models = data.output?.models || [];
     if (models.length === 0) {
@@ -35455,7 +35564,7 @@ Installing routstr models in pi models.json...`);
       apiKey,
       models: providerModels
     };
-    await writeFile2(configPath, JSON.stringify(piConfig, null, 2));
+    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);
@@ -35464,8 +35573,8 @@ Installing routstr models in pi models.json...`);
 
 // src/integrations/openclaw.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3 } from "path";
+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";
@@ -35478,7 +35587,7 @@ Installing routstr models in openclaw.json...`);
   let openclawConfig = {};
   try {
     if (existsSync6(configPath)) {
-      const content2 = await readFile3(configPath, "utf-8");
+      const content2 = await readFile4(configPath, "utf-8");
       openclawConfig = JSON.parse(content2);
     }
   } catch {
@@ -35497,7 +35606,7 @@ Installing routstr models in openclaw.json...`);
     openclawConfig.agents.defaults = {};
   }
   try {
-    mkdirSync3(dirname3(configPath), { recursive: true });
+    mkdirSync3(dirname4(configPath), { recursive: true });
     const data = await callDaemon("/models");
     const models = data.output?.models || [];
     if (models.length === 0) {
@@ -35529,7 +35638,7 @@ Installing routstr models in openclaw.json...`);
         fallbacks: [OPENCLAW_DEFAULT_FALLBACK_MODEL]
       };
     }
-    await writeFile3(configPath, JSON.stringify(openclawConfig, null, 2));
+    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);
@@ -35538,8 +35647,8 @@ Installing routstr models in openclaw.json...`);
 
 // src/integrations/claudecode.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname4 } from "path";
+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(`
@@ -35549,7 +35658,7 @@ Installing routstr configuration in ${configPath}...`);
   let settings = {};
   try {
     if (existsSync7(configPath)) {
-      const content2 = await readFile4(configPath, "utf-8");
+      const content2 = await readFile5(configPath, "utf-8");
       settings = JSON.parse(content2);
     }
   } catch (error) {
@@ -35584,8 +35693,8 @@ Installing routstr configuration in ${configPath}...`);
     logger3.error("Failed to fetch models for Claude Code integration:", error);
   }
   try {
-    mkdirSync4(dirname4(configPath), { recursive: true });
-    await writeFile4(configPath, JSON.stringify(settings, null, 2));
+    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);