@pentoshi/clai 2.0.8 → 2.0.10

package/dist/tui/App.js

@@ -1,10 +1,11 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text, useApp, useInput, useStdin } from "ink";
+import chalk from "chalk";
 import { useCallback, useEffect, useMemo, useReducer, useRef, useState, } from "react";
 import { providerIds } from "../types.js";
 import { assertProvider } from "../llm/provider.js";
 import { getProvider } from "../llm/router.js";
-import { envValue, getProviderSecret, getSearchProviderKey, listProviderStatuses, maskSecret, setProviderSecret, setSecret, } from "../store/keys.js";
+import { envValue, getProviderSecret, getSearchProviderKey, listProviderStatuses, maskSecret, setProviderSecret, setSecret, unsetProviderSecret, } from "../store/keys.js";
 import { setActiveSearchProvider } from "../store/config.js";
 import { searchProviderIds, } from "../tools/web/types.js";
 import { assertSearchProvider, searchProviders, } from "../tools/web/providers/provider.js";
@@ -838,10 +839,348 @@ export function App({ version, initialMode, provider: initialProvider, initialMo
                     });
                 })().catch((error) => warn(`could not read keys: ${error instanceof Error ? error.message : String(error)}`));
                 return true;
-            case "/set":
-            case "/unset":
+            case "/set": {
+                const parts = arg.split(/\s+/).filter(Boolean);
+                const providerVal = parts[0];
+                const keyVal = parts[1];
+                void (async () => {
+                    if (!providerVal) {
+                        const llm = await listProviderStatuses(provider);
+                        const activeSearch = getConfig().activeSearchProvider;
+                        const search = await Promise.all(searchProviderIds.map(async (id) => {
+                            const secret = await getSearchProviderKey(id);
+                            const keyless = id === "duckduckgo";
+                            return {
+                                provider: id,
+                                configured: keyless || Boolean(secret.value),
+                                maskedKey: secret.value ? maskSecret(secret.value) : undefined,
+                            };
+                        }));
+                        setOverlay({
+                            kind: "picker",
+                            title: "Set API key for provider",
+                            options: [
+                                ...llm.map((status) => ({
+                                    value: `llm:${status.provider}`,
+                                    label: `${status.provider.padEnd(12)} ${status.configured ? chalk.green("✓ key set") : chalk.red("✗ no key")}${status.active ? " (active)" : ""}`,
+                                    description: status.model,
+                                })),
+                                ...search.map((status) => ({
+                                    value: `search:${status.provider}`,
+                                    label: `${status.provider.padEnd(12)} ${status.configured ? chalk.green("✓ key set") : chalk.red("✗ no key")}`,
+                                    description: `Search provider${status.provider === activeSearch ? " (active)" : ""}`,
+                                })),
+                            ],
+                            onSelect: (val) => {
+                                setOverlay({ kind: "none" });
+                                void (async () => {
+                                    const isSearch = val.startsWith("search:");
+                                    const id = val.split(":")[1];
+                                    if (isSearch) {
+                                        const next = id;
+                                        if (next === "duckduckgo") {
+                                            info("duckduckgo is keyless and requires no setup");
+                                            return;
+                                        }
+                                        const secret = await getSearchProviderKey(next);
+                                        if (secret.value) {
+                                            const reset = await new Promise((resolveConfirm) => {
+                                                confirmResolver.current = resolveConfirm;
+                                                dispatch({
+                                                    type: "event",
+                                                    event: {
+                                                        type: "confirm-request",
+                                                        id: "c",
+                                                        kind: "reset",
+                                                        prompt: `${next} already has a key (${maskSecret(secret.value)}). Reset it?`,
+                                                    },
+                                                });
+                                            });
+                                            if (!reset) {
+                                                info("cancelled");
+                                                return;
+                                            }
+                                        }
+                                        const key = await requestSecret({
+                                            title: `${next} API key`,
+                                            prompt: `Enter API key for ${next}:`,
+                                        });
+                                        if (!key) {
+                                            info("cancelled");
+                                            return;
+                                        }
+                                        await setSecret("search", next, key.trim());
+                                        info(`saved ${next} ${maskSecret(key.trim())}`);
+                                    }
+                                    else {
+                                        const next = id;
+                                        if (next === "ollama") {
+                                            const key = await requestSecret({
+                                                title: "Ollama host URL",
+                                                prompt: `Enter host URL for Ollama:`,
+                                            });
+                                            if (!key) {
+                                                info("cancelled");
+                                                return;
+                                            }
+                                            updateConfig({ ollamaHost: key.trim() });
+                                            info(`saved ollama host → ${key.trim()}`);
+                                            return;
+                                        }
+                                        const secret = await getProviderSecret(next);
+                                        if (secret.value) {
+                                            const reset = await new Promise((resolveConfirm) => {
+                                                confirmResolver.current = resolveConfirm;
+                                                dispatch({
+                                                    type: "event",
+                                                    event: {
+                                                        type: "confirm-request",
+                                                        id: "c",
+                                                        kind: "reset",
+                                                        prompt: `${next} already has a key (${maskSecret(secret.value)}). Reset it?`,
+                                                    },
+                                                });
+                                            });
+                                            if (!reset) {
+                                                info("cancelled");
+                                                return;
+                                            }
+                                        }
+                                        const key = await requestSecret({
+                                            title: `${next} API key`,
+                                            prompt: `Enter API key for ${next}:`,
+                                        });
+                                        if (!key) {
+                                            info("cancelled");
+                                            return;
+                                        }
+                                        if (!getProvider(next).validateKey(key.trim())) {
+                                            warn(`invalid API key format for ${next}`);
+                                            return;
+                                        }
+                                        await setProviderSecret(next, key.trim());
+                                        info(`saved ${next} ${maskSecret(key.trim())}`);
+                                    }
+                                })();
+                            },
+                        });
+                    }
+                    else {
+                        try {
+                            const isSearch = ["brave", "tavily", "duckduckgo"].includes(providerVal);
+                            if (isSearch) {
+                                const next = providerVal;
+                                if (next === "duckduckgo") {
+                                    info("duckduckgo is keyless and requires no setup");
+                                    return;
+                                }
+                                let key = keyVal;
+                                if (!key) {
+                                    const secret = await getSearchProviderKey(next);
+                                    if (secret.value) {
+                                        const reset = await new Promise((resolveConfirm) => {
+                                            confirmResolver.current = resolveConfirm;
+                                            dispatch({
+                                                type: "event",
+                                                event: {
+                                                    type: "confirm-request",
+                                                    id: "c",
+                                                    kind: "reset",
+                                                    prompt: `${next} already has a key (${maskSecret(secret.value)}). Reset it?`,
+                                                },
+                                            });
+                                        });
+                                        if (!reset) {
+                                            info("cancelled");
+                                            return;
+                                        }
+                                    }
+                                    key = await requestSecret({
+                                        title: `${next} API key`,
+                                        prompt: `Enter API key for ${next}:`,
+                                    });
+                                    if (!key) {
+                                        info("cancelled");
+                                        return;
+                                    }
+                                }
+                                await setSecret("search", next, key.trim());
+                                info(`saved ${next} ${maskSecret(key.trim())}`);
+                            }
+                            else {
+                                const next = assertProvider(providerVal);
+                                if (next === "ollama") {
+                                    let key = keyVal;
+                                    if (!key) {
+                                        key = await requestSecret({
+                                            title: "Ollama host URL",
+                                            prompt: `Enter host URL for Ollama:`,
+                                        });
+                                        if (!key) {
+                                            info("cancelled");
+                                            return;
+                                        }
+                                    }
+                                    updateConfig({ ollamaHost: key.trim() });
+                                    info(`saved ollama host → ${key.trim()}`);
+                                    return;
+                                }
+                                let key = keyVal;
+                                if (!key) {
+                                    const secret = await getProviderSecret(next);
+                                    if (secret.value) {
+                                        const reset = await new Promise((resolveConfirm) => {
+                                            confirmResolver.current = resolveConfirm;
+                                            dispatch({
+                                                type: "event",
+                                                event: {
+                                                    type: "confirm-request",
+                                                    id: "c",
+                                                    kind: "reset",
+                                                    prompt: `${next} already has a key (${maskSecret(secret.value)}). Reset it?`,
+                                                },
+                                            });
+                                        });
+                                        if (!reset) {
+                                            info("cancelled");
+                                            return;
+                                        }
+                                    }
+                                    key = await requestSecret({
+                                        title: `${next} API key`,
+                                        prompt: `Enter API key for ${next}:`,
+                                    });
+                                    if (!key) {
+                                        info("cancelled");
+                                        return;
+                                    }
+                                }
+                                if (!getProvider(next).validateKey(key.trim())) {
+                                    warn(`invalid API key format for ${next}`);
+                                    return;
+                                }
+                                await setProviderSecret(next, key.trim());
+                                info(`saved ${next} ${maskSecret(key.trim())}`);
+                            }
+                        }
+                        catch (e) {
+                            warn(e.message);
+                        }
+                    }
+                })();
+                return true;
+            }
+            case "/unset": {
+                const parts = arg.split(/\s+/).filter(Boolean);
+                const providerVal = parts[0];
+                void (async () => {
+                    if (!providerVal) {
+                        const llm = await listProviderStatuses(provider);
+                        const activeSearch = getConfig().activeSearchProvider;
+                        const search = await Promise.all(searchProviderIds.map(async (id) => {
+                            const secret = await getSearchProviderKey(id);
+                            const keyless = id === "duckduckgo";
+                            return {
+                                provider: id,
+                                configured: keyless || Boolean(secret.value),
+                                maskedKey: secret.value ? maskSecret(secret.value) : undefined,
+                            };
+                        }));
+                        setOverlay({
+                            kind: "picker",
+                            title: "Unset API key for provider",
+                            options: [
+                                ...llm.map((status) => ({
+                                    value: `llm:${status.provider}`,
+                                    label: `${status.provider.padEnd(12)} ${status.configured ? chalk.green("✓ ") + (status.maskedKey ?? "key set") : chalk.red("✗ no key")}${status.active ? " (active)" : ""}`,
+                                    description: status.model,
+                                })),
+                                ...search.map((status) => ({
+                                    value: `search:${status.provider}`,
+                                    label: `${status.provider.padEnd(12)} ${status.configured ? chalk.green("✓ ") + (status.maskedKey ?? "keyless") : chalk.red("✗ no key")}`,
+                                    description: `Search provider${status.provider === activeSearch ? " (active)" : ""}`,
+                                })),
+                            ],
+                            onSelect: (val) => {
+                                setOverlay({ kind: "none" });
+                                void (async () => {
+                                    const isSearch = val.startsWith("search:");
+                                    const id = val.split(":")[1];
+                                    if (isSearch) {
+                                        const next = id;
+                                        if (next === "duckduckgo") {
+                                            info("duckduckgo requires no credentials and cannot be unset");
+                                            return;
+                                        }
+                                        const secret = await getSearchProviderKey(next);
+                                        if (!secret.value) {
+                                            warn(`${next} has no key to unset`);
+                                            return;
+                                        }
+                                        const { unsetSearchProviderKey } = await import("../commands/search-providers.js");
+                                        await unsetSearchProviderKey(next);
+                                        info(`unset ${next}`);
+                                    }
+                                    else {
+                                        const next = id;
+                                        if (next === "ollama") {
+                                            info("ollama does not store an API key");
+                                            return;
+                                        }
+                                        const secret = await getProviderSecret(next);
+                                        if (!secret.value) {
+                                            warn(`${next} has no key to unset`);
+                                            return;
+                                        }
+                                        await unsetProviderSecret(next);
+                                        info(`unset ${next}`);
+                                    }
+                                })();
+                            },
+                        });
+                    }
+                    else {
+                        try {
+                            const isSearch = ["brave", "tavily", "duckduckgo"].includes(providerVal);
+                            if (isSearch) {
+                                const next = providerVal;
+                                if (next === "duckduckgo") {
+                                    info("duckduckgo requires no credentials and cannot be unset");
+                                    return;
+                                }
+                                const secret = await getSearchProviderKey(next);
+                                if (!secret.value) {
+                                    warn(`${next} has no key to unset`);
+                                    return;
+                                }
+                                const { unsetSearchProviderKey } = await import("../commands/search-providers.js");
+                                await unsetSearchProviderKey(next);
+                                info(`unset ${next}`);
+                            }
+                            else {
+                                const next = assertProvider(providerVal);
+                                if (next === "ollama") {
+                                    info("ollama does not store an API key");
+                                    return;
+                                }
+                                const secret = await getProviderSecret(next);
+                                if (!secret.value) {
+                                    warn(`${next} has no key to unset`);
+                                    return;
+                                }
+                                await unsetProviderSecret(next);
+                                info(`unset ${next}`);
+                            }
+                        }
+                        catch (e) {
+                            warn(e.message);
+                        }
+                    }
+                })();
+                return true;
+            }
             case "/update":
-                info(`${cmd} manages external credentials or updates; use the equivalent \`clai ${cmd.slice(1)}\` command outside the TUI`);
+                info(`${cmd} manages updates; use the equivalent \`clai update\` command outside the TUI`);
                 return true;
             case "/help":
                 setOverlay({
@@ -886,6 +1225,8 @@ export function App({ version, initialMode, provider: initialProvider, initialMo
         openToolOutput,
         setReasoning,
         state.items,
+        requestSecret,
+        setOverlay,
     ]);
     const submitText = useCallback((text) => {
         const trimmed = text.trim();