@datename/fastcode-termux 0.1.6 → 0.1.8-beta.0

package/src/{cli.ts → cli-main.ts}

@@ -12,8 +12,11 @@ import { loadConfig, saveConfig, resolveProviderKey } from "./config/store.js";
 import { getPaths } from "./config/paths.js";
 import { PROVIDERS, getProvider } from "./providers/index.js";
 import { collectDiagnostics, formatDiagnostics } from "./lib/diagnostics.js";
-import { latestSessionFile, listSessions, readSession, resolveSessionFile } from "./session/log.js";
-import { listTrusted, trustProject, untrustProject } from "./config/trust.js";
+import { probeConnectivity } from "./lib/http.js";
+import { existsSync } from "node:fs";
+import { latestSessionFile, listSessions, projectionPath, readSession, resolveSessionFile } from "./session/log.js";
+import { readProjection, sessionMetaFromFile } from "./session/projection.js";
+import { forgetToolApproval, listToolApprovals, listTrusted, trustProject, untrustProject } from "./config/trust.js";
 const NL = String.fromCharCode(10);
 const HELP = [
     "",
@@ -37,7 +40,8 @@ const HELP = [
     "  Trust (first-run safety)",
     "    $ fastcode trust [dir]           Trust a folder (enables agent tools)",
     "    $ fastcode untrust [dir]         Revoke trust for a folder",
-    "    $ fastcode trusted               List trusted folders",
+    "    $ fastcode trusted               List trusted folders and remembered approvals",
+    "    $ fastcode trust --forget <key>  Revoke one remembered approval",
     "",
     "  Skills & maintenance",
     "    $ fastcode skills list           Print installed skills",
@@ -45,6 +49,7 @@ const HELP = [
     "    $ fastcode skills uninstall <id> Remove an installed skill",
     "    $ fastcode skills search <q>     Search the registry",
     "    $ fastcode doctor                Environment diagnostics (Termux/mobile)",
+    "    $ fastcode doctor --net          Also probe registry connectivity",
     "    $ fastcode update                Check for a newer release",
     "",
     "  Options",
@@ -61,16 +66,26 @@ const HELP = [
     "  DASHSCOPE_API_KEY) or from /login inside the TUI.",
     "  Override the data directory with FASTCODE_HOME.",
     "",
+    "  Approval UI:  --ui tty|native|plain|json   (default tty)",
+    "",
 ].join(NL);
 export async function parseCli(): Promise<any> {
     const cli = meow(HELP, {
         importMeta: import.meta,
         flags: {
             version: { type: "boolean", shortFlag: "v" },
+            ui: { type: "string", default: "tty" },
+            forget: { type: "string" },
+            net: { type: "boolean", default: false },
         },
         autoHelp: true,
         autoVersion: true,
     });
+    const uiMode = String(cli.flags.ui ?? "tty").toLowerCase();
+    if (!["tty", "native", "plain", "json"].includes(uiMode)) {
+        console.error("Unknown --ui mode: " + uiMode + " (use tty, native, plain, or json)");
+        process.exit(1);
+    }
     // First positional dictates the sub-command. Anything else is a prompt.
     const [first, ...rest] = cli.input;
     if (first === "provider") {
@@ -156,13 +171,26 @@ export async function parseCli(): Promise<any> {
             return { done: true };
         }
         if (rest[0] === "show") {
-            const entries = readSession(rest[1] ?? all[0].id);
+            const idOrFile = rest[1] ?? all[0].id;
+            const entries = readSession(idOrFile);
             for (const entry of entries) {
                 if (entry.type === "message")
                     console.log("[" + entry.role + "] " + entry.content);
+                else if (entry.type === "user" || entry.type === "assistant_raw")
+                    console.log("[" + entry.type + "] " + String(entry.content ?? "").slice(0, 300));
                 else
                     console.log("[" + entry.type + "]");
             }
+            const file = resolveSessionFile(idOrFile);
+            const projection = readProjection(file);
+            console.log("");
+            if (projection) {
+                console.log("[projection] " + projectionPath(file));
+                console.log("  messages: " + projection.messages.length + " · activeFiles: " + projection.activeFiles.length + " · lastFactSeq: " + projection.lastFactSeq);
+            }
+            else {
+                console.log("[projection] (none)");
+            }
             return { done: true };
         }
         console.log("Sessions (newest first):");
@@ -177,22 +205,44 @@ export async function parseCli(): Promise<any> {
     if (first === "resume") {
         const target = rest[0];
         const file = !target || target === "latest" ? latestSessionFile() : resolveSessionFile(target);
-        if (!file) {
+        if (!file || !existsSync(file)) {
             console.error("No saved session to resume. Start one with: fastcode");
             process.exit(1);
         }
+        const meta = sessionMetaFromFile(file);
+        if (meta.cwd) {
+            if (existsSync(meta.cwd)) {
+                process.chdir(meta.cwd);
+                console.log("Working directory: " + meta.cwd);
+            }
+            else {
+                console.log("Session directory no longer exists: " + meta.cwd + " (staying in " + process.cwd() + ")");
+            }
+        }
+        if (meta.providerId)
+            console.log("Session model: " + meta.providerId + "::" + meta.model);
         console.log("Resuming " + file);
         return { done: false, resume: file };
     }
     if (first === "trust" || first === "untrust" || first === "trusted") {
         if (first === "trusted") {
             const all = listTrusted();
-            if (all.length === 0) {
+            if (all.length === 0)
                 console.log("No trusted folders yet. Run: fastcode trust");
-                return { done: true };
-            }
             for (const entry of all)
                 console.log("  " + entry.path + "   (" + entry.addedAt + ")");
+            const approvals = listToolApprovals();
+            if (approvals.length > 0) {
+                console.log("");
+                console.log("Remembered tool approvals:");
+                for (const entry of approvals)
+                    console.log("  " + entry.key + "   catalog=" + entry.catalogHash);
+            }
+            return { done: true };
+        }
+        if (first === "trust" && typeof cli.flags.forget === "string") {
+            const key = String(cli.flags.forget);
+            console.log(forgetToolApproval(key) ? "Forgot approval: " + key : "No such approval: " + key);
             return { done: true };
         }
         const dir = rest[0] ?? process.cwd();
@@ -258,6 +308,11 @@ export async function parseCli(): Promise<any> {
     }
     if (first === "doctor") {
         console.log(formatDiagnostics(collectDiagnostics()));
+        if (cli.flags.net === true) {
+            const url = "https://registry.npmjs.org/";
+            const reachable = await probeConnectivity(url);
+            console.log(`  network       ${reachable ? "reachable" : "unreachable"} (${url})`);
+        }
         return { done: true };
     }
     if (first === "update") {
@@ -266,7 +321,7 @@ export async function parseCli(): Promise<any> {
     }
     // No sub-command → treat all positionals as the initial prompt.
     const prompt = cli.input.length > 0 ? cli.input.join(" ") : undefined;
-    return prompt ? { prompt, done: false } : { done: false };
+    return prompt ? { prompt, done: false, ui: uiMode } : { done: false, ui: uiMode };
 }
 function compareVersions(a, b) {
     const pa = a.split(".").map((n) => parseInt(n, 10) || 0);

package/src/commands/about.ts

@@ -9,7 +9,7 @@ export const aboutCommand = {
             `Platform: ${platformLabel()}  •  Node ${process.version}`,
             ``,
             `GitHub:   https://github.com/dateName/fastcode-termux`,
-            `Skills:   https://skillshub.wtf`,
+            `Skills:   configure a registry with /skills registry <url>`,
         ];
         return { message: lines.join("\n") };
     },

package/src/commands/attach.ts

@@ -0,0 +1,16 @@
+import { pollShellSession } from "../agent/shell-session.js";
+
+export const attachCommand = {
+    name: "attach",
+    description: "Show new output from a background shell session (/attach <id>)",
+    async run({ args }) {
+        const id = args[0];
+        if (!id)
+            return { message: "Usage: /attach <session-id>  (see /jobs)" };
+        const result = await pollShellSession(id, 0);
+        if (!result)
+            return { message: `Unknown session: ${id}` };
+        const status = result.status === "running" ? "running" : `${result.status} (exit ${result.exitCode ?? "?"})`;
+        return { message: `[session ${id}] ${status}\n${result.output || "(no new output)"}` };
+    },
+};

package/src/commands/bg.ts

@@ -0,0 +1,9 @@
+export const bgCommand = {
+    name: "bg",
+    description: "Explain backgrounding (long shell commands auto-background after ~2s)",
+    run() {
+        return {
+            message: "Long shell commands already return a session id after ~2s; use /jobs to list them, /attach <id> for new output, /kill <id> to stop.",
+        };
+    },
+};

package/src/commands/cancel.ts

@@ -0,0 +1,10 @@
+export const cancelCommand = {
+    name: "cancel",
+    description: "Cancel the active agent run (soft keyboard alternative to Esc)",
+    run({ state, actions }) {
+        if (!state.busy)
+            return { message: "Nothing is running." };
+        actions.cancelRun();
+        return { message: "Cancelling the active run…" };
+    },
+};

package/src/commands/clear.ts

@@ -4,6 +4,6 @@ export const clearCommand = {
     aliases: ["cls"],
     run({ actions }) {
         actions.clearHistory();
-        return { message: "Conversation cleared.", silent: false };
+        return { message: "Conversation cleared.", silent: false, cleared: true };
     },
 };

package/src/commands/compact.ts

@@ -0,0 +1,35 @@
+import { compactMessages, compactionConfigFromEnv } from "../agent/compaction.js";
+import { getModelMeta } from "../lib/model-meta.js";
+
+export const compactCommand = {
+    name: "compact",
+    description: "Force local context compaction now",
+    run({ state, actions }) {
+        const config = compactionConfigFromEnv();
+        if (!config.enabled)
+            return { message: "Compaction is disabled by FASTCODE_COMPACTION." };
+        const meta = getModelMeta(state.providerId, state.model);
+        const result = compactMessages(state.history, { ...config, localThresholdRatio: 0 }, {
+            contextWindow: meta.contextWindow,
+            providerId: state.providerId,
+            model: state.model,
+            force: true,
+        });
+        if (!result.compacted)
+            return { message: "Nothing to compact (history is already small)." };
+        actions.replaceHistory(result.messages);
+        return {
+            message: `[context compacted] ${result.beforeTokens} → ${result.afterTokens} tokens (${result.droppedMessages} messages summarized).` +
+                (result.summaryFile ? `\nSummary: ${result.summaryFile}` : ""),
+            compacted: {
+                summaryRef: result.summaryFile,
+                source: "local",
+                beforeTokens: result.beforeTokens,
+                afterTokens: result.afterTokens,
+                droppedMessages: result.droppedMessages,
+                keepMessages: result.keptMessages,
+                reason: "manual",
+            },
+        };
+    },
+};

package/src/commands/context.ts

@@ -0,0 +1,26 @@
+import { compactionConfigFromEnv, heapExceeded, localThresholdTokens } from "../agent/compaction.js";
+import { estMessagesTokens, getModelMeta } from "../lib/model-meta.js";
+
+export const contextCommand = {
+    name: "context",
+    description: "Show estimated context tokens, compaction threshold, and heap usage",
+    run(ctx) {
+        const meta = getModelMeta(ctx.state.providerId, ctx.state.model);
+        const config = compactionConfigFromEnv();
+        const tokens = estMessagesTokens(ctx.state.history, {
+            providerId: ctx.state.providerId,
+            model: ctx.state.model,
+        });
+        const threshold = localThresholdTokens(config, meta.contextWindow);
+        const percent = meta.contextWindow > 0 ? (tokens / meta.contextWindow) * 100 : 0;
+        const heapMb = process.memoryUsage().heapUsed / 1024 / 1024;
+        return {
+            message: [
+                `Context: ~${tokens.toLocaleString()} / ${meta.contextWindow.toLocaleString()} tokens (${percent.toFixed(1)}%)`,
+                `Compaction threshold: ${threshold.toLocaleString()} tokens (${Math.round(config.localThresholdRatio * 100)}%)${config.enabled ? "" : "  [disabled]"}`,
+                `Heap: ${heapMb.toFixed(1)} MB / ${config.heapLimitMb} MB${heapExceeded(config) ? "  [forced compaction]" : ""}`,
+                `Messages: ${ctx.state.history.length}  ·  chars/token: ~${meta.charsPerToken}`,
+            ].join("\n"),
+        };
+    },
+};

package/src/commands/edit.ts

@@ -0,0 +1,37 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export const editCommand = {
+    name: "edit",
+    description: "Edit the prompt in $EDITOR (works around Ink IME issues on Termux)",
+    run({ state, actions }) {
+        const file = join(tmpdir(), `fastcode-edit-${Date.now()}.md`);
+        writeFileSync(file, state.draft ?? "", "utf8");
+        const editor = process.env["EDITOR"] || process.env["VISUAL"] || "nano";
+        const wasRaw = Boolean(process.stdin.isTTY && process.stdin.isRaw);
+        try {
+            if (wasRaw)
+                process.stdin.setRawMode(false);
+            const result = spawnSync(editor, [file], { stdio: "inherit" });
+            if (result.error)
+                return { message: `Could not launch ${editor}: ${result.error.message}` };
+            const text = readFileSync(file, "utf8").trim();
+            if (!text)
+                return { message: "Editor closed with no text." };
+            actions.setInput(text);
+            return { message: "Draft loaded into the prompt; press Enter to send." };
+        }
+        finally {
+            if (wasRaw)
+                process.stdin.setRawMode(true);
+            try {
+                unlinkSync(file);
+            }
+            catch {
+                // temp file may already be gone
+            }
+        }
+    },
+};

package/src/commands/effort.ts

@@ -0,0 +1,49 @@
+import { getProvider } from "../providers/index.js";
+import type { ReasoningEffort } from "../types.js";
+const EFFORTS: ReasoningEffort[] = ["auto", "low", "medium", "high", "max"];
+const HINTS: Record<ReasoningEffort, string> = {
+    auto: "provider default (send nothing)",
+    low: "fast, minimal thinking",
+    medium: "balanced",
+    high: "deeper reasoning, slower",
+    max: "maximum budget where supported",
+};
+export const effortCommand = {
+    name: "effort",
+    description: "Set thinking effort (auto/low/medium/high/max). Usage: /effort [level]",
+    run({ args, state, actions }) {
+        const provider = getProvider(state.providerId);
+        const supported = provider?.supportsReasoning?.(state.model) ?? false;
+        const current = (state.reasoningEffort ?? "auto");
+        const apply = (value: ReasoningEffort) => {
+            actions.setReasoningEffort(value);
+            return describe(value, provider, supported);
+        };
+        if (args.length > 0) {
+            const value = args[0].toLowerCase();
+            if (!EFFORTS.includes(value as ReasoningEffort)) {
+                return { message: `Unknown effort "${args[0]}". Choose: ${EFFORTS.join(", ")}.` };
+            }
+            return { message: apply(value as ReasoningEffort) };
+        }
+        return {
+            message: `Thinking effort: ${current}${supported ? "" : " (this provider has no thinking parameter)"}`,
+            picker: {
+                title: `Thinking effort · ${provider?.label ?? state.providerId}`,
+                current,
+                items: EFFORTS.map((value) => ({ value, label: value, hint: HINTS[value] })),
+                onSelect: (value) => actions.pushSystemMessage(apply(value as ReasoningEffort)),
+            },
+        };
+    },
+};
+function describe(value, provider, supported) {
+    if (value === "auto") {
+        return "Thinking effort: auto — the provider's default is used (no thinking parameter is sent).";
+    }
+    if (!supported) {
+        return `Thinking effort saved as ${value}, but ${provider?.label ?? "this provider"} does not expose a thinking parameter; ` +
+            "requests will omit it. Switch to a reasoning-capable model/provider to use it.";
+    }
+    return `Thinking effort: ${value}. The next request will carry the provider-specific thinking parameter.`;
+}

package/src/commands/expand.ts

@@ -0,0 +1,8 @@
+export const expandCommand = {
+    name: "expand",
+    description: "Toggle full tool output in the transcript (stable UI defaults to collapsed)",
+    run({ state, actions }) {
+        actions.setExpanded(!state.expanded);
+        return { message: state.expanded ? "Tool output: collapsed." : "Tool output: expanded (new output only)." };
+    },
+};

package/src/commands/index.ts

@@ -7,6 +7,7 @@ import { clearCommand } from "./clear.js";
 import { exitCommand } from "./exit.js";
 import { modelCommand } from "./model.js";
 import { providerCommand } from "./provider.js";
+import { effortCommand } from "./effort.js";
 import { loginCommand } from "./login.js";
 import { logoutCommand } from "./logout.js";
 import { skillsCommand } from "./skills.js";
@@ -17,6 +18,17 @@ import { systemCommand } from "./system.js";
 import { aboutCommand } from "./about.js";
 import { configCommand } from "./config.js";
 import { whoamiCommand } from "./whoami.js";
+import { contextCommand } from "./context.js";
+import { jobsCommand } from "./jobs.js";
+import { killCommand } from "./kill.js";
+import { cancelCommand } from "./cancel.js";
+import { steerCommand } from "./steer.js";
+import { compactCommand } from "./compact.js";
+import { expandCommand } from "./expand.js";
+import { attachCommand } from "./attach.js";
+import { bgCommand } from "./bg.js";
+import { editCommand } from "./edit.js";
+import { threadsCommand } from "./threads.js";
 export const COMMANDS = [
     helpCommand,
     agentCommand,
@@ -27,6 +39,7 @@ export const COMMANDS = [
     exitCommand,
     modelCommand,
     providerCommand,
+    effortCommand,
     loginCommand,
     logoutCommand,
     skillsCommand,
@@ -37,6 +50,17 @@ export const COMMANDS = [
     aboutCommand,
     configCommand,
     whoamiCommand,
+    contextCommand,
+    jobsCommand,
+    killCommand,
+    cancelCommand,
+    steerCommand,
+    compactCommand,
+    expandCommand,
+    attachCommand,
+    bgCommand,
+    editCommand,
+    threadsCommand,
 ];
 export function findCommand(name) {
     const lower = name.toLowerCase();

package/src/commands/jobs.ts

@@ -0,0 +1,18 @@
+import { listShellSessions } from "../agent/shell-session.js";
+
+export const jobsCommand = {
+    name: "jobs",
+    description: "List background shell sessions",
+    run() {
+        const jobs = listShellSessions();
+        if (jobs.length === 0)
+            return { message: "No shell sessions. Long commands return a session id automatically." };
+        const lines = jobs.map((job) => {
+            const exit = job.exitCode === undefined || job.exitCode === null ? "" : ` exit=${job.exitCode}`;
+            const age = Math.max(0, Math.round((Date.now() - job.startedAt) / 1000));
+            const command = job.command.length > 80 ? job.command.slice(0, 77) + "…" : job.command;
+            return `${job.id}  ${job.status}${exit}  ${age}s  ${(job.bytes / 1024).toFixed(1)}KB  ${command}`;
+        });
+        return { message: ["Shell sessions:", ...lines, "", "Kill one with: /kill <id>", "Completed sessions are pruned after 10 minutes; resident pool cap is 2."].join("\n") };
+    },
+};

package/src/commands/kill.ts

@@ -0,0 +1,14 @@
+import { killShellSession } from "../agent/shell-session.js";
+
+export const killCommand = {
+    name: "kill",
+    description: "Kill a background shell session (/kill <id>)",
+    run(ctx) {
+        const id = ctx.args[0];
+        if (!id)
+            return { message: "Usage: /kill <session-id>  (see /jobs)" };
+        return { message: killShellSession(id)
+                ? `Killed ${id} (process group killed; setsid descendants may escape).`
+                : `No running session named ${id}.` };
+    },
+};

package/src/commands/login.ts

@@ -2,8 +2,10 @@ import { getProvider, PROVIDERS } from "../providers/index.js";
 import { maskKey, setCredential } from "../config/store.js";
 import { getPaths } from "../config/paths.js";
 /**
- * Save a key scoped to one provider + model and describe it for the terminal.
- * Shared by the `/login` command and the guided flow in the app.
+ * Save a provider-wide key and describe it for the terminal. `model` is kept
+ * for the `/login provider model key` one-liner and only recorded as the
+ * credential's origin — the key itself is reused by every model of that
+ * provider. Shared by the `/login` command and the guided flow in the app.
  */
 export function saveScopedKey(providerId, providerLabel, model, key) {
     const trimmed = key.trim();
@@ -12,20 +14,32 @@ export function saveScopedKey(providerId, providerLabel, model, key) {
     return [
         "Saved API key",
         `  provider  ${providerLabel} (${providerId})`,
-        `  model     ${model}`,
+        `  scope     all ${providerId} models (saved from ${model || "unknown"})`,
         `  key       ${maskKey(trimmed)}`,
         `  stored    ${paths.auth} (mode 0600)`,
         "",
-        `Remove with /logout ${providerId} ${model}`,
+        `Remove with /logout ${providerId}`,
     ].join("\n");
 }
+export function maskLoginEcho(args) {
+    const parts = ["/login", args[0] ?? ""];
+    if (args.length === 2) {
+        parts.push("********");
+    }
+    else if (args.length >= 3) {
+        parts.push(args[1]);
+        for (let i = 2; i < args.length; i += 1)
+            parts.push("********");
+    }
+    return parts.filter((part) => part !== "").join(" ");
+}
 export const loginCommand = {
     name: "login",
-    description: "Bind an API key to a provider + model. Usage: /login [provider] [model] [key]",
-    run({ args, state, actions }) {
+    description: "Bind a provider-wide API key. Usage: /login [provider] [model] [key]",
+    run({ args, actions }) {
         if (args.length === 0) {
-            actions.startLogin({});
-            return { message: introText(state) };
+            actions.startLogin({ flow: "login" });
+            return { message: "Configure a provider: choose a provider and model, then enter its API key." };
         }
         const provider = getProvider(args[0]);
         if (!provider) {
@@ -36,26 +50,14 @@ export const loginCommand = {
         }
         if (args.length === 1) {
             actions.startLogin({ provider: provider.id });
-            return { message: `Provider: ${provider.label} (${provider.id}).\nNow pick the model this key is for.` };
+            return { message: `Provider: ${provider.label} (${provider.id}).\nThe key will apply to every model of this provider.` };
         }
         const model = args[1];
         if (args.length === 2) {
             actions.startLogin({ provider: provider.id, model });
-            return { message: `Provider: ${provider.id} · model: ${model}.\nNow paste the API key (input is masked).` };
+            return { message: `Provider: ${provider.id} · saved from model: ${model}.\nNow paste the API key (input is masked).` };
         }
         const key = args.slice(2).join(" ");
         return { message: saveScopedKey(provider.id, provider.label, model, key) };
     },
-};
-function introText(state) {
-    const env = getProvider(state.providerId)?.authEnv?.[0] ?? "PROVIDER_API_KEY";
-    return [
-        "Bind an API key to a specific provider + model.",
-        "",
-        `  current scope: ${state.providerId} · ${state.model}`,
-        "",
-        "FastCode will ask for the provider, then the model, then the key.",
-        "  one-liner:  /login <provider> <model> <key>",
-        `  or set:     export ${env}=<key>   (provider-wide, any model)`,
-    ].join("\n");
 }

package/src/commands/logout.ts

@@ -8,11 +8,11 @@ export const logoutCommand = {
             const credentials = listCredentials();
             if (credentials.length === 0)
                 return { message: "No stored keys. Use /login to add one." };
-            const lines = ["Stored keys (provider :: model):"];
+            const lines = ["Stored keys (provider-wide):"];
             for (const c of credentials)
-                lines.push(`  ${c.provider}::${c.model}   ${maskKey(c.key)}`);
+                lines.push(`  ${c.provider}   ${maskKey(c.key)}`);
             lines.push("");
-            lines.push("Remove: /logout <provider> <model>");
+            lines.push("Remove: /logout <provider>");
             lines.push("        /logout <provider> --all");
             return { message: lines.join("\n") };
         }
@@ -29,25 +29,17 @@ export const logoutCommand = {
             };
         }
         if (args.length >= 2) {
-            const model = args[1];
-            const ok = removeCredential(provider.id, model);
+            const ok = removeCredential(provider.id);
             return {
                 message: ok
-                    ? `Removed stored key for ${provider.id}::${model}.`
-                    : `No stored key for ${provider.id}::${model}.`,
+                    ? `Removed the stored key for ${provider.id} (applies to all its models).`
+                    : `No stored key for ${provider.id}.`,
             };
         }
         const forProvider = listCredentials().filter((c) => c.provider === provider.id);
         if (forProvider.length === 0)
             return { message: `No stored key for ${provider.label}.` };
-        if (forProvider.length === 1) {
-            removeCredential(forProvider[0].provider, forProvider[0].model);
-            return { message: `Removed stored key for ${forProvider[0].provider}::${forProvider[0].model}.` };
-        }
-        const lines = [`${provider.label} has ${forProvider.length} stored keys — pick one to remove:`];
-        for (const c of forProvider)
-            lines.push(`  /logout ${c.provider} ${c.model}   (${maskKey(c.key)})`);
-        lines.push(`  /logout ${provider.id} --all   (remove all)`);
-        return { message: lines.join("\n") };
+        removeCredential(provider.id);
+        return { message: `Removed the stored key for ${provider.label} (all models).` };
     },
 };

package/src/commands/model.ts

@@ -1,30 +1,18 @@
 import { getProviderOrThrow } from "../providers/index.js";
-import { resolveProviderKey } from "../config/store.js";
+export function isValidModelId(value) {
+    return /^[A-Za-z0-9][A-Za-z0-9._:/+-]{0,199}$/.test(value);
+}
 export const modelCommand = {
     name: "model",
-    description: "List models for the current provider, or switch model. Usage: /model [id]",
+    description: "Pick a model interactively, or switch with /model <id>",
     async run({ args, state, actions }) {
         const provider = getProviderOrThrow(state.providerId);
-        if (args.length === 0) {
-            const { key } = resolveProviderKey(provider.id, provider.authEnv);
-            const models = await provider.listModels(key);
-            if (models.length === 0) {
-                return { message: `No models available from ${provider.label}.` };
-            }
-            const lines = [`Models for ${provider.label}:`];
-            for (const m of models.slice(0, 50)) {
-                const marker = m.id === state.model ? "● " : "  ";
-                const label = m.label ? ` — ${m.label}` : "";
-                lines.push(`${marker}${m.id}${label}`);
-            }
-            if (models.length > 50)
-                lines.push(`  … and ${models.length - 50} more.`);
-            lines.push("");
-            lines.push("Switch with `/model <id>`.");
-            return { message: lines.join("\n") };
+        if (args.length > 0) {
+            const id = args.join(" ");
+            actions.setModel(id);
+            return { message: `Model set to ${id}.` };
         }
-        const id = args.join(" ");
-        actions.setModel(id);
-        return { message: `Model set to ${id}.` };
+        actions.startLogin({ flow: "model", provider: provider.id, model: state.model });
+        return { message: `Configure ${provider.label}: choose a model, then enter its API key.` };
     },
 };

package/src/commands/provider.ts

@@ -1,18 +1,11 @@
-import { PROVIDERS, getProvider } from "../providers/index.js";
+import { getProvider } from "../providers/index.js";
 export const providerCommand = {
     name: "provider",
     description: "List or switch the active LLM provider. Usage: /provider [id]",
-    run({ args, actions, state }) {
+    run({ args, actions }) {
         if (args.length === 0) {
-            const lines = ["Available providers:"];
-            for (const p of PROVIDERS) {
-                const marker = p.id === state.providerId ? "● " : "  ";
-                const auth = p.authEnv.length === 0 ? "(no key needed)" : `[${p.authEnv.join(", ")}]`;
-                lines.push(`${marker}${p.id.padEnd(12)} ${p.label}  ${auth}`);
-            }
-            lines.push("");
-            lines.push("Switch with `/provider <id>` (e.g. `/provider openrouter`).");
-            return { message: lines.join("\n") };
+            actions.startLogin({ flow: "provider" });
+            return { message: "Configure a provider: choose a provider and model, then enter its API key." };
         }
         const target = args[0];
         const next = getProvider(target);