laohuang 0.3.2 → 0.4.0

package/dist/cli.js

@@ -0,0 +1,1307 @@
+#!/usr/bin/env node
+/** Command-line interface and subcommands for laoHuangCode. */
+import { existsSync, readFileSync, readSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { AgentError, CodingAgent, } from "./agent.js";
+import { createClient, } from "./client.js";
+import { SessionCommands } from "./commands.js";
+import { ConfigManager, defaultConfigPath, } from "./config.js";
+import { CredentialStore } from "./credentials.js";
+import { EventProjector } from "./events.js";
+import { ModelSelector } from "./model-selection.js";
+import { getProvider, providerNames } from "./providers.js";
+import { findProjectRoot } from "./project-instructions.js";
+import { SmallModelSemanticClassifier, } from "./semantic-classifier.js";
+import { AgentSession } from "./session.js";
+import { BufferedInputKind, EditorState, InputActionKind, RawInputDecoder, StdinBuffer, TerminalInputFilter, inputAction, } from "./terminal/editor.js";
+import { PromptCancelledError, PromptEofError } from "./terminal/input.js";
+import { PlainEventSink, StdTerminalDriver, TerminalUI, } from "./terminal/ui.js";
+import { ToolRegistry } from "./tools.js";
+import { EventLog, WebDashboard, consumePullBuffer } from "./web.js";
+export const VERSION = readPackageVersion();
+function readPackageVersion() {
+    try {
+        const packageJsonPath = fileURLToPath(new URL("../package.json", import.meta.url));
+        const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            typeof parsed.version === "string") {
+            return parsed.version;
+        }
+    }
+    catch {
+        // Fall through to the placeholder when the package manifest is missing.
+    }
+    return "0.0.0";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function writeStderr(message) {
+    process.stderr.write(`${message}\n`);
+}
+function isEofError(error) {
+    return (error instanceof PromptEofError ||
+        (error instanceof Error &&
+            (error.name === "PromptEofError" || error.name === "EOFError")));
+}
+function isInterruptedError(error) {
+    return (error instanceof PromptCancelledError ||
+        (error instanceof Error &&
+            (error.name === "PromptCancelledError" ||
+                error.name === "KeyboardInterrupt")));
+}
+// ---------------------------------------------------------------------------
+// Synchronous stdin line prompts (non-TTY and pre-loop setup questions)
+// ---------------------------------------------------------------------------
+// These blocking readers are the non-interactive fallback: before the
+// terminal loop starts (first-run setup, pipes, tests) nothing else owns
+// fd 0, so reading lines synchronously is safe. Once the interactive loop
+// runs, questions must go through TerminalUI.prompt/promptSecret instead —
+// see terminalUiPrompts below.
+const stdinBuffer = { pending: "", eof: false };
+function readLineFromStdin() {
+    const chunk = Buffer.alloc(4096);
+    for (;;) {
+        const newline = stdinBuffer.pending.indexOf("\n");
+        if (newline !== -1) {
+            const line = stdinBuffer.pending.slice(0, newline);
+            stdinBuffer.pending = stdinBuffer.pending.slice(newline + 1);
+            return line.endsWith("\r") ? line.slice(0, -1) : line;
+        }
+        if (stdinBuffer.eof) {
+            const rest = stdinBuffer.pending;
+            stdinBuffer.pending = "";
+            if (rest) {
+                return rest;
+            }
+            throw new PromptEofError();
+        }
+        let bytesRead = 0;
+        try {
+            bytesRead = readSync(0, chunk, 0, chunk.length, null);
+        }
+        catch (error) {
+            if (error.code === "EAGAIN") {
+                // A non-blocking fd 0: wait briefly and retry (mirrors blocking input).
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+                continue;
+            }
+            throw error;
+        }
+        if (bytesRead === 0) {
+            stdinBuffer.eof = true;
+            continue;
+        }
+        stdinBuffer.pending += chunk.toString("utf8", 0, bytesRead);
+    }
+}
+/** Default replacement for Python's ``input(prompt)``. */
+function defaultInputFn(prompt) {
+    if (prompt) {
+        process.stdout.write(prompt);
+    }
+    return readLineFromStdin();
+}
+/** Default replacement for Python's ``getpass.getpass(prompt)``. */
+function defaultSecretInputFn(prompt) {
+    if (prompt) {
+        process.stderr.write(prompt);
+    }
+    if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== "function") {
+        return readLineFromStdin();
+    }
+    // Echo-less read of one line on a TTY: raw mode, byte at a time.
+    const byte = Buffer.alloc(1);
+    let answer = "";
+    process.stdin.setRawMode(true);
+    try {
+        for (;;) {
+            const bytesRead = readSync(0, byte, 0, 1, null);
+            if (bytesRead === 0) {
+                throw new PromptEofError();
+            }
+            const value = byte[0];
+            if (value === 0x03) {
+                process.stderr.write("\n");
+                throw new PromptCancelledError();
+            }
+            if (value === 0x04) {
+                process.stderr.write("\n");
+                throw new PromptEofError();
+            }
+            if (value === 0x0a || value === 0x0d) {
+                break;
+            }
+            if (value === 0x7f || value === 0x08) {
+                answer = [...answer].slice(0, -1).join("");
+                continue;
+            }
+            answer += byte.toString("utf8", 0, 1);
+        }
+    }
+    finally {
+        process.stdin.setRawMode(false);
+    }
+    process.stderr.write("\n");
+    return answer;
+}
+// ---------------------------------------------------------------------------
+// Argument parsing (argparse-compatible surface)
+// ---------------------------------------------------------------------------
+class CliUsageError extends Error {
+}
+const USAGE = "usage: laohuang [--version] [--profile PROFILE] [--model MODEL] " +
+    "[--base-url BASE_URL] [--theme {auto,dark,light}] [--web] " +
+    "[--web-port PORT] [config ...] [doctor]";
+const HELP = `${USAGE}
+
+A minimal coding agent
+
+options:
+  --version          show program's version number and exit
+  -h, --help         show this help message and exit
+  --profile PROFILE  model profile for this session
+  --model MODEL      model override for this session
+  --base-url URL     API base URL override for this session
+  --theme THEME      interactive terminal theme: auto, dark, light (default: auto)
+  --web              start the local agent trace dashboard
+  --web-port PORT    dashboard port (default: 8765; use 0 for any free port)
+
+subcommands:
+  config [set|list|use] [target] [--profile P] [--provider P] [--model M] [--base-url U]
+  doctor             check local configuration`;
+function splitOption(token) {
+    if (token.startsWith("--")) {
+        const equals = token.indexOf("=");
+        if (equals !== -1) {
+            return [token.slice(0, equals), token.slice(equals + 1)];
+        }
+    }
+    return [token, undefined];
+}
+function parseArgs(argv) {
+    const args = {
+        command: null,
+        profile: null,
+        model: null,
+        baseUrl: null,
+        theme: "auto",
+        web: false,
+        webPort: 8765,
+        configAction: "set",
+        configTarget: null,
+        configProfile: "default",
+        provider: null,
+        configModel: null,
+        configBaseUrl: null,
+    };
+    let index = 0;
+    const takeValue = (option, inline) => {
+        if (inline !== undefined) {
+            return inline;
+        }
+        index += 1;
+        const value = argv[index];
+        if (value === undefined) {
+            throw new CliUsageError(`argument ${option}: expected one argument`);
+        }
+        return value;
+    };
+    for (; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "config" || token === "doctor") {
+            args.command = token;
+            index += 1;
+            break;
+        }
+        const [name, inline] = splitOption(token);
+        switch (name) {
+            case "--version":
+                return { kind: "version" };
+            case "-h":
+            case "--help":
+                return { kind: "help" };
+            case "--profile":
+                args.profile = takeValue(name, inline);
+                break;
+            case "--model":
+                args.model = takeValue(name, inline);
+                break;
+            case "--base-url":
+                args.baseUrl = takeValue(name, inline);
+                break;
+            case "--theme": {
+                const theme = takeValue(name, inline);
+                if (theme !== "auto" && theme !== "dark" && theme !== "light") {
+                    throw new CliUsageError(`argument --theme: invalid choice: '${theme}' (choose from 'auto', 'dark', 'light')`);
+                }
+                args.theme = theme;
+                break;
+            }
+            case "--web":
+                if (inline !== undefined) {
+                    throw new CliUsageError(`argument --web: ignored explicit argument`);
+                }
+                args.web = true;
+                break;
+            case "--web-port": {
+                const raw = takeValue(name, inline);
+                if (!/^[+-]?\d+$/.test(raw.trim())) {
+                    throw new CliUsageError(`argument --web-port: invalid int value: '${raw}'`);
+                }
+                args.webPort = Number.parseInt(raw, 10);
+                break;
+            }
+            default:
+                throw new CliUsageError(`unrecognized arguments: ${token}`);
+        }
+    }
+    if (args.command === "config") {
+        const positionals = [];
+        for (; index < argv.length; index += 1) {
+            const token = argv[index];
+            const [name, inline] = splitOption(token);
+            switch (name) {
+                case "--profile":
+                    args.configProfile = takeValue(name, inline);
+                    break;
+                case "--provider": {
+                    const provider = takeValue(name, inline);
+                    if (!providerNames().includes(provider)) {
+                        throw new CliUsageError(`argument --provider: invalid choice: '${provider}' (choose from ${providerNames()
+                            .map((item) => `'${item}'`)
+                            .join(", ")})`);
+                    }
+                    args.provider = provider;
+                    break;
+                }
+                case "--model":
+                    args.configModel = takeValue(name, inline);
+                    break;
+                case "--base-url":
+                    args.configBaseUrl = takeValue(name, inline);
+                    break;
+                case "-h":
+                case "--help":
+                    return { kind: "help" };
+                default:
+                    if (token.startsWith("-")) {
+                        throw new CliUsageError(`unrecognized arguments: ${token}`);
+                    }
+                    positionals.push(token);
+            }
+        }
+        if (positionals.length > 2) {
+            throw new CliUsageError(`unrecognized arguments: ${positionals.slice(2).join(" ")}`);
+        }
+        const action = positionals[0];
+        if (action !== undefined) {
+            if (action !== "set" && action !== "list" && action !== "use") {
+                throw new CliUsageError(`argument config_action: invalid choice: '${action}' (choose from 'set', 'list', 'use')`);
+            }
+            args.configAction = action;
+        }
+        args.configTarget = positionals[1] ?? null;
+    }
+    else if (args.command === "doctor") {
+        if (index < argv.length) {
+            throw new CliUsageError(`unrecognized arguments: ${argv.slice(index).join(" ")}`);
+        }
+    }
+    return { kind: "run", args };
+}
+/** Only enable the interactive UI for the process's real TTY streams. */
+export function supportsTerminalUI(options = {}) {
+    if (options.inputFn !== undefined || options.outputFn !== undefined) {
+        return false;
+    }
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    return Boolean(stdin.isTTY) && Boolean(stdout.isTTY);
+}
+export async function runRepl(agent, options = {}) {
+    const inputFn = options.inputFn ?? defaultInputFn;
+    const outputFn = options.outputFn ?? ((message) => console.log(message));
+    const ui = options.ui ?? null;
+    if (ui !== null) {
+        ui.showWelcome();
+    }
+    else {
+        outputFn("laoHuangCode is ready. Type /help for commands or /exit to quit.");
+    }
+    for (;;) {
+        let userInput;
+        try {
+            userInput = (await (ui !== null ? ui.prompt() : inputFn("\nyou> "))).trim();
+        }
+        catch (error) {
+            if (isEofError(error)) {
+                if (ui !== null) {
+                    ui.showGoodbye();
+                }
+                else {
+                    outputFn("\nGoodbye.");
+                }
+                return;
+            }
+            if (isInterruptedError(error)) {
+                if (ui !== null) {
+                    ui.showInterrupted();
+                }
+                else {
+                    outputFn("\nInterrupted. Type /exit to quit.");
+                }
+                continue;
+            }
+            throw error;
+        }
+        if (userInput === "/exit") {
+            if (ui !== null) {
+                ui.showGoodbye();
+            }
+            else {
+                outputFn("Goodbye.");
+            }
+            return;
+        }
+        if (!userInput) {
+            continue;
+        }
+        if (userInput.startsWith("/")) {
+            if (options.commandHandler !== undefined &&
+                (await options.commandHandler(userInput))) {
+                continue;
+            }
+            const message = `Unknown command: ${userInput.split(/\s/)[0] ?? userInput}`;
+            if (ui !== null) {
+                ui.write(message);
+            }
+            else {
+                outputFn(message);
+            }
+            continue;
+        }
+        let response;
+        try {
+            if (ui !== null && typeof ui.thinking === "function") {
+                const thinking = ui.thinking();
+                try {
+                    response = await agent.run(userInput);
+                }
+                finally {
+                    thinking?.close();
+                }
+            }
+            else {
+                response = await agent.run(userInput);
+            }
+        }
+        catch (error) {
+            if (error instanceof AgentError) {
+                if (ui !== null) {
+                    ui.showError(error.message);
+                }
+                else {
+                    outputFn(`\nError: ${error.message}`);
+                }
+            }
+            else if (isInterruptedError(error)) {
+                if (ui !== null) {
+                    ui.showInterrupted({ operation: true });
+                }
+                else {
+                    outputFn("\nOperation interrupted.");
+                }
+            }
+            else {
+                throw error;
+            }
+            continue;
+        }
+        if (ui !== null) {
+            ui.showAssistant(response);
+        }
+        else {
+            outputFn(`\nlaoHuangCode> ${response}`);
+        }
+    }
+}
+function suggestCommand(ui, name) {
+    const registry = ui?.commandRegistry;
+    return typeof registry?.suggest === "function" ? registry.suggest(name) : null;
+}
+/**
+ * Shared input routing for the session REPLs. Returns false only for /exit,
+ * which the persistent loop reports back to the terminal instead.
+ */
+async function handleSessionInput(session, commandHandler, ui, userInput) {
+    if (userInput === "/exit") {
+        await session.submitInput(userInput);
+        return false;
+    }
+    if (!userInput) {
+        return true;
+    }
+    if (userInput.startsWith("/")) {
+        if (userInput === "/cancel") {
+            const submission = await session.submitInput(userInput);
+            if (submission.taskId === null) {
+                session.publishNotice("No active task to cancel.");
+            }
+            return true;
+        }
+        await session.submitInput(userInput);
+        if (commandHandler !== undefined && (await commandHandler(userInput))) {
+            return true;
+        }
+        const commandName = userInput.split(/\s/)[0] ?? userInput;
+        const suggestion = suggestCommand(ui, commandName);
+        const suffix = suggestion ? ` Did you mean ${suggestion}?` : "";
+        session.publishNotice(`Unknown command: ${commandName}.${suffix}`);
+        return true;
+    }
+    let submission;
+    try {
+        submission = await session.submitInput(userInput);
+    }
+    catch (error) {
+        session.publishNotice(`Error: ${errorMessage(error)}`, { style: "bold red" });
+        return true;
+    }
+    if (submission.queued) {
+        const status = session.queueStatus();
+        session.publishNotice(`Message queued (pending ${status.pending ?? 0} · held ${status.held ?? 0}).`);
+    }
+    else if (submission.rejected) {
+        session.publishNotice(`Message rejected: ${submission.reason}`, {
+            style: "bold red",
+        });
+    }
+    return true;
+}
+/** Keep accepting input while AgentSession executes in the background. */
+export async function runSessionRepl(session, options) {
+    if (options.runUi !== undefined || typeof options.ui.run === "function") {
+        return runPersistentSessionRepl(session, options);
+    }
+    return runClassicSessionRepl(session, options);
+}
+async function runClassicSessionRepl(session, options) {
+    const { commandHandler, ui } = options;
+    ui.startEventRenderer?.();
+    ui.showWelcome?.();
+    let cleanShutdown = false;
+    try {
+        for (;;) {
+            let userInput;
+            try {
+                userInput = (await ui.prompt()).trim();
+            }
+            catch (error) {
+                if (isEofError(error)) {
+                    break;
+                }
+                if (isInterruptedError(error)) {
+                    session.publishNotice("Interrupted.", { style: "yellow" });
+                    continue;
+                }
+                throw error;
+            }
+            const keepGoing = await handleSessionInput(session, commandHandler, ui, userInput);
+            if (!keepGoing) {
+                break;
+            }
+        }
+    }
+    finally {
+        cleanShutdown = await session.close({ wait: true, timeoutMs: 10_000 });
+        if (cleanShutdown) {
+            await session.eventBus.flush();
+            ui.flushEventRenderer?.();
+        }
+        ui.stopEventRenderer?.();
+    }
+    if (cleanShutdown) {
+        ui.showGoodbye?.();
+    }
+    else {
+        ui.showError?.("Task worker did not stop before the shutdown timeout.");
+    }
+    return cleanShutdown;
+}
+/**
+ * Serialize routing and command handling on one async worker so the terminal
+ * loop never blocks on semantic classification (the Python original used a
+ * dedicated coordinator thread fed by a queue).
+ */
+function startCoordinator(session, commandHandler, ui) {
+    const queue = [];
+    let wake = null;
+    let stopping = false;
+    let unfinished = 0;
+    const errors = [];
+    const done = (async () => {
+        for (;;) {
+            if (queue.length === 0) {
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+                wake = null;
+            }
+            const item = queue.shift();
+            if (item === undefined) {
+                continue;
+            }
+            try {
+                if (item === null || stopping) {
+                    return;
+                }
+                await handleSessionInput(session, commandHandler, ui, item);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            finally {
+                unfinished -= 1;
+            }
+        }
+    })();
+    return {
+        submit(text) {
+            unfinished += 1;
+            queue.push(text);
+            wake?.();
+        },
+        stop() {
+            stopping = true;
+            queue.push(null);
+            wake?.();
+        },
+        done,
+        errors,
+        pending() {
+            return unfinished;
+        },
+    };
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+/** Resolve true when the promise settles within the timeout, false otherwise. */
+async function settlesWithin(promise, ms) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), ms);
+    });
+    const settled = promise.then(() => true, () => true);
+    try {
+        return await Promise.race([settled, timeout]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+}
+async function waitForDrain(isDrained, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        if (isDrained()) {
+            return true;
+        }
+        if (Date.now() >= deadline) {
+            return isDrained();
+        }
+        await delay(5);
+    }
+}
+/** Drive a single-renderer terminal without writing outside its layout. */
+async function runPersistentSessionRepl(session, options) {
+    const { commandHandler, ui } = options;
+    const runUi = options.runUi ?? ((onSubmit) => ui.run(onSubmit));
+    ui.showWelcome?.();
+    const coordinator = startCoordinator(session, commandHandler, ui);
+    let cleanShutdown = false;
+    try {
+        const enqueue = (userInput) => {
+            // Exit is a local UI operation and should not wait behind a slow
+            // semantic classification of an earlier queued message.
+            if (userInput === "/exit") {
+                void (async () => {
+                    try {
+                        await session.submitInput(userInput);
+                    }
+                    catch (error) {
+                        try {
+                            session.publishNotice(`Error: ${errorMessage(error)}`, {
+                                style: "bold red",
+                            });
+                        }
+                        catch {
+                            // The event bus may already be closed during shutdown.
+                        }
+                    }
+                })();
+                ui.requestExit?.();
+                return;
+            }
+            coordinator.submit(userInput);
+        };
+        await runUi(enqueue);
+    }
+    finally {
+        const queueDrained = await waitForDrain(() => coordinator.pending() === 0, 50);
+        coordinator.stop();
+        let coordinatorAlive = !(await settlesWithin(coordinator.done, queueDrained ? 2000 : 50));
+        const sessionStopped = await session.close({ wait: true, timeoutMs: 10_000 });
+        if (coordinatorAlive) {
+            coordinatorAlive = !(await settlesWithin(coordinator.done, 250));
+        }
+        cleanShutdown =
+            sessionStopped && !coordinatorAlive && coordinator.errors.length === 0;
+        if (cleanShutdown) {
+            await session.eventBus.flush();
+            ui.flushEventRenderer?.();
+        }
+        const renderError = ui.renderError ?? null;
+        try {
+            if (!cleanShutdown && renderError === null) {
+                const shutdownMessage = coordinatorAlive
+                    ? "Input coordinator did not stop before the shutdown timeout."
+                    : coordinator.errors.length > 0
+                        ? "Input coordinator failed during shutdown."
+                        : "Task worker did not stop before the shutdown timeout.";
+                ui.showError?.(shutdownMessage);
+            }
+        }
+        finally {
+            ui.close?.();
+        }
+    }
+    const renderError = ui.renderError ?? null;
+    return cleanShutdown && renderError === null;
+}
+/** Run the same event-driven session with append-only plain output. */
+export async function runPlainSessionRepl(session, options) {
+    const inputFn = options.inputFn ?? defaultInputFn;
+    const { commandHandler, sink } = options;
+    session.publishNotice("laoHuangCode is ready. Type /help for commands or /exit to quit.");
+    await session.eventBus.flush();
+    sink.flush();
+    let cleanShutdown = false;
+    try {
+        for (;;) {
+            let userInput;
+            try {
+                userInput = (await inputFn("")).trim();
+            }
+            catch (error) {
+                if (isEofError(error)) {
+                    // A pipe may close immediately after submitting work. Let the
+                    // active task and its compatible pending batch finish normally.
+                    await session.waitForIdle();
+                    break;
+                }
+                if (isInterruptedError(error)) {
+                    session.publishNotice("Interrupted. Type /exit to quit.");
+                    continue;
+                }
+                throw error;
+            }
+            if (userInput === "/exit") {
+                await session.submitInput(userInput);
+                break;
+            }
+            if (!userInput) {
+                continue;
+            }
+            if (userInput.startsWith("/")) {
+                if (userInput === "/cancel") {
+                    const submission = await session.submitInput(userInput);
+                    if (submission.taskId === null) {
+                        session.publishNotice("No active task to cancel.");
+                    }
+                    continue;
+                }
+                await session.submitInput(userInput);
+                if (commandHandler !== undefined && (await commandHandler(userInput))) {
+                    continue;
+                }
+                session.publishNotice(`Unknown command: ${userInput.split(/\s/)[0] ?? userInput}`);
+                continue;
+            }
+            let submission;
+            try {
+                submission = await session.submitInput(userInput);
+            }
+            catch (error) {
+                session.publishNotice(`Error: ${errorMessage(error)}`);
+                continue;
+            }
+            if (submission.queued) {
+                const status = session.queueStatus();
+                session.publishNotice(`Message queued (pending ${status.pending ?? 0} · held ${status.held ?? 0}).`);
+            }
+            else if (submission.rejected) {
+                session.publishNotice(`Message rejected: ${submission.reason}`);
+            }
+        }
+    }
+    finally {
+        cleanShutdown = await session.close({ wait: true, timeoutMs: 10_000 });
+        if (cleanShutdown) {
+            await session.eventBus.flush();
+            sink.flush();
+        }
+        sink.stop({ drain: cleanShutdown });
+    }
+    const output = sink.outputFn;
+    if (cleanShutdown) {
+        output("Goodbye.");
+    }
+    else {
+        output("Error: Task worker did not stop before the shutdown timeout.");
+    }
+    return cleanShutdown;
+}
+// ---------------------------------------------------------------------------
+// Production wiring helpers
+// ---------------------------------------------------------------------------
+/**
+ * The full input pipeline from terminal/editor.ts (buffer → negotiation
+ * filter → raw decoder), mirroring PiInputSession. Replaces the Basic*
+ * defaults of terminal/ui.ts inside the interactive loop.
+ */
+class ProductionInputDecoder {
+    #stdinBuffer = new StdinBuffer();
+    #filter;
+    #decoder = new RawInputDecoder();
+    constructor(hooks) {
+        this.#filter = new TerminalInputFilter({
+            enableModifyOtherKeys: () => {
+                hooks.enableModifyOtherKeys();
+            },
+            disableModifyOtherKeys: () => {
+                hooks.disableModifyOtherKeys();
+            },
+        });
+    }
+    get kittyProtocolActive() {
+        return this.#filter.kittyProtocolActive;
+    }
+    set kittyProtocolActive(value) {
+        this.#filter.kittyProtocolActive = value;
+    }
+    feed(data) {
+        const actions = [];
+        for (const event of this.#stdinBuffer.feed(data)) {
+            if (event.kind === BufferedInputKind.Paste) {
+                actions.push(inputAction(InputActionKind.Insert, event.data.toString("utf8")));
+                continue;
+            }
+            for (const sequence of this.#filter.feed(event.data)) {
+                actions.push(...this.#decoder.feed(sequence));
+            }
+        }
+        return actions;
+    }
+    flush() {
+        const actions = [];
+        for (const event of this.#stdinBuffer.flush()) {
+            for (const sequence of this.#filter.feed(event.data)) {
+                actions.push(...this.#decoder.feed(sequence));
+            }
+        }
+        for (const sequence of this.#filter.flush()) {
+            actions.push(...this.#decoder.feed(sequence));
+        }
+        actions.push(...this.#decoder.flush());
+        return actions;
+    }
+    clear() {
+        this.#stdinBuffer.clear();
+        this.#filter.clear();
+        // RawInputDecoder has no clear(); a fresh instance drops partial escapes.
+        this.#decoder = new RawInputDecoder();
+    }
+}
+/**
+ * Wraps the production editor from terminal/editor.ts with the render result
+ * shape terminal/ui.ts's EditorLike expects (cursorColumn → cursorCol).
+ * Composition rather than inheritance: EditorState.renderLines has a
+ * different, incompatible return type.
+ */
+class ProductionEditor {
+    #state = new EditorState();
+    get text() {
+        return this.#state.text;
+    }
+    set text(value) {
+        this.#state.text = value;
+    }
+    get cursor() {
+        return this.#state.cursor;
+    }
+    set cursor(value) {
+        this.#state.cursor = value;
+    }
+    get historyIndex() {
+        return this.#state.historyIndex;
+    }
+    set historyIndex(value) {
+        this.#state.historyIndex = value;
+    }
+    get completions() {
+        return this.#state.completions;
+    }
+    get selectedCompletion() {
+        return this.#state.selectedCompletion;
+    }
+    set selectedCompletion(value) {
+        this.#state.selectedCompletion = value;
+    }
+    apply(action, options) {
+        return this.#state.apply(action, options);
+    }
+    setCompletions(values) {
+        this.#state.setCompletions(values);
+    }
+    renderLines(width, options = {}) {
+        const rendered = this.#state.renderLines(width, options);
+        return {
+            lines: rendered.lines,
+            cursorRow: rendered.cursorRow,
+            cursorCol: rendered.cursorColumn,
+        };
+    }
+}
+/** Drive the interactive loop of a real TerminalUI with process stdin. */
+async function runTerminalUi(ui, driver, onSubmit) {
+    const loop = ui.interactiveLoop;
+    if (loop === null) {
+        throw new Error("interactive terminal loop is unavailable");
+    }
+    // TerminalUI.run() does not forward an input source to the loop yet, so
+    // the CLI starts the loop itself with the driver's stdin stream.
+    loop.start(onSubmit);
+    await loop.run(driver.inputStream);
+}
+/**
+ * Route setup/command questions through the running terminal UI loop
+ * (mirrors the Python original's `input_fn = terminal_ui.prompt` and
+ * `session_secret_input_fn = terminal_ui.prompt_secret`). The loop's ask()
+ * coordinates the question with its editor, so no pause/resume is needed —
+ * and nothing reads fd 0 behind the driver's raw-mode stream.
+ */
+export function terminalUiPrompts(ui) {
+    return {
+        input: (prompt) => ui.prompt(prompt),
+        secretInput: (prompt) => ui.promptSecret(prompt),
+    };
+}
+export async function main(argv, options = {}) {
+    let parsed;
+    try {
+        parsed = parseArgs(argv ?? process.argv.slice(2));
+    }
+    catch (error) {
+        if (error instanceof CliUsageError) {
+            writeStderr(USAGE);
+            writeStderr(`laohuang: error: ${error.message}`);
+            return 2;
+        }
+        throw error;
+    }
+    if (parsed.kind === "version") {
+        process.stdout.write(`laohuang ${VERSION}\n`);
+        return 0;
+    }
+    if (parsed.kind === "help") {
+        process.stdout.write(`${HELP}\n`);
+        return 0;
+    }
+    const args = parsed.args;
+    const environ = options.environ ?? process.env;
+    const projectRoot = process.cwd();
+    // Instruction loading roots at the nearest .git ancestor; the tool
+    // registry keeps the plain cwd as its root.
+    const instructionRoot = findProjectRoot(process.cwd(), projectRoot);
+    const interactive = supportsTerminalUI({
+        inputFn: options.inputFn,
+        outputFn: options.outputFn,
+        stdin: options.stdin,
+        stdout: options.stdout,
+    });
+    const inputFn = options.inputFn ?? defaultInputFn;
+    const outputFn = options.outputFn ?? ((message) => console.log(message));
+    const secretInputFn = options.secretInputFn ?? defaultSecretInputFn;
+    const configPath = options.configPath ?? defaultConfigPath(environ);
+    const manager = new ConfigManager(configPath);
+    const credentials = new CredentialStore(options.credentialsPath ?? join(dirname(configPath), "credentials.json"));
+    // The selector's input/output targets are rewired once the session exists,
+    // mirroring the Python original which mutated selector.input_fn/output_fn.
+    // Like the Python original, the selector's own secret prompts (first-run
+    // setup, `config` subcommand) always use the default secret reader — only
+    // the session commands switch to the terminal UI's secret prompt.
+    let selectorInput = async (prompt) => inputFn(prompt);
+    const selectorSecretInput = async (prompt) => secretInputFn(prompt);
+    let selectorOutput = outputFn;
+    const selector = new ModelSelector({
+        credentials,
+        registry: { get: getProvider, names: providerNames },
+        createClient,
+        input: (prompt) => selectorInput(prompt),
+        secretInput: (prompt) => selectorSecretInput(prompt),
+        output: (message) => {
+            selectorOutput(message);
+        },
+        clientFactory: options.clientFactory,
+    });
+    if (args.command === "config") {
+        if (args.configAction === "list") {
+            let profiles;
+            try {
+                profiles = manager.listProfiles();
+            }
+            catch (error) {
+                writeStderr(`Configuration error: ${errorMessage(error)}`);
+                return 2;
+            }
+            for (const profile of profiles) {
+                const marker = profile.active ? "*" : " ";
+                outputFn(`${marker} ${profile.name}  ${profile.provider}  ${profile.model}`);
+            }
+            return 0;
+        }
+        if (args.configAction === "use") {
+            if (!args.configTarget) {
+                writeStderr("Configuration error: profile name is required");
+                return 2;
+            }
+            try {
+                manager.setActive(args.configTarget);
+            }
+            catch (error) {
+                writeStderr(`Configuration error: ${errorMessage(error)}`);
+                return 2;
+            }
+            outputFn(`Active profile: ${args.configTarget}`);
+            return 0;
+        }
+        try {
+            const selection = await selector.select({
+                providerName: args.provider ?? undefined,
+                modelName: args.configModel ?? undefined,
+            });
+            if (selection === null) {
+                return 2;
+            }
+            manager.configure({
+                name: args.configProfile,
+                provider: selection.config.provider,
+                model: selection.config.model,
+                baseUrl: args.configBaseUrl ?? selection.config.baseUrl,
+            });
+        }
+        catch (error) {
+            writeStderr(`Configuration error: ${errorMessage(error)}`);
+            return 2;
+        }
+        outputFn(`Saved profile '${args.configProfile}' to ${configPath}`);
+        return 0;
+    }
+    if (args.command === "doctor") {
+        let settings;
+        try {
+            settings = manager.resolveSettings({
+                environ,
+                profile: args.profile,
+                model: args.model,
+                baseUrl: args.baseUrl,
+            });
+        }
+        catch (error) {
+            writeStderr(`Configuration error: ${errorMessage(error)}`);
+            return 2;
+        }
+        const keyConfigured = credentials.get(settings.provider) !== null;
+        outputFn(`Provider: ${settings.provider}`);
+        outputFn(`Model: ${settings.model}`);
+        outputFn(`Base URL: ${settings.baseUrl ?? "SDK default"}`);
+        outputFn(`API key: ${keyConfigured ? "configured" : "not configured"}`);
+        outputFn(`Configuration: ${configPath}`);
+        outputFn(`Node: ${process.version}`);
+        outputFn(`Bash: ${existsSync("/bin/bash") ? "available" : "missing"}`);
+        return keyConfigured ? 0 : 1;
+    }
+    let config;
+    let runtimeClient = null;
+    try {
+        if (existsSync(configPath)) {
+            config = manager.resolve({
+                credentials,
+                environ,
+                profile: args.profile,
+                model: args.model,
+                baseUrl: args.baseUrl,
+            });
+        }
+        else {
+            const selection = await selector.select();
+            if (selection === null) {
+                return 2;
+            }
+            config = {
+                model: selection.config.model,
+                baseUrl: selection.config.baseUrl,
+                provider: selection.config.provider,
+                profile: null,
+                apiKey: selection.config.apiKey,
+            };
+            runtimeClient = selection.client;
+            manager.configure({
+                name: "default",
+                provider: config.provider,
+                model: config.model,
+                baseUrl: config.baseUrl,
+            });
+            outputFn(`Configured ${config.provider} / ${config.model} as default.`);
+        }
+    }
+    catch (error) {
+        const message = errorMessage(error);
+        if (existsSync(configPath) && message.startsWith("No API key configured")) {
+            // A stored profile without its API key re-runs interactive selection
+            // for the resolved provider/model (first-run setup flow).
+            let selection;
+            try {
+                const settings = manager.resolveSettings({
+                    environ,
+                    profile: args.profile,
+                    model: args.model,
+                    baseUrl: args.baseUrl,
+                });
+                selection = await selector.select({
+                    providerName: settings.provider,
+                    modelName: settings.model,
+                });
+            }
+            catch (selectionError) {
+                writeStderr(`Configuration error: ${errorMessage(selectionError)}`);
+                return 2;
+            }
+            if (selection === null) {
+                return 2;
+            }
+            config = {
+                model: selection.config.model,
+                baseUrl: selection.config.baseUrl,
+                provider: selection.config.provider,
+                profile: null,
+                apiKey: selection.config.apiKey,
+            };
+            runtimeClient = selection.client;
+        }
+        else {
+            writeStderr(`Configuration error: ${message}`);
+            return 2;
+        }
+    }
+    const client = runtimeClient ??
+        createClient(config, { clientFactory: options.clientFactory });
+    let eventLog = null;
+    let dashboard = null;
+    if (args.web) {
+        eventLog = new EventLog();
+        eventLog.record("session_start", {
+            project_root: projectRoot,
+            provider: config.provider,
+            model: config.model,
+            profile: config.profile,
+        });
+        dashboard = new WebDashboard(eventLog, { port: args.webPort });
+        try {
+            await dashboard.start();
+        }
+        catch (error) {
+            writeStderr(`Web dashboard error: ${errorMessage(error)}`);
+            return 2;
+        }
+        if (!interactive) {
+            outputFn(`Web dashboard: ${dashboard.url}`);
+        }
+    }
+    // The interactive UI is constructed only once configuration (and the
+    // dashboard URL) are known; its provider/model are read-only in TS.
+    let terminalUi = null;
+    let terminalDriver = null;
+    if (interactive) {
+        terminalDriver = new StdTerminalDriver();
+        terminalUi = new TerminalUI({
+            projectRoot,
+            provider: config.provider,
+            model: config.model,
+            dashboardUrl: dashboard?.url,
+            theme: args.theme,
+            driver: terminalDriver,
+            editorFactory: () => new ProductionEditor(),
+            decoderFactory: (hooks) => new ProductionInputDecoder(hooks),
+        });
+        terminalUi.state.provider = config.provider;
+        terminalUi.state.model = config.model;
+    }
+    const agent = new CodingAgent({
+        client: client,
+        model: config.model,
+        tools: new ToolRegistry(projectRoot),
+        provider: config.provider,
+        projectRoot: instructionRoot,
+        startupCwd: process.cwd(),
+    });
+    const semanticClassifier = new SmallModelSemanticClassifier({
+        client: client,
+        model: config.model,
+    });
+    // session.ts asserts at compile time that CodingAgent satisfies its
+    // AgentRunnerLike contract (run(userInput, TaskContext)), so the agent can
+    // be handed to the session directly — no adapter needed.
+    const runtime = new AgentSession(agent, { semanticClassifier });
+    const plainSink = terminalUi === null ? new PlainEventSink(outputFn) : null;
+    const sessionSink = terminalUi ?? plainSink;
+    let replInputFn = inputFn;
+    let commandsSecretInput = selectorSecretInput;
+    if (plainSink !== null) {
+        const underlyingInput = inputFn;
+        const underlyingSecretInput = secretInputFn;
+        // Setup/command prompts go through the event pipeline in plain mode so
+        // they interleave with task output. The Python original also flushed the
+        // bus here; TS delivery is microtask-driven and catches up at the next
+        // await.
+        const plainInput = async (prompt) => {
+            if (prompt) {
+                runtime.publishNotice(prompt);
+            }
+            return underlyingInput("");
+        };
+        const plainSecretInput = async (prompt) => {
+            if (prompt) {
+                runtime.publishNotice(prompt);
+            }
+            return underlyingSecretInput("");
+        };
+        replInputFn = plainInput;
+        selectorInput = plainInput;
+        commandsSecretInput = plainSecretInput;
+    }
+    else if (terminalUi !== null) {
+        // /login and interactive /model run while the terminal loop owns stdin in
+        // raw mode: their questions must be asked through the UI loop, not read
+        // from fd 0 directly.
+        const prompts = terminalUiPrompts(terminalUi);
+        selectorInput = prompts.input;
+        commandsSecretInput = prompts.secretInput;
+    }
+    selectorOutput = (message) => {
+        runtime.publishNotice(message);
+    };
+    const sessionOutput = (message) => {
+        runtime.publishNotice(message);
+    };
+    const commands = new SessionCommands({
+        agent,
+        selector,
+        credentials,
+        currentConfig: {
+            apiKey: config.apiKey,
+            model: config.model,
+            baseUrl: config.baseUrl,
+            provider: config.provider,
+        },
+        input: (prompt) => selectorInput(prompt),
+        secretInput: (prompt) => commandsSecretInput(prompt),
+        output: sessionOutput,
+        session: runtime,
+    });
+    const unsubscribers = [];
+    const projector = new EventProjector();
+    unsubscribers.push(runtime.eventBus.subscribe((event) => {
+        sessionSink.publishEvent(projector.project(event, "terminal"));
+    }));
+    if (eventLog !== null) {
+        // The dashboard feeds from the canonical pull buffer; the promise
+        // resolves when the bus closes. Unexpected failures are dropped the same
+        // way the Python daemon thread lost them.
+        void consumePullBuffer(runtime.eventBus, eventLog).catch(() => { });
+    }
+    if (terminalUi !== null) {
+        terminalUi.setCommandRegistry(commands.registry);
+        terminalUi.setCancelCallback(() => {
+            void commands.handle("/cancel");
+        });
+        terminalUi.setRuntimeRunningCallback(() => runtime.activeTask !== null);
+    }
+    const handleCommand = async (command) => {
+        const handled = await commands.handle(command);
+        semanticClassifier.configure({
+            client: agent.client,
+            model: agent.model,
+        });
+        return handled;
+    };
+    let cleanShutdown = false;
+    try {
+        if (terminalUi !== null && terminalDriver !== null) {
+            const ui = terminalUi;
+            const driver = terminalDriver;
+            cleanShutdown = await runSessionRepl(runtime, {
+                commandHandler: handleCommand,
+                ui,
+                runUi: (enqueue) => runTerminalUi(ui, driver, enqueue),
+            });
+        }
+        else {
+            cleanShutdown = await runPlainSessionRepl(runtime, {
+                commandHandler: handleCommand,
+                inputFn: replInputFn,
+                sink: plainSink,
+            });
+        }
+    }
+    finally {
+        for (const unsubscribe of unsubscribers) {
+            unsubscribe();
+        }
+        if (dashboard !== null) {
+            await dashboard.stop();
+        }
+    }
+    return cleanShutdown ? 0 : 1;
+}
+// ---------------------------------------------------------------------------
+// Direct execution (dist/cli.js is the npm bin entry)
+// ---------------------------------------------------------------------------
+function invokedAsScript() {
+    const entry = process.argv[1];
+    if (!entry) {
+        return false;
+    }
+    try {
+        return import.meta.url === pathToFileURL(realpathSync(entry)).href;
+    }
+    catch {
+        return false;
+    }
+}
+if (invokedAsScript()) {
+    main().then((code) => {
+        process.exitCode = code;
+    }, (error) => {
+        writeStderr(`laohuang: ${errorMessage(error)}`);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=cli.js.map