@giovannijecha/jecode 0.3.2 → 0.5.0

package/dist/credential-commands.js

@@ -1,10 +1,7 @@
-// Credential command flows shared by settings and provider selection.
-import { heading } from "./tui/picker.js";
+// Masked API-key interaction shared by provider connection flows.
+import { credentialSource, forgetSaved, forgetSession, hasSaved, hold, keep, storeLabel, } from "./credentials.js";
 import { EMPTY } from "./tui/editor.js";
-import { PROVIDERS } from "./providers/index.js";
-import { openAIAccountHint } from "./openai-account.js";
-import { ensureOpenAIAccount, openAIAccountCommand, } from "./openai-account-command.js";
-import { credentialSource, forgetSaved, hasSaved, hold, keep, storeLabel, } from "./credentials.js";
+import { heading } from "./tui/picker.js";
 /** Ask for a key, then ask separately whether it may be written to disk. */
 export async function askForKey(name, host, pal) {
     if (host.type === undefined || host.choose === undefined)
@@ -43,109 +40,95 @@ export async function askForKey(name, host, pal) {
             return true;
         }
         catch (error) {
-            host.emit({ kind: "notice", text: `could not save API key · ${error.message}`, tone: "error" });
+            host.emit({
+                kind: "notice",
+                text: `could not save API key · ${error.message}`,
+                tone: "error",
+            });
             return false;
         }
     }
     return false;
 }
-export async function credentialsCommand(session, host) {
+/** Manage one provider key without ever placing its value on screen. */
+export async function apiKeyCommand(name, label, session, host) {
     const choose = chooser(host);
     if (choose === undefined)
         return;
-    const index = await choose({
-        title: heading("authentication", "secrets are never shown", session.palette),
-        options: PROVIDERS.map((provider) => ({
-            label: provider.auth.kind === "api-key" ? provider.auth.keyVar : `${provider.auth.label} account`,
-            hint: provider.auth.kind === "api-key"
-                ? credentialSource(provider.auth.keyVar) ?? "missing"
-                : openAIAccountHint(),
-        })),
-        index: Math.max(0, PROVIDERS.findIndex((provider) => provider.id === session.provider.id)),
-    });
-    if (index === undefined)
-        return;
-    const provider = PROVIDERS[index];
-    if (provider === undefined)
-        return;
-    if (provider.auth.kind === "oauth") {
-        await openAIAccountCommand(session, host);
-        return;
-    }
-    const name = provider.auth.keyVar;
     const source = credentialSource(name);
     if (source === "environment") {
-        host.emit({
-            kind: "notice",
-            text: `${name} comes from the environment · restart after changing it`,
-            tone: "info",
+        if (!hasSaved(name)) {
+            host.emit({
+                kind: "notice",
+                text: `${label} API key comes from the environment · restart after changing it`,
+                tone: "info",
+            });
+            return;
+        }
+        const action = await choose({
+            title: heading(`${label} API key`, `${name} · environment`, session.palette),
+            description: "The environment value is read-only. A saved copy is currently shadowed.",
+            options: [{ label: "forget saved copy", hint: storeLabel(), key: "f" }],
+            index: 0,
         });
-        if (hasSaved(name))
-            await offerForget(name, session, host, "a saved copy is currently shadowed");
+        if (action === 0)
+            await forgetSavedKey(name, host);
         return;
     }
     const actions = [
-        { label: source === undefined ? "add credential" : "replace credential", key: "r" },
-        ...(hasSaved(name) ? [{ label: "forget saved copy", hint: storeLabel(), key: "f" }] : []),
+        {
+            label: source === undefined ? "add API key" : "replace API key",
+            hint: source === undefined ? "session or owner-only file" : `currently ${source}`,
+            key: "r",
+        },
+        ...(source === "session"
+            ? [{ label: "clear session key", hint: "this process only", key: "c" }]
+            : []),
+        ...(hasSaved(name)
+            ? [{ label: "forget saved copy", hint: storeLabel(), key: "f" }]
+            : []),
     ];
-    const action = await choose({
-        title: heading(name, source ?? "missing", session.palette),
+    const index = await choose({
+        title: heading(`${label} API key`, `${name} · ${source ?? "missing"}`, session.palette),
         options: actions,
         index: 0,
     });
-    if (action === undefined)
-        return;
-    if (actions[action]?.key === "f") {
-        await forget(name, host);
-        return;
-    }
-    await askForKey(name, host, session.palette);
+    const action = index === undefined ? undefined : actions[index]?.key;
+    if (action === "r")
+        await askForKey(name, host, session.palette);
+    else if (action === "c")
+        clearSessionKey(name, host);
+    else if (action === "f")
+        await forgetSavedKey(name, host);
 }
-/** Offer the authentication flow owned by a provider, if that is its blocker. */
-export async function ensureProviderAuthentication(provider, session, host) {
-    const blocked = provider.blocked();
-    if (blocked === undefined)
-        return true;
-    if (provider.auth.kind === "oauth") {
-        return provider.auth.account === "openai-codex"
-            ? ensureOpenAIAccount(session, host)
-            : false;
-    }
-    if (!blocked.startsWith(`${provider.auth.keyVar} `)) {
-        host.emit({ kind: "notice", text: blocked, tone: "error" });
-        return false;
-    }
-    await askForKey(provider.auth.keyVar, host, session.palette);
-    return provider.blocked() === undefined;
-}
-export function authenticationNeed(provider) {
-    return provider.auth.kind === "oauth" ? `${provider.auth.label} sign-in` : "an API key";
-}
-async function offerForget(name, session, host, hint) {
-    if (host.choose === undefined)
-        return;
-    const index = await host.choose({
-        title: heading(name, hint, session.palette),
-        options: [
-            { label: "keep saved copy", key: "k" },
-            { label: "forget saved copy", hint: storeLabel(), key: "f" },
-        ],
-        index: 0,
+function clearSessionKey(name, host) {
+    const removed = forgetSession(name);
+    const fallback = credentialSource(name);
+    host.emit({
+        kind: "notice",
+        text: removed
+            ? fallback === undefined
+                ? "session API key removed"
+                : `session API key removed · ${fallback} copy now active`
+            : "no session API key",
+        tone: removed ? "info" : "warn",
     });
-    if (index === 1)
-        await forget(name, host);
 }
-async function forget(name, host) {
+async function forgetSavedKey(name, host) {
     try {
         const removed = await forgetSaved(name);
         host.emit({
             kind: "notice",
-            text: removed ? "API key removed" : "no saved API key",
+            text: removed ? "saved API key removed" : "no saved API key",
             tone: removed ? "info" : "warn",
         });
     }
     catch (error) {
-        host.emit({ kind: "notice", text: `could not remove API key · ${error.message}`, tone: "error" });
+        host.emit({
+            kind: "notice",
+            text: `could not remove API key · ${error.message}`,
+            tone: "error",
+        });
     }
 }
 function chooser(host) {

package/dist/credentials.js

@@ -60,6 +60,10 @@ export function hasSaved(name) {
 export function hold(name, value) {
     held.set(name, value);
 }
+/** Remove only the value held by this process. Saved and environment values remain. */
+export function forgetSession(name) {
+    return held.delete(name);
+}
 /**
  * Take a key and write it down, returning the path it went to.
  *
@@ -74,8 +78,10 @@ export async function keep(name, value) {
     return withStoreLock(file, async () => {
         const all = { ...readSavedStore(), [name]: value };
         await persist(file, all);
-        hold(name, value);
         saved = all;
+        // A newly saved replacement must become active immediately. Otherwise an
+        // older session-only value would keep shadowing the value just written.
+        held.delete(name);
         return file;
     });
 }

package/dist/launch.js

@@ -0,0 +1,19 @@
+export function parseLaunch(argv) {
+    const first = argv[0];
+    if (first !== undefined && !first.startsWith("--") && first !== "-h" && first !== "-v") {
+        if (first !== "resume")
+            throw new Error(`unknown command ${first}`);
+        const rest = argv.slice(1);
+        const latest = rest.filter((value) => value === "--latest").length;
+        if (latest > 1)
+            throw new Error("--latest may be passed only once");
+        return {
+            kind: "resume",
+            latest: latest === 1,
+            configArgs: rest.filter((value) => value !== "--latest"),
+        };
+    }
+    if (argv.includes("--latest"))
+        throw new Error("--latest requires `jecode resume`");
+    return { kind: "new", latest: false, configArgs: [...argv] };
+}

package/dist/model-command.js

@@ -0,0 +1,171 @@
+// Model-first runtime selection across every provider that can answer now.
+import { saveCommandSettings } from "./command-settings.js";
+import { compatibleEffort } from "./effort.js";
+import { providerFailure } from "./provider-errors.js";
+import { providerLabel } from "./provider-label.js";
+import { PROVIDERS } from "./providers/index.js";
+import { readSettings } from "./settings.js";
+/** Build one searchable catalogue from every provider that is usable now. */
+export async function modelsCommand(session, host, behavior = {}, providers = PROVIDERS) {
+    const choose = chooser(host);
+    if (choose === undefined)
+        return false;
+    const availability = providers.map((provider) => ({
+        provider,
+        blocked: provider.blocked(),
+    }));
+    const connected = availability
+        .filter((entry) => entry.blocked === undefined)
+        .map((entry) => entry.provider);
+    const disconnected = availability
+        .filter((entry) => entry.blocked !== undefined)
+        .map((entry) => entry.provider);
+    if (connected.length === 0) {
+        host.emit({
+            kind: "notice",
+            text: "no providers are connected · use /providers",
+            tone: "warn",
+        });
+        return false;
+    }
+    throwIfAborted(host.signal);
+    host.status?.("Loading model catalogs");
+    let settled;
+    try {
+        settled = await Promise.allSettled(connected.map(async (provider) => ({
+            provider,
+            models: await provider.models(host.signal, (status) => host.status?.(`${providerLabel(provider.id)} · ${status}`)),
+        })));
+        // allSettled deliberately preserves partial provider failures, but an
+        // explicit command cancellation is not a catalogue failure.
+        throwIfAborted(host.signal);
+    }
+    finally {
+        host.status?.(undefined);
+    }
+    const choices = [];
+    const failed = [];
+    for (let index = 0; index < settled.length; index++) {
+        const result = settled[index];
+        const provider = connected[index];
+        if (result === undefined || provider === undefined)
+            continue;
+        if (result.status === "rejected") {
+            failed.push({
+                provider,
+                error: result.reason instanceof Error ? result.reason : new Error(String(result.reason)),
+            });
+            continue;
+        }
+        for (const model of result.value.models)
+            choices.push({ provider, model });
+    }
+    if (choices.length === 0) {
+        host.emit({
+            kind: "notice",
+            text: emptyCatalogMessage(connected, failed),
+            tone: failed.length === connected.length ? "error" : "warn",
+        });
+        return false;
+    }
+    const description = catalogDescription(disconnected, failed);
+    const index = await choose({
+        title: [],
+        ...(description === undefined ? {} : { description }),
+        options: choices.map((choice) => ({
+            label: choice.model,
+            // Provider identity is part of the choice, not optional help: keep it
+            // visible even when the terminal is only at the supported minimum.
+            value: providerLabel(choice.provider.id),
+        })),
+        searchable: true,
+        query: "",
+        index: Math.max(0, choices.findIndex((choice) => choice.provider.id === session.provider.id && choice.model === session.model)),
+    });
+    throwIfAborted(host.signal);
+    const chosen = index === undefined ? undefined : choices[index];
+    if (chosen === undefined)
+        return false;
+    const beforeEffort = session.config.effort;
+    const alignment = await alignEffort(chosen.provider, chosen.model, beforeEffort, host);
+    if (!alignment.ok)
+        return false;
+    if (behavior.save !== false) {
+        const saved = readSettings();
+        const patch = {
+            provider: chosen.provider.id,
+            models: { ...saved.models, [chosen.provider.id]: chosen.model },
+            ...(alignment.effort === beforeEffort ? {} : { effort: alignment.effort }),
+        };
+        if (!(await saveCommandSettings(host, patch)))
+            return false;
+    }
+    // Commit the runtime selection only after both provider validation and
+    // persistence succeed, so neither the footer nor a later turn can observe a
+    // half-applied provider/model pair.
+    session.provider = chosen.provider;
+    session.model = chosen.model;
+    session.config.providerId = chosen.provider.id;
+    session.config.model = chosen.model;
+    session.config.effort = alignment.effort;
+    if (behavior.announce !== false) {
+        host.emit({
+            kind: "notice",
+            text: `model · ${providerLabel(chosen.provider.id)} · ${chosen.model}`,
+            tone: "info",
+        });
+    }
+    return true;
+}
+async function alignEffort(provider, model, effort, host) {
+    if (provider.efforts === undefined)
+        return { ok: true, effort };
+    try {
+        throwIfAborted(host.signal);
+        const supported = await provider.efforts(model, host.signal, (status) => host.status?.(status));
+        throwIfAborted(host.signal);
+        return { ok: true, effort: compatibleEffort(effort, supported) ?? effort };
+    }
+    catch (error) {
+        throwIfAborted(host.signal);
+        host.emit({
+            kind: "notice",
+            text: providerFailure(provider, error, true),
+            tone: "error",
+        });
+        return { ok: false };
+    }
+}
+function catalogDescription(disconnected, failed) {
+    const parts = [
+        disconnected.length === 0
+            ? undefined
+            : `Not connected: ${disconnected.map((provider) => providerLabel(provider.id)).join(", ")}`,
+        failed.length === 0
+            ? undefined
+            : `Unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")}`,
+    ].filter((part) => part !== undefined);
+    return parts.length === 0 ? undefined : `${parts.join(" · ")} · manage in /providers`;
+}
+function emptyCatalogMessage(connected, failed) {
+    if (failed.length === 1 && connected.length === 1) {
+        const one = failed[0];
+        if (one !== undefined)
+            return providerFailure(one.provider, one.error, true);
+    }
+    if (failed.length > 0) {
+        return `model catalogs unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")} · /providers`;
+    }
+    return "connected providers offer no models · check /providers";
+}
+function chooser(host) {
+    if (host.choose === undefined) {
+        host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });
+    }
+    return host.choose;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}

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",
+    });
 }