@giovannijecha/jecode 0.3.1 → 0.4.0

package/dist/permission-command.js

@@ -9,59 +9,55 @@ export async function permissionsCommand(session, host) {
     }
     let selected = 0;
     while (true) {
-        const tools = control.listTools();
-        const index = await choose(permissionsPicker(tools, session.palette, selected));
+        const index = await choose(permissionControlPicker(control, host, selected));
         if (index === undefined)
             return;
-        const tool = tools[index];
+        const tool = control.listTools()[index];
         if (tool === undefined)
             return;
         selected = index;
-        await configureTool(tool, control, choose, session.palette);
+        if (tool.locked) {
+            lockedNotice(tool.name, host);
+            continue;
+        }
+        if (tool.remembered > 0) {
+            await reviewGrants(tool.name, control, choose, session.palette);
+        }
     }
 }
-export function permissionsPicker(tools, pal, index = 0) {
-    const launchOverride = tools.some((tool) => tool.locked);
+export function permissionsPicker(tools, index = 0, adjust) {
     return {
-        title: heading("permissions", launchOverride ? "session only · auto approve at launch" : "session only", pal),
-        description: "Changes apply now · /new resets them",
-        options: tools.map((tool) => ({ label: tool.name, hint: toolHint(tool) })),
+        title: [],
+        options: tools.map((tool) => {
+            const description = toolDescription(tool);
+            return {
+                label: tool.name,
+                ...(description === undefined ? {} : { description }),
+                value: tool.locked ? `${tool.mode} · locked` : tool.mode,
+                adjustable: !tool.locked,
+            };
+        }),
+        visible: tools.length,
+        ...(adjust === undefined ? {} : { adjust }),
         index: Math.min(Math.max(0, index), Math.max(0, tools.length - 1)),
     };
 }
-async function configureTool(tool, control, choose, pal) {
-    if (tool.locked) {
-        await choose({
-            title: heading(tool.name, "launch override", pal),
-            description: "Restart without --auto-approve to change this tool",
-            options: [{ label: "allow", hint: "locked for this process" }],
-            index: 0,
-        });
-        return;
-    }
-    const modes = tool.dangerous ? ["ask", "allow", "deny"] : ["allow", "deny"];
-    const grants = control.listGrants(tool.name);
-    const index = await choose({
-        title: heading(tool.name, tool.dangerous ? "dangerous tool" : "read-only tool", pal),
-        description: tool.dangerous
-            ? "Session only · ask is the safe default"
-            : "Session only · deny hides this tool from the model",
-        options: [
-            ...modes.map((mode) => ({ label: mode, hint: modeHint(mode, tool.dangerous) })),
-            ...(grants.length === 0
-                ? []
-                : [{ label: "remembered approvals", hint: String(grants.length) }]),
-        ],
-        index: Math.max(0, modes.indexOf(tool.mode)),
+function permissionControlPicker(control, host, selected) {
+    return permissionsPicker(control.listTools(), selected, (index, step) => {
+        const tool = control.listTools()[index];
+        if (tool === undefined)
+            return permissionControlPicker(control, host, selected);
+        if (tool.locked) {
+            lockedNotice(tool.name, host);
+            return permissionControlPicker(control, host, index);
+        }
+        const modes = modesFor(tool);
+        const at = Math.max(0, modes.indexOf(tool.mode));
+        const next = modes[(at + step + modes.length) % modes.length];
+        if (next !== undefined)
+            control.set(tool.name, next);
+        return permissionControlPicker(control, host, index);
     });
-    if (index === undefined)
-        return;
-    const mode = modes[index];
-    if (mode !== undefined) {
-        control.set(tool.name, mode);
-        return;
-    }
-    await reviewGrants(tool.name, control, choose, pal);
 }
 async function reviewGrants(tool, control, choose, pal) {
     let selected = 0;
@@ -75,7 +71,6 @@ async function reviewGrants(tool, control, choose, pal) {
         ];
         const index = await choose({
             title: heading("remembered", tool, pal),
-            description: "Allowed without asking · this session",
             options,
             index: Math.min(selected, options.length - 1),
         });
@@ -92,16 +87,20 @@ async function reviewGrants(tool, control, choose, pal) {
         selected = index;
     }
 }
-function toolHint(tool) {
-    const kind = tool.dangerous ? "" : " · read only";
-    const remembered = tool.remembered === 0 ? "" : ` · ${tool.remembered} remembered`;
-    const locked = tool.locked ? " · launch override" : "";
-    return `${tool.mode}${kind}${remembered}${locked}`;
+function modesFor(tool) {
+    return tool.dangerous ? ["ask", "allow", "deny"] : ["allow", "deny"];
+}
+function toolDescription(tool) {
+    const parts = [
+        tool.dangerous ? undefined : "read only",
+        tool.remembered === 0 ? undefined : `${tool.remembered} remembered`,
+    ].filter((part) => part !== undefined);
+    return parts.length === 0 ? undefined : parts.join(" · ");
 }
-function modeHint(mode, dangerous) {
-    if (mode === "deny")
-        return "hide from the model";
-    if (mode === "ask")
-        return "prompt when needed";
-    return dangerous ? "every call this session" : "offer to the model";
+function lockedNotice(tool, host) {
+    host.emit({
+        kind: "notice",
+        text: `restart without --auto-approve to change ${tool}`,
+        tone: "warn",
+    });
 }

package/dist/provider-commands.js

@@ -1,227 +1,81 @@
-// Provider and model command flows.
-import { heading } from "./tui/picker.js";
-import { PROVIDERS } from "./providers/index.js";
-import { readSettings } from "./settings.js";
-import { authenticationNeed, ensureProviderAuthentication, } from "./credential-commands.js";
-import { providerFailure } from "./provider-errors.js";
+// Provider access and connection management. Runtime selection lives in /models.
+import { saveCommandSettings } from "./command-settings.js";
+import { apiKeyCommand } from "./credential-commands.js";
+import { credentialSource } from "./credentials.js";
+import { ollamaConnectionHint, ollamaConnectionSetting, } from "./ollama-settings-command.js";
+import { openAIAccountHint } from "./openai-account.js";
+import { openAIAccountCommand } from "./openai-account-command.js";
 import { providerLabel } from "./provider-label.js";
-import { compatibleEffort } from "./effort.js";
-/**
- * The provider menu.
- *
- * Every provider is offered, including the ones that cannot run: the reason
- * one is unusable — the variable it wants, by name — is worth more on screen
- * than the row would be worth hidden. A blocked choice opens the same masked
- * credential flow used by settings, and cancellation leaves the old choice.
- */
-export async function providersCommand(session, host, behavior = {}) {
+import { PROVIDERS } from "./providers/index.js";
+import { ollamaConnection } from "./providers/ollama.js";
+import { heading } from "./tui/picker.js";
+const OLLAMA_KEY = "OLLAMA_API_KEY";
+/** The single control plane for API keys, OAuth accounts, and Ollama endpoints. */
+export async function providersCommand(session, host) {
     const choose = chooser(host);
     if (choose === undefined)
-        return false;
-    const options = PROVIDERS.map((provider) => ({
-        label: provider.id,
-        hint: provider.blocked() ?? "ready",
-    }));
-    const at = PROVIDERS.findIndex((provider) => provider.id === session.provider.id);
-    const index = await choose({
-        title: heading("provider", "where the next turn runs", session.palette),
-        options,
-        index: Math.max(0, at),
-    });
-    if (index === undefined)
-        return false;
-    const chosen = PROVIDERS[index];
-    if (chosen === undefined)
-        return false;
-    // Picking the provider already in use is not a no-op when it cannot run:
-    // it is how the user asks to fix the reason it cannot.
-    if (chosen.id === session.provider.id) {
-        if (!(await ensureProviderAuthentication(chosen, session, host)))
-            return false;
-        return session.model === ""
-            ? modelsCommand(session, host, { announce: false, save: behavior.save })
-            : true;
-    }
-    // A provider that cannot run is worth one offer to fix it, here, rather
-    // than a note telling the user to leave and export something.
-    const blocked = chosen.blocked();
-    if (blocked !== undefined) {
-        await ensureProviderAuthentication(chosen, session, host);
-        const still = chosen.blocked();
-        if (still !== undefined) {
-            host.emit({
-                kind: "notice",
-                text: `${providerLabel(chosen.id)} still needs ${authenticationNeed(chosen)} · provider unchanged`,
-                tone: "warn",
-            });
-            return false;
-        }
-    }
-    const before = {
-        provider: session.provider,
-        model: session.model,
-        providerId: session.config.providerId,
-        configModel: session.config.model,
-        effort: session.config.effort,
-    };
-    session.provider = chosen;
-    // The model belonged to the old provider. Carrying it across would send
-    // `claude-sonnet-5` to OpenAI and call the 404 a bug in the provider.
-    session.model = readSettings().models?.[chosen.id] ?? chosen.defaultModel;
-    session.config.providerId = chosen.id;
-    session.config.model = session.model;
-    if (session.model === "") {
-        if (!(await modelsCommand(session, host, { announce: false, save: false }))) {
-            restoreProvider(session, before);
-            return false;
-        }
-    }
-    else {
-        const alignment = await alignEffort(session, host);
-        if (!alignment.ok) {
-            restoreProvider(session, before);
-            return false;
-        }
-    }
-    if (behavior.save !== false) {
-        const saved = readSettings();
-        const models = { ...saved.models };
-        if (session.model !== "")
-            models[chosen.id] = session.model;
-        const patch = {
-            provider: chosen.id,
-            models,
-            ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
-        };
-        if (!(await saveDefaults(host, patch))) {
-            restoreProvider(session, before);
-            return false;
-        }
-    }
-    if (behavior.announce !== false) {
-        host.emit({
-            kind: "notice",
-            text: session.model === "" ? `provider · ${chosen.id} · pick a model` : `provider · ${chosen.id}`,
-            tone: "info",
+        return;
+    let selected = Math.max(0, PROVIDERS.findIndex((provider) => provider.id === session.provider.id));
+    while (true) {
+        const index = await choose({
+            title: [],
+            options: PROVIDERS.map((provider) => ({
+                label: providerLabel(provider.id),
+                value: providerAccessHint(provider),
+            })),
+            index: selected,
         });
+        if (index === undefined)
+            return;
+        const provider = PROVIDERS[index];
+        if (provider === undefined)
+            return;
+        selected = index;
+        await manageProvider(provider, session, host);
+        // Esc closes only the nested provider flow. Ctrl+C also settles that
+        // picker, but aborts the command signal and must not reopen the parent.
+        throwIfAborted(host.signal);
     }
-    return true;
 }
-/** The model menu, built from what the provider says it has right now. */
-export async function modelsCommand(session, host, behavior = {}) {
-    // Before the network, not after: asking a provider for a list nothing can
-    // be picked from is a request spent on a menu that will never open.
-    const choose = chooser(host);
-    if (choose === undefined)
-        return false;
-    const provider = session.provider;
-    // Offer the key rather than only naming what is missing: the user came here
-    // to pick a model, and "go and export a variable" is not an answer.
-    const blocked = provider.blocked();
-    if (blocked !== undefined) {
-        await ensureProviderAuthentication(provider, session, host);
-        const still = provider.blocked();
-        if (still !== undefined) {
-            host.emit({
-                kind: "notice",
-                text: `${providerLabel(provider.id)} still needs ${authenticationNeed(provider)}`,
-                tone: "warn",
-            });
-            return false;
-        }
-    }
-    host.status?.(`Asking ${provider.id}`);
-    let ids;
-    try {
-        ids = await provider.models(host.signal, (status) => host.status?.(status));
-    }
-    catch (error) {
-        host.emit({
-            kind: "notice",
-            text: providerFailure(provider, error, true),
-            tone: "error",
-        });
-        return false;
-    }
-    finally {
-        host.status?.(undefined);
-    }
-    if (ids.length === 0) {
-        host.emit({ kind: "notice", text: `${provider.id} offers no models`, tone: "warn" });
-        return false;
-    }
-    const index = await choose({
-        title: heading("model", provider.id, session.palette),
-        options: ids.map((id) => ({ label: id })),
-        searchable: true,
-        query: "",
-        index: Math.max(0, ids.indexOf(session.model)),
-    });
-    if (index === undefined)
-        return false;
-    const chosen = ids[index];
-    if (chosen === undefined)
-        return false;
-    const before = {
-        model: session.model,
-        configModel: session.config.model,
-        effort: session.config.effort,
-    };
-    session.model = chosen;
-    session.config.model = chosen;
-    const alignment = await alignEffort(session, host);
-    if (!alignment.ok) {
-        session.model = before.model;
-        session.config.model = before.configModel;
-        session.config.effort = before.effort;
-        return false;
-    }
-    if (behavior.save !== false) {
-        const saved = readSettings();
-        const models = { ...saved.models, [provider.id]: chosen };
-        const patch = {
-            models,
-            ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
-        };
-        if (!(await saveDefaults(host, patch))) {
-            session.model = before.model;
-            session.config.model = before.configModel;
-            session.config.effort = before.effort;
-            return false;
-        }
+export function providerAccessHint(provider) {
+    if (provider.id === "ollama") {
+        const connection = ollamaConnection();
+        if (connection.loopback)
+            return `${ollamaConnectionHint()} · no key needed`;
+        return `${ollamaConnectionHint()} · API key ${credentialSource(OLLAMA_KEY) ?? "missing"}`;
+    }
+    if (provider.auth.kind === "oauth")
+        return openAIAccountHint();
+    return `API key · ${credentialSource(provider.auth.keyVar) ?? "missing"}`;
+}
+async function manageProvider(provider, session, host) {
+    if (provider.id === "ollama") {
+        await ollamaProviderCommand(session, host);
+        return;
     }
-    if (behavior.announce !== false) {
-        host.emit({ kind: "notice", text: `model · ${chosen}`, tone: "info" });
+    if (provider.auth.kind === "oauth") {
+        await openAIAccountCommand(session, host);
+        return;
     }
-    return true;
+    await apiKeyCommand(provider.auth.keyVar, providerLabel(provider.id), session, host);
 }
-function restoreProvider(session, before) {
-    session.provider = before.provider;
-    session.model = before.model;
-    session.config.providerId = before.providerId;
-    session.config.model = before.configModel;
-    session.config.effort = before.effort;
-}
-async function alignEffort(session, host) {
-    if (session.provider.efforts === undefined)
-        return { ok: true };
-    let supported;
-    try {
-        supported = await session.provider.efforts(session.model, host.signal, (status) => host.status?.(status));
+async function ollamaProviderCommand(session, host) {
+    if (host.choose === undefined)
+        return;
+    const index = await host.choose({
+        title: heading("Ollama", "access and connection", session.palette),
+        options: [
+            { label: "connection", hint: ollamaConnectionHint() },
+            { label: "API key", hint: credentialSource(OLLAMA_KEY) ?? "missing" },
+        ],
+        index: 0,
+    });
+    if (index === 0) {
+        await ollamaConnectionSetting(session, host, (patch) => saveCommandSettings(host, patch));
     }
-    catch (error) {
-        host.emit({
-            kind: "notice",
-            text: providerFailure(session.provider, error, true),
-            tone: "error",
-        });
-        return { ok: false };
+    else if (index === 1) {
+        await apiKeyCommand(OLLAMA_KEY, "Ollama", session, host);
     }
-    const adjusted = compatibleEffort(session.config.effort, supported);
-    if (adjusted === undefined || adjusted === session.config.effort)
-        return { ok: true };
-    session.config.effort = adjusted;
-    return { ok: true, adjusted };
 }
 function chooser(host) {
     if (host.choose === undefined) {
@@ -229,19 +83,8 @@ function chooser(host) {
     }
     return host.choose;
 }
-async function saveDefaults(host, patch) {
-    if (host.saveSettings === undefined)
-        return true;
-    try {
-        await host.saveSettings(patch);
-        return true;
-    }
-    catch (error) {
-        host.emit({
-            kind: "notice",
-            text: `could not save settings · ${error.message}`,
-            tone: "error",
-        });
-        return false;
-    }
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
 }

package/dist/provider-errors.js

@@ -1,10 +1,11 @@
 // Actionable provider failures for user-facing command and turn surfaces.
+import { providerLabel } from "./provider-label.js";
 const CONNECTION_FAILURE = /network error calling|timed out waiting for response headers|response body was idle/i;
 export function providerFailure(provider, error, labelProvider = false) {
     if (provider.id === "ollama" && CONNECTION_FAILURE.test(error.message)) {
         return provider.location?.() === "local"
-            ? "Ollama is not reachable on this computer · start Ollama or choose cloud in /settings"
-            : "Ollama is not reachable · check its connection in /settings";
+            ? "Ollama is not reachable on this computer · start Ollama or choose cloud in /providers"
+            : "Ollama is not reachable · check its connection in /providers";
     }
-    return labelProvider ? `${provider.id}: ${error.message}` : error.message;
+    return labelProvider ? `${providerLabel(provider.id)}: ${error.message}` : error.message;
 }

package/dist/provider-label.js

@@ -2,8 +2,8 @@
 export function providerLabel(id) {
     switch (id) {
         case "anthropic": return "Anthropic";
-        case "openai": return "OpenAI";
-        case "openai-codex": return "OpenAI Codex";
+        case "openai": return "OpenAI API";
+        case "openai-codex": return "ChatGPT";
         case "ollama": return "Ollama";
         default: return id === "" ? "Provider" : `${id[0]?.toUpperCase() ?? ""}${id.slice(1)}`;
     }