hoomanjs 1.29.1 → 1.30.0

package/dist/configure/app.js

@@ -1,18 +1,17 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
 import { Box, Text, useApp, useInput } from "ink";
 import { LlmProvider, } from "../core/config.js";
+import { McpOAuthConfigSchema, } from "../core/mcp/oauth/types.js";
 import { McpTransportSchema, } from "../core/mcp/types.js";
-import { Storage } from "../core/wiki/storage.js";
 import { basePath, configJsonPath, instructionsMdPath, mcpJsonPath, skillsPath, } from "../core/utils/paths.js";
 import { BusyScreen } from "./components/BusyScreen.js";
 import { HomeScreen } from "./components/HomeScreen.js";
 import { MenuScreen } from "./components/MenuScreen.js";
 import { PromptForm } from "./components/PromptForm.js";
 import { openFileInEditor } from "./open-in-editor.js";
-import { DEFAULT_INSTRUCTIONS, compactJson, folderNameForSkill, normalizeOptional, noticeColor, parseNumber, parseObjectRecord, maskSensitiveParamsForDisplay, parseStringArray, parseStringRecord, transportSummary, truncate, } from "./utils.js";
+import { DEFAULT_INSTRUCTIONS, compactJson, folderNameForSkill, paramsPreview, normalizeOptional, noticeColor, parseOptionalBoolean, parseNumber, parseObjectRecord, maskSensitiveParamsForDisplay, parseStringArray, parseStringRecord, transportSummary, truncate, } from "./utils.js";
 const PROMPT_LABELS = {
     behaviour: "Behaviour",
     communication: "Communication",
@@ -26,10 +25,39 @@ const SEARCH_PROVIDER_LABELS = {
     serper: "Serper",
     tavily: "Tavily",
 };
+const SUPPORTED_PROVIDER_TYPES = [
+    LlmProvider.Anthropic,
+    LlmProvider.Bedrock,
+    LlmProvider.Google,
+    LlmProvider.Groq,
+    LlmProvider.Moonshot,
+    LlmProvider.Ollama,
+    LlmProvider.OpenAI,
+    LlmProvider.Xai,
+];
+function providerParamsTemplate(provider) {
+    switch (provider) {
+        case LlmProvider.Anthropic:
+            return { apiKey: "" };
+        case LlmProvider.Bedrock:
+            return { region: "us-west-2" };
+        case LlmProvider.Google:
+            return { apiKey: "" };
+        case LlmProvider.Groq:
+            return { apiKey: "" };
+        case LlmProvider.Moonshot:
+            return { apiKey: "" };
+        case LlmProvider.Ollama:
+            return {};
+        case LlmProvider.OpenAI:
+            return { apiKey: "" };
+        case LlmProvider.Xai:
+            return { apiKey: "" };
+    }
+}
 /** On/off display for tool rows (`Tool • Yes` / `Tool • No`). */
 const yesNo = (on) => (on ? "Yes" : "No");
-const WIKI_DOCS_PAGE_SIZE = 15;
-export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
+export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, }) {
     const { exit } = useApp();
     const [screen, setScreen] = useState({ kind: "home" });
     const [prompt, setPrompt] = useState(null);
@@ -38,13 +66,7 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
     const [revision, setRevision] = useState(0);
     const [installedSkills, setInstalledSkills] = useState([]);
     const [searchResults, setSearchResults] = useState([]);
-    const [wikiDocsList, setWikiDocsList] = useState({
-        status: "idle",
-    });
-    const [wikiDocsNonce, setWikiDocsNonce] = useState(0);
-    const bumpWikiDocs = useCallback(() => {
-        setWikiDocsNonce((n) => n + 1);
-    }, []);
+    const [mcpAuthStatuses, setMcpAuthStatuses] = useState({});
     const refresh = useCallback(() => {
         setRevision((value) => value + 1);
     }, []);
@@ -72,38 +94,37 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
     useEffect(() => {
         void refreshSkills();
     }, [refreshSkills]);
-    const wikiDocsPage = screen.kind === "config-wiki-docs" ? screen.page : null;
     useEffect(() => {
-        if (wikiDocsPage == null) {
-            setWikiDocsList({ status: "idle" });
-            return;
-        }
         let cancelled = false;
-        setWikiDocsList({ status: "loading", page: wikiDocsPage });
-        void (async () => {
+        const loadStatuses = async () => {
             try {
-                const storage = Storage.create();
-                await storage.warmup();
-                const result = await storage.list(wikiDocsPage, WIKI_DOCS_PAGE_SIZE);
-                await storage.close();
-                if (!cancelled) {
-                    setWikiDocsList({ status: "ready", page: wikiDocsPage, result });
+                const rows = await mcpManager.listAuthStatuses();
+                if (cancelled) {
+                    return;
                 }
+                setMcpAuthStatuses(Object.fromEntries(rows.map((row) => [row.name, row.status])));
             }
-            catch (error) {
+            catch {
                 if (!cancelled) {
-                    setWikiDocsList({
-                        status: "error",
-                        page: wikiDocsPage,
-                        message: error instanceof Error ? error.message : String(error),
-                    });
+                    setMcpAuthStatuses({});
                 }
             }
-        })();
+        };
+        void loadStatuses();
         return () => {
             cancelled = true;
         };
-    }, [wikiDocsPage, wikiDocsNonce]);
+    }, [mcpManager, revision]);
+    const configData = useMemo(() => ({
+        name: config.name,
+        providers: config.providers,
+        llms: config.llms,
+        search: config.search,
+        prompts: config.prompts,
+        tools: config.tools,
+        compaction: config.compaction,
+    }), [config, revision]);
+    const mcpServers = useMemo(() => mcpConfig.list(), [mcpConfig, revision]);
     useInput((input, key) => {
         if (key.ctrl && input.toLowerCase() === "c") {
             onExit();
@@ -130,34 +151,31 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
             setScreen({ kind: "config-llm-edit", name: screen.name });
             return;
         }
-        if (screen.kind === "config-wiki-delete-confirm") {
-            setScreen({ kind: "config-wiki-docs", page: screen.page });
-            return;
-        }
-        if (screen.kind === "config-wiki-docs") {
-            setScreen({ kind: "config-wiki" });
-            return;
-        }
-        if (screen.kind === "config-wiki") {
-            setScreen({ kind: "config-tools" });
+        if (screen.kind === "config-provider-delete-confirm") {
+            setScreen({ kind: "config-provider-edit", name: screen.name });
             return;
         }
         if (screen.kind !== "home") {
             setScreen({ kind: "home" });
         }
     }, { isActive: true });
-    const configData = useMemo(() => ({
-        name: config.name,
-        llms: config.llms,
-        search: config.search,
-        prompts: config.prompts,
-        tools: config.tools,
-        compaction: config.compaction,
-    }), [config, revision]);
-    const mcpServers = useMemo(() => mcpConfig.list(), [mcpConfig, revision]);
     const setSuccess = useCallback((text) => {
         setNotice({ kind: "success", text });
     }, []);
+    const authenticateMcpServer = useCallback(async (name) => {
+        await runTask(`Authenticating MCP server "${name}"...`, async () => {
+            await mcpManager.authenticate(name);
+            refresh();
+            setSuccess(`Authenticated MCP server "${name}".`);
+        });
+    }, [mcpManager, refresh, runTask, setSuccess]);
+    const logoutMcpServer = useCallback(async (name) => {
+        await runTask(`Logging out MCP server "${name}"...`, async () => {
+            await mcpManager.logout(name);
+            refresh();
+            setSuccess(`Cleared OAuth credentials for "${name}".`);
+        });
+    }, [mcpManager, refresh, runTask, setSuccess]);
     const updateConfig = useCallback((partial, message) => {
         config.update(partial);
         refresh();
@@ -171,7 +189,7 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
         {
             name,
             options: {
-                provider: LlmProvider.Ollama,
+                provider: config.providers[0]?.name ?? LlmProvider.Ollama,
                 model: "gemma4:e4b",
                 params: {},
             },
@@ -179,6 +197,39 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
         },
     ], [config]);
     const removeLlm = useCallback((name) => config.llms.filter((m) => m.name !== name), [config]);
+    const patchProvider = useCallback((name, patch) => config.providers.map((provider) => provider.name === name
+        ? {
+            ...provider,
+            options: {
+                ...provider.options,
+                ...patch,
+                params: patch.params ?? provider.options.params,
+            },
+        }
+        : provider), [config]);
+    const renameProvider = useCallback((oldName, newName) => ({
+        providers: config.providers.map((provider) => provider.name === oldName ? { ...provider, name: newName } : provider),
+        llms: config.llms.map((llm) => llm.options.provider === oldName
+            ? {
+                ...llm,
+                options: {
+                    ...llm.options,
+                    provider: newName,
+                },
+            }
+            : llm),
+    }), [config]);
+    const addProvider = useCallback((name) => [
+        ...config.providers,
+        {
+            name,
+            options: {
+                provider: LlmProvider.Ollama,
+                params: providerParamsTemplate(LlmProvider.Ollama),
+            },
+        },
+    ], [config]);
+    const removeProvider = useCallback((name) => config.providers.filter((provider) => provider.name !== name), [config]);
     const promptValue = useCallback((state) => {
         setPrompt(state);
     }, []);
@@ -260,6 +311,192 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
     }, [mcpConfig, promptValue, refresh, setSuccess]);
     const promptForRemote = useCallback((name, type, initial) => {
         const mode = initial ? "Edit" : "Add";
+        const persistRemote = (url, headers, oauth) => {
+            const transport = McpTransportSchema.parse({
+                type,
+                url,
+                ...(headers && Object.keys(headers).length > 0 ? { headers } : {}),
+                ...(oauth ? { oauth } : {}),
+            });
+            if (initial) {
+                mcpConfig.update(name, transport);
+                setSuccess(`Updated MCP server "${name}".`);
+            }
+            else {
+                mcpConfig.add(name, transport);
+                setSuccess(`Added MCP server "${name}".`);
+            }
+            setPrompt(null);
+            setScreen({ kind: "mcp" });
+            refresh();
+        };
+        const promptForOAuthDetails = (url, headers, oauthEnabled) => {
+            if (!oauthEnabled) {
+                persistRemote(url, headers, undefined);
+                return;
+            }
+            promptValue({
+                title: `${mode} ${type} server`,
+                label: "OAuth client ID (optional)",
+                initialValue: initial?.oauth?.clientId ?? "",
+                placeholder: "client-id",
+                onSubmit: async (clientIdValue) => {
+                    promptValue({
+                        title: `${mode} ${type} server`,
+                        label: "OAuth client secret (optional)",
+                        initialValue: initial?.oauth?.clientSecret ?? "",
+                        placeholder: "secret",
+                        note: "Stored in mcp.json only if you enter a value.",
+                        onSubmit: async (clientSecretValue) => {
+                            promptValue({
+                                title: `${mode} ${type} server`,
+                                label: "OAuth scopes (optional)",
+                                initialValue: initial?.oauth?.scopes
+                                    ? compactJson(initial.oauth.scopes)
+                                    : "",
+                                placeholder: '["read","write"]',
+                                onSubmit: async (scopesValue) => {
+                                    promptValue({
+                                        title: `${mode} ${type} server`,
+                                        label: "OAuth audiences (optional)",
+                                        initialValue: initial?.oauth?.audiences
+                                            ? compactJson(initial.oauth.audiences)
+                                            : "",
+                                        placeholder: '["https://api.example.com"]',
+                                        onSubmit: async (audiencesValue) => {
+                                            promptValue({
+                                                title: `${mode} ${type} server`,
+                                                label: "OAuth callback port (optional)",
+                                                initialValue: initial?.oauth?.callbackPort !== undefined
+                                                    ? String(initial.oauth.callbackPort)
+                                                    : "",
+                                                placeholder: "19876",
+                                                onSubmit: async (callbackPortValue) => {
+                                                    promptValue({
+                                                        title: `${mode} ${type} server`,
+                                                        label: "OAuth redirect URI (optional)",
+                                                        initialValue: initial?.oauth?.redirectUri ?? "",
+                                                        placeholder: "http://127.0.0.1:19876/mcp/oauth/callback",
+                                                        onSubmit: async (redirectUriValue) => {
+                                                            promptValue({
+                                                                title: `${mode} ${type} server`,
+                                                                label: "OAuth issuer (optional)",
+                                                                initialValue: initial?.oauth?.issuer ?? "",
+                                                                placeholder: "https://auth.example.com",
+                                                                onSubmit: async (issuerValue) => {
+                                                                    promptValue({
+                                                                        title: `${mode} ${type} server`,
+                                                                        label: "OAuth authorization URL override (optional)",
+                                                                        initialValue: initial?.oauth?.authorizationUrl ?? "",
+                                                                        placeholder: "https://auth.example.com/authorize",
+                                                                        onSubmit: async (authorizationUrlValue) => {
+                                                                            promptValue({
+                                                                                title: `${mode} ${type} server`,
+                                                                                label: "OAuth token URL override (optional)",
+                                                                                initialValue: initial?.oauth?.tokenUrl ?? "",
+                                                                                placeholder: "https://auth.example.com/token",
+                                                                                onSubmit: async (tokenUrlValue) => {
+                                                                                    promptValue({
+                                                                                        title: `${mode} ${type} server`,
+                                                                                        label: "OAuth registration URL override (optional)",
+                                                                                        initialValue: initial?.oauth
+                                                                                            ?.registrationUrl ?? "",
+                                                                                        placeholder: "https://auth.example.com/register",
+                                                                                        onSubmit: async (registrationUrlValue) => {
+                                                                                            promptValue({
+                                                                                                title: `${mode} ${type} server`,
+                                                                                                label: "OAuth token param name (optional)",
+                                                                                                initialValue: initial?.oauth
+                                                                                                    ?.tokenParamName ?? "",
+                                                                                                placeholder: "access_token",
+                                                                                                onSubmit: async (tokenParamNameValue) => {
+                                                                                                    const scopes = parseStringArray(scopesValue, "OAuth scopes");
+                                                                                                    const audiences = parseStringArray(audiencesValue, "OAuth audiences");
+                                                                                                    const callbackPort = normalizeOptional(callbackPortValue) !== undefined
+                                                                                                        ? parseNumber(callbackPortValue, "OAuth callback port", {
+                                                                                                            integer: true,
+                                                                                                            min: 1,
+                                                                                                            max: 65535,
+                                                                                                        })
+                                                                                                        : undefined;
+                                                                                                    const oauth = McpOAuthConfigSchema.parse({
+                                                                                                        enabled: true,
+                                                                                                        ...(normalizeOptional(clientIdValue)
+                                                                                                            ? {
+                                                                                                                clientId: normalizeOptional(clientIdValue),
+                                                                                                            }
+                                                                                                            : {}),
+                                                                                                        ...(normalizeOptional(clientSecretValue)
+                                                                                                            ? {
+                                                                                                                clientSecret: normalizeOptional(clientSecretValue),
+                                                                                                            }
+                                                                                                            : {}),
+                                                                                                        ...(scopes.length > 0
+                                                                                                            ? { scopes }
+                                                                                                            : {}),
+                                                                                                        ...(audiences.length >
+                                                                                                            0
+                                                                                                            ? { audiences }
+                                                                                                            : {}),
+                                                                                                        ...(callbackPort !==
+                                                                                                            undefined
+                                                                                                            ? { callbackPort }
+                                                                                                            : {}),
+                                                                                                        ...(normalizeOptional(redirectUriValue)
+                                                                                                            ? {
+                                                                                                                redirectUri: normalizeOptional(redirectUriValue),
+                                                                                                            }
+                                                                                                            : {}),
+                                                                                                        ...(normalizeOptional(issuerValue)
+                                                                                                            ? {
+                                                                                                                issuer: normalizeOptional(issuerValue),
+                                                                                                            }
+                                                                                                            : {}),
+                                                                                                        ...(normalizeOptional(authorizationUrlValue)
+                                                                                                            ? {
+                                                                                                                authorizationUrl: normalizeOptional(authorizationUrlValue),
+                                                                                                            }
+                                                                                                            : {}),
+                                                                                                        ...(normalizeOptional(tokenUrlValue)
+                                                                                                            ? {
+                                                                                                                tokenUrl: normalizeOptional(tokenUrlValue),
+                                                                                                            }
+                                                                                                            : {}),
+                                                                                                        ...(normalizeOptional(registrationUrlValue)
+                                                                                                            ? {
+                                                                                                                registrationUrl: normalizeOptional(registrationUrlValue),
+                                                                                                            }
+                                                                                                            : {}),
+                                                                                                        ...(normalizeOptional(tokenParamNameValue)
+                                                                                                            ? {
+                                                                                                                tokenParamName: normalizeOptional(tokenParamNameValue),
+                                                                                                            }
+                                                                                                            : {}),
+                                                                                                    });
+                                                                                                    persistRemote(url, headers, oauth);
+                                                                                                },
+                                                                                            });
+                                                                                        },
+                                                                                    });
+                                                                                },
+                                                                            });
+                                                                        },
+                                                                    });
+                                                                },
+                                                            });
+                                                        },
+                                                    });
+                                                },
+                                            });
+                                        },
+                                    });
+                                },
+                            });
+                        },
+                    });
+                },
+            });
+        };
         promptValue({
             title: `${mode} ${type} server`,
             label: "URL",
@@ -277,24 +514,17 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                     placeholder: '{"Authorization":"Bearer ..."}',
                     onSubmit: async (headersValue) => {
                         const headers = parseStringRecord(headersValue, "Headers");
-                        const transport = McpTransportSchema.parse({
-                            type,
-                            url,
-                            ...(headers && Object.keys(headers).length > 0
-                                ? { headers }
-                                : {}),
+                        promptValue({
+                            title: `${mode} ${type} server`,
+                            label: "Enable OAuth? (yes/no)",
+                            initialValue: initial?.oauth ? "yes" : "no",
+                            placeholder: "no",
+                            note: "Choose yes for servers that use OAuth 2.0/2.1 or dynamic client registration.",
+                            onSubmit: async (oauthEnabledValue) => {
+                                const oauthEnabled = parseOptionalBoolean(oauthEnabledValue, "Enable OAuth");
+                                promptForOAuthDetails(url, headers, oauthEnabled);
+                            },
                         });
-                        if (initial) {
-                            mcpConfig.update(name, transport);
-                            setSuccess(`Updated MCP server "${name}".`);
-                        }
-                        else {
-                            mcpConfig.add(name, transport);
-                            setSuccess(`Added MCP server "${name}".`);
-                        }
-                        setPrompt(null);
-                        setScreen({ kind: "mcp" });
-                        refresh();
                     },
                 });
             },
@@ -318,10 +548,24 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
             },
         });
     }, [promptForRemote, promptForStdio, promptValue]);
+    const llmSummary = useCallback((entry) => {
+        const compactModelId = (model) => {
+            if (model.length <= 23) {
+                return model;
+            }
+            return `${model.slice(0, 10)}...${model.slice(-10)}`;
+        };
+        const resolved = config.resolveLlm(entry.name);
+        if (!resolved) {
+            return `${entry.options.provider}/${compactModelId(entry.options.model)}`;
+        }
+        return `${entry.options.provider} -> ${resolved.options.provider}/${compactModelId(resolved.options.model)}`;
+    }, [config]);
+    const providerUsageCount = useCallback((name) => config.llms.filter((llm) => llm.options.provider === name).length, [config]);
     const renderHome = () => {
         const items = [
             {
-                label: `Configuration • ${config.llm.provider}/${config.llm.model}`,
+                label: `Inference • ${llmSummary(config.llms.find((m) => m.default) ?? config.llms[0])}`,
                 value: () => setScreen({ kind: "config" }),
             },
             {
@@ -392,6 +636,10 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                 })(),
                 value: () => setScreen({ kind: "config-llms" }),
             },
+            {
+                label: `Providers • ${config.providers.length} configured`,
+                value: () => setScreen({ kind: "config-providers" }),
+            },
             {
                 label: `Prompts • ${enabledPrompts}/${totalPrompts} enabled`,
                 value: () => setScreen({ kind: "config-prompts" }),
@@ -526,24 +774,194 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                 },
             },
             {
-                label: `Memory tool • ${yesNo(configData.tools.memory.enabled)}`,
-                value: () => setScreen({ kind: "config-ltm" }),
+                label: `Subagents tool • ${yesNo(configData.tools.agents.enabled)}`,
+                value: () => {
+                    updateConfig({
+                        tools: {
+                            ...config.tools,
+                            agents: {
+                                ...config.tools.agents,
+                                enabled: !configData.tools.agents.enabled,
+                            },
+                        },
+                    }, `Subagents tool ${configData.tools.agents.enabled ? "disabled" : "enabled"}.`);
+                    setScreen({ kind: "config-tools" });
+                },
+            },
+            {
+                label: "Back",
+                value: () => setScreen({ kind: "config" }),
             },
+        ];
+        return (_jsx(MenuScreen, { title: "Tools", description: "Enable, disable, and configure built-in tools.", items: items }));
+    };
+    const renderProvidersMenu = () => {
+        const providerItems = config.providers.map((provider) => ({
+            key: `provider:${provider.name}`,
+            label: `${provider.name} • ${provider.options.provider} • ${providerUsageCount(provider.name)} model(s)`,
+            boldSubstring: provider.name,
+            value: () => setScreen({ kind: "config-provider-edit", name: provider.name }),
+        }));
+        const items = [
             {
-                label: `Wiki tool • ${yesNo(configData.tools.wiki.enabled)}`,
-                value: () => setScreen({ kind: "config-wiki" }),
+                label: "Add provider",
+                value: () => promptValue({
+                    title: "Add a new provider",
+                    label: "Name",
+                    placeholder: "openai-prod",
+                    onSubmit: async (value) => {
+                        const name = value.trim();
+                        if (!name) {
+                            throw new Error("Name is required.");
+                        }
+                        if (config.providers.some((provider) => provider.name === name)) {
+                            throw new Error(`A provider named "${name}" already exists.`);
+                        }
+                        updateConfig({ providers: addProvider(name) }, `Added provider "${name}" with an Ollama scaffold.`);
+                        setPrompt(null);
+                        setScreen({ kind: "config-provider-edit", name });
+                    },
+                }),
             },
+            ...providerItems,
             {
                 label: "Back",
                 value: () => setScreen({ kind: "config" }),
             },
         ];
-        return (_jsx(MenuScreen, { title: "Tools", description: "Enable, disable, and configure built-in tools.", items: items }));
+        return (_jsx(MenuScreen, { title: "Providers", description: "Configure reusable provider credentials and shared params.", items: items }));
+    };
+    const renderProviderEditMenu = () => {
+        if (screen.kind !== "config-provider-edit") {
+            return null;
+        }
+        const { name } = screen;
+        const entry = config.providers.find((provider) => provider.name === name);
+        if (!entry) {
+            return null;
+        }
+        const usageCount = providerUsageCount(entry.name);
+        const items = [
+            {
+                label: `Name • ${entry.name}`,
+                value: () => promptValue({
+                    title: "Rename provider",
+                    label: "Name",
+                    initialValue: entry.name,
+                    onSubmit: async (value) => {
+                        const next = value.trim();
+                        if (!next) {
+                            throw new Error("Name is required.");
+                        }
+                        if (next === entry.name) {
+                            setPrompt(null);
+                            return;
+                        }
+                        if (config.providers.some((provider) => provider.name === next)) {
+                            throw new Error(`A provider named "${next}" already exists.`);
+                        }
+                        updateConfig(renameProvider(entry.name, next), `Renamed provider "${entry.name}" to "${next}".`);
+                        setPrompt(null);
+                        setScreen({ kind: "config-provider-edit", name: next });
+                    },
+                }),
+            },
+            {
+                label: `Type • ${entry.options.provider}`,
+                value: () => setScreen({ kind: "config-provider-type", name: entry.name }),
+            },
+            {
+                label: `Params • ${paramsPreview(entry.options.params)}`,
+                value: () => promptValue({
+                    title: "Update provider params",
+                    label: "Parameters",
+                    initialValue: compactJson(entry.options.params),
+                    placeholder: '{"apiKey":"..."}',
+                    onSubmit: async (value) => {
+                        const params = parseObjectRecord(value, "Provider params");
+                        updateConfig({ providers: patchProvider(entry.name, { params }) }, "Updated provider params.");
+                        setPrompt(null);
+                    },
+                }),
+            },
+            ...(usageCount > 0
+                ? []
+                : [
+                    {
+                        label: `Delete "${entry.name}"`,
+                        boldSubstring: entry.name,
+                        value: () => setScreen({
+                            kind: "config-provider-delete-confirm",
+                            name: entry.name,
+                        }),
+                    },
+                ]),
+            {
+                label: "Back",
+                value: () => setScreen({ kind: "config-providers" }),
+            },
+        ];
+        return (_jsx(MenuScreen, { title: `Edit Provider • ${entry.name}`, description: usageCount > 0
+                ? `Used by ${usageCount} model(s). Rename updates references automatically; delete is disabled while in use.`
+                : "Edit shared provider settings or delete this provider.", items: items }));
+    };
+    const renderProviderTypeMenu = () => {
+        if (screen.kind !== "config-provider-type") {
+            return null;
+        }
+        const { name } = screen;
+        const entry = config.providers.find((provider) => provider.name === name);
+        if (!entry) {
+            return null;
+        }
+        const items = [
+            ...SUPPORTED_PROVIDER_TYPES.map((provider) => ({
+                label: provider === entry.options.provider
+                    ? `${provider} • current`
+                    : provider,
+                value: () => {
+                    updateConfig({
+                        providers: patchProvider(entry.name, {
+                            provider,
+                            params: providerParamsTemplate(provider),
+                        }),
+                    }, `Updated provider type for "${entry.name}" to "${provider}" and scaffolded params.`);
+                    setScreen({ kind: "config-provider-edit", name: entry.name });
+                },
+            })),
+            {
+                label: "Back",
+                value: () => setScreen({ kind: "config-provider-edit", name: entry.name }),
+            },
+        ];
+        return (_jsx(MenuScreen, { title: `Choose Provider Type • ${entry.name}`, description: "Pick which runtime provider this shared config targets.", items: items }));
+    };
+    const renderProviderDeleteConfirm = () => {
+        if (screen.kind !== "config-provider-delete-confirm") {
+            return null;
+        }
+        const { name } = screen;
+        const items = [
+            {
+                key: `provider-del-cancel:${name}`,
+                label: "No — keep provider",
+                value: () => setScreen({ kind: "config-provider-edit", name }),
+            },
+            {
+                key: `provider-del-confirm:${name}`,
+                label: "Yes — remove provider",
+                value: () => {
+                    updateConfig({ providers: removeProvider(name) }, `Deleted provider "${name}".`);
+                    setScreen({ kind: "config-providers" });
+                },
+            },
+        ];
+        return (_jsx(MenuScreen, { title: "Delete provider?", description: `Remove "${name}" from the configured providers?`, items: items }));
     };
     const renderLlmsMenu = () => {
         const llmItems = config.llms.map((m) => ({
             key: `llm:${m.name}`,
-            label: `${m.name} • ${m.options.provider}/${m.options.model}${m.default ? " • default" : ""}`,
+            label: `${m.name} • ${llmSummary(m)}${m.default ? " • default" : ""}`,
             boldSubstring: m.name,
             value: () => setScreen({ kind: "config-llm-edit", name: m.name }),
         }));
@@ -562,6 +980,9 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                         if (config.llms.some((m) => m.name === name)) {
                             throw new Error(`An LLM named "${name}" already exists.`);
                         }
+                        if (config.providers.length === 0) {
+                            throw new Error("Add at least one provider first so the model can reference it.");
+                        }
                         updateConfig({ llms: addLlm(name) }, `Added LLM "${name}".`);
                         setPrompt(null);
                         setScreen({ kind: "config-llm-edit", name });
@@ -633,7 +1054,7 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                 }),
             },
             {
-                label: `Params • ${truncate(compactJson(maskSensitiveParamsForDisplay(entry.options.params)))}`,
+                label: `Params • ${paramsPreview(entry.options.params)}`,
                 value: () => promptValue({
                     title: "Update LLM params",
                     label: "Parameters",
@@ -688,12 +1109,12 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
             return null;
         }
         const items = [
-            ...Object.values(LlmProvider).map((provider) => ({
-                label: provider === entry.options.provider
-                    ? `${provider} • current`
-                    : provider,
+            ...config.providers.map((provider) => ({
+                label: provider.name === entry.options.provider
+                    ? `${provider.name} • current`
+                    : `${provider.name} • ${provider.options.provider}`,
                 value: () => {
-                    updateConfig({ llms: patchLlm(entry.name, { provider }) }, `Updated provider for "${entry.name}" to "${provider}".`);
+                    updateConfig({ llms: patchLlm(entry.name, { provider: provider.name }) }, `Updated provider for "${entry.name}" to "${provider.name}".`);
                     setScreen({ kind: "config-llm-edit", name: entry.name });
                 },
             })),
@@ -702,7 +1123,7 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                 value: () => setScreen({ kind: "config-llm-edit", name: entry.name }),
             },
         ];
-        return (_jsx(MenuScreen, { title: `Choose Provider • ${entry.name}`, description: "Pick which model provider to use for this LLM.", items: items }));
+        return (_jsx(MenuScreen, { title: `Choose Provider • ${entry.name}`, description: "Pick which shared provider config this LLM should use.", items: items }));
     };
     const renderLlmDeleteConfirm = () => {
         if (screen.kind !== "config-llm-delete-confirm") {
@@ -828,209 +1249,18 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
         ];
         return (_jsx(MenuScreen, { title: "Search", description: "Configure web search provider and credentials.", items: items }));
     };
-    const renderLtmConfigMenu = () => {
-        const items = [
-            {
-                label: `Enabled • ${yesNo(configData.tools.memory.enabled)}`,
-                value: () => {
-                    updateConfig({
-                        tools: {
-                            ...config.tools,
-                            memory: {
-                                ...config.tools.memory,
-                                enabled: !configData.tools.memory.enabled,
-                            },
-                        },
-                    }, `Memory tool ${configData.tools.memory.enabled ? "disabled" : "enabled"}.`);
-                    setScreen({ kind: "config-ltm" });
-                },
-            },
-            {
-                label: "Back",
-                value: () => setScreen({ kind: "config-tools" }),
-            },
-        ];
-        return (_jsx(MenuScreen, { title: "Memory tool", description: "Vectors live in ~/.hooman/memory.sqlite (sqlite-vec). Embedding model is fixed in code (DEFAULT_EMBED_MODEL).", items: items }));
-    };
-    const renderWikiConfigMenu = () => {
-        const items = [
-            {
-                label: `Tool • ${yesNo(configData.tools.wiki.enabled)}`,
-                value: () => {
-                    updateConfig({
-                        tools: {
-                            ...config.tools,
-                            wiki: {
-                                ...config.tools.wiki,
-                                enabled: !configData.tools.wiki.enabled,
-                            },
-                        },
-                    }, `Wiki tool ${configData.tools.wiki.enabled ? "disabled" : "enabled"}.`);
-                    setScreen({ kind: "config-wiki" });
-                },
-            },
-            {
-                label: "Manage documents",
-                value: () => setScreen({ kind: "config-wiki-docs", page: 1 }),
-            },
-            {
-                label: "Back",
-                value: () => setScreen({ kind: "config-tools" }),
-            },
-        ];
-        return (_jsx(MenuScreen, { title: "Tool", description: "Turn wiki_search on or off for the agent, then open Manage documents to add or remove PDF/DOCX files under ~/.hooman/wiki. Embedding may download the model on first use.", items: items }));
-    };
-    const renderWikiDocsMenu = () => {
-        if (screen.kind !== "config-wiki-docs") {
-            return null;
-        }
-        const { page } = screen;
-        if (wikiDocsList.status === "loading" || wikiDocsList.status === "idle") {
-            return _jsx(BusyScreen, { message: "Loading documents\u2026" });
-        }
-        if (wikiDocsList.status === "error") {
-            return (_jsx(MenuScreen, { title: "Manage documents", description: `Could not load index: ${wikiDocsList.message}`, items: [
-                    {
-                        label: "Retry",
-                        value: () => bumpWikiDocs(),
-                    },
-                    {
-                        label: "Back",
-                        value: () => setScreen({ kind: "config-wiki" }),
-                    },
-                ] }));
-        }
-        if (wikiDocsList.page !== page) {
-            return _jsx(BusyScreen, { message: "Loading documents\u2026" });
-        }
-        const { result } = wikiDocsList;
-        const totalPages = Math.max(1, Math.ceil(result.total / WIKI_DOCS_PAGE_SIZE));
-        const hasPrev = page > 1;
-        const hasNext = page < totalPages;
-        const formatUpdated = (ms) => {
-            try {
-                return new Date(ms).toLocaleString(undefined, {
-                    dateStyle: "short",
-                    timeStyle: "short",
-                });
-            }
-            catch {
-                return String(ms);
-            }
-        };
-        const docItems = result.items.map((doc) => {
-            const summary = truncate(`${doc.file_name} • ${formatUpdated(doc.updated_at_ms)} • ${doc.original_mime_type}`, 96);
-            return {
-                key: `wiki-remove:${doc.doc_id}`,
-                label: `Remove • ${summary}`,
-                boldSubstring: doc.file_name,
-                value: () => setScreen({
-                    kind: "config-wiki-delete-confirm",
-                    docId: doc.doc_id,
-                    displayName: doc.file_name,
-                    page,
-                }),
-            };
-        });
-        const items = [
-            {
-                label: "Add document (file path)",
-                value: () => promptValue({
-                    title: "Index a file into the wiki",
-                    label: "Absolute path",
-                    placeholder: "/path/to/document.pdf",
-                    note: "Only PDF and DOCX are supported (PDF needs Java 11+ for OpenDataLoader).",
-                    onSubmit: async (value) => {
-                        const raw = value.trim();
-                        if (!raw) {
-                            throw new Error("Path is required.");
-                        }
-                        const abs = path.resolve(raw);
-                        if (!existsSync(abs)) {
-                            throw new Error(`File not found: ${abs}`);
-                        }
-                        setPrompt(null);
-                        await runTask(`Indexing "${path.basename(abs)}"…`, async () => {
-                            const storage = Storage.create();
-                            try {
-                                await storage.warmup();
-                                await storage.add({ filePath: abs });
-                            }
-                            finally {
-                                await storage.close();
-                            }
-                            bumpWikiDocs();
-                            setSuccess(`Indexed "${path.basename(abs)}".`);
-                        });
-                        setScreen({ kind: "config-wiki-docs", page: 1 });
-                    },
-                }),
-            },
-            ...docItems,
-            ...(hasPrev
-                ? [
-                    {
-                        label: "Previous page",
-                        value: () => setScreen({ kind: "config-wiki-docs", page: page - 1 }),
-                    },
-                ]
-                : []),
-            ...(hasNext
-                ? [
-                    {
-                        label: "Next page",
-                        value: () => setScreen({ kind: "config-wiki-docs", page: page + 1 }),
-                    },
-                ]
-                : []),
-            {
-                label: "Back",
-                value: () => setScreen({ kind: "config-wiki" }),
-            },
-        ];
-        return (_jsx(MenuScreen, { title: `Manage documents · page ${page} of ${totalPages}`, description: result.items.length === 0
-                ? "No documents yet. Add a PDF or DOCX path below (PDF needs Java 11+ on PATH)."
-                : `${result.total} document(s) total · ${result.items.length} on this page.`, items: items }));
-    };
-    const renderWikiDeleteConfirm = () => {
-        if (screen.kind !== "config-wiki-delete-confirm") {
-            return null;
-        }
-        const { docId, displayName, page } = screen;
-        const items = [
-            {
-                key: `wiki-del-cancel:${docId}`,
-                label: "No — keep document",
-                value: () => setScreen({ kind: "config-wiki-docs", page }),
-            },
-            {
-                key: `wiki-del-confirm:${docId}`,
-                label: "Yes — remove from index",
-                value: () => void runTask(`Removing "${displayName}"…`, async () => {
-                    const storage = Storage.create();
-                    try {
-                        await storage.warmup();
-                        const ok = await storage.remove(docId);
-                        if (!ok) {
-                            throw new Error("Document was already removed.");
-                        }
-                    }
-                    finally {
-                        await storage.close();
-                    }
-                    bumpWikiDocs();
-                    setSuccess(`Removed "${displayName}" from the wiki index.`);
-                    setScreen({ kind: "config-wiki-docs", page });
-                }),
-            },
-        ];
-        return (_jsx(MenuScreen, { title: "Remove wiki document?", description: `Drop "${displayName}" from the index and delete its stored copies under ~/.hooman/wiki? This cannot be undone.`, items: items }));
-    };
     const renderMcpMenu = () => {
-        const serverItems = mcpServers.flatMap((server) => [
-            {
-                label: `Edit ${server.name} • ${transportSummary(server.transport)}`,
+        const serverItems = mcpServers.map((server) => {
+            const oauthStatus = mcpAuthStatuses[server.name];
+            return {
+                key: `mcp-server:${server.name}`,
+                label: `Edit ${server.name} • ${formatMcpServerLabel(server.transport, oauthStatus)}`,
                 boldSubstring: server.name,
+                oauthStatus: oauthStatus === "authenticated" ||
+                    oauthStatus === "expired" ||
+                    oauthStatus === "unauthenticated"
+                    ? oauthStatus
+                    : undefined,
                 value: () => {
                     if (server.transport.type === "stdio") {
                         promptForStdio(server.name, server.transport);
@@ -1039,13 +1269,8 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                         promptForRemote(server.name, server.transport.type, server.transport);
                     }
                 },
-            },
-            {
-                label: `Delete ${server.name}`,
-                boldSubstring: server.name,
-                value: () => setScreen({ kind: "mcp-delete-confirm", name: server.name }),
-            },
-        ]);
+            };
+        });
         const items = [
             {
                 label: "Add stdio server",
@@ -1073,7 +1298,29 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                 value: () => setScreen({ kind: "home" }),
             },
         ];
-        return (_jsx(MenuScreen, { title: "MCP Servers", description: "Add, edit, or remove named MCP transports from ~/.hooman/mcp.json.", items: items }));
+        return (_jsx(MenuScreen, { title: "MCP Servers", description: "Add, edit, or remove named MCP transports from ~/.hooman/mcp.json.", items: items, footerHint: (item) => formatMcpFooterHint(item, mcpServers, mcpAuthStatuses), onShortcut: async (input, item) => {
+                const server = findMcpServerFromMenuItem(item, mcpServers);
+                if (!server) {
+                    return;
+                }
+                const status = mcpAuthStatuses[server.name];
+                const key = input.toLowerCase();
+                if (key === "d") {
+                    setScreen({ kind: "mcp-delete-confirm", name: server.name });
+                    return;
+                }
+                if (key === "r" &&
+                    server.transport.type !== "stdio" &&
+                    status !== "unsupported") {
+                    await authenticateMcpServer(server.name);
+                    return;
+                }
+                if (key === "l" &&
+                    server.transport.type !== "stdio" &&
+                    (status === "authenticated" || status === "expired")) {
+                    await logoutMcpServer(server.name);
+                }
+            } }));
     };
     const renderSkillsMenu = () => {
         const skillItems = installedSkills.map((skill) => {
@@ -1094,7 +1341,7 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                 value: () => promptValue({
                     title: "Search skills catalog",
                     label: "Query",
-                    placeholder: "memory, github, playwright...",
+                    placeholder: "github, playwright, slack...",
                     onSubmit: async (value) => {
                         const query = value.trim();
                         if (query.length < 2) {
@@ -1239,6 +1486,14 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                 return renderHome();
             case "config":
                 return renderConfigMenu();
+            case "config-providers":
+                return renderProvidersMenu();
+            case "config-provider-edit":
+                return renderProviderEditMenu();
+            case "config-provider-type":
+                return renderProviderTypeMenu();
+            case "config-provider-delete-confirm":
+                return renderProviderDeleteConfirm();
             case "config-llms":
                 return renderLlmsMenu();
             case "config-llm-edit":
@@ -1255,14 +1510,6 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                 return renderSearchConfigMenu();
             case "config-search-provider":
                 return renderSearchProviderMenu();
-            case "config-ltm":
-                return renderLtmConfigMenu();
-            case "config-wiki":
-                return renderWikiConfigMenu();
-            case "config-wiki-docs":
-                return renderWikiDocsMenu();
-            case "config-wiki-delete-confirm":
-                return renderWikiDeleteConfirm();
             case "mcp":
                 return renderMcpMenu();
             case "mcp-delete-confirm":
@@ -1277,6 +1524,37 @@ export function ConfigureApp({ config, mcpConfig, skills, onExit, }) {
                 return null;
         }
     })();
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", paddingX: 1, children: [notice ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: noticeColor(notice.kind), children: notice.text }) })) : null, _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: `config: ${config.llm.provider}/${config.llm.model} • mcp: ${mcpServers.length} • skills: ${installedSkills.length}` }) }), body] }));
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", paddingX: 1, children: [notice ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: noticeColor(notice.kind), children: notice.text }) })) : null, _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: `inference: ${llmSummary(config.llms.find((m) => m.default) ?? config.llms[0])} • mcp: ${mcpServers.length} • skills: ${installedSkills.length}` }) }), body] }));
+}
+function formatMcpServerLabel(transport, status) {
+    const summary = transportSummary(transport);
+    if ((status === "expired" || status === "unauthenticated") &&
+        summary.endsWith(" • oauth")) {
+        return `${summary.slice(0, -" • oauth".length)} • oauth needed`;
+    }
+    return summary;
+}
+function findMcpServerFromMenuItem(item, servers) {
+    if (!item?.key?.startsWith("mcp-server:")) {
+        return null;
+    }
+    const serverName = item.key.slice("mcp-server:".length);
+    return servers.find((server) => server.name === serverName) ?? null;
+}
+function formatMcpFooterHint(item, servers, statuses) {
+    const server = findMcpServerFromMenuItem(item, servers);
+    const status = server ? statuses[server.name] : undefined;
+    const parts = ["enter: edit"];
+    if (server && server.transport.type !== "stdio" && status !== "unsupported") {
+        parts.push(status === "authenticated" ? "r: re-auth" : "r: authenticate");
+        if (status === "authenticated" || status === "expired") {
+            parts.push("l: logout");
+        }
+    }
+    if (server) {
+        parts.push("d: delete");
+    }
+    parts.push("esc: back", "ctrl+c: exit");
+    return parts.join(" | ");
 }
 //# sourceMappingURL=app.js.map