@humain/terminal 0.0.2 → 0.0.3-beta.0

package/dist/main.js

@@ -9,22 +9,25 @@ import { createInterface } from "node:readline";
 import { modelsAreEqual } from "@earendil-works/pi-ai";
 import chalk from "chalk";
 import { parseArgs, printHelp } from "./cli/args.js";
-import { CredentialPrintError, isCredentialPrintHelp, parseCredentialPrintCommand, printCredentialPrintHelp, resolveCredentialForPrint, validateCredentialPrintArgs, } from "./cli/credential-print.js";
+import { checkProviderAuth, createAuthCheckModelRuntime, getProviderCredential, } from "./cli/auth-check.js";
+import { AuthCommandError, getAuthCommandName, getAuthCommandUsage, isAuthCommandHelp, parseAuthCommand, printAuthCommandHelp, validateAuthCommandArgs, } from "./cli/auth-command.js";
+import { resolveCredentialForPrint } from "./cli/credential-print.js";
 import { processFileArguments } from "./cli/file-processor.js";
 import { buildInitialMessage } from "./cli/initial-message.js";
 import { listModels } from "./cli/list-models.js";
 import { createProjectTrustContext } from "./cli/project-trust.js";
 import { selectSession } from "./cli/session-picker.js";
 import { shouldRunFirstTimeSetup, showFirstTimeSetup, showStartupSelector } from "./cli/startup-ui.js";
-import { APP_NAME, ENV_OFFLINE, ENV_SESSION_DIR, ENV_SKIP_VERSION_CHECK, ENV_STARTUP_BENCHMARK, expandTildePath, getAgentDir, getPackageDir, VERSION, } from "./config.js";
+import { APP_NAME, ENV_SESSION_DIR, expandTildePath, getAgentDir, getPackageDir, VERSION } from "./config.js";
 import { createAgentSessionRuntime } from "./core/agent-session-runtime.js";
 import { createAgentSessionFromServices, createAgentSessionServices, } from "./core/agent-session-services.js";
 import { formatNoModelsAvailableMessage } from "./core/auth-guidance.js";
+import { AuthStorage, ReadOnlyAuthStorage } from "./core/auth-storage.js";
 import { exportFromFile } from "./core/export-html/index.js";
 import { applyHttpProxySettings, configureHttpDispatcher } from "./core/http-dispatcher.js";
 import { resolveCliModel, resolveModelScope } from "./core/model-resolver.js";
 import { ModelRuntime } from "./core/model-runtime.js";
-import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
+import { flushRawStdout, restoreStdout, takeOverStdout, writeRawStdout } from "./core/output-guard.js";
 import { resolveProjectTrusted } from "./core/project-trust.js";
 import { formatMissingSessionCwdPrompt, getMissingSessionCwdIssue, MissingSessionCwdError, } from "./core/session-cwd.js";
 import { assertValidSessionId, SessionManager } from "./core/session-manager.js";
@@ -33,14 +36,15 @@ import { printTimings, resetTimings, time } from "./core/timings.js";
 import { hasTrustRequiringProjectResources, ProjectTrustStore } from "./core/trust-manager.js";
 import { builtInExtensions } from "./extensions/index.js";
 import { getHumainBundledExtensionFactories, getHumainDefaultPackageSources, HUMAIN_FORGE_CWD_ENV, } from "./humain/index.js";
+import { createAdmittedPiAgentExecutionHost } from "./humain/pi-agent-execution-host.js";
 import { runMigrations, showDeprecationWarnings } from "./migrations.js";
-import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.js";
+import { AgentExecInputError, InteractiveMode, runAgentExecMode, runPrintMode, runRpcMode } from "./modes/index.js";
 import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js";
 import { handleConfigCommand, handlePackageCommand } from "./package-manager-cli.js";
 import { isLocalPath, normalizePath, resolvePath } from "./utils/paths.js";
 import { cleanupWindowsSelfUpdateQuarantine } from "./utils/windows-self-update.js";
-const HUMAIN_DEFAULT_CWD_ENV = "HUMAIN_TERMINAL_DEFAULT_CWD";
 const EXTENSION_LOAD_FAILURE_HINT = `Hint: Start without extensions using "${APP_NAME} -ne".`;
+const HUMAIN_DEFAULT_CWD_ENV = "HUMAIN_TERMINAL_DEFAULT_CWD";
 /**
  * Read all content from piped stdin.
  * Returns undefined if stdin is a TTY (interactive terminal).
@@ -84,6 +88,9 @@ function resolveAppMode(parsed, stdinIsTTY, stdoutIsTTY) {
     if (parsed.mode === "rpc") {
         return "rpc";
     }
+    if (parsed.mode === "agent-exec") {
+        return "print";
+    }
     if (parsed.mode === "json") {
         return "json";
     }
@@ -98,17 +105,17 @@ function toPrintOutputMode(appMode) {
 function isPlainRuntimeMetadataCommand(parsed) {
     return !parsed.print && parsed.mode === undefined && (parsed.help === true || parsed.listModels !== undefined);
 }
-async function runCredentialPrintCommand(args) {
-    if (isCredentialPrintHelp(args)) {
-        printCredentialPrintHelp();
+async function runAuthCommand(args) {
+    if (isAuthCommandHelp(args)) {
+        printAuthCommandHelp();
         return true;
     }
     let command;
     try {
-        command = parseCredentialPrintCommand(args);
+        command = parseAuthCommand(args);
     }
     catch (error) {
-        const message = error instanceof CredentialPrintError ? error.message : "Failed to parse auth command";
+        const message = error instanceof AuthCommandError ? error.message : "Failed to parse auth command";
         console.error(chalk.red(`Error: ${message}`));
         process.exitCode = 1;
         return true;
@@ -116,23 +123,57 @@ async function runCredentialPrintCommand(args) {
     if (!command)
         return false;
     const parsed = parseArgs(command.args);
-    if (parsed.diagnostics.length > 0) {
-        for (const diagnostic of parsed.diagnostics) {
-            console.error(chalk.red(`Error: ${diagnostic.message}`));
-        }
+    if (parsed.unknownFlags.size > 0) {
+        const option = parsed.unknownFlags.keys().next().value;
+        console.error(chalk.red(`Unknown option --${option} for "${getAuthCommandName(command.kind)}".`));
+        console.error(chalk.dim(`Use "${APP_NAME} --help" or "${getAuthCommandUsage(command.kind)}".`));
         process.exitCode = 1;
         return true;
     }
     try {
-        validateCredentialPrintArgs(parsed);
-        const modelRuntime = await ModelRuntime.create({ allowModelNetwork: false });
-        const credential = await resolveCredentialForPrint(parsed, modelRuntime, command.kind, command.minExpiryMs);
-        process.stdout.write(`${credential}\n`);
+        if (parsed.diagnostics.length > 0) {
+            throw new AuthCommandError(parsed.diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+        }
+        if (command.kind !== "check") {
+            const signal = AbortSignal.timeout(15_000);
+            const modelRuntime = await ModelRuntime.create({ allowModelNetwork: false, signal });
+            const credential = await resolveCredentialForPrint(parsed, modelRuntime, command.kind, command.minExpiryMs, signal);
+            process.stdout.write(`${credential}\n`);
+            return true;
+        }
+        const requestedAuth = validateAuthCommandArgs(parsed, command.kind);
+        let result;
+        let credential;
+        try {
+            const credentials = command.noRefresh ? new ReadOnlyAuthStorage() : AuthStorage.create();
+            const modelRuntime = await createAuthCheckModelRuntime(credentials);
+            result = await checkProviderAuth(parsed, modelRuntime, { refresh: !command.noRefresh });
+            if (command.credentials && result.status === "ready") {
+                credential = await getProviderCredential(result.provider, modelRuntime, credentials, {
+                    refresh: !command.noRefresh,
+                });
+                if (!credential) {
+                    result = { status: "not_ready", provider: result.provider, reason: "credential_not_available" };
+                }
+            }
+        }
+        catch {
+            result = {
+                status: "invalid",
+                provider: requestedAuth.provider ?? requestedAuth.model,
+                reason: "invalid_state",
+            };
+        }
+        const output = command.json
+            ? JSON.stringify({ ...result, ...(credential ? { credentials: credential } : {}) })
+            : (credential ?? result.status);
+        process.stdout.write(`${output}\n`);
+        process.exitCode = result.status === "ready" ? 0 : result.status === "not_ready" ? 1 : 2;
     }
     catch (error) {
-        const message = error instanceof CredentialPrintError ? error.message : "Failed to resolve credential";
+        const message = error instanceof AuthCommandError ? error.message : "Failed to resolve credential";
         console.error(chalk.red(`Error: ${message}`));
-        process.exitCode = 1;
+        process.exitCode = command.kind === "check" ? 2 : 1;
     }
     return true;
 }
@@ -397,77 +438,40 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRunt
 function resolveCliPaths(cwd, paths) {
     return paths?.map((value) => (isLocalPath(value) ? resolvePath(value, cwd) : value));
 }
+async function promptForMissingSessionCwd(issue, settingsManager) {
+    return showStartupSelector(settingsManager, formatMissingSessionCwdPrompt(issue), [
+        { label: "Continue", value: issue.fallbackCwd },
+        { label: "Cancel", value: undefined },
+    ]);
+}
 export function stripStartupCwdArgs(args) {
-    const stripped = [];
-    for (let index = 0; index < args.length; index++) {
-        const arg = args[index];
-        if (arg === "--cwd") {
-            index++;
-            continue;
-        }
-        if (arg.startsWith("--cwd=")) {
-            continue;
-        }
-        stripped.push(arg);
-    }
-    return stripped;
+    return args.filter((arg, index) => arg !== "--cwd" && args[index - 1] !== "--cwd" && !arg.startsWith("--cwd="));
 }
 export function resolveStartupCwd(parsed, env, currentCwd) {
-    const rawCwd = parsed.cwd || env[HUMAIN_DEFAULT_CWD_ENV] || env[HUMAIN_FORGE_CWD_ENV];
-    if (!rawCwd) {
+    const rawCwd = parsed.cwd ?? env[HUMAIN_DEFAULT_CWD_ENV] ?? env[HUMAIN_FORGE_CWD_ENV];
+    if (!rawCwd)
         return currentCwd;
-    }
     const resolvedCwd = isLocalPath(rawCwd) ? resolvePath(rawCwd, currentCwd) : normalizePath(rawCwd);
-    let stat;
-    try {
-        stat = statSync(resolvedCwd);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Invalid --cwd "${rawCwd}": ${message}`);
-    }
-    if (!stat.isDirectory()) {
+    if (!statSync(resolvedCwd).isDirectory())
         throw new Error(`Invalid --cwd "${rawCwd}": not a directory`);
-    }
     return resolvedCwd;
 }
-async function promptForMissingSessionCwd(issue, settingsManager) {
-    return showStartupSelector(settingsManager, formatMissingSessionCwdPrompt(issue), [
-        { label: "Continue", value: issue.fallbackCwd },
-        { label: "Cancel", value: undefined },
-    ]);
-}
-function isPackageOrConfigCommand(args) {
-    switch (args[0]) {
-        case "config":
-        case "install":
-        case "list":
-        case "remove":
-        case "uninstall":
-        case "update":
-            return true;
-        default:
-            return false;
-    }
-}
 export async function main(args, options) {
     resetTimings();
-    const commandArgs = stripStartupCwdArgs(args);
     const parsed = parseArgs(args);
-    if (!isPackageOrConfigCommand(commandArgs) && parsed.diagnostics.length > 0) {
-        for (const d of parsed.diagnostics) {
-            const color = d.type === "error" ? chalk.red : chalk.yellow;
-            console.error(color(`${d.type === "error" ? "Error" : "Warning"}: ${d.message}`));
-        }
-        if (parsed.diagnostics.some((d) => d.type === "error")) {
-            process.exit(1);
-        }
-    }
-    time("parseArgs");
-    const offlineMode = parsed.offline || isTruthyEnvFlag(process.env[ENV_OFFLINE]);
+    const commandArgs = stripStartupCwdArgs(args);
+    const extensionFactories = [
+        ...builtInExtensions,
+        ...getHumainBundledExtensionFactories(process.env),
+        ...(options?.extensionFactories ?? []),
+    ];
+    const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
     if (offlineMode) {
-        process.env[ENV_OFFLINE] = "1";
-        process.env[ENV_SKIP_VERSION_CHECK] = "1";
+        process.env.PI_OFFLINE = "1";
+        process.env.PI_SKIP_VERSION_CHECK = "1";
+    }
+    if (await runAuthCommand(commandArgs)) {
+        return;
     }
     if (process.platform === "win32") {
         cleanupWindowsSelfUpdateQuarantine(getPackageDir());
@@ -477,30 +481,22 @@ export async function main(args, options) {
         cwd = resolveStartupCwd(parsed, process.env, process.cwd());
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red(`Error: ${message}`));
+        console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
         process.exit(1);
         return;
     }
-    if (cwd !== process.cwd()) {
+    if (cwd !== process.cwd())
         process.chdir(cwd);
-    }
-    const extensionFactories = [
-        ...builtInExtensions,
-        ...getHumainBundledExtensionFactories(process.env),
-        ...(options?.extensionFactories ?? []),
-    ];
-    const defaultPackageSources = getHumainDefaultPackageSources();
     const agentDir = getAgentDir();
     const bootstrapSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
     applyHttpProxySettings(bootstrapSettingsManager.getGlobalSettings().httpProxy);
     configureHttpDispatcher();
     if (await handlePackageCommand(commandArgs, { extensionFactories })) {
         const exitCode = process.exitCode ?? 0;
-        if (process.platform === "win32" && exitCode === 0 && commandArgs[0] === "update") {
+        if (process.platform === "win32" && exitCode === 0 && args[0] === "update") {
             // We normally prefer process.exit(0) for package commands so bad extensions cannot keep
             // one-shot commands alive. On Windows, Node can assert after fetch() if process.exit(0)
-            // runs during teardown; let successful self-updates drain naturally instead.
+            // runs during teardown; let successful `pi update` drain naturally instead.
             // https://github.com/nodejs/node/issues/56645
             return;
         }
@@ -510,9 +506,16 @@ export async function main(args, options) {
     if (await handleConfigCommand(commandArgs, { extensionFactories })) {
         return;
     }
-    if (await runCredentialPrintCommand(commandArgs)) {
-        return;
+    if (parsed.diagnostics.length > 0) {
+        for (const d of parsed.diagnostics) {
+            const color = d.type === "error" ? chalk.red : chalk.yellow;
+            console.error(color(`${d.type === "error" ? "Error" : "Warning"}: ${d.message}`));
+        }
+        if (parsed.diagnostics.some((d) => d.type === "error")) {
+            process.exit(1);
+        }
     }
+    time("parseArgs");
     if (parsed.version) {
         console.log(VERSION);
         process.exit(0);
@@ -532,6 +535,7 @@ export async function main(args, options) {
         process.exit(0);
     }
     let appMode = resolveAppMode(parsed, process.stdin.isTTY, process.stdout.isTTY);
+    const isAgentExecMode = parsed.mode === "agent-exec";
     const shouldTakeOverStdout = appMode !== "interactive" && !isPlainRuntimeMetadataCommand(parsed);
     if (shouldTakeOverStdout) {
         takeOverStdout();
@@ -540,12 +544,16 @@ export async function main(args, options) {
         console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
         process.exit(1);
     }
+    if (isAgentExecMode && (parsed.fileArgs.length > 0 || parsed.messages.length > 0)) {
+        console.error(chalk.red("Error: agent-exec accepts its request only from stdin"));
+        process.exit(1);
+    }
     validateForkFlags(parsed);
     validateSessionIdFlags(parsed);
     // Run migrations (pass cwd for project-local migrations)
     const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(cwd);
     time("runMigrations");
-    const startupSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
+    const startupSettingsManager = SettingsManager.create(cwd, agentDir);
     reportDiagnostics(collectSettingsDiagnostics(startupSettingsManager, "startup session lookup"));
     // Experimental first-time setup: theme choice and analytics opt-in.
     // Runs before any runtime services are created so the chosen settings apply everywhere.
@@ -613,6 +621,7 @@ export async function main(args, options) {
             cwd,
             agentDir,
             settingsManager: runtimeSettingsManager,
+            modelRuntimeSignal: AbortSignal.timeout(15_000),
             extensionFlagValues: parsed.unknownFlags,
             resourceLoaderReloadOptions: shouldResolveProjectTrust
                 ? {
@@ -650,7 +659,7 @@ export async function main(args, options) {
                 systemPrompt: parsed.systemPrompt,
                 appendSystemPrompt: parsed.appendSystemPrompt,
                 extensionFactories,
-                defaultPackageSources,
+                defaultPackageSources: getHumainDefaultPackageSources(),
             },
         });
         const { settingsManager, modelRuntime, resourceLoader } = services;
@@ -664,7 +673,9 @@ export async function main(args, options) {
             })),
         ];
         const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
-        const scopedModels = modelPatterns && modelPatterns.length > 0 ? await resolveModelScope(modelPatterns, modelRuntime) : [];
+        const scopedModels = modelPatterns && modelPatterns.length > 0
+            ? await resolveModelScope(modelPatterns, modelRuntime, { signal: AbortSignal.timeout(15_000) })
+            : [];
         const { options: sessionOptions, cliThinkingFromModel, diagnostics: sessionOptionDiagnostics, } = buildSessionOptions(parsed, scopedModels, sessionManager.buildSessionContext().messages.length > 0, modelRuntime, settingsManager);
         diagnostics.push(...sessionOptionDiagnostics);
         if (parsed.apiKey) {
@@ -675,8 +686,7 @@ export async function main(args, options) {
                 });
             }
             else {
-                await modelRuntime.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey, { allowNetwork: false });
-                await services.modelRuntime.getAvailable();
+                await modelRuntime.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
             }
         }
         const created = await createAgentSessionFromServices({
@@ -721,9 +731,60 @@ export async function main(args, options) {
     }
     if (parsed.listModels !== undefined) {
         const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
-        await listModels(modelRuntime, searchPattern);
+        await listModels(modelRuntime, searchPattern, AbortSignal.timeout(15_000));
         process.exit(0);
     }
+    if (isAgentExecMode) {
+        reportDiagnostics(runtime.diagnostics);
+        if (runtime.diagnostics.some((diagnostic) => diagnostic.type === "error")) {
+            if (runtime.diagnostics.some((diagnostic) => diagnostic.message.includes("Failed to load extension"))) {
+                console.error(chalk.yellow(EXTENSION_LOAD_FAILURE_HINT));
+            }
+            await runtime.dispose();
+            restoreStdout();
+            process.exit(1);
+        }
+        const controller = new AbortController();
+        const onSigterm = () => controller.abort();
+        process.on("SIGTERM", onSigterm);
+        let exitCode = 0;
+        try {
+            const host = createAdmittedPiAgentExecutionHost({
+                cwd: runtime.cwd,
+                agentDir: services.agentDir,
+                model: session.model,
+                thinkingLevel: session.thinkingLevel,
+                baseSessionOptions: { modelRuntime, resourceLoader, settingsManager },
+            });
+            await runAgentExecMode({
+                input: process.stdin,
+                host,
+                signal: controller.signal,
+                writeLine: async (line) => {
+                    writeRawStdout(`${line}\n`);
+                    await flushRawStdout();
+                },
+            });
+        }
+        catch (error) {
+            exitCode = controller.signal.aborted ? 143 : 1;
+            const message = error instanceof AgentExecInputError
+                ? error.message
+                : error instanceof Error
+                    ? error.message
+                    : "agent-exec failed";
+            console.error(chalk.red(`Error: ${message}`));
+        }
+        finally {
+            process.off("SIGTERM", onSigterm);
+            await runtime.dispose();
+            await flushRawStdout();
+            restoreStdout();
+        }
+        if (exitCode !== 0)
+            process.exitCode = exitCode;
+        return;
+    }
     // Read piped stdin content (if any) - skip for RPC mode which uses stdin for JSON-RPC
     let stdinContent;
     if (appMode !== "rpc") {
@@ -754,14 +815,19 @@ export async function main(args, options) {
         console.error(chalk.red(formatNoModelsAvailableMessage()));
         process.exit(1);
     }
-    const startupBenchmark = isTruthyEnvFlag(process.env[ENV_STARTUP_BENCHMARK]);
+    const startupBenchmark = isTruthyEnvFlag(process.env.PI_STARTUP_BENCHMARK);
     if (startupBenchmark && appMode !== "interactive") {
-        console.error(chalk.red(`Error: ${ENV_STARTUP_BENCHMARK} only supports interactive mode`));
+        console.error(chalk.red("Error: PI_STARTUP_BENCHMARK only supports interactive mode"));
         process.exit(1);
     }
     // RPC refreshes catalogs here in the background; interactive mode starts its refresh after TUI initialization.
     if (!offlineMode && appMode === "rpc") {
-        void modelRuntime.refresh().catch(() => { });
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15_000);
+        void modelRuntime
+            .refresh({ signal: controller.signal })
+            .catch(() => { })
+            .finally(() => clearTimeout(timeout));
     }
     if (appMode === "rpc") {
         printTimings();
@@ -776,6 +842,7 @@ export async function main(args, options) {
             initialImages,
             initialMessages: parsed.messages,
             verbose: parsed.verbose,
+            tuiMode: parsed.tuiMode,
         });
         if (startupBenchmark) {
             await interactiveMode.init();