riskmodels 2.0.0

package/dist/commands/uninstall.js

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { detectClients, selectedClients } from "../lib/mcp-config-paths.js";
+import { printResults } from "../lib/display.js";
+import { uninstallMcpConfig } from "../lib/mcp-config-writer.js";
+export function uninstallCommand() {
+    return new Command("uninstall")
+        .description("Remove the RiskModels MCP server from client configs")
+        .option("--client <name>", "claude | cursor | codex | vscode")
+        .option("--all", "Check all supported clients")
+        .option("--dry-run", "Show planned removals without writing")
+        .option("--json", "JSON output")
+        .action(async (opts, cmd) => {
+        const json = opts.json || cmd.optsWithGlobals().json || false;
+        const clients = selectedClients({ client: opts.client, all: opts.all });
+        const detections = await detectClients(clients);
+        const dryRun = opts.dryRun ?? false;
+        const output = {
+            dryRun,
+            plannedAction: "Remove only the `riskmodels` MCP server block from detected client configs.",
+            preservesSharedApiKey: true,
+            clients: detections.map((detection) => ({
+                client: detection.client,
+                label: detection.label,
+                configPath: detection.configPath,
+                mode: detection.mode,
+                status: detection.status,
+                notes: detection.notes,
+            })),
+        };
+        if (dryRun) {
+            printResults(output, json);
+            return;
+        }
+        const removals = await Promise.all(detections.map((detection) => uninstallMcpConfig(detection)));
+        printResults({ ...output, removals }, json);
+        if (removals.some((removal) => removal.action === "error")) {
+            process.exitCode = 1;
+            return;
+        }
+        if (!json) {
+            console.error(chalk.green("RiskModels MCP uninstall completed with backups where files changed."));
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import { configCommand } from "./commands/config.js";
+import { queryCommand } from "./commands/query.js";
+import { schemaCommand } from "./commands/schema.js";
+import { balanceCommand } from "./commands/balance.js";
+import { manifestCommand } from "./commands/manifest.js";
+import { mcpConfigCommand } from "./commands/mcp-config.js";
+import { mcpServeCommand } from "./commands/mcp.js";
+import { agentCommand } from "./commands/agent.js";
+import { metricsCommand } from "./commands/metrics.js";
+import { batchCommand } from "./commands/batch.js";
+import { portfolioCommand } from "./commands/portfolio.js";
+import { tickersCommand } from "./commands/tickers.js";
+import { healthCommand } from "./commands/health.js";
+import { estimateCommand } from "./commands/estimate.js";
+import { returnsCommand } from "./commands/returns.js";
+import { l3Command } from "./commands/l3.js";
+import { correlationCommand } from "./commands/correlation.js";
+import { macroFactorsCommand } from "./commands/macro-factors.js";
+import { rankingsCommand } from "./commands/rankings.js";
+import { installCommand } from "./commands/install.js";
+import { statusCommand } from "./commands/status.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { uninstallCommand } from "./commands/uninstall.js";
+const program = new Command();
+program
+    .name("riskmodels")
+    .description("RiskModels CLI — REST API, SQL query, schema, billing, and agent manifests")
+    .version("2.0.0", "-V, --version", "output version")
+    .option("--json", "JSON output for supported commands (query, schema, balance, API calls, config list)")
+    .configureHelp({ sortSubcommands: true })
+    .addHelpText("after", `
+${chalk.bold("Quick start")}
+  ${chalk.dim("$")} riskmodels config init
+  ${chalk.dim("$")} riskmodels install --dry-run
+  ${chalk.dim("$")} riskmodels health
+  ${chalk.dim("$")} riskmodels metrics NVDA
+  ${chalk.dim("$")} riskmodels query ${chalk.green('"SELECT ticker FROM ticker_metadata LIMIT 3"')}
+  ${chalk.dim("$")} riskmodels manifest --format anthropic
+
+${chalk.bold("Docs")} https://riskmodels.app/docs/api`);
+program.addCommand(configCommand());
+program.addCommand(installCommand());
+program.addCommand(statusCommand());
+program.addCommand(doctorCommand());
+program.addCommand(uninstallCommand());
+program.addCommand(queryCommand());
+program.addCommand(metricsCommand());
+program.addCommand(batchCommand());
+program.addCommand(portfolioCommand());
+program.addCommand(returnsCommand());
+program.addCommand(l3Command());
+program.addCommand(correlationCommand());
+program.addCommand(macroFactorsCommand());
+program.addCommand(rankingsCommand());
+program.addCommand(tickersCommand());
+program.addCommand(healthCommand());
+program.addCommand(estimateCommand());
+program.addCommand(schemaCommand());
+program.addCommand(balanceCommand());
+program.addCommand(manifestCommand());
+program.addCommand(mcpConfigCommand());
+program.addCommand(mcpServeCommand());
+program.addCommand(agentCommand());
+await program.parseAsync(process.argv);

package/dist/lib/api-client.d.ts

@@ -0,0 +1,22 @@
+import type { ResolvedApiAuth } from "./credentials.js";
+/** Thrown on non-2xx API responses so callers can inspect `status` (e.g. retries on 503). */
+export declare class ApiHttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export type ApiJsonResult = {
+    body: unknown;
+    costUsd?: string;
+    status: number;
+    headers: Headers;
+};
+export declare function apiFetchJson(auth: ResolvedApiAuth, method: string, path: string, options?: {
+    query?: Record<string, string | number | boolean | undefined | null>;
+    jsonBody?: unknown;
+}): Promise<ApiJsonResult>;
+export declare function apiFetchOptionalAuth(apiRoot: string, method: string, path: string, options?: {
+    query?: Record<string, string | number | boolean | undefined | null>;
+    jsonBody?: unknown;
+    auth?: ResolvedApiAuth | null;
+    signal?: AbortSignal;
+}): Promise<ApiJsonResult>;

package/dist/lib/api-client.js

@@ -0,0 +1,100 @@
+import { getAuthorizationHeader, invalidateAuthForRetry } 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;
+    constructor(status, message) {
+        super(message);
+        this.name = "ApiHttpError";
+        this.status = status;
+    }
+}
+function errorMessageFromBody(body) {
+    if (body && typeof body === "object") {
+        const o = body;
+        const msg = o.message ?? o.error;
+        if (typeof msg === "string" && msg.trim())
+            return msg;
+        const detail = o.detail;
+        if (typeof detail === "string" && detail.trim())
+            return detail;
+    }
+    return "";
+}
+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 };
+    }
+    throw new Error("Unreachable");
+}
+export async function apiFetchOptionalAuth(apiRoot, method, path, options) {
+    const url = buildUrl(apiRoot, path, options?.query);
+    const headers = { Accept: "application/json" };
+    if (options?.auth) {
+        Object.assign(headers, await getAuthorizationHeader(options.auth));
+    }
+    if (options?.jsonBody !== undefined) {
+        headers["Content-Type"] = "application/json";
+    }
+    const res = await fetch(url, {
+        method,
+        headers,
+        body: options?.jsonBody !== undefined ? JSON.stringify(options.jsonBody) : undefined,
+        signal: options?.signal,
+    });
+    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 };
+}
+function buildUrl(apiRoot, path, query) {
+    const base = apiRoot.replace(/\/$/, "");
+    const p = path.startsWith("/") ? path : `/${path}`;
+    const u = new URL(base + p);
+    if (query) {
+        for (const [k, v] of Object.entries(query)) {
+            if (v === undefined || v === null)
+                continue;
+            u.searchParams.set(k, String(v));
+        }
+    }
+    return u.toString();
+}

package/dist/lib/api-url.d.ts

@@ -0,0 +1,2 @@
+/** User-facing base is usually `https://riskmodels.app`; SDK uses `…/api`. */
+export declare function apiRootFromUserBase(apiBaseUrl: string | undefined): string;

package/dist/lib/api-url.js

@@ -0,0 +1,8 @@
+import { DEFAULT_API_BASE } from "./config.js";
+/** User-facing base is usually `https://riskmodels.app`; SDK uses `…/api`. */
+export function apiRootFromUserBase(apiBaseUrl) {
+    const raw = (apiBaseUrl ?? DEFAULT_API_BASE).replace(/\/$/, "");
+    if (raw.endsWith("/api"))
+        return raw;
+    return `${raw}/api`;
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,22 @@
+export type AuthMode = "billed" | "direct";
+export interface RiskmodelsConfig {
+    mode: AuthMode;
+    apiKey?: string;
+    /** 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;
+}
+export declare const DEFAULT_API_BASE = "https://riskmodels.app";
+export declare function configPath(): string;
+export declare function loadConfig(): Promise<RiskmodelsConfig | null>;
+export declare function saveConfig(cfg: RiskmodelsConfig): Promise<void>;
+export declare function maskSecret(value: string | undefined, visible?: number): string;
+export declare function isBilledReady(cfg: RiskmodelsConfig | null): boolean;
+export declare function isDirectReady(cfg: RiskmodelsConfig | null): boolean;
+export declare function needsConfigMessage(): string;
+export declare function needsApiKeyMessage(): string;

package/dist/lib/config.js

@@ -0,0 +1,46 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+export const DEFAULT_API_BASE = "https://riskmodels.app";
+export function configPath() {
+    return path.join(homedir(), ".config", "riskmodels", "config.json");
+}
+export async function loadConfig() {
+    const p = configPath();
+    try {
+        const raw = await readFile(p, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveConfig(cfg) {
+    const p = configPath();
+    await mkdir(path.dirname(p), { recursive: true });
+    await writeFile(p, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+}
+export function maskSecret(value, visible = 6) {
+    if (!value)
+        return "(not set)";
+    if (value.length <= visible)
+        return "***";
+    return `${value.slice(0, visible)}...`;
+}
+export function isBilledReady(cfg) {
+    return (!!cfg &&
+        cfg.mode === "billed" &&
+        (!!cfg.apiKey?.trim() || (!!cfg.clientId?.trim() && !!cfg.clientSecret?.trim())));
+}
+export function isDirectReady(cfg) {
+    return (!!cfg &&
+        cfg.mode === "direct" &&
+        !!cfg.supabaseUrl?.trim() &&
+        !!cfg.serviceRoleKey?.trim());
+}
+export function needsConfigMessage() {
+    return "Supabase credentials not configured. Run: riskmodels config init";
+}
+export function needsApiKeyMessage() {
+    return "API key not configured. Run: riskmodels config init (billed mode) or: riskmodels config set apiKey <rm_agent_...>";
+}

package/dist/lib/credentials.d.ts

@@ -0,0 +1,26 @@
+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";
+export type ResolvedApiAuth = {
+    apiRoot: string;
+    /** Static Bearer (API key) — preferred when set */
+    apiKey?: string;
+    oauth?: {
+        clientId: string;
+        clientSecret: string;
+        scope: string;
+    };
+};
+export declare function resolveApiAuth(cfg: RiskmodelsConfig | null): ResolvedApiAuth | null;
+/** True when user has API key or OAuth credentials (config and/or env). */
+export declare function hasRestApiCredentials(cfg: RiskmodelsConfig | null): boolean;
+/**
+ * REST analytics require Bearer auth. Direct (Supabase-only) config is OK if env provides credentials.
+ */
+export declare function assertRestApiAuth(cfg: RiskmodelsConfig | null, chalkYellow: (s: string) => string): void;
+/** 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

@@ -0,0 +1,70 @@
+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;
+}
+export function resolveApiAuth(cfg) {
+    const apiRoot = apiRootFromUserBase(cfg?.apiBaseUrl);
+    const apiKey = cfg?.apiKey?.trim() || trimEnv("RISKMODELS_API_KEY");
+    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). */
+export function hasRestApiCredentials(cfg) {
+    return resolveApiAuth(cfg) !== null;
+}
+/**
+ * REST analytics require Bearer auth. Direct (Supabase-only) config is OK if env provides credentials.
+ */
+export function assertRestApiAuth(cfg, chalkYellow) {
+    if (hasRestApiCredentials(cfg))
+        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), " +
+            "or run `riskmodels config init` in billed mode."));
+        process.exitCode = 1;
+        return;
+    }
+    console.error(chalkYellow("API credentials not configured. Run: riskmodels config init"));
+    process.exitCode = 1;
+}
+/** Returns auth or sets process.exitCode and prints via assertRestApiAuth. */
+export function requireResolvedAuth(cfg, chalkYellow) {
+    const auth = resolveApiAuth(cfg);
+    if (auth)
+        return auth;
+    assertRestApiAuth(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);
+    }
+}
+/** Public origin for docs (no `/api` suffix). */
+export function displayApiOrigin(cfg) {
+    return (cfg?.apiBaseUrl ?? DEFAULT_API_BASE).replace(/\/$/, "").replace(/\/api$/, "");
+}

package/dist/lib/display.d.ts

@@ -0,0 +1 @@
+export declare function printResults(data: unknown, asJson: boolean): void;

package/dist/lib/display.js

@@ -0,0 +1,19 @@
+export function printResults(data, asJson) {
+    if (asJson) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    if (data === null || data === undefined) {
+        console.log("(no data)");
+        return;
+    }
+    if (Array.isArray(data) && data.length > 0 && typeof data[0] === "object") {
+        console.table(data);
+        return;
+    }
+    if (typeof data === "object") {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    console.log(String(data));
+}

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

@@ -0,0 +1,16 @@
+export type InstallClient = "claude" | "cursor" | "codex" | "vscode";
+export interface ClientDetection {
+    client: InstallClient;
+    label: string;
+    mode: "auto-write" | "command" | "guidance";
+    status: "found" | "missing" | "unknown";
+    configPath?: string;
+    commandAvailable?: boolean;
+    notes: string[];
+}
+export declare function selectedClients(opts: {
+    client?: string;
+    all?: boolean;
+}): InstallClient[];
+export declare function detectClient(client: InstallClient, cwd?: string): Promise<ClientDetection>;
+export declare function detectClients(clients: InstallClient[], cwd?: string): Promise<ClientDetection[]>;

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

@@ -0,0 +1,100 @@
+import { access } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function commandAvailable(command, args = ["--version"]) {
+    const result = spawnSync(command, args, { stdio: "ignore" });
+    return result.status === 0 || result.status === 1;
+}
+function claudeDesktopPath() {
+    const home = homedir();
+    const os = platform();
+    if (os === "darwin") {
+        return path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (os === "win32") {
+        return path.join(process.env.APPDATA ?? path.join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    }
+    return path.join(home, ".config", "Claude", "claude_desktop_config.json");
+}
+export function selectedClients(opts) {
+    if (opts.all || !opts.client)
+        return ["claude", "cursor", "codex", "vscode"];
+    const value = opts.client.toLowerCase();
+    if (!["claude", "cursor", "codex", "vscode"].includes(value)) {
+        throw new Error(`Unknown client: ${opts.client}. Use claude, cursor, codex, vscode, or --all.`);
+    }
+    return [value];
+}
+export async function detectClient(client, cwd = process.cwd()) {
+    if (client === "claude") {
+        const configPath = claudeDesktopPath();
+        const claudeCodeAvailable = commandAvailable("claude", ["--version"]);
+        const found = (await exists(configPath)) || claudeCodeAvailable;
+        return {
+            client,
+            label: "Claude Desktop / Claude Code",
+            mode: claudeCodeAvailable ? "command" : "auto-write",
+            status: found ? "found" : "missing",
+            configPath,
+            commandAvailable: claudeCodeAvailable,
+            notes: [
+                claudeCodeAvailable
+                    ? "Claude Code CLI detected; future safe-write flow should prefer `claude mcp add`."
+                    : "Claude Code CLI not detected; Claude Desktop config path is the fallback target.",
+            ],
+        };
+    }
+    if (client === "cursor") {
+        const globalPath = path.join(homedir(), ".cursor", "mcp.json");
+        const projectPath = path.join(cwd, ".cursor", "mcp.json");
+        const globalExists = await exists(globalPath);
+        const projectExists = await exists(projectPath);
+        return {
+            client,
+            label: "Cursor",
+            mode: "auto-write",
+            status: globalExists || projectExists ? "found" : "missing",
+            configPath: globalExists ? globalPath : projectPath,
+            notes: [
+                globalExists
+                    ? "Global Cursor MCP config exists."
+                    : "Workspace .cursor/mcp.json is the first dry-run target; safe writes should ask before project-scoped edits.",
+            ],
+        };
+    }
+    if (client === "codex") {
+        const configPath = path.join(homedir(), ".codex", "config.toml");
+        return {
+            client,
+            label: "Codex",
+            mode: "auto-write",
+            status: (await exists(configPath)) ? "found" : "missing",
+            configPath,
+            notes: ["Codex uses TOML config; safe-write flow must validate TOML before and after merge."],
+        };
+    }
+    const codeAvailable = commandAvailable("code", ["--version"]);
+    return {
+        client,
+        label: "VS Code",
+        mode: "guidance",
+        status: codeAvailable ? "found" : "unknown",
+        commandAvailable: codeAvailable,
+        notes: [
+            "VS Code support is detect + guidance only in v1; no auto-write target is selected until the MCP extension/config surface is verified.",
+        ],
+    };
+}
+export async function detectClients(clients, cwd = process.cwd()) {
+    return Promise.all(clients.map((client) => detectClient(client, cwd)));
+}

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

@@ -0,0 +1,36 @@
+import type { ClientDetection } from "./mcp-config-paths.js";
+export interface ConfigWriteResult {
+    client: string;
+    label: string;
+    configPath?: string;
+    action: "written" | "skipped" | "error";
+    backupPath?: string;
+    message: string;
+}
+export interface SafeWriteOptions {
+    apiKey?: string;
+    embedKey?: boolean;
+    apiBaseUrl?: string;
+    now?: Date;
+}
+export interface SharedConfigWriteResult {
+    configPath: string;
+    backupPath?: string;
+    message: string;
+}
+export declare function mergeJsonMcpConfig(existingText: string, mcpServer: unknown): string;
+export declare function mergeCodexTomlConfig(existingText: string, mcpServer: unknown): string;
+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>;
+export declare function removeJsonMcpConfig(existingText: string): {
+    text: string;
+    removed: boolean;
+};
+export declare function removeCodexTomlConfig(existingText: string): {
+    text: string;
+    removed: boolean;
+};
+export declare function uninstallMcpConfig(detection: ClientDetection, opts?: {
+    now?: Date;
+}): Promise<ConfigWriteResult>;