agent-sh 0.13.6 → 0.14.0

package/dist/agent/subagent.d.ts

@@ -10,7 +10,7 @@
  * Used by the subagent extension to delegate tasks from the main agent.
  */
 import type { EventBus } from "../core/event-bus.js";
-import type { LlmClient } from "../utils/llm-client.js";
+import type { LlmClient } from "./llm-client.js";
 import type { ToolDefinition } from "./types.js";
 export interface SubagentOptions {
     /** LLM client to use. */

package/dist/agent/tool-protocol.d.ts

@@ -9,7 +9,7 @@
  * The agent loop uses this interface uniformly so the rest of the code
  * doesn't need to know which mode is active.
  */
-import type { ChatCompletionTool } from "../utils/llm-client.js";
+import type { ChatCompletionTool } from "./llm-client.js";
 import type { ToolDefinition } from "./types.js";
 import type { ConversationState } from "./conversation-state.js";
 export interface PendingToolCall {

package/dist/agent/tool-registry.d.ts

@@ -1,5 +1,5 @@
 import type { ToolDefinition, ToolResult } from "./types.js";
-import type { ChatCompletionTool } from "../utils/llm-client.js";
+import type { ChatCompletionTool } from "./llm-client.js";
 import type { HandlerFunctions } from "../utils/handler-registry.js";
 /**
  * Registry for agent tools. Execution is routed through the named-handler

package/dist/cli/args.d.ts

@@ -0,0 +1,2 @@
+import type { AppConfig } from "../shell/host-types.js";
+export declare function parseArgs(argv: string[], env?: NodeJS.ProcessEnv): AppConfig;

package/dist/cli/args.js

@@ -0,0 +1,90 @@
+import { PACKAGE_VERSION } from "../utils/package-version.js";
+const HELP_TEXT = `agent-sh — a shell-first terminal where AI is one keystroke away
+
+Usage: agent-sh [options]
+       agent-sh init [--force]            Scaffold ~/.agent-sh/ (settings, examples, AGENTS.md)
+       agent-sh install <spec> [--force]  Install an extension (bundled name, file:, npm:, github:)
+       agent-sh uninstall <name>          Remove an installed extension
+       agent-sh list                      List installed extensions
+       agent-sh auth login [provider]     Store an API key for a built-in provider
+       agent-sh auth logout <provider>    Remove a stored key
+       agent-sh auth list                 Show configured providers
+
+Provider Profiles:
+  --provider <name>   Use a provider from ~/.agent-sh/settings.json
+  --model <name>      Override default model
+
+Direct LLM API:
+  --api-key <key>     API key for OpenAI-compatible provider (or set OPENAI_API_KEY)
+  --base-url <url>    Base URL for API (or set OPENAI_BASE_URL)
+
+General Options:
+  --backend <name>    Agent backend to launch (e.g. ash, pi); overrides settings.defaultBackend for this session
+  --shell <path>      Shell to use (default: $SHELL or /bin/bash)
+  -e, --extensions    Extensions to load (comma-separated, repeatable)
+  -h, --help          Show this help
+  -V, --version       Print version and exit
+
+Environment Variables:
+  OPENAI_API_KEY     API key for LLM provider
+  OPENAI_BASE_URL    Base URL override (e.g., http://localhost:11434/v1 for Ollama)
+
+Examples:
+  # Use a configured provider
+  agent-sh --provider openai
+
+  # Direct API access
+  agent-sh --api-key "$KEY" --model gpt-4o
+
+  # Local model via Ollama
+  agent-sh --base-url http://localhost:11434/v1 --model llama3
+
+Inside the shell:
+  Type normally        Commands run in your real shell
+  > <query>           Ask the AI agent (it decides how to help)
+  > /help             Show available slash commands
+  Ctrl-C              Cancel agent response (or signal shell as usual)
+`;
+export function parseArgs(argv, env = process.env) {
+    let model;
+    let extensions;
+    let provider;
+    let backend;
+    let shell = env.SHELL || "/bin/bash";
+    let apiKey = env.OPENAI_API_KEY;
+    let baseURL = env.OPENAI_BASE_URL;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--model" && argv[i + 1]) {
+            model = argv[++i];
+        }
+        else if (arg === "--api-key" && argv[i + 1]) {
+            apiKey = argv[++i];
+        }
+        else if (arg === "--base-url" && argv[i + 1]) {
+            baseURL = argv[++i];
+        }
+        else if (arg === "--provider" && argv[i + 1]) {
+            provider = argv[++i];
+        }
+        else if (arg === "--backend" && argv[i + 1]) {
+            backend = argv[++i];
+        }
+        else if (arg === "--shell" && argv[i + 1]) {
+            shell = argv[++i];
+        }
+        else if ((arg === "--extensions" || arg === "-e") && argv[i + 1]) {
+            const exts = argv[++i].split(",").map((s) => s.trim());
+            extensions = extensions ? [...extensions, ...exts] : exts;
+        }
+        else if (arg === "--version" || arg === "-V") {
+            console.log(PACKAGE_VERSION);
+            process.exit(0);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            console.log(HELP_TEXT);
+            process.exit(0);
+        }
+    }
+    return { shell, model, extensions, apiKey, baseURL, provider, backend };
+}

package/dist/cli/auth/cli.js

@@ -1,6 +1,6 @@
 import * as readline from "node:readline";
 import { palette as p } from "../../utils/palette.js";
-import { KNOWN_PROVIDERS, KEYS_PATH, loadKeysFile, saveKeysFile, resolveApiKey, listAllProviders, findProvider as findProviderById, } from "./keys.js";
+import { KNOWN_PROVIDERS, KEYS_PATH, loadKeysFile, saveKeysFile, resolveApiKey, listAllProvidersWithDiscovery, findProvider as findProviderById, } from "./keys.js";
 export async function runAuth(args) {
     const sub = args[0];
     if (!sub || sub === "--help" || sub === "-h") {
@@ -16,7 +16,7 @@ export async function runAuth(args) {
         return;
     }
     if (sub === "list" || sub === "ls" || sub === "status") {
-        runList();
+        await runList();
         return;
     }
     console.error(`agent-sh auth: unknown subcommand "${sub}"`);
@@ -90,8 +90,8 @@ function runLogout(providerArg) {
     saveKeysFile(keys);
     console.log(`${p.success}✓${p.reset} Removed ${id} key from ${KEYS_PATH}`);
 }
-function runList() {
-    const providers = listAllProviders();
+async function runList() {
+    const providers = await listAllProvidersWithDiscovery();
     console.log("Provider key status:\n");
     const idWidth = Math.max(...providers.map((p) => p.id.length));
     for (const info of providers) {
@@ -105,6 +105,9 @@ function runList() {
         if (resolved.key) {
             console.log(`  ${p.success}●${p.reset} ${padded}  ${p.dim}(${sourceLabel(resolved.source, info)})${p.reset}${marker}`);
         }
+        else if (info.noAuth) {
+            console.log(`  ${p.success}●${p.reset} ${padded}  ${p.dim}(no auth required)${p.reset}${marker}`);
+        }
         else {
             console.log(`  ${p.muted}○${p.reset} ${padded}  ${p.dim}(not configured)${p.reset}${marker}`);
         }
@@ -117,13 +120,15 @@ async function pickProvider() {
         console.error("agent-sh auth: no provider specified and stdin is not a TTY.");
         return null;
     }
-    const providers = listAllProviders();
+    const providers = await listAllProvidersWithDiscovery();
     console.log("Select a provider:");
     providers.forEach((info, i) => {
         const resolved = resolveApiKey(info.id);
         const tag = resolved.key
             ? `${p.dim}(currently from ${sourceLabel(resolved.source, info)})${p.reset}`
-            : `${p.dim}(not configured)${p.reset}`;
+            : info.noAuth
+                ? `${p.dim}(no auth required)${p.reset}`
+                : `${p.dim}(not configured)${p.reset}`;
         const labelStr = info.custom
             ? `${p.dim}custom${p.reset}`
             : info.unattached

package/dist/cli/auth/discover.d.ts

@@ -0,0 +1,5 @@
+export interface DiscoveredProvider {
+    id: string;
+    noAuth?: boolean;
+}
+export declare function discoverExtensionProviders(): Promise<DiscoveredProvider[]>;

package/dist/cli/auth/discover.js

@@ -0,0 +1,25 @@
+/** Bootstrap a throwaway core to enumerate provider ids extensions
+ *  would register, so `auth list` shows ids the user hasn't keyed yet. */
+import { createCore } from "../../core/index.js";
+import { activateAgent } from "../../agent/index.js";
+import { loadExtensions } from "../../core/extension-loader.js";
+import { loadBuiltinExtensions } from "../../extensions/index.js";
+import { getSettings } from "../../core/settings.js";
+let cached = null;
+export async function discoverExtensionProviders() {
+    if (cached)
+        return cached;
+    const core = createCore({});
+    try {
+        const ctx = core.extensionContext({ quit: () => { } });
+        activateAgent(ctx);
+        await loadBuiltinExtensions(ctx, getSettings().disabledBuiltins);
+        await loadExtensions(ctx).catch(() => { });
+        const { providers } = core.bus.emitPipe("agent:providers", { providers: [] });
+        cached = providers.map((p) => ({ id: p.id, noAuth: p.noAuth }));
+        return cached;
+    }
+    finally {
+        core.kill();
+    }
+}

package/dist/cli/auth/keys.d.ts

@@ -9,11 +9,14 @@ export interface ProviderAuthInfo {
     /** True for ids only present in keys.json — likely owned by an extension
      *  that registers a provider at runtime. */
     unattached?: boolean;
+    /** Auth UI shows "no auth required" instead of "not configured". */
+    noAuth?: boolean;
 }
 export declare const KNOWN_PROVIDERS: ProviderAuthInfo[];
-/** Built-ins merged with settings-declared providers, plus any ids that only
- *  appear in keys.json (likely registered by an extension at runtime). */
+/** Built-ins + settings + keys.json. Sync, no extension load. */
 export declare function listAllProviders(): ProviderAuthInfo[];
+/** Augments listAllProviders with extension-registered ids. */
+export declare function listAllProvidersWithDiscovery(): Promise<ProviderAuthInfo[]>;
 /** Resolve an id against known + settings entries only. Returns null for
  *  unattached or unknown ids — callers decide whether to accept them. */
 export declare function findProvider(id: string): ProviderAuthInfo | null;

package/dist/cli/auth/keys.js

@@ -8,8 +8,7 @@ export const KNOWN_PROVIDERS = [
     { id: "openrouter", label: "OpenRouter", envVar: "OPENROUTER_API_KEY" },
     { id: "deepseek", label: "DeepSeek", envVar: "DEEPSEEK_API_KEY" },
 ];
-/** Built-ins merged with settings-declared providers, plus any ids that only
- *  appear in keys.json (likely registered by an extension at runtime). */
+/** Built-ins + settings + keys.json. Sync, no extension load. */
 export function listAllProviders() {
     const out = [...KNOWN_PROVIDERS];
     const seen = new Set(out.map((p) => p.id));
@@ -28,6 +27,27 @@ export function listAllProviders() {
     }
     return out;
 }
+/** Augments listAllProviders with extension-registered ids. */
+export async function listAllProvidersWithDiscovery() {
+    const out = listAllProviders();
+    const byId = new Map(out.map((p) => [p.id, p]));
+    const { discoverExtensionProviders } = await import("./discover.js");
+    try {
+        for (const d of await discoverExtensionProviders()) {
+            const existing = byId.get(d.id);
+            if (existing) {
+                if (d.noAuth && !existing.noAuth)
+                    existing.noAuth = true;
+                continue;
+            }
+            const entry = { id: d.id, label: d.id, custom: true, noAuth: d.noAuth };
+            out.push(entry);
+            byId.set(d.id, entry);
+        }
+    }
+    catch { }
+    return out;
+}
 /** Resolve an id against known + settings entries only. Returns null for
  *  unattached or unknown ids — callers decide whether to accept them. */
 export function findProvider(id) {

package/dist/cli/index.d.ts

@@ -1,2 +1,18 @@
 #!/usr/bin/env node
+declare module "../core/event-bus.js" {
+    interface BusEvents {
+        /** Startup banner collection (sync pipe). Extensions contribute
+         *  labeled item lists; the CLI renders them between the product
+         *  name and the help hint. */
+        "banner:collect": {
+            sections: Array<{
+                label: string;
+                items: string[];
+            }>;
+            /** Name of the backend being launched. Extensions should gate
+             *  per-backend sections on this rather than settings.defaultBackend. */
+            activeBackend?: string;
+        };
+    }
+}
 export {};

package/dist/cli/index.js

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
 import { activateShell, registerShellHandlers } from "../shell/index.js";
-import { pickStrategy, FALLBACK_STRATEGY } from "../shell/strategies/index.js";
 import { activateAgent } from "../agent/index.js";
 import { createCore } from "../core/index.js";
 import { palette as p } from "../utils/palette.js";
@@ -11,158 +9,9 @@ import { getSettings } from "../core/settings.js";
 import { dispatchSubcommand } from "./subcommands.js";
 import { suggestBridgeFor } from "./install.js";
 import { anyProviderConfigured } from "./auth/keys.js";
-import { PACKAGE_VERSION } from "../utils/package-version.js";
 import { clearOpost } from "../utils/tty.js";
-/**
- * Capture the user's full shell environment.
- * This picks up env vars exported in .zshrc/.bashrc that the
- * Node.js process doesn't have (e.g. when launched from an IDE).
- */
-async function captureShellEnvAsync(shell) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const done = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(result);
-        };
-        try {
-            const strategy = pickStrategy(shell) ?? FALLBACK_STRATEGY;
-            const captureCmd = strategy.envCaptureCommand();
-            const child = spawn(shell, ["-l", "-c", captureCmd], {
-                stdio: ["ignore", "pipe", "ignore"],
-                timeout: 5000,
-            });
-            let output = "";
-            child.stdout?.on("data", (data) => {
-                output += data.toString("utf-8");
-            });
-            child.on("close", (code) => {
-                clearTimeout(timer);
-                if (code !== 0 || !output) {
-                    done({});
-                    return;
-                }
-                const env = {};
-                for (const entry of output.split("\0")) {
-                    const eq = entry.indexOf("=");
-                    if (eq > 0)
-                        env[entry.slice(0, eq)] = entry.slice(eq + 1);
-                }
-                done(env);
-            });
-            child.on("error", () => {
-                clearTimeout(timer);
-                done({});
-            });
-            const timer = setTimeout(() => {
-                child.kill("SIGTERM");
-                done({});
-            }, 5000);
-        }
-        catch {
-            done({});
-        }
-    });
-}
-function mergeShellEnv(baseEnv, shellEnv) {
-    const merged = { ...baseEnv };
-    for (const [key, value] of Object.entries(shellEnv)) {
-        if (!(key in merged) || !merged[key]) {
-            merged[key] = value;
-        }
-    }
-    return merged;
-}
-function parseArgs(argv) {
-    let model;
-    let extensions;
-    let provider;
-    let backend;
-    let shell = process.env.SHELL || "/bin/bash";
-    let apiKey = process.env.OPENAI_API_KEY;
-    let baseURL = process.env.OPENAI_BASE_URL;
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        if (arg === "--model" && argv[i + 1]) {
-            model = argv[++i];
-        }
-        else if (arg === "--api-key" && argv[i + 1]) {
-            apiKey = argv[++i];
-        }
-        else if (arg === "--base-url" && argv[i + 1]) {
-            baseURL = argv[++i];
-        }
-        else if (arg === "--provider" && argv[i + 1]) {
-            provider = argv[++i];
-        }
-        else if (arg === "--backend" && argv[i + 1]) {
-            backend = argv[++i];
-        }
-        else if (arg === "--shell" && argv[i + 1]) {
-            shell = argv[++i];
-        }
-        else if ((arg === "--extensions" || arg === "-e") && argv[i + 1]) {
-            const exts = argv[++i].split(",").map(s => s.trim());
-            extensions = extensions ? [...extensions, ...exts] : exts;
-        }
-        else if (arg === "--version" || arg === "-V") {
-            console.log(PACKAGE_VERSION);
-            process.exit(0);
-        }
-        else if (arg === "--help" || arg === "-h") {
-            console.log(`agent-sh — a shell-first terminal where AI is one keystroke away
-
-Usage: agent-sh [options]
-       agent-sh init [--force]            Scaffold ~/.agent-sh/ (settings, examples, AGENTS.md)
-       agent-sh install <spec> [--force]  Install an extension (bundled name, file:, npm:, github:)
-       agent-sh uninstall <name>          Remove an installed extension
-       agent-sh list                      List installed extensions
-       agent-sh auth login [provider]     Store an API key for a built-in provider
-       agent-sh auth logout <provider>    Remove a stored key
-       agent-sh auth list                 Show configured providers
-
-Provider Profiles:
-  --provider <name>   Use a provider from ~/.agent-sh/settings.json
-  --model <name>      Override default model
-
-Direct LLM API:
-  --api-key <key>     API key for OpenAI-compatible provider (or set OPENAI_API_KEY)
-  --base-url <url>    Base URL for API (or set OPENAI_BASE_URL)
-
-General Options:
-  --backend <name>    Agent backend to launch (e.g. ash, pi); overrides settings.defaultBackend for this session
-  --shell <path>      Shell to use (default: $SHELL or /bin/bash)
-  -e, --extensions    Extensions to load (comma-separated, repeatable)
-  -h, --help          Show this help
-  -V, --version       Print version and exit
-
-Environment Variables:
-  OPENAI_API_KEY     API key for LLM provider
-  OPENAI_BASE_URL    Base URL override (e.g., http://localhost:11434/v1 for Ollama)
-
-Examples:
-  # Use a configured provider
-  agent-sh --provider openai
-
-  # Direct API access
-  agent-sh --api-key "$KEY" --model gpt-4o
-
-  # Local model via Ollama
-  agent-sh --base-url http://localhost:11434/v1 --model llama3
-
-Inside the shell:
-  Type normally        Commands run in your real shell
-  > <query>           Ask the AI agent (it decides how to help)
-  > /help             Show available slash commands
-  Ctrl-C              Cancel agent response (or signal shell as usual)
-`);
-            process.exit(0);
-        }
-    }
-    return { shell, model, extensions, apiKey, baseURL, provider, backend };
-}
+import { parseArgs } from "./args.js";
+import { captureShellEnvAsync, mergeShellEnv } from "./shell-env.js";
 async function main() {
     const rawArgs = process.argv.slice(2);
     if (await dispatchSubcommand(rawArgs))
@@ -211,9 +60,18 @@ async function main() {
     // ── Core (frontend-agnostic) ──────────────────────────────────
     const core = createCore(config);
     const { bus } = core;
-    // Track agent info from bus events (populated by extension backends)
     let agentInfo = null;
-    bus.on("agent:info", (info) => { agentInfo = info; });
+    bus.on("agent:info", (info) => {
+        agentInfo = info;
+        // Redraw so late agent:info emits (opencode-bridge after session.create) reach the prompt.
+        bus.emit("config:changed", {});
+    });
+    // tui-renderer subscribes to ui:error inside activateShell, after backend
+    // activation — pipe to stderr until the shell is up so boot failures surface.
+    const bootUiError = (e) => {
+        process.stderr.write(`agent-sh: ${e.message}\n`);
+    };
+    bus.on("ui:error", bootUiError);
     // ── Interactive frontend ──────────────────────────────────────
     if (process.env.DEBUG) {
         console.error('[agent-sh] Setting up interactive frontend...');
@@ -293,6 +151,7 @@ async function main() {
             "\n  " + hint + "\n" +
             borderLine + "\n\n");
     }
+    await core.activateBackend(config.backend);
     // 100ms sidesteps macOS SIGTTOU during fg-pgrp handoff.
     await new Promise(resolve => setTimeout(resolve, 100));
     shell = activateShell(extCtx, {
@@ -307,6 +166,7 @@ async function main() {
             return { info: "" };
         },
     });
+    bus.off("ui:error", bootUiError);
     bus.emit("input-mode:register", {
         id: "agent",
         trigger: ">",
@@ -318,7 +178,6 @@ async function main() {
         },
         returnToSelf: true,
     });
-    core.activateBackend(config.backend);
     // ── Terminal lifecycle ────────────────────────────────────────
     process.on("SIGTERM", cleanup);
     process.on("SIGHUP", cleanup);

package/dist/cli/shell-env.d.ts

@@ -0,0 +1,2 @@
+export declare function captureShellEnvAsync(shell: string): Promise<Record<string, string>>;
+export declare function mergeShellEnv(baseEnv: Record<string, string>, shellEnv: Record<string, string>): Record<string, string>;

package/dist/cli/shell-env.js

@@ -0,0 +1,61 @@
+import { spawn } from "node:child_process";
+import { pickStrategy, FALLBACK_STRATEGY } from "../shell/strategies/index.js";
+export async function captureShellEnvAsync(shell) {
+    if (process.env.AGENT_SH_SKIP_SHELL_ENV)
+        return {};
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        try {
+            const strategy = pickStrategy(shell) ?? FALLBACK_STRATEGY;
+            const captureCmd = strategy.envCaptureCommand();
+            const child = spawn(shell, ["-l", "-c", captureCmd], {
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 5000,
+            });
+            let output = "";
+            child.stdout?.on("data", (data) => {
+                output += data.toString("utf-8");
+            });
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                if (code !== 0 || !output) {
+                    done({});
+                    return;
+                }
+                const env = {};
+                for (const entry of output.split("\0")) {
+                    const eq = entry.indexOf("=");
+                    if (eq > 0)
+                        env[entry.slice(0, eq)] = entry.slice(eq + 1);
+                }
+                done(env);
+            });
+            child.on("error", () => {
+                clearTimeout(timer);
+                done({});
+            });
+            const timer = setTimeout(() => {
+                child.kill("SIGTERM");
+                done({});
+            }, 5000);
+        }
+        catch {
+            done({});
+        }
+    });
+}
+export function mergeShellEnv(baseEnv, shellEnv) {
+    const merged = { ...baseEnv };
+    for (const [key, value] of Object.entries(shellEnv)) {
+        if (!(key in merged) || !merged[key]) {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}