riskmodels 2.0.2 → 2.1.0

package/dist/commands/install.js

@@ -3,11 +3,11 @@ import inquirer from "inquirer";
 import chalk from "chalk";
 import { configPath, DEFAULT_API_BASE, loadConfig, sharedRiskmodelsConfigExists, } from "../lib/config.js";
 import { detectClients, selectedClients } from "../lib/mcp-config-paths.js";
-import { buildInstallPlans, firstPrompt } from "../lib/mcp-install-plan.js";
+import { buildInstallPlans, firstPrompt, looksLikeRiskmodelsKey, } from "../lib/mcp-install-plan.js";
 import { printResults } from "../lib/display.js";
 import { API_KEY_EMAIL_HINT, printInstallDryRunHuman, printInstallMissingKeyHuman, printInstallSuccessHuman, } from "../lib/mcp-cli-human-output.js";
 import { redactSecret } from "../lib/redact.js";
-import { installMcpConfig, writeSharedApiKey } from "../lib/mcp-config-writer.js";
+import { installClaudeCodeRemote, installMcpConfig, writeSharedApiKey, } from "../lib/mcp-config-writer.js";
 import { apiRootFromUserBase } from "../lib/api-url.js";
 import { apiFetchOptionalAuth } from "../lib/api-client.js";
 import { warnIfGlobalJsonBeforeSubcommand } from "../lib/global-json-hint.js";
@@ -64,7 +64,9 @@ export function installCommand() {
         .option("--api-key <key>", "RiskModels API key for one-shot setup")
         .option("--dry-run", "Show planned config changes without writing")
         .option("--yes", "Non-interactive mode")
-        .option("--embed-key", "Explicitly embed the API key in MCP config env (not recommended)")
+        .option("--remote", "Use the hosted endpoint via mcp-remote (default)")
+        .option("--local", "Use the local stdio server (npx @riskmodels/mcp) instead of the hosted endpoint")
+        .option("--embed-key", "Local stdio only: embed the API key in MCP config env (not recommended)")
         .option("--json", "Structured JSON instead of formatted text (matches historical output shape)")
         .action(async (opts, cmd) => {
         const json = opts.json || cmd.optsWithGlobals().json || false;
@@ -78,19 +80,36 @@ export function installCommand() {
             return;
         }
         const dryRun = opts.dryRun ?? false;
+        const transport = opts.local ? "local" : "remote";
         const { apiKey, source } = await resolveApiKey(opts);
+        if (apiKey && !looksLikeRiskmodelsKey(apiKey)) {
+            const msg = 'That does not look like a RiskModels API key (expected an "rm_…" value). ' +
+                "Get one at https://riskmodels.app/get-key";
+            if (json) {
+                warnIfGlobalJsonBeforeSubcommand("install");
+                printResults({ error: msg, apiKey: { source } }, json);
+            }
+            else {
+                console.error(chalk.red(msg));
+            }
+            process.exitCode = 1;
+            return;
+        }
         const detections = await detectClients(clients);
-        const plans = buildInstallPlans(detections, { apiKey, embedKey: opts.embedKey });
+        const plans = buildInstallPlans(detections, { apiKey, embedKey: opts.embedKey, transport });
         const existingConfig = await loadConfig();
         const output = {
             dryRun,
+            transport,
             apiKey: {
                 found: !!apiKey,
                 source,
                 value: redactSecret(apiKey),
                 storage: configPath(),
                 willStoreInSharedConfig: !!apiKey && source !== configPath() && !dryRun,
-                embeddedInMcpConfig: !!opts.embedKey,
+                // Remote always carries the key in the Authorization header; local only
+                // embeds it when --embed-key is passed.
+                embeddedInMcpConfig: transport === "remote" ? !!apiKey : !!opts.embedKey,
             },
             clients: plans,
             firstPrompt: firstPrompt(),
@@ -128,11 +147,19 @@ export function installCommand() {
         }
         const sharedBefore = await sharedRiskmodelsConfigExists();
         const sharedConfigWrite = await writeSharedApiKey(apiKey, existingConfig?.apiBaseUrl ?? DEFAULT_API_BASE);
-        const writes = await Promise.all(detections.map((detection) => installMcpConfig(detection, {
-            apiKey,
-            embedKey: opts.embedKey,
-            apiBaseUrl: existingConfig?.apiBaseUrl,
-        })));
+        const writes = await Promise.all(detections.map((detection) => {
+            // Claude Code reads its own config, not claude_desktop_config.json —
+            // register via its CLI over HTTP transport instead of writing Desktop JSON.
+            if (transport === "remote" && detection.client === "claude" && detection.commandAvailable) {
+                return Promise.resolve(installClaudeCodeRemote(detection, { apiKey }));
+            }
+            return installMcpConfig(detection, {
+                apiKey,
+                embedKey: opts.embedKey,
+                apiBaseUrl: existingConfig?.apiBaseUrl,
+                transport,
+            });
+        }));
         const test = await connectionTest(existingConfig?.apiBaseUrl);
         const result = {
             ...output,
@@ -152,7 +179,7 @@ export function installCommand() {
                 connectionTest: test,
                 firstPrompt: firstPrompt(),
                 hadErrors: writes.some((w) => w.action === "error") || !test.ok,
-                showClaudeCodeMcpTip: detections.some((d) => d.client === "claude" && d.commandAvailable),
+                showClaudeCodeMcpTip: transport === "local" && detections.some((d) => d.client === "claude" && d.commandAvailable),
             });
         }
         if (writes.some((write) => write.action === "error") || !test.ok) {

package/dist/lib/mcp-config-writer.d.ts

@@ -1,4 +1,5 @@
 import type { ClientDetection } from "./mcp-config-paths.js";
+import { type McpTransport } from "./mcp-install-plan.js";
 export interface ConfigWriteResult {
     client: string;
     label: string;
@@ -11,6 +12,7 @@ export interface SafeWriteOptions {
     apiKey?: string;
     embedKey?: boolean;
     apiBaseUrl?: string;
+    transport?: McpTransport;
     now?: Date;
 }
 export interface SharedConfigWriteResult {
@@ -23,6 +25,16 @@ export declare function mergeCodexTomlConfig(existingText: string, mcpServer: un
 export declare function validateRiskmodelsToml(text: string): void;
 export declare function writeSharedApiKey(apiKey: string, apiBaseUrl?: string, now?: Date): Promise<SharedConfigWriteResult>;
 export declare function installMcpConfig(detection: ClientDetection, opts?: SafeWriteOptions): Promise<ConfigWriteResult>;
+/**
+ * Register the hosted endpoint with Claude Code via its own CLI
+ * (`claude mcp add --transport http …`) instead of writing Desktop JSON —
+ * Claude Code reads its own config, not claude_desktop_config.json. Idempotent:
+ * removes any existing `riskmodels` entry first so re-running doesn't error on
+ * "already exists". Used for the remote transport when the `claude` CLI is present.
+ */
+export declare function installClaudeCodeRemote(detection: ClientDetection, opts?: {
+    apiKey?: string;
+}): ConfigWriteResult;
 export declare function removeJsonMcpConfig(existingText: string): {
     text: string;
     removed: boolean;

package/dist/lib/mcp-config-writer.js

@@ -1,7 +1,8 @@
 import { mkdir, readFile, writeFile, copyFile } from "node:fs/promises";
+import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { configPath, DEFAULT_API_BASE, loadConfig } from "./config.js";
-import { defaultMcpServerConfig } from "./mcp-install-plan.js";
+import { claudeCodeRemoteAddArgs, mcpServerConfigFor, } from "./mcp-install-plan.js";
 const RISKMODELS_SERVER_NAME = "riskmodels";
 const TOML_MANAGED_HEADER = "# RiskModels MCP (managed by riskmodels CLI)";
 function timestamp(date = new Date()) {
@@ -165,7 +166,7 @@ export async function installMcpConfig(detection, opts = {}) {
     }
     try {
         const { exists, text } = await readIfExists(detection.configPath);
-        const mcpServer = defaultMcpServerConfig(opts.apiKey, !!opts.embedKey);
+        const mcpServer = mcpServerConfigFor(opts.transport ?? "remote", opts.apiKey, !!opts.embedKey);
         const nextText = detection.client === "codex"
             ? mergeCodexTomlConfig(text, mcpServer)
             : mergeJsonMcpConfig(text, mcpServer);
@@ -189,6 +190,42 @@ export async function installMcpConfig(detection, opts = {}) {
         };
     }
 }
+/**
+ * Register the hosted endpoint with Claude Code via its own CLI
+ * (`claude mcp add --transport http …`) instead of writing Desktop JSON —
+ * Claude Code reads its own config, not claude_desktop_config.json. Idempotent:
+ * removes any existing `riskmodels` entry first so re-running doesn't error on
+ * "already exists". Used for the remote transport when the `claude` CLI is present.
+ */
+export function installClaudeCodeRemote(detection, opts = {}) {
+    const base = {
+        client: detection.client,
+        label: detection.label,
+        configPath: detection.configPath,
+    };
+    // Best-effort removal of a prior entry — ignore failure (none registered yet).
+    spawnSync("claude", ["mcp", "remove", "--scope", "user", "riskmodels"], { stdio: "ignore" });
+    const res = spawnSync("claude", claudeCodeRemoteAddArgs(opts.apiKey), {
+        stdio: "pipe",
+        encoding: "utf8",
+    });
+    if (res.error) {
+        return { ...base, action: "error", message: `Failed to run \`claude\`: ${res.error.message}` };
+    }
+    if (res.status === 0) {
+        return {
+            ...base,
+            action: "written",
+            message: "Registered with Claude Code via `claude mcp add --transport http` (user scope).",
+        };
+    }
+    const detail = (res.stderr || res.stdout || "").trim();
+    return {
+        ...base,
+        action: "error",
+        message: detail || `\`claude mcp add\` exited with status ${res.status ?? "unknown"}.`,
+    };
+}
 export function removeJsonMcpConfig(existingText) {
     const parsed = existingText.trim() ? JSON.parse(existingText) : {};
     assertPlainObject(parsed, "MCP config");

package/dist/lib/mcp-install-plan.d.ts

@@ -8,9 +8,39 @@ export interface InstallPlan {
     notes: string[];
     mcpServer: unknown;
 }
+/** Hosted MCP endpoint (Streamable HTTP). Key-first auth, no npm publish needed. */
+export declare const REMOTE_MCP_URL = "https://riskmodels.app/api/mcp/sse";
+export type McpTransport = "remote" | "local";
+/**
+ * Local stdio path: runs the published `@riskmodels/mcp` server via npx. The key
+ * is read from the shared config by default; `--embed-key` writes it into env.
+ */
 export declare function defaultMcpServerConfig(apiKey?: string, embedKey?: boolean): unknown;
+/**
+ * Remote path (default): bridges a stdio client to the hosted endpoint via
+ * `mcp-remote`. The key rides in an `Authorization: Bearer` header — kept out of
+ * the URL so it never lands in server access logs or referrers. Works today with
+ * no npm publish dependency.
+ */
+export declare function remoteMcpServerConfig(apiKey?: string): unknown;
+/**
+ * Native `claude mcp add` args for Claude Code — registers the hosted endpoint
+ * over HTTP transport at user scope (no mcp-remote shim needed; Claude Code
+ * speaks Streamable HTTP directly).
+ */
+export declare function claudeCodeRemoteAddArgs(apiKey?: string): string[];
+export declare function mcpServerConfigFor(transport: McpTransport, apiKey?: string, embedKey?: boolean): unknown;
+/** RiskModels keys are `rm_agent_live_…` / `rm_…`. Cheap client-side sanity check. */
+export declare function looksLikeRiskmodelsKey(key: string): boolean;
+/**
+ * Mask `Authorization: Bearer <token>` strings anywhere in a config tree.
+ * `redactJson` only masks values whose *key name* matches (e.g. `env.RISKMODELS_API_KEY`);
+ * the remote header lives inside an `args` string, so it needs this pass too.
+ */
+export declare function redactBearerStrings(value: unknown): unknown;
 export declare function buildInstallPlans(detections: ClientDetection[], opts: {
     apiKey?: string;
     embedKey?: boolean;
+    transport: McpTransport;
 }): InstallPlan[];
 export declare function firstPrompt(): string;

package/dist/lib/mcp-install-plan.js

@@ -1,4 +1,10 @@
-import { redactJson } from "./redact.js";
+import { redactJson, redactSecret } from "./redact.js";
+/** Hosted MCP endpoint (Streamable HTTP). Key-first auth, no npm publish needed. */
+export const REMOTE_MCP_URL = "https://riskmodels.app/api/mcp/sse";
+/**
+ * Local stdio path: runs the published `@riskmodels/mcp` server via npx. The key
+ * is read from the shared config by default; `--embed-key` writes it into env.
+ */
 export function defaultMcpServerConfig(apiKey, embedKey = false) {
     return {
         command: "npx",
@@ -12,16 +18,76 @@ export function defaultMcpServerConfig(apiKey, embedKey = false) {
             : {}),
     };
 }
+/**
+ * Remote path (default): bridges a stdio client to the hosted endpoint via
+ * `mcp-remote`. The key rides in an `Authorization: Bearer` header — kept out of
+ * the URL so it never lands in server access logs or referrers. Works today with
+ * no npm publish dependency.
+ */
+export function remoteMcpServerConfig(apiKey) {
+    const args = ["-y", "mcp-remote", REMOTE_MCP_URL];
+    if (apiKey) {
+        args.push("--header", `Authorization: Bearer ${apiKey}`);
+    }
+    return { command: "npx", args };
+}
+/**
+ * Native `claude mcp add` args for Claude Code — registers the hosted endpoint
+ * over HTTP transport at user scope (no mcp-remote shim needed; Claude Code
+ * speaks Streamable HTTP directly).
+ */
+export function claudeCodeRemoteAddArgs(apiKey) {
+    const args = ["mcp", "add", "--scope", "user", "--transport", "http", "riskmodels", REMOTE_MCP_URL];
+    if (apiKey) {
+        args.push("--header", `Authorization: Bearer ${apiKey}`);
+    }
+    return args;
+}
+export function mcpServerConfigFor(transport, apiKey, embedKey = false) {
+    return transport === "remote"
+        ? remoteMcpServerConfig(apiKey)
+        : defaultMcpServerConfig(apiKey, embedKey);
+}
+/** RiskModels keys are `rm_agent_live_…` / `rm_…`. Cheap client-side sanity check. */
+export function looksLikeRiskmodelsKey(key) {
+    return /^rm_[A-Za-z0-9_]+$/.test(key.trim());
+}
+/**
+ * Mask `Authorization: Bearer <token>` strings anywhere in a config tree.
+ * `redactJson` only masks values whose *key name* matches (e.g. `env.RISKMODELS_API_KEY`);
+ * the remote header lives inside an `args` string, so it needs this pass too.
+ */
+export function redactBearerStrings(value) {
+    if (Array.isArray(value))
+        return value.map(redactBearerStrings);
+    if (typeof value === "string") {
+        const m = value.match(/^(Authorization:\s*Bearer\s+)(.+)$/i);
+        return m ? `${m[1]}${redactSecret(m[2])}` : value;
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = redactBearerStrings(v);
+        return out;
+    }
+    return value;
+}
 export function buildInstallPlans(detections, opts) {
-    return detections.map((detection) => ({
-        client: detection.client,
-        label: detection.label,
-        status: detection.status,
-        mode: detection.mode,
-        configPath: detection.configPath,
-        notes: detection.notes,
-        mcpServer: redactJson(defaultMcpServerConfig(opts.apiKey, opts.embedKey)),
-    }));
+    return detections.map((detection) => {
+        const claudeCodeNative = opts.transport === "remote" && detection.client === "claude" && detection.commandAvailable;
+        const mcpServer = redactBearerStrings(redactJson(mcpServerConfigFor(opts.transport, opts.apiKey, opts.embedKey)));
+        return {
+            client: detection.client,
+            label: detection.label,
+            status: detection.status,
+            mode: claudeCodeNative ? "command" : detection.mode,
+            configPath: detection.configPath,
+            notes: claudeCodeNative
+                ? [...detection.notes, "Remote: will register via `claude mcp add --transport http` (user scope)."]
+                : detection.notes,
+            mcpServer,
+        };
+    });
 }
 export function firstPrompt() {
     return "Compare AAPL and NVDA using RiskModels. What am I really betting on?";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "riskmodels",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "RiskModels CLI — REST API, SQL query, schema, billing, and agent manifests",
   "type": "module",
   "bin": {