riskmodels 2.0.2 → 3.0.0

package/README.md

@@ -27,9 +27,8 @@ node dist/index.js install --dry-run
 ## Authentication
 
 - **API key (recommended):** `riskmodels config init` (billed mode) or `riskmodels config set apiKey <rm_agent_...>`.
-- **OAuth client credentials:** `riskmodels config set clientId …` and `config set clientSecret …`, or set `RISKMODELS_CLIENT_ID` / `RISKMODELS_CLIENT_SECRET` (optional `RISKMODELS_OAUTH_SCOPE`; default matches the Python SDK).
 - **Environment:** `RISKMODELS_API_KEY` works without a config file for REST commands.
-- **Direct (Supabase) mode** is for `query` + `schema` only. REST analytics need an API key or OAuth (config or env).
+- **Direct (Supabase) mode** is for `query` + `schema` only. REST analytics need an API key (config or env).
 
 Base URL: stored as `apiBaseUrl` (default `https://riskmodels.app`). The CLI calls paths under `…/api/...` (same as `OPENAPI_SPEC.yaml`).
 
@@ -51,7 +50,7 @@ Config file: `~/.config/riskmodels/config.json`
 
 | Command | Description |
 |--------|-------------|
-| `riskmodels config init \| set \| list` | API key, OAuth fields (`clientId`, `clientSecret`, `oauthScope`), `apiBaseUrl`, or Supabase (direct) |
+| `riskmodels config init \| set \| list` | API key, `apiBaseUrl`, or Supabase (direct) |
 | `riskmodels install` | Detect Claude, Cursor, Codex, and VS Code MCP targets, store the API key in shared config, merge MCP configs with backups, and run a connection test. |
 | `riskmodels status` | Show shared config and MCP client detection status. |
 | `riskmodels doctor` | Local install-readiness diagnostics: Node, npx, API credentials, and client detection. |

package/dist/commands/config.js

@@ -76,15 +76,12 @@ export function configCommand() {
     cmd
         .command("set")
         .description("Set a config value")
-        .argument("<key>", "apiKey | apiBaseUrl | clientId | clientSecret | oauthScope | supabaseUrl | serviceRoleKey")
+        .argument("<key>", "apiKey | apiBaseUrl | supabaseUrl | serviceRoleKey")
         .argument("<value>", "value to store")
         .action(async (key, value) => {
         const allowed = new Set([
             "apiKey",
             "apiBaseUrl",
-            "clientId",
-            "clientSecret",
-            "oauthScope",
             "supabaseUrl",
             "serviceRoleKey",
         ]);
@@ -101,18 +98,6 @@ export function configCommand() {
         else if (key === "apiBaseUrl") {
             cfg.apiBaseUrl = value.replace(/\/$/, "");
         }
-        else if (key === "clientId") {
-            cfg.mode = "billed";
-            cfg.clientId = value;
-        }
-        else if (key === "clientSecret") {
-            cfg.mode = "billed";
-            cfg.clientSecret = value;
-        }
-        else if (key === "oauthScope") {
-            cfg.mode = "billed";
-            cfg.oauthScope = value;
-        }
         else if (key === "supabaseUrl") {
             cfg.mode = "direct";
             cfg.supabaseUrl = value.replace(/\/$/, "");
@@ -140,9 +125,6 @@ export function configCommand() {
             mode: cfg.mode,
             apiBaseUrl: cfg.apiBaseUrl ?? DEFAULT_API_BASE,
             apiKey: maskSecret(cfg.apiKey),
-            clientId: maskSecret(cfg.clientId),
-            clientSecret: maskSecret(cfg.clientSecret),
-            oauthScope: cfg.oauthScope ?? "(not set)",
             supabaseUrl: cfg.supabaseUrl ?? "(not set)",
             serviceRoleKey: maskSecret(cfg.serviceRoleKey),
         };

package/dist/commands/doctor.js

@@ -31,7 +31,7 @@ export function doctorCommand() {
             },
             {
                 id: "api_credentials",
-                ok: !!cfg?.apiKey || !!process.env.RISKMODELS_API_KEY || (!!cfg?.clientId && !!cfg?.clientSecret),
+                ok: !!cfg?.apiKey || !!process.env.RISKMODELS_API_KEY,
                 detail: cfg?.apiKey
                     ? `Config API key ${maskSecret(cfg.apiKey)} in ${abbreviatePath(configPath())}`
                     : process.env.RISKMODELS_API_KEY

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/commands/status.js

@@ -20,7 +20,6 @@ export function statusCommand() {
             configFound: !!cfg,
             apiBaseUrl: cfg?.apiBaseUrl ?? "https://riskmodels.app",
             apiKey: maskSecret(cfg?.apiKey),
-            oauthConfigured: !!cfg?.clientId && !!cfg?.clientSecret,
             mcpClients: detections,
         };
         if (json) {

package/dist/lib/api-client.js

@@ -1,4 +1,4 @@
-import { getAuthorizationHeader, invalidateAuthForRetry } from "./credentials.js";
+import { getAuthorizationHeader } from "./credentials.js";
 /** Thrown on non-2xx API responses so callers can inspect `status` (e.g. retries on 503). */
 export class ApiHttpError extends Error {
     status;
@@ -22,38 +22,33 @@ function errorMessageFromBody(body) {
 }
 export async function apiFetchJson(auth, method, path, options) {
     const url = buildUrl(auth.apiRoot, path, options?.query);
-    for (let attempt = 1; attempt <= 2; attempt += 1) {
-        const headers = await getAuthorizationHeader(auth);
-        const init = {
-            method,
-            headers: {
-                ...headers,
-                Accept: "application/json",
-                ...(options?.jsonBody !== undefined ? { "Content-Type": "application/json" } : {}),
-            },
-            body: options?.jsonBody !== undefined ? JSON.stringify(options.jsonBody) : undefined,
-        };
-        const res = await fetch(url, init);
-        if (res.status === 401 && attempt === 1 && auth.oauth) {
-            invalidateAuthForRetry(auth);
-            continue;
-        }
-        const costUsd = res.headers.get("x-api-cost-usd") ?? undefined;
-        const text = await res.text();
-        let body;
-        try {
-            body = text ? JSON.parse(text) : null;
-        }
-        catch {
-            body = { raw: text };
-        }
-        if (!res.ok) {
-            const msg = errorMessageFromBody(body) || `HTTP ${res.status}`;
-            throw new ApiHttpError(res.status, msg);
-        }
-        return { body, costUsd, status: res.status, headers: res.headers };
+    // Single attempt: the retry existed only to refresh an expiring OAuth access
+    // token, and auth is now a static API key with nothing to refresh.
+    const headers = await getAuthorizationHeader(auth);
+    const init = {
+        method,
+        headers: {
+            ...headers,
+            Accept: "application/json",
+            ...(options?.jsonBody !== undefined ? { "Content-Type": "application/json" } : {}),
+        },
+        body: options?.jsonBody !== undefined ? JSON.stringify(options.jsonBody) : undefined,
+    };
+    const res = await fetch(url, init);
+    const costUsd = res.headers.get("x-api-cost-usd") ?? undefined;
+    const text = await res.text();
+    let body;
+    try {
+        body = text ? JSON.parse(text) : null;
     }
-    throw new Error("Unreachable");
+    catch {
+        body = { raw: text };
+    }
+    if (!res.ok) {
+        const msg = errorMessageFromBody(body) || `HTTP ${res.status}`;
+        throw new ApiHttpError(res.status, msg);
+    }
+    return { body, costUsd, status: res.status, headers: res.headers };
 }
 export async function apiFetchOptionalAuth(apiRoot, method, path, options) {
     const url = buildUrl(apiRoot, path, options?.query);

package/dist/lib/cli-human-diagnostics.d.ts

@@ -15,7 +15,6 @@ export type StatusPayload = {
     configFound: boolean;
     apiBaseUrl: string;
     apiKey: string;
-    oauthConfigured: boolean;
     mcpClients: ClientDetection[];
 };
 export declare function printStatusHuman(payload: StatusPayload): void;

package/dist/lib/cli-human-diagnostics.js

@@ -38,7 +38,6 @@ export function printStatusHuman(payload) {
     logLine(`  ${BULLET} ${payload.configFound ? chalk.green("file present") : chalk.dim("file missing (run install or config init)")}`);
     logLine(`  ${BULLET} ${chalk.bold("apiBaseUrl")} ${chalk.dim(payload.apiBaseUrl)}`);
     logLine(`  ${BULLET} ${chalk.bold("API key")} ${payload.apiKey}`);
-    logLine(`  ${BULLET} ${chalk.bold("OAuth")} ${payload.oauthConfigured ? chalk.green("configured") : chalk.dim("not configured")}`);
     logLine("");
     logLine(chalk.bold("MCP-related clients:"));
     for (const d of payload.mcpClients) {

package/dist/lib/config.d.ts

@@ -5,9 +5,6 @@ export interface RiskmodelsConfig {
     /** Base URL without trailing slash, e.g. https://riskmodels.app */
     apiBaseUrl?: string;
     /** OAuth client credentials (billed mode); scope defaults match the Python SDK. */
-    clientId?: string;
-    clientSecret?: string;
-    oauthScope?: string;
     supabaseUrl?: string;
     serviceRoleKey?: string;
 }

package/dist/lib/config.js

@@ -42,7 +42,7 @@ export function maskSecret(value, visible = 6) {
 export function isBilledReady(cfg) {
     return (!!cfg &&
         cfg.mode === "billed" &&
-        (!!cfg.apiKey?.trim() || (!!cfg.clientId?.trim() && !!cfg.clientSecret?.trim())));
+        !!cfg.apiKey?.trim());
 }
 export function isDirectReady(cfg) {
     return (!!cfg &&

package/dist/lib/credentials.d.ts

@@ -1,15 +1,18 @@
 import type { RiskmodelsConfig } from "./config.js";
-/** Matches sdk/riskmodels/client.py DEFAULT_SCOPE. */
-export declare const DEFAULT_OAUTH_SCOPE = "ticker-returns risk-decomposition batch-analysis factor-correlation macro-factor-series rankings";
+/**
+ * Auth is a static Bearer API key. There is no token exchange.
+ *
+ * Removed in 3.0.0: the OAuth client-credentials path. It POSTed a
+ * `client_credentials` grant to `{apiRoot}/auth/token`, an endpoint that was
+ * documented but never implemented — it returns 404, so any invocation
+ * configured that way failed on its first request. The API's only OAuth flow is
+ * authorization-code + PKCE for MCP clients, which issues an `rm_user_*` key
+ * that is used here as a plain API key.
+ */
 export type ResolvedApiAuth = {
     apiRoot: string;
-    /** Static Bearer (API key) — preferred when set */
-    apiKey?: string;
-    oauth?: {
-        clientId: string;
-        clientSecret: string;
-        scope: string;
-    };
+    /** Static Bearer (`rm_agent_*` or `rm_user_*`). */
+    apiKey: string;
 };
 export declare function resolveApiAuth(cfg: RiskmodelsConfig | null): ResolvedApiAuth | null;
 /** True when user has API key or OAuth credentials (config and/or env). */
@@ -21,6 +24,5 @@ export declare function assertRestApiAuth(cfg: RiskmodelsConfig | null, chalkYel
 /** Returns auth or sets process.exitCode and prints via assertRestApiAuth. */
 export declare function requireResolvedAuth(cfg: RiskmodelsConfig | null, chalkYellow: (s: string) => string): ResolvedApiAuth | null;
 export declare function getAuthorizationHeader(auth: ResolvedApiAuth): Promise<Record<string, string>>;
-export declare function invalidateAuthForRetry(auth: ResolvedApiAuth): void;
 /** Public origin for docs (no `/api` suffix). */
 export declare function displayApiOrigin(cfg: RiskmodelsConfig | null): string;

package/dist/lib/credentials.js

@@ -1,8 +1,5 @@
 import { apiRootFromUserBase } from "./api-url.js";
 import { DEFAULT_API_BASE } from "./config.js";
-import { fetchOAuthAccessToken, invalidateOAuthToken } from "./oauth.js";
-/** Matches sdk/riskmodels/client.py DEFAULT_SCOPE. */
-export const DEFAULT_OAUTH_SCOPE = "ticker-returns risk-decomposition batch-analysis factor-correlation macro-factor-series rankings";
 function trimEnv(key) {
     const v = process.env[key];
     return v?.trim() || undefined;
@@ -13,12 +10,6 @@ export function resolveApiAuth(cfg) {
     if (apiKey) {
         return { apiRoot, apiKey };
     }
-    const clientId = cfg?.clientId?.trim() || trimEnv("RISKMODELS_CLIENT_ID");
-    const clientSecret = cfg?.clientSecret?.trim() || trimEnv("RISKMODELS_CLIENT_SECRET");
-    const scope = cfg?.oauthScope?.trim() || trimEnv("RISKMODELS_OAUTH_SCOPE") || DEFAULT_OAUTH_SCOPE;
-    if (clientId && clientSecret) {
-        return { apiRoot, oauth: { clientId, clientSecret, scope } };
-    }
     return null;
 }
 /** True when user has API key or OAuth credentials (config and/or env). */
@@ -33,7 +24,7 @@ export function assertRestApiAuth(cfg, chalkYellow) {
         return;
     if (cfg?.mode === "direct") {
         console.error(chalkYellow("REST API commands need an API key or OAuth client credentials. " +
-            "Set RISKMODELS_API_KEY (or RISKMODELS_CLIENT_ID + RISKMODELS_CLIENT_SECRET), " +
+            "Set RISKMODELS_API_KEY — get a key at https://riskmodels.app/get-key — " +
             "or run `riskmodels config init` in billed mode."));
         process.exitCode = 1;
         return;
@@ -50,19 +41,7 @@ export function requireResolvedAuth(cfg, chalkYellow) {
     return null;
 }
 export async function getAuthorizationHeader(auth) {
-    if (auth.apiKey) {
-        return { Authorization: `Bearer ${auth.apiKey}` };
-    }
-    if (auth.oauth) {
-        const token = await fetchOAuthAccessToken(auth.apiRoot, auth.oauth.clientId, auth.oauth.clientSecret, auth.oauth.scope);
-        return { Authorization: `Bearer ${token}` };
-    }
-    throw new Error("No API credentials");
-}
-export function invalidateAuthForRetry(auth) {
-    if (auth.oauth) {
-        invalidateOAuthToken(auth.apiRoot, auth.oauth.clientId, auth.oauth.scope);
-    }
+    return { Authorization: `Bearer ${auth.apiKey}` };
 }
 /** Public origin for docs (no `/api` suffix). */
 export function displayApiOrigin(cfg) {

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": "3.0.0",
   "description": "RiskModels CLI — REST API, SQL query, schema, billing, and agent manifests",
   "type": "module",
   "bin": {
@@ -11,7 +11,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
     "prepublishOnly": "npm run build",
     "install:global": "npm run build && npm link"
   },

package/dist/lib/oauth.d.ts

@@ -1,2 +0,0 @@
-export declare function invalidateOAuthToken(apiRoot: string, clientId: string, scope: string): void;
-export declare function fetchOAuthAccessToken(apiRoot: string, clientId: string, clientSecret: string, scope: string): Promise<string>;

package/dist/lib/oauth.js

@@ -1,47 +0,0 @@
-const skewSeconds = 60;
-const cache = new Map();
-function cacheKey(apiRoot, clientId, scope) {
-    return `${apiRoot}\0${clientId}\0${scope}`;
-}
-export function invalidateOAuthToken(apiRoot, clientId, scope) {
-    cache.delete(cacheKey(apiRoot, clientId, scope));
-}
-export async function fetchOAuthAccessToken(apiRoot, clientId, clientSecret, scope) {
-    const key = cacheKey(apiRoot, clientId, scope);
-    const now = performance.now();
-    const hit = cache.get(key);
-    if (hit && now < hit.expiresAtMono - skewSeconds * 1000) {
-        return hit.token;
-    }
-    const url = `${apiRoot.replace(/\/$/, "")}/auth/token`;
-    const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            grant_type: "client_credentials",
-            client_id: clientId,
-            client_secret: clientSecret,
-            scope,
-        }),
-    });
-    const text = await res.text();
-    let data;
-    try {
-        data = JSON.parse(text);
-    }
-    catch {
-        throw new Error(`OAuth token: HTTP ${res.status}: ${text.slice(0, 200)}`);
-    }
-    if (!res.ok) {
-        throw new Error(data?.error ?? `OAuth token: HTTP ${res.status}: ${text.slice(0, 200)}`);
-    }
-    if (!data.access_token) {
-        throw new Error("OAuth token response missing access_token");
-    }
-    const expiresIn = Math.max(30, Number(data.expires_in ?? 900));
-    cache.set(key, {
-        token: data.access_token,
-        expiresAtMono: now + expiresIn * 1000,
-    });
-    return data.access_token;
-}