agent-sh 0.13.7 → 0.14.1

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/agent/types.d.ts

@@ -57,8 +57,8 @@ export interface InteractiveSession<T> {
     render(width: number): string[];
     /** Handle raw input. Call done(result) to finish the session. */
     handleInput(data: string, done: (result: T) => void): void;
-    /** Called when session starts. Receives invalidate() for async re-renders. */
-    onMount?(invalidate: () => void): void;
+    /** done() lets the session resolve itself from outside handleInput. */
+    onMount?(invalidate: () => void, done: (result: T) => void): void;
     /** Called when session ends (cleanup). */
     onUnmount?(): void;
 }

package/dist/cli/args.js

@@ -3,7 +3,9 @@ const HELP_TEXT = `agent-sh — a shell-first terminal where AI is one keystroke
 
 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 install <spec> [--force] [--sync-deps]
+                                          Install an extension (bundled name, file:, npm:, github:)
+                                          --sync-deps rewrites a stale agent-sh pin to the host version
        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

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

@@ -60,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...');
@@ -157,6 +166,7 @@ async function main() {
             return { info: "" };
         },
     });
+    bus.off("ui:error", bootUiError);
     bus.emit("input-mode:register", {
         id: "agent",
         trigger: ">",

package/dist/cli/install.d.ts

@@ -1,5 +1,6 @@
 interface InstallOpts {
     force?: boolean;
+    syncDeps?: boolean;
 }
 export declare function listBundled(): string[];
 /** Heuristic: a backend named "pi" is typically provided by an extension called "pi-bridge". */

package/dist/cli/install.js

@@ -75,6 +75,84 @@ function readPackageJson(target) {
         return null;
     return JSON.parse(fs.readFileSync(pkgJson, "utf-8"));
 }
+function hostAgentShVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf-8"));
+        return typeof pkg.version === "string" ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+function satisfies(version, spec) {
+    if (spec === version || spec === "*" || spec === "latest")
+        return true;
+    const [vMaj, vMin, vPatch] = version.split(/[.-]/, 3).map(Number);
+    if ([vMaj, vMin, vPatch].some(Number.isNaN))
+        return true;
+    const m = spec.match(/^([\^~]?)(\d+)\.(\d+)\.(\d+)/);
+    if (!m)
+        return true;
+    const op = m[1];
+    const sMaj = Number(m[2]);
+    const sMin = Number(m[3]);
+    const sPatch = Number(m[4]);
+    if (op === "")
+        return vMaj === sMaj && vMin === sMin && vPatch === sPatch;
+    if (op === "~")
+        return vMaj === sMaj && vMin === sMin && vPatch >= sPatch;
+    // ^x.y.z: zero-major treats minor as the breaking boundary (npm rule).
+    if (sMaj > 0)
+        return vMaj === sMaj && (vMin > sMin || (vMin === sMin && vPatch >= sPatch));
+    if (sMin > 0)
+        return vMaj === 0 && vMin === sMin && vPatch >= sPatch;
+    return vMaj === 0 && vMin === 0 && vPatch === sPatch;
+}
+/** Warn when the extension's `agent-sh` pin can't admit the host version;
+ *  only rewrite when --sync-deps is set. */
+function syncAgentShVersion(target, syncDeps) {
+    const hostVersion = hostAgentShVersion();
+    if (!hostVersion)
+        return;
+    // Prerelease hosts aren't on npm; rewriting would leave npm install unable to resolve.
+    if (hostVersion.includes("-"))
+        return;
+    const pkgJson = path.join(target, "package.json");
+    if (!fs.existsSync(pkgJson))
+        return;
+    const raw = fs.readFileSync(pkgJson, "utf-8");
+    const pkg = JSON.parse(raw);
+    const sections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+    const name = path.basename(target);
+    let changed = false;
+    let warned = false;
+    for (const section of sections) {
+        const deps = pkg[section];
+        if (!deps || typeof deps !== "object")
+            continue;
+        const d = deps;
+        const current = d["agent-sh"];
+        if (typeof current !== "string")
+            continue;
+        if (current.startsWith("file:"))
+            continue;
+        if (satisfies(hostVersion, current))
+            continue;
+        if (syncDeps) {
+            console.log(`agent-sh: rewriting ${name} agent-sh ${current} -> ${hostVersion}.`);
+            d["agent-sh"] = hostVersion;
+            changed = true;
+        }
+        else if (!warned) {
+            console.warn(`agent-sh: ${name} pins agent-sh ${current}, which doesn't admit host ${hostVersion}. ` +
+                `npm install will land an older agent-sh inside the extension and drift from the running host. ` +
+                `Re-run with --sync-deps to rewrite the pin to ${hostVersion}, or update the bridge's source pin.`);
+            warned = true;
+        }
+    }
+    if (changed)
+        fs.writeFileSync(pkgJson, `${JSON.stringify(pkg, null, 2)}\n`);
+}
 /** Relative `file:` deps in bundled extensions (e.g. `"agent-sh": "file:../../.."`)
  *  point at the wrong location after the source is copied into ~/.agent-sh/extensions/.
  *  Resolve them against the original source dir so npm install in the target succeeds. */
@@ -165,7 +243,7 @@ function linkBins(target, pkg) {
 }
 export async function runInstall(spec, opts = {}) {
     if (!spec) {
-        console.error("Usage: agent-sh install <name|file:|npm:|github:> [--force]\n\n" +
+        console.error("Usage: agent-sh install <name|file:|npm:|github:> [--force] [--sync-deps]\n\n" +
             "Bundled extensions:\n" +
             listBundled()
                 .map((n) => `  ${n}`)
@@ -191,9 +269,15 @@ export async function runInstall(spec, opts = {}) {
     }
     let linkedBins = [];
     if (resolved.isDirectory) {
-        fs.cpSync(resolved.sourcePath, target, { recursive: true });
+        fs.cpSync(resolved.sourcePath, target, {
+            recursive: true,
+            // Skip source node_modules: maybeNpmInstall short-circuits on
+            // existing node_modules, silently leaving the bridge's deps stale.
+            filter: (src) => path.basename(src) !== "node_modules",
+        });
         try {
             rewriteFileDeps(target, resolved.sourcePath);
+            syncAgentShVersion(target, opts.syncDeps ?? false);
             const pkg = readPackageJson(target);
             if (pkg) {
                 maybeNpmInstall(target, pkg);

package/dist/cli/subcommands.js

@@ -3,7 +3,10 @@ import { runInstall, runUninstall, runList } from "./install.js";
 import { runAuth } from "./auth/cli.js";
 const SUBCOMMANDS = {
     init: (args) => runInit({ force: args.includes("--force") }),
-    install: (args) => runInstall(args[0] ?? "", { force: args.includes("--force") }),
+    install: (args) => runInstall(args[0] ?? "", {
+        force: args.includes("--force"),
+        syncDeps: args.includes("--sync-deps"),
+    }),
     uninstall: (args) => runUninstall(args[0] ?? ""),
     list: () => runList(),
     auth: (args) => runAuth(args),