routstrd 0.2.14 → 0.2.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "routstrd",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "module": "src/index.ts",
   "type": "module",
   "private": false,

package/src/cli.ts

@@ -820,6 +820,7 @@ clientsCmd
   .option("--openclaw", "Set up OpenClaw integration")
   .option("--pi-agent", "Set up Pi Agent integration")
   .option("--claude-code", "Set up Claude Code integration")
+  .option("--hermes", "Set up Hermes integration")
   .action(
     async (options: {
       name?: string;
@@ -827,19 +828,25 @@ clientsCmd
       openclaw?: boolean;
       piAgent?: boolean;
       claudeCode?: boolean;
+      hermes?: boolean;
     }) => {
       await addClientAction(options);
     },
   );
 
-// Npubs - manage admin npubs
+// Npubs - manage npubs (admin and user roles)
 const npubsCmd = program
   .command("npubs")
-  .description("Manage admin npubs on the daemon");
+  .description("Manage npubs on the daemon (admin or user roles)");
+
+type NpubEntry = {
+  npub: string;
+  role: string;
+};
 
 npubsCmd
   .command("list")
-  .description("List configured admin npubs")
+  .description("List configured npubs with their roles")
   .action(async () => {
     await ensureDaemonRunning();
     const config = await loadConfig();
@@ -850,20 +857,20 @@ npubsCmd
       process.exit(1);
     }
     // Handle both wrapped { output: { npubs } } and direct { npubs } response formats
-    const data = (result.output as { npubs?: string[] } | undefined)?.npubs
+    const data = (result.output as { npubs?: NpubEntry[] } | undefined)?.npubs
       ? result.output
       : result;
-    const npubs = (data as { npubs?: string[] } | undefined)?.npubs ?? [];
+    const npubs = (data as { npubs?: NpubEntry[] } | undefined)?.npubs ?? [];
     if (npubs.length === 0) {
       console.log("No admin npubs configured. Run 'routstrd npubs register' to register yourself as the first admin.");
       return;
     }
-    console.log(`Admin npubs (${npubs.length}):`);
+    console.log(`Npubs (${npubs.length}):`);
     let found = false;
-    for (const npub of npubs) {
-      const marker = npub === userNpub ? " → you" : "";
-      if (npub === userNpub) found = true;
-      console.log(`- ${npub}${marker}`);
+    for (const entry of npubs) {
+      const marker = entry.npub === userNpub ? " → you" : "";
+      if (entry.npub === userNpub) found = true;
+      console.log(`- ${entry.npub} [${entry.role}]${marker}`);
     }
     if (userNpub && !found) {
       console.log("");
@@ -892,10 +899,10 @@ npubsCmd
       console.log(result.error);
       process.exit(1);
     }
-    const data = (result.output as { npubs?: string[] } | undefined)?.npubs
+    const data = (result.output as { npubs?: NpubEntry[] } | undefined)?.npubs
       ? result.output
       : result;
-    const npubs = (data as { npubs?: string[] } | undefined)?.npubs ?? [];
+    const npubs = (data as { npubs?: NpubEntry[] } | undefined)?.npubs ?? [];
     if (npubs.length > 0) {
       console.log(`Admin npubs already configured (${npubs.length}). Ask your admin to add your npub. \n Your npub: ${userNpub}`);
       return;
@@ -925,35 +932,75 @@ npubsCmd
 
 npubsCmd
   .command("add <npub>")
-  .description("Add an admin npub (hex pubkey or npub1...)")
-  .action(async (npubArg: string) => {
+  .description("Add a npub (hex pubkey or npub1...). Defaults to 'user' role unless --role is specified.")
+  .option("-r, --role <role>", "Role for the npub: 'admin' or 'user' (default: 'user')", "user")
+  .action(async (npubArg: string, options: { role: string }) => {
     await ensureDaemonRunning();
     const normalized = normalizeNostrPubkey(npubArg);
     if (!normalized) {
       console.error("Invalid npub value. Use npub1... or 64-char hex pubkey.");
       process.exit(1);
     }
+    if (options.role !== "admin" && options.role !== "user") {
+      console.error("Invalid role. Expected 'admin' or 'user'.");
+      process.exit(1);
+    }
+    const body: Record<string, string> = { npub: npubFromPubkey(normalized), role: options.role };
     const result = await callDaemon("/npubs", {
       method: "POST",
-      body: { npub: npubFromPubkey(normalized) },
+      body,
     });
     if (result.error) {
       console.log(result.error);
       process.exit(1);
     }
     const output = result.output as
-      | { npub?: string; added?: boolean; error?: string }
+      | { npub?: string; role?: string; added?: boolean; error?: string }
       | undefined;
     if (output?.npub) {
       console.log(
-        `${output.added ? "Added" : "Already configured"} admin npub: ${output.npub}`,
+        `${output.added ? "Added" : "Already configured"} npub: ${output.npub} [${output.role ?? "user"}]`,
       );
     }
   });
 
+npubsCmd
+  .command("update <npub>")
+  .description("Update the role of an existing npub (requires admin)")
+  .requiredOption("-r, --role <role>", "New role: 'admin' or 'user'")
+  .action(async (npubArg: string, options: { role: string }) => {
+    await ensureDaemonRunning();
+    const normalized = normalizeNostrPubkey(npubArg);
+    if (!normalized) {
+      console.error("Invalid npub value. Use npub1... or 64-char hex pubkey.");
+      process.exit(1);
+    }
+    if (options.role !== "admin" && options.role !== "user") {
+      console.error("Invalid role. Expected 'admin' or 'user'.");
+      process.exit(1);
+    }
+    const result = await callDaemon("/npubs", {
+      method: "PATCH",
+      body: { npub: npubFromPubkey(normalized), role: options.role },
+    });
+    if (result.error) {
+      console.log(result.error);
+      process.exit(1);
+    }
+    // PATCH /npubs returns { npub, pubkey, role } at the top level, not wrapped in { output }
+    const data = (result.output ?? result) as
+      | { npub?: string; pubkey?: string; role?: string; error?: string }
+      | undefined;
+    if (data?.npub) {
+      console.log(`Updated npub ${data.npub} role to '${data.role}'.`);
+    } else {
+      console.log("Npub not found or update failed.");
+    }
+  });
+
 npubsCmd
   .command("delete <npub>")
-  .description("Delete an admin npub (hex pubkey or npub1...)")
+  .description("Delete an npub (hex pubkey or npub1...)")
   .action(async (npubArg: string) => {
     await ensureDaemonRunning();
     const normalized = normalizeNostrPubkey(npubArg);

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/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();