@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/dist/commands/index.js

@@ -7,7 +7,6 @@ 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";
@@ -18,16 +17,6 @@ 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";
 export const COMMANDS = [
     helpCommand,
     agentCommand,
@@ -38,7 +27,6 @@ export const COMMANDS = [
     exitCommand,
     modelCommand,
     providerCommand,
-    effortCommand,
     loginCommand,
     logoutCommand,
     skillsCommand,
@@ -49,16 +37,6 @@ export const COMMANDS = [
     aboutCommand,
     configCommand,
     whoamiCommand,
-    contextCommand,
-    jobsCommand,
-    killCommand,
-    cancelCommand,
-    steerCommand,
-    compactCommand,
-    expandCommand,
-    attachCommand,
-    bgCommand,
-    editCommand,
 ];
 export function findCommand(name) {
     const lower = name.toLowerCase();

package/dist/commands/login.d.ts

@@ -1,8 +1,6 @@
 /**
- * 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.
+ * 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.
  */
 export declare function saveScopedKey(providerId: any, providerLabel: any, model: any, key: any): string;
 export declare const loginCommand: {

package/dist/commands/login.js

@@ -2,10 +2,8 @@ import { getProvider, PROVIDERS } from "../providers/index.js";
 import { maskKey, setCredential } from "../config/store.js";
 import { getPaths } from "../config/paths.js";
 /**
- * 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.
+ * 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.
  */
 export function saveScopedKey(providerId, providerLabel, model, key) {
     const trimmed = key.trim();
@@ -14,16 +12,16 @@ export function saveScopedKey(providerId, providerLabel, model, key) {
     return [
         "Saved API key",
         `  provider  ${providerLabel} (${providerId})`,
-        `  scope     all ${providerId} models (saved from ${model || "unknown"})`,
+        `  model     ${model}`,
         `  key       ${maskKey(trimmed)}`,
         `  stored    ${paths.auth} (mode 0600)`,
         "",
-        `Remove with /logout ${providerId}`,
+        `Remove with /logout ${providerId} ${model}`,
     ].join("\n");
 }
 export const loginCommand = {
     name: "login",
-    description: "Bind a provider-wide API key. Usage: /login [provider] [model] [key]",
+    description: "Bind an API key to a provider + model. Usage: /login [provider] [model] [key]",
     run({ args, state, actions }) {
         if (args.length === 0) {
             actions.startLogin({});
@@ -38,12 +36,12 @@ export const loginCommand = {
         }
         if (args.length === 1) {
             actions.startLogin({ provider: provider.id });
-            return { message: `Provider: ${provider.label} (${provider.id}).\nThe key will apply to every model of this provider.` };
+            return { message: `Provider: ${provider.label} (${provider.id}).\nNow pick the model this key is for.` };
         }
         const model = args[1];
         if (args.length === 2) {
             actions.startLogin({ provider: provider.id, model });
-            return { message: `Provider: ${provider.id} · saved from model: ${model}.\nNow paste the API key (input is masked).` };
+            return { message: `Provider: ${provider.id} · 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) };
@@ -52,11 +50,11 @@ export const loginCommand = {
 function introText(state) {
     const env = getProvider(state.providerId)?.authEnv?.[0] ?? "PROVIDER_API_KEY";
     return [
-        "Bind a provider-wide API key (reused by every model of that provider).",
+        "Bind an API key to a specific provider + model.",
         "",
-        `  current provider: ${state.providerId}`,
+        `  current scope: ${state.providerId} · ${state.model}`,
         "",
-        "FastCode will ask for the provider, then optionally a model name, then the key.",
+        "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/dist/commands/logout.js

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

package/dist/commands/model.d.ts

@@ -7,18 +7,5 @@ export declare const modelCommand: {
         actions: any;
     }): Promise<{
         message: string;
-        picker?: undefined;
-    } | {
-        message: string;
-        picker: {
-            title: string;
-            current: any;
-            items: {
-                value: any;
-                label: any;
-                hint: string;
-            }[];
-            onSelect: (id: any) => void;
-        };
     }>;
 };

package/dist/commands/model.js

@@ -1,50 +1,30 @@
-import { getProviderOrThrow, probeProvider } from "../providers/index.js";
+import { getProviderOrThrow } from "../providers/index.js";
 import { resolveProviderKey } from "../config/store.js";
 export const modelCommand = {
     name: "model",
-    description: "Pick a model interactively, or switch with /model <id>",
+    description: "List models for the current provider, or switch model. Usage: /model [id]",
     async run({ args, state, actions }) {
         const provider = getProviderOrThrow(state.providerId);
-        if (args.length > 0) {
-            const id = args.join(" ");
-            actions.setModel(id);
-            return { message: `Model set to ${id}.` };
+        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") };
         }
-        const { key } = resolveProviderKey(provider.id, provider.authEnv);
-        const fetched = await provider.listModels(key).catch(() => []);
-        const models = dedupe(fetched);
-        if (models.length === 0) {
-            return { message: `No models available from ${provider.label}.` };
-        }
-        const online = await probeProvider(provider, key);
-        const list = models.slice(0, 50);
-        return {
-            message: `Models for ${provider.label}: ${list.length}${online ? "" : " (offline — showing the built-in list)"}.\n` +
-                "Use ↑/↓, a number, or Enter to select.",
-            picker: {
-                title: `Select model · ${provider.label}${online ? "" : " (offline)"}`,
-                current: state.model,
-                items: list.map((m) => ({
-                    value: m.id,
-                    label: m.id,
-                    hint: m.label ? `— ${m.label}` : undefined,
-                })),
-                onSelect: (id) => {
-                    actions.setModel(id);
-                    actions.pushSystemMessage(`Model set to ${id}.`);
-                },
-            },
-        };
+        const id = args.join(" ");
+        actions.setModel(id);
+        return { message: `Model set to ${id}.` };
     },
 };
-function dedupe(models) {
-    const seen = new Set();
-    const out = [];
-    for (const model of models) {
-        if (!model?.id || seen.has(model.id))
-            continue;
-        seen.add(model.id);
-        out.push(model);
-    }
-    return out;
-}

package/dist/commands/provider.d.ts

@@ -7,18 +7,5 @@ export declare const providerCommand: {
         state: any;
     }): {
         message: string;
-        picker: {
-            title: string;
-            current: any;
-            items: {
-                value: string;
-                label: string;
-                hint: string;
-            }[];
-            onSelect: (id: any) => void;
-        };
-    } | {
-        message: string;
-        picker?: undefined;
     };
 };

package/dist/commands/provider.js

@@ -4,26 +4,15 @@ export const providerCommand = {
     description: "List or switch the active LLM provider. Usage: /provider [id]",
     run({ args, actions, state }) {
         if (args.length === 0) {
-            return {
-                message: "Select a provider (↑/↓ or a number, Enter to confirm).",
-                picker: {
-                    title: "Select provider",
-                    current: state.providerId,
-                    items: PROVIDERS.map((p) => ({
-                        value: p.id,
-                        label: `${p.id.padEnd(12)} ${p.label}`,
-                        hint: p.authEnv.length === 0 ? "(no key needed)" : `[${p.authEnv.join(", ")}]`,
-                    })),
-                    onSelect: (id) => {
-                        const next = getProvider(id);
-                        if (!next)
-                            return;
-                        actions.setProvider(next.id);
-                        actions.setModel(next.defaultModel);
-                        actions.pushSystemMessage(`Provider set to ${next.label}. Default model: ${next.defaultModel}.`);
-                    },
-                },
-            };
+            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") };
         }
         const target = args[0];
         const next = getProvider(target);

package/dist/commands/whoami.js

@@ -10,20 +10,19 @@ export const whoamiCommand = {
             lines.push("  " + describeLookup(current, resolveApiKey(current.id, state.model, current.authEnv)));
         const credentials = listCredentials();
         lines.push("");
-        lines.push(`Stored keys (${credentials.length}, provider-wide):`);
+        lines.push(`Stored keys (${credentials.length}):`);
         if (credentials.length === 0)
             lines.push("  (none) — add one with /login");
         for (const c of credentials) {
-            const marker = c.provider === state.providerId ? "● " : "  ";
-            const origin = c.model ? `   (originally saved for ${c.model})` : "";
-            lines.push(`${marker}${c.provider}   ${maskKey(c.key)}${origin}`);
+            const marker = c.provider === state.providerId && c.model === state.model ? "● " : "  ";
+            lines.push(`${marker}${c.provider}::${c.model}   ${maskKey(c.key)}`);
         }
         const legacy = listLegacy();
         if (legacy.length > 0) {
             lines.push("");
-            lines.push("Legacy keys (could not be migrated — re-save with /login):");
+            lines.push("Unbound legacy keys (NOT used — re-bind them to a model):");
             for (const l of legacy)
-                lines.push(`  ${l.provider}   ${maskKey(l.key)}`);
+                lines.push(`  ${l.provider}   ${maskKey(l.key)}   → /login ${l.provider} <model> <key>`);
         }
         const envLines = [];
         for (const p of PROVIDERS) {

package/dist/config/store.d.ts

@@ -8,40 +8,20 @@ export declare const DEFAULT_CONFIG: {
     enabledPlugins: any[];
     skillsRegistry: string;
     lifetimeCostUsd: number;
-    /**
-     * Extra directories the file tools may read and write outside the project
-     * root. Relative entries are resolved against the project root; `~/` is
-     * expanded against the user's home directory.
-     */
-    sharedDirs: any[];
-    /** Maximum agent tool turns before the loop asks the user to continue. */
-    maxAgentTurns: number;
-    /** Abort a stream that receives no data for this long (ms). */
-    requestIdleTimeoutMs: number;
-    /** Approximate character budget before history compaction kicks in. */
-    contextBudgetChars: number;
-    /** Thinking depth: auto = send nothing, provider default. */
-    reasoningEffort: string;
-    /** Cached per-provider/model capabilities (native vs pseudo tool calling). */
-    capabilities: {
-        toolCalling: {};
-    };
 };
 export interface StoredCredential {
     provider: string;
-    /** Model the key was originally saved for (display only; keys are provider-wide). */
-    model?: string;
+    model: string;
     key: string;
     addedAt: string;
 }
 export interface AuthStore {
     version: number;
-    /** Provider-scoped credentials, keyed by provider id. */
+    /** Scoped credentials, keyed by `provider::model`. */
     keys: Record<string, StoredCredential>;
-    /** Old provider-only keys that could not be migrated (kept for diagnostics). */
+    /** Old provider-only keys we refuse to use until the user re-binds them. */
     legacy: Record<string, string>;
 }
-export declare const AUTH_VERSION = 3;
 export type KeyLookup = {
     status: "ok";
     key: string;
@@ -56,31 +36,31 @@ export type KeyLookup = {
 };
 export declare function loadConfig(): any;
 export declare function saveConfig(cfg: any): void;
-/** Composite id used by the legacy v2 format; kept for API compatibility. */
+/** Composite scope id for a provider + model credential. */
 export declare function scopeId(providerId: any, model: any): string;
 export declare function loadAuth(): AuthStore;
 export declare function saveAuth(store: AuthStore): void;
-export declare function getCredential(providerId: any, _model?: any): StoredCredential | undefined;
+export declare function getCredential(providerId: any, model: any): StoredCredential | undefined;
 export declare function listCredentials(): StoredCredential[];
 export declare function listLegacy(): Array<{
     provider: string;
     key: string;
 }>;
 export declare function getLegacy(providerId: any): string | undefined;
-/** Save/replace the provider-wide credential (drops any legacy key). */
+/** Save/replace the credential for one provider+model scope (drops the legacy key). */
 export declare function setCredential(providerId: any, model: any, key: any): StoredCredential;
-export declare function removeCredential(providerId: any, _model?: any): boolean;
-/** Remove the provider-wide credential plus any legacy leftovers. */
+export declare function removeCredential(providerId: any, model: any): boolean;
+/** Remove every credential for a provider (all models) plus its legacy key. */
 export declare function removeCredentialsForProvider(providerId: any): number;
 /** Turn a key into a safe terminal echo: `sk-****abcd`. */
 export declare function maskKey(key: any): string;
 /**
- * Resolve the key to use for a provider:
- *   1. the provider-wide credential in auth.json,
+ * Resolve the key to use for a specific provider+model:
+ *   1. the scoped credential in auth.json (exact provider+model match), then
  *   2. the provider's environment variable (provider-scoped, any model), and
- *   3. a legacy provider-only key that somehow escaped migration.
+ *   3. report an "unbound" legacy key instead of using it silently.
  */
-export declare function resolveApiKey(providerId: any, _model: any, envVars: any): KeyLookup;
+export declare function resolveApiKey(providerId: any, model: any, envVars: any): KeyLookup;
 /** Best-effort key for a provider regardless of model (used to list models). */
 export declare function resolveProviderKey(providerId: any, envVars: any): {
     key?: string;