@zhijiewang/openharness 2.12.0 → 2.14.0

package/dist/main.js

@@ -276,38 +276,62 @@ program
                 : opts.permissionMode !== "ask"
                     ? opts.permissionMode
                     : (savedConfig?.permissionMode ?? "ask");
-    // Auto-detect provider or prompt for setup
+    // Auto-detect provider or launch the setup wizard
     let provider;
     let resolvedModel;
-    try {
+    const tryCreateProvider = async () => {
         const { createProvider } = await import("./providers/index.js");
         const overrides = {};
-        if (savedConfig?.apiKey)
-            overrides.apiKey = savedConfig.apiKey;
-        if (savedConfig?.baseUrl)
-            overrides.baseUrl = savedConfig.baseUrl;
-        const result = await createProvider(effectiveModel, Object.keys(overrides).length ? overrides : undefined);
+        const fresh = readOhConfig();
+        if (fresh?.apiKey)
+            overrides.apiKey = fresh.apiKey;
+        if (fresh?.baseUrl)
+            overrides.baseUrl = fresh.baseUrl;
+        const targetModel = fresh?.model ?? effectiveModel;
+        return createProvider(targetModel, Object.keys(overrides).length ? overrides : undefined);
+    };
+    try {
+        const result = await tryCreateProvider();
         provider = result.provider;
         resolvedModel = result.model;
     }
     catch (_err) {
-        // First-run experience: guide the user
-        console.log();
-        console.log("  Welcome to OpenHarness!");
-        console.log();
-        console.log("  To get started, choose a provider:");
-        console.log();
-        console.log("  Local (free, no API key):");
-        console.log("    npx openharness --model ollama/llama3");
-        console.log("    npx openharness --model ollama/qwen2.5:7b-instruct");
-        console.log();
-        console.log("  Cloud (needs API key in env var):");
-        console.log("    OPENAI_API_KEY=sk-... npx openharness --model gpt-4o");
-        console.log("    ANTHROPIC_API_KEY=sk-ant-... npx openharness --model claude-sonnet-4-6");
-        console.log();
-        console.log("  Make sure Ollama is running: ollama serve");
-        console.log();
-        process.exit(0);
+        // First-run: launch the interactive wizard in TTY mode; fall back to
+        // static help text for non-TTY (CI, piped stdin, etc.).
+        if (process.stdout.isTTY && process.stdin.isTTY) {
+            const { default: InitWizard } = await import("./components/InitWizard.js");
+            const { waitUntilExit } = render(_jsx(InitWizard, { onDone: () => { } }));
+            await waitUntilExit();
+            try {
+                const result = await tryCreateProvider();
+                provider = result.provider;
+                resolvedModel = result.model;
+            }
+            catch {
+                console.log();
+                console.log("  Setup incomplete. Run 'oh init' to try again, or set a provider via --model.");
+                console.log();
+                process.exit(0);
+            }
+        }
+        else {
+            console.log();
+            console.log("  Welcome to OpenHarness!");
+            console.log();
+            console.log("  To get started, choose a provider:");
+            console.log();
+            console.log("  Local (free, no API key):");
+            console.log("    npx openharness --model ollama/llama3");
+            console.log("    npx openharness --model ollama/qwen2.5:7b-instruct");
+            console.log();
+            console.log("  Cloud (needs API key in env var):");
+            console.log("    OPENAI_API_KEY=sk-... npx openharness --model gpt-4o");
+            console.log("    ANTHROPIC_API_KEY=sk-ant-... npx openharness --model claude-sonnet-4-6");
+            console.log();
+            console.log("  Make sure Ollama is running: ollama serve");
+            console.log();
+            process.exit(0);
+        }
     }
     const mcpTools = await loadMcpTools();
     const mcpNames = connectedMcpServers();

package/dist/mcp/oauth-keychain.d.ts

@@ -0,0 +1,16 @@
+/**
+ * OS keychain backend for MCP OAuth tokens.
+ *
+ * Wraps @napi-rs/keyring (optional dependency). All functions catch every error
+ * and return an "unavailable" sentinel so the orchestrator in oauth-storage.ts
+ * can fall back to the filesystem store without any user-visible disruption.
+ */
+import type { OhCredentials } from "./oauth-storage-fs.js";
+/** Clear the cached module reference. For tests only. */
+export declare function _resetForTesting(): void;
+/** True iff @napi-rs/keyring loaded successfully AND the platform has an Entry class. */
+export declare function keychainAvailable(): boolean;
+export declare function saveCredentialsKeychain(name: string, creds: OhCredentials): boolean;
+export declare function loadCredentialsKeychain(name: string): OhCredentials | undefined;
+export declare function deleteCredentialsKeychain(name: string): boolean;
+//# sourceMappingURL=oauth-keychain.d.ts.map

package/dist/mcp/oauth-keychain.js

@@ -0,0 +1,70 @@
+/**
+ * OS keychain backend for MCP OAuth tokens.
+ *
+ * Wraps @napi-rs/keyring (optional dependency). All functions catch every error
+ * and return an "unavailable" sentinel so the orchestrator in oauth-storage.ts
+ * can fall back to the filesystem store without any user-visible disruption.
+ */
+import { createRequire } from "node:module";
+const SERVICE = "openharness-mcp";
+const nodeRequire = createRequire(import.meta.url);
+let entryCtorCache;
+function getEntryCtor() {
+    if (entryCtorCache !== undefined)
+        return entryCtorCache;
+    try {
+        const mod = nodeRequire("@napi-rs/keyring");
+        entryCtorCache = mod.Entry;
+    }
+    catch {
+        entryCtorCache = null;
+    }
+    return entryCtorCache;
+}
+/** Clear the cached module reference. For tests only. */
+export function _resetForTesting() {
+    entryCtorCache = undefined;
+}
+/** True iff @napi-rs/keyring loaded successfully AND the platform has an Entry class. */
+export function keychainAvailable() {
+    return getEntryCtor() !== null;
+}
+export function saveCredentialsKeychain(name, creds) {
+    const Ctor = getEntryCtor();
+    if (!Ctor)
+        return false;
+    try {
+        new Ctor(SERVICE, name).setPassword(JSON.stringify(creds));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function loadCredentialsKeychain(name) {
+    const Ctor = getEntryCtor();
+    if (!Ctor)
+        return undefined;
+    try {
+        const raw = new Ctor(SERVICE, name).getPassword();
+        if (!raw)
+            return undefined;
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function deleteCredentialsKeychain(name) {
+    const Ctor = getEntryCtor();
+    if (!Ctor)
+        return false;
+    try {
+        new Ctor(SERVICE, name).deletePassword();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=oauth-keychain.js.map

package/dist/mcp/oauth-storage-fs.d.ts

@@ -0,0 +1,23 @@
+export type OhCredentials = {
+    issuerUrl: string;
+    clientInformation: {
+        client_id: string;
+        client_secret?: string;
+    } & Record<string, unknown>;
+    tokens: {
+        access_token: string;
+        refresh_token?: string;
+        expires_at?: number;
+        token_type?: string;
+        scope?: string;
+    };
+    codeVerifier?: string;
+    updatedAt: string;
+};
+/** Atomically write credentials for one server. Creates the directory with 0o700 on first use. */
+export declare function saveCredentials(storageDir: string, name: string, creds: OhCredentials): Promise<void>;
+/** Load credentials. Returns undefined on missing file OR corrupt JSON. Warns on world/group-readable mode. */
+export declare function loadCredentials(storageDir: string, name: string): Promise<OhCredentials | undefined>;
+/** Idempotent delete — ENOENT is swallowed. */
+export declare function deleteCredentials(storageDir: string, name: string): Promise<void>;
+//# sourceMappingURL=oauth-storage-fs.d.ts.map

package/dist/mcp/oauth-storage-fs.js

@@ -0,0 +1,58 @@
+import { promises as fs } from "node:fs";
+import { dirname, join } from "node:path";
+function pathFor(storageDir, name) {
+    return join(storageDir, `${name}.json`);
+}
+/** Atomically write credentials for one server. Creates the directory with 0o700 on first use. */
+export async function saveCredentials(storageDir, name, creds) {
+    const filePath = pathFor(storageDir, name);
+    const tmpPath = `${filePath}.tmp`;
+    await fs.mkdir(dirname(filePath), { recursive: true, mode: 0o700 });
+    const body = JSON.stringify(creds, null, 2);
+    await fs.writeFile(tmpPath, body, { mode: 0o600 });
+    await fs.rename(tmpPath, filePath);
+}
+/** Load credentials. Returns undefined on missing file OR corrupt JSON. Warns on world/group-readable mode. */
+export async function loadCredentials(storageDir, name) {
+    const filePath = pathFor(storageDir, name);
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+    try {
+        if (process.platform !== "win32") {
+            const s = await fs.stat(filePath);
+            if ((s.mode & 0o077) !== 0) {
+                console.warn(`[mcp] credentials file for '${name}' is world/group-readable; run 'chmod 600 ${filePath}'`);
+            }
+        }
+    }
+    catch {
+        // stat failure is non-fatal for load
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        console.warn(`[mcp] credentials file for '${name}' is corrupt; ignoring`);
+        return undefined;
+    }
+}
+/** Idempotent delete — ENOENT is swallowed. */
+export async function deleteCredentials(storageDir, name) {
+    const filePath = pathFor(storageDir, name);
+    try {
+        await fs.unlink(filePath);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return;
+        throw err;
+    }
+}
+//# sourceMappingURL=oauth-storage-fs.js.map

package/dist/mcp/oauth-storage.d.ts

@@ -1,23 +1,28 @@
-export type OhCredentials = {
-    issuerUrl: string;
-    clientInformation: {
-        client_id: string;
-        client_secret?: string;
-    } & Record<string, unknown>;
-    tokens: {
-        access_token: string;
-        refresh_token?: string;
-        expires_at?: number;
-        token_type?: string;
-        scope?: string;
-    };
-    codeVerifier?: string;
-    updatedAt: string;
-};
-/** Atomically write credentials for one server. Creates the directory with 0o700 on first use. */
+/**
+ * OAuth token storage orchestrator.
+ *
+ * Prefers the OS keychain via `oauth-keychain.ts` when available and not
+ * opted out via `credentials.storage: "filesystem"`. Falls back to the
+ * filesystem store in `oauth-storage-fs.ts` on any keychain failure.
+ *
+ * Public API unchanged: callers in oauth.ts and commands/mcp-auth.ts
+ * continue to import `saveCredentials` / `loadCredentials` /
+ * `deleteCredentials` / `OhCredentials` from this module.
+ */
+export type { OhCredentials } from "./oauth-storage-fs.js";
+import type { OhCredentials } from "./oauth-storage-fs.js";
+/**
+ * Save credentials. Tries keychain first when available; falls back to
+ * filesystem on any keychain failure.
+ */
 export declare function saveCredentials(storageDir: string, name: string, creds: OhCredentials): Promise<void>;
-/** Load credentials. Returns undefined on missing file OR corrupt JSON. Warns on world/group-readable mode. */
+/**
+ * Load credentials. Checks keychain first (when available), then filesystem.
+ * If both have entries for the same name, keychain wins.
+ */
 export declare function loadCredentials(storageDir: string, name: string): Promise<OhCredentials | undefined>;
-/** Idempotent delete — ENOENT is swallowed. */
+/**
+ * Delete credentials from BOTH keychain and filesystem. Idempotent.
+ */
 export declare function deleteCredentials(storageDir: string, name: string): Promise<void>;
 //# sourceMappingURL=oauth-storage.d.ts.map

package/dist/mcp/oauth-storage.js

@@ -1,58 +1,55 @@
-import { promises as fs } from "node:fs";
-import { dirname, join } from "node:path";
-function pathFor(storageDir, name) {
-    return join(storageDir, `${name}.json`);
+/**
+ * OAuth token storage orchestrator.
+ *
+ * Prefers the OS keychain via `oauth-keychain.ts` when available and not
+ * opted out via `credentials.storage: "filesystem"`. Falls back to the
+ * filesystem store in `oauth-storage-fs.ts` on any keychain failure.
+ *
+ * Public API unchanged: callers in oauth.ts and commands/mcp-auth.ts
+ * continue to import `saveCredentials` / `loadCredentials` /
+ * `deleteCredentials` / `OhCredentials` from this module.
+ */
+import { readOhConfig } from "../harness/config.js";
+import { deleteCredentialsKeychain, keychainAvailable, loadCredentialsKeychain, saveCredentialsKeychain, } from "./oauth-keychain.js";
+import { deleteCredentials as deleteFs, loadCredentials as loadFs, saveCredentials as saveFs, } from "./oauth-storage-fs.js";
+function shouldUseKeychain() {
+    // Explicit opt-out via env var (used by the test runner to isolate tests
+    // from the real OS keychain). Accepts "disabled", "false", "0", or "off".
+    const envOpt = (process.env.OH_KEYCHAIN ?? "").toLowerCase();
+    if (envOpt === "disabled" || envOpt === "false" || envOpt === "0" || envOpt === "off")
+        return false;
+    const cfg = readOhConfig();
+    if (cfg?.credentials?.storage === "filesystem")
+        return false;
+    return keychainAvailable();
 }
-/** Atomically write credentials for one server. Creates the directory with 0o700 on first use. */
+/**
+ * Save credentials. Tries keychain first when available; falls back to
+ * filesystem on any keychain failure.
+ */
 export async function saveCredentials(storageDir, name, creds) {
-    const filePath = pathFor(storageDir, name);
-    const tmpPath = `${filePath}.tmp`;
-    await fs.mkdir(dirname(filePath), { recursive: true, mode: 0o700 });
-    const body = JSON.stringify(creds, null, 2);
-    await fs.writeFile(tmpPath, body, { mode: 0o600 });
-    await fs.rename(tmpPath, filePath);
+    if (shouldUseKeychain() && saveCredentialsKeychain(name, creds))
+        return;
+    await saveFs(storageDir, name, creds);
 }
-/** Load credentials. Returns undefined on missing file OR corrupt JSON. Warns on world/group-readable mode. */
+/**
+ * Load credentials. Checks keychain first (when available), then filesystem.
+ * If both have entries for the same name, keychain wins.
+ */
 export async function loadCredentials(storageDir, name) {
-    const filePath = pathFor(storageDir, name);
-    let raw;
-    try {
-        raw = await fs.readFile(filePath, "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return undefined;
-        throw err;
-    }
-    try {
-        if (process.platform !== "win32") {
-            const s = await fs.stat(filePath);
-            if ((s.mode & 0o077) !== 0) {
-                console.warn(`[mcp] credentials file for '${name}' is world/group-readable; run 'chmod 600 ${filePath}'`);
-            }
-        }
-    }
-    catch {
-        // stat failure is non-fatal for load
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        console.warn(`[mcp] credentials file for '${name}' is corrupt; ignoring`);
-        return undefined;
+    if (shouldUseKeychain()) {
+        const fromKc = loadCredentialsKeychain(name);
+        if (fromKc)
+            return fromKc;
     }
+    return loadFs(storageDir, name);
 }
-/** Idempotent delete — ENOENT is swallowed. */
+/**
+ * Delete credentials from BOTH keychain and filesystem. Idempotent.
+ */
 export async function deleteCredentials(storageDir, name) {
-    const filePath = pathFor(storageDir, name);
-    try {
-        await fs.unlink(filePath);
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return;
-        throw err;
-    }
+    if (keychainAvailable())
+        deleteCredentialsKeychain(name);
+    await deleteFs(storageDir, name);
 }
 //# sourceMappingURL=oauth-storage.js.map

package/dist/providers/fallback.js

@@ -33,20 +33,26 @@ export function createFallbackProvider(primary, fallbacks) {
             ];
             for (let i = 0; i < providers.length; i++) {
                 const p = providers[i];
+                let hasYielded = false;
                 try {
-                    let _hasYielded = false;
                     for await (const event of p.provider.stream(messages, systemPrompt, tools, p.model)) {
-                        _hasYielded = true;
+                        hasYielded = true;
                         yield event;
                     }
-                    _activeFallback = i === 0 ? null : p.provider.name;
+                    if (i > 0) {
+                        console.warn(`[provider] fell back from ${primary.name} to ${p.provider.name}`);
+                        _activeFallback = p.provider.name;
+                    }
+                    else {
+                        _activeFallback = null;
+                    }
                     return;
                 }
                 catch (err) {
-                    // Mid-stream failure: can't un-send events, propagate error
-                    if (i > 0 || !isRetriableError(err))
+                    // Mid-stream failure OR non-retriable OR fallback error: propagate.
+                    if (i > 0 || !isRetriableError(err) || hasYielded)
                         throw err;
-                    // Pre-stream failure on primary: try next provider
+                    // Pre-stream retriable failure on primary only: try next provider.
                     _activeFallback = null;
                 }
             }
@@ -63,7 +69,13 @@ export function createFallbackProvider(primary, fallbacks) {
                 const p = providers[i];
                 try {
                     const result = await p.provider.complete(messages, systemPrompt, tools, p.model);
-                    _activeFallback = i === 0 ? null : p.provider.name;
+                    if (i > 0) {
+                        console.warn(`[provider] fell back from ${primary.name} to ${p.provider.name}`);
+                        _activeFallback = p.provider.name;
+                    }
+                    else {
+                        _activeFallback = null;
+                    }
                     return result;
                 }
                 catch (err) {

package/dist/providers/index.js

@@ -1,7 +1,9 @@
 /**
  * Provider factory — create the right provider from a model string.
  */
+import { readOhConfig } from "../harness/config.js";
 import { AnthropicProvider } from "./anthropic.js";
+import { createFallbackProvider } from "./fallback.js";
 import { LlamaCppProvider } from "./llamacpp.js";
 import { OllamaProvider } from "./ollama.js";
 import { OpenAIProvider } from "./openai.js";
@@ -29,8 +31,22 @@ export async function createProvider(modelArg, overrides) {
         defaultModel: model,
         ...overrides,
     };
-    const provider = createProviderInstance(providerName, config);
-    return { provider, model };
+    const primary = createProviderInstance(providerName, config);
+    const fallbackCfgs = readOhConfig()?.fallbackProviders ?? [];
+    if (fallbackCfgs.length === 0) {
+        return { provider: primary, model };
+    }
+    const fallbacks = fallbackCfgs.map((fb) => ({
+        provider: createProviderInstance(fb.provider, {
+            name: fb.provider,
+            apiKey: fb.apiKey ?? process.env[`${fb.provider.toUpperCase()}_API_KEY`],
+            baseUrl: fb.baseUrl,
+            defaultModel: fb.model ?? model,
+        }),
+        model: fb.model,
+    }));
+    const wrapped = createFallbackProvider(primary, fallbacks);
+    return { provider: wrapped, model };
 }
 export { createProviderInstance, guessProviderFromModel };
 function createProviderInstance(name, config) {

package/dist/providers/router.d.ts

@@ -45,4 +45,8 @@ export declare class ModelRouter {
     /** Get all configured tiers */
     get tiers(): Record<ModelTier, string>;
 }
+/** Record the router's selection for a session. Keeps only the most recent 256 sessions. */
+export declare function recordRouteSelection(sessionId: string, result: RouteResult): void;
+/** Retrieve the most recent selection for a session, or undefined. */
+export declare function getRouteSelection(sessionId: string): RouteResult | undefined;
 //# sourceMappingURL=router.d.ts.map

package/dist/providers/router.js

@@ -58,4 +58,23 @@ export class ModelRouter {
         };
     }
 }
+const ROUTE_SELECTION_CAP = 256;
+const routeSelections = new Map();
+/** Record the router's selection for a session. Keeps only the most recent 256 sessions. */
+export function recordRouteSelection(sessionId, result) {
+    // Map preserves insertion order. Delete-then-set moves the key to the end,
+    // so oldest is always keys().next().
+    if (routeSelections.has(sessionId))
+        routeSelections.delete(sessionId);
+    routeSelections.set(sessionId, result);
+    if (routeSelections.size > ROUTE_SELECTION_CAP) {
+        const oldest = routeSelections.keys().next().value;
+        if (oldest !== undefined)
+            routeSelections.delete(oldest);
+    }
+}
+/** Retrieve the most recent selection for a session, or undefined. */
+export function getRouteSelection(sessionId) {
+    return routeSelections.get(sessionId);
+}
 //# sourceMappingURL=router.js.map

package/dist/query/index.js

@@ -8,7 +8,9 @@
  * - types.ts — shared types
  */
 import { DeferredTool } from "../DeferredTool.js";
+import { readOhConfig } from "../harness/config.js";
 import { getContextWindow } from "../harness/cost.js";
+import { ModelRouter } from "../providers/router.js";
 import { StreamingToolExecutor } from "../services/StreamingToolExecutor.js";
 import { toolToAPIFormat } from "../Tool.js";
 import { createAssistantMessage, createToolResultMessage, createUserMessage } from "../types/message.js";
@@ -18,8 +20,27 @@ import { isNetworkError, isOverloadError, isPromptTooLongError, isRateLimitError
 import { executeToolCalls } from "./tools.js";
 export { compressMessages } from "./compress.js";
 const DEFAULT_MAX_TURNS = 50;
+/** Rough context-usage estimate in [0, 1]. Returns undefined when tokenization is unavailable. */
+function estimateRouteContextUsage(messages, provider, model) {
+    const estimate = provider.estimateTokens?.bind(provider);
+    if (!estimate)
+        return undefined;
+    const info = provider.getModelInfo?.(model);
+    const window = info?.contextWindow;
+    if (!window || window <= 0)
+        return undefined;
+    let total = 0;
+    for (const m of messages) {
+        if (typeof m.content === "string")
+            total += estimate(m.content);
+        // Non-string content (tool calls etc.) is skipped — rough estimate only.
+    }
+    return Math.min(1, total / window);
+}
 export async function* query(userMessage, config, existingMessages = []) {
     const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
+    const routerCfg = readOhConfig()?.modelRouter ?? {};
+    const router = new ModelRouter(routerCfg, config.model ?? "");
     const toolContext = {
         workingDir: config.workingDir ?? process.cwd(),
         abortSignal: config.abortSignal,
@@ -160,7 +181,16 @@ export async function* query(userMessage, config, existingMessages = []) {
         let streamError = null;
         const streamingExecutor = new StreamingToolExecutor(config.tools, toolContext, config.permissionMode, config.askUser, config.abortSignal);
         try {
-            for await (const event of config.provider.stream(state.messages, turnPrompt, apiTools, config.model)) {
+            const ctxUsage = estimateRouteContextUsage(state.messages, config.provider, config.model ?? "");
+            const selection = router.select({
+                turn: state.turn,
+                hadToolCalls: state.lastTurnHadTools ?? false,
+                toolCallCount: state.lastTurnToolCount ?? 0,
+                contextUsage: ctxUsage,
+                isFinalResponse: (state.lastTurnHadTools === false || state.lastTurnHadTools === undefined) && state.turn > 1,
+                role: config.role,
+            });
+            for await (const event of config.provider.stream(state.messages, turnPrompt, apiTools, selection.model)) {
                 if (config.abortSignal?.aborted)
                     break;
                 switch (event.type) {
@@ -283,6 +313,8 @@ export async function* query(userMessage, config, existingMessages = []) {
         if (remaining.length > 0) {
             yield* executeToolCalls(remaining, config.tools, toolContext, config.permissionMode, config.askUser, state);
         }
+        state.lastTurnHadTools = toolCalls.length > 0;
+        state.lastTurnToolCount = toolCalls.length;
         state.transition = "next_turn";
     }
     yield { type: "turn_complete", reason: "max_turns" };