@lesliechan721/aw 0.1.0-beta.10

package/dist/src/commands/runtime.js

@@ -0,0 +1,720 @@
+import os from 'node:os';
+import path from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { Writable } from 'node:stream';
+import { createFileDebugLogger } from '../output/debug-log.js';
+import { createIoReporter, createNoopReporter, } from '../output/reporter.js';
+import { NativeCliError, getDefaultNativeCliRunner } from '../utils/native-cli.js';
+import { resolveAwHome } from '../utils/paths.js';
+import { assertTestWritablePath } from '../utils/test-path-fence.js';
+import { createInkPrompt } from '../tui/prompt.js';
+import { createInkTuiRunner } from '../tui/runner.js';
+const reporterRoutes = new WeakMap();
+function createSessionAwareReporter(defaultReporter) {
+    const route = { current: defaultReporter };
+    const reporter = {
+        event: (event) => route.current.event(event),
+        notice: (notice) => route.current.notice(notice),
+    };
+    reporterRoutes.set(reporter, route);
+    return reporter;
+}
+export async function withCommandReporterSession(reporter, sessionReporter, task) {
+    const route = reporterRoutes.get(reporter);
+    if (!route)
+        return task();
+    const previous = route.current;
+    route.current = sessionReporter;
+    try {
+        return await task();
+    }
+    finally {
+        route.current = previous;
+    }
+}
+function createDefaultIo() {
+    return {
+        stdout: (text) => process.stdout.write(text),
+        stderr: (text) => process.stderr.write(text),
+    };
+}
+function isTruthy(value) {
+    return value === '1' || value === 'true' || value === 'yes';
+}
+function createRunId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createTimestampForPath() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}
+function assertDebugLogPathForTests(logFile, source, commandName) {
+    return assertTestWritablePath(logFile, source === 'explicit'
+        ? '--log-file'
+        : commandName === 'status'
+            ? 'AW_DEBUG default status log file'
+            : 'AW_DEBUG default log file', source === 'explicit'
+        ? '用 createIsolatedTestEnv() 提供安全 cwd/TMPDIR/AW_HOME，或通过 registerWritableStateRoot() 登记 --log-file 目标路径。'
+        : '用 createIsolatedTestEnv() 生成默认 TMPDIR/AW_HOME，或通过 registerWritableStateRoot() 登记调试日志目录。');
+}
+function defaultLogFile(commandName, env) {
+    const fileName = `aw-${createTimestampForPath()}-${commandName}.log`;
+    if (commandName === 'status') {
+        return assertDebugLogPathForTests(path.join(os.tmpdir(), 'agent-workflows', fileName), 'default', commandName);
+    }
+    return assertDebugLogPathForTests(path.join(resolveAwHome(env), 'logs', fileName), 'default', commandName);
+}
+export function createCommandDiagnostics(input = {}, env = process.env) {
+    const commandName = input.commandName ?? 'command';
+    const envDebug = isTruthy(env.AW_DEBUG);
+    const debug = input.debug === true || envDebug;
+    const hasLogFile = Boolean(input.logFile || debug);
+    return {
+        verbose: input.verbose === true || debug,
+        debug,
+        commandName,
+        runId: input.runId ?? createRunId(),
+        metadata: input.metadata,
+        ...(hasLogFile
+            ? {
+                logFile: input.logFile
+                    ? assertDebugLogPathForTests(input.logFile, 'explicit', commandName)
+                    : defaultLogFile(commandName, env),
+                logFileSource: input.logFile ? input.logFileSource ?? 'explicit' : 'default',
+            }
+            : {}),
+    };
+}
+export function validateCliConfigPromptResult(options, result) {
+    if (!options.allowedScopes.includes(result.selectedScope)) {
+        throw new Error(`Unsupported config scope "${result.selectedScope}". Expected one of: ${options.allowedScopes.join(', ')}.`);
+    }
+    const schemaKeys = new Set(Object.keys(options.schema));
+    const updateKeys = Object.keys(result.updates);
+    const removeKeys = result.removeKeys ?? [];
+    for (const key of [...result.updatedKeys, ...updateKeys, ...removeKeys]) {
+        if (!schemaKeys.has(key)) {
+            throw new Error(`Unsupported config key "${key}".`);
+        }
+    }
+    const updatedKeySet = new Set(result.updatedKeys);
+    for (const key of updateKeys) {
+        if (!updatedKeySet.has(key)) {
+            throw new Error(`Config prompt result update "${key}" is missing from updatedKeys.`);
+        }
+    }
+    for (const key of result.updatedKeys) {
+        if (!Object.hasOwn(result.updates, key)) {
+            throw new Error(`Config prompt result updatedKeys contains "${key}" without an update value.`);
+        }
+    }
+    for (const key of removeKeys) {
+        if (Object.hasOwn(result.updates, key)) {
+            throw new Error(`Config prompt result cannot update and remove "${key}" in the same submission.`);
+        }
+    }
+    return result;
+}
+function createUnavailablePrompt() {
+    const unavailable = async () => {
+        throw new Error('Interactive prompt is not available in this runtime.');
+    };
+    return {
+        select: unavailable,
+        multiSelect: unavailable,
+        confirm: unavailable,
+        input: unavailable,
+        password: unavailable,
+        selectPlatform: unavailable,
+        selectScope: unavailable,
+        selectPlugins: unavailable,
+        configurePlugin: unavailable,
+    };
+}
+function formatChoice(choice, index, defaultValues) {
+    const marker = defaultValues.has(choice.value) ? ' (默认)' : '';
+    const disabled = choice.disabled
+        ? ` - ${typeof choice.disabled === 'string' ? choice.disabled : '不可选'}`
+        : '';
+    return `${index + 1}. ${choice.label}${marker}${disabled}`;
+}
+function parseSelectionInput(answer, choices, defaults, allowMultiple) {
+    const trimmed = answer.trim();
+    if (!trimmed) {
+        return defaults;
+    }
+    const tokens = allowMultiple
+        ? trimmed.split(',').map((entry) => entry.trim()).filter(Boolean)
+        : [trimmed];
+    const selected = [];
+    for (const token of tokens) {
+        const numericIndex = Number(token);
+        const choice = Number.isInteger(numericIndex)
+            ? choices[numericIndex - 1]
+            : choices.find((entry) => entry.value === token);
+        if (!choice) {
+            throw new Error(`无效选择：${token}`);
+        }
+        if (choice.disabled) {
+            throw new Error(`不可选择 ${choice.label}：${typeof choice.disabled === 'string' ? choice.disabled : '已禁用'}`);
+        }
+        selected.push(choice.value);
+    }
+    return [...new Set(selected)];
+}
+function createPromptWritable(outputSink) {
+    const writable = new Writable({
+        write(chunk, _encoding, callback) {
+            outputSink.write(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+            callback();
+        },
+    });
+    writable.isTTY = outputSink.isTTY;
+    return writable;
+}
+function createPromptResult(value) {
+    return {
+        action: 'select',
+        cancelled: false,
+        value,
+    };
+}
+function createPromptActionResult(action) {
+    return {
+        action,
+        cancelled: action === 'cancel',
+    };
+}
+function unwrapPromptResult(result, message = 'Interactive prompt cancelled.') {
+    if (result.action !== 'select' || result.value === undefined) {
+        throw new Error(message);
+    }
+    return result.value;
+}
+function shouldPromptConfigKey(key, definition, options) {
+    const currentValue = options.currentValues?.[key];
+    const configured = currentValue !== undefined || options.configuredKeys?.includes(key) === true;
+    return Boolean(definition.required ||
+        options.requiredKeys?.includes(key) ||
+        !configured);
+}
+function formatConfigKeyChoiceLabel(key, definition, options) {
+    const label = definition.label ?? key;
+    const currentValue = options.currentValues?.[key];
+    const configured = currentValue !== undefined || options.configuredKeys?.includes(key) === true;
+    if (!configured) {
+        return label;
+    }
+    if (definition.sensitive) {
+        return `${label}（当前：已配置）`;
+    }
+    return `${label}（当前：${String(currentValue)}）`;
+}
+function parsePromptedConfigValue(key, definition, answer) {
+    const trimmed = answer.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (definition.type === 'number') {
+        const parsed = Number(trimmed);
+        if (!Number.isFinite(parsed)) {
+            throw new Error(`配置项 ${key} 需要数字。`);
+        }
+        return parsed;
+    }
+    if (definition.type === 'boolean') {
+        const normalized = trimmed.toLowerCase();
+        if (['true', '1', 'yes', 'y'].includes(normalized)) {
+            return true;
+        }
+        if (['false', '0', 'no', 'n'].includes(normalized)) {
+            return false;
+        }
+        throw new Error(`配置项 ${key} 需要布尔值。`);
+    }
+    return answer;
+}
+function normalizePromptInput(value) {
+    return value.trim();
+}
+function resolveTypedPromptAction(answer, options = {}) {
+    const mode = options.mode ?? 'text';
+    const normalized = normalizePromptInput(answer);
+    if (normalized === '\u0003') {
+        return 'exit';
+    }
+    if (normalized === '\u001B') {
+        if (mode === 'menu') {
+            return options.allowBack ? 'back' : 'exit';
+        }
+        return 'cancel';
+    }
+    if (mode !== 'menu') {
+        return null;
+    }
+    if (options.allowBack && ['b', 'B'].includes(normalized)) {
+        return 'back';
+    }
+    if ((options.allowExit ?? true) && ['q', 'Q'].includes(normalized)) {
+        return 'exit';
+    }
+    return null;
+}
+function resolveChoiceResult(value, choices) {
+    const choice = choices.find((entry) => entry.value === value);
+    if (choice?.role === 'back') {
+        return createPromptActionResult('back');
+    }
+    if (choice?.role === 'exit') {
+        return createPromptActionResult('exit');
+    }
+    return createPromptResult(value);
+}
+function createMutedOutput(outputSink) {
+    const mutedOutput = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        },
+    });
+    mutedOutput.isTTY = outputSink.isTTY;
+    return mutedOutput;
+}
+export function createReadlinePrompt(options = {}) {
+    const input = options.input ?? process.stdin;
+    const outputSink = options.outputSink ?? process.stderr;
+    const output = createPromptWritable(outputSink);
+    async function ask(message, askOptions = {}) {
+        const hidden = askOptions.hidden === true;
+        if (hidden) {
+            outputSink.write(message);
+        }
+        const rl = createInterface({
+            input,
+            output: hidden ? createMutedOutput(outputSink) : output,
+            terminal: Boolean(input.isTTY && outputSink.isTTY),
+        });
+        const promptText = hidden ? '' : message;
+        try {
+            const result = await new Promise((resolve, reject) => {
+                const handleSigint = () => {
+                    resolve(createPromptActionResult('exit'));
+                };
+                rl.once('SIGINT', handleSigint);
+                rl.question(promptText)
+                    .then((answer) => {
+                    const action = resolveTypedPromptAction(answer, askOptions);
+                    resolve(action ? createPromptActionResult(action) : createPromptResult(answer));
+                })
+                    .catch(reject)
+                    .finally(() => {
+                    rl.off('SIGINT', handleSigint);
+                });
+            });
+            if (hidden) {
+                outputSink.write('\n');
+            }
+            return result;
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const select = async ({ message, choices, defaultValue }) => {
+        const enabledChoices = choices.filter((choice) => !choice.disabled);
+        if (enabledChoices.length === 0) {
+            throw new Error('没有可选择的候选项。');
+        }
+        const defaultValues = [defaultValue ?? enabledChoices[0].value];
+        const body = choices
+            .map((choice, index) => formatChoice(choice, index, new Set(defaultValues)))
+            .join('\n');
+        const answer = await ask(`${message}\n${body}\n选择编号：`, {
+            mode: 'menu',
+            allowBack: choices.some((choice) => choice.role === 'back'),
+            allowExit: true,
+        });
+        if (answer.action !== 'select') {
+            return answer;
+        }
+        const selected = parseSelectionInput(answer.value, choices, defaultValues, false);
+        return resolveChoiceResult(selected[0], choices);
+    };
+    const multiSelect = async ({ message, choices, defaultValues, }) => {
+        const enabledChoices = choices.filter((choice) => !choice.disabled);
+        if (enabledChoices.length === 0) {
+            throw new Error('没有可选择的候选项。');
+        }
+        const defaults = defaultValues && defaultValues.length > 0
+            ? defaultValues
+            : [enabledChoices[0].value];
+        const body = choices
+            .map((choice, index) => formatChoice(choice, index, new Set(defaults)))
+            .join('\n');
+        const answer = await ask(`${message}\n${body}\n选择编号，可用逗号分隔多个：`, {
+            mode: 'menu',
+            allowBack: choices.some((choice) => choice.role === 'back'),
+            allowExit: true,
+        });
+        if (answer.action !== 'select') {
+            return createPromptActionResult(answer.action);
+        }
+        return createPromptResult(parseSelectionInput(answer.value, choices, defaults, true));
+    };
+    const confirm = async ({ message, defaultValue = true }) => {
+        const suffix = defaultValue ? 'Y/n' : 'y/N';
+        const answer = await ask(`${message} [${suffix}] `, { mode: 'confirm' });
+        if (answer.action !== 'select') {
+            return createPromptActionResult(answer.action);
+        }
+        const normalized = answer.value.trim().toLowerCase();
+        if (!normalized) {
+            return createPromptResult(defaultValue);
+        }
+        return createPromptResult(normalized === 'y' || normalized === 'yes');
+    };
+    const inputPrompt = async ({ message, defaultValue }) => {
+        const answer = await ask(defaultValue === undefined
+            ? `${message}: `
+            : `${message}（默认：${defaultValue}）: `, { mode: 'text' });
+        if (answer.action !== 'select') {
+            return answer;
+        }
+        return createPromptResult(answer.value.trim() === '' && defaultValue !== undefined ? defaultValue : answer.value);
+    };
+    const passwordPrompt = async ({ message }) => {
+        const answer = await ask(`${message}: `, { hidden: true, mode: 'text' });
+        if (answer.action !== 'select') {
+            return answer;
+        }
+        return createPromptResult(answer.value);
+    };
+    return {
+        select,
+        multiSelect,
+        confirm,
+        input: inputPrompt,
+        password: passwordPrompt,
+        selectPlatform: async ({ available, defaultValue, message }) => unwrapPromptResult(await select({
+            message: message ?? '选择目标平台',
+            choices: available.map((value) => ({
+                value,
+                label: value === 'both' ? '全部支持平台' : value === 'codex' ? 'Codex' : 'Claude Code',
+            })),
+            defaultValue,
+        })),
+        selectScope: async ({ defaultValue = 'user' }) => unwrapPromptResult(await select({
+            message: '选择安装范围',
+            choices: [
+                { value: 'user', label: 'user' },
+                { value: 'project', label: 'project' },
+            ],
+            defaultValue,
+        })),
+        selectPlugins: async ({ command, candidates, defaultValues, allowMultiple }) => {
+            const choices = candidates.map((candidate) => ({
+                value: candidate.id,
+                label: `${candidate.pluginName}${candidate.platform ? ` / ${candidate.platform}` : ''}${candidate.scope ? ` / ${candidate.scope}` : ''}`,
+                disabled: candidate.selectable ? undefined : candidate.disabledReason ?? true,
+            }));
+            return allowMultiple
+                ? unwrapPromptResult(await multiSelect({
+                    message: `选择要${command === 'install' ? '安装' : '卸载'}的插件`,
+                    choices,
+                    defaultValues,
+                }))
+                : [unwrapPromptResult(await select({
+                        message: `选择要${command === 'install' ? '安装' : '卸载'}的插件`,
+                        choices,
+                        defaultValue: defaultValues?.[0],
+                    }))];
+        },
+        configurePlugin: async (configOptions) => {
+            const selectedScope = configOptions.allowedScopes.length > 1
+                ? unwrapPromptResult(await select({
+                    message: `选择 ${configOptions.pluginName} 配置写入范围`,
+                    choices: configOptions.allowedScopes.map((value) => ({ value, label: value })),
+                    defaultValue: configOptions.initialScope,
+                }))
+                : configOptions.initialScope;
+            const updates = {};
+            const removeKeys = [];
+            const keysToPrompt = new Set();
+            const optionalConfiguredChoices = [];
+            for (const [key, definition] of Object.entries(configOptions.schema)) {
+                if (shouldPromptConfigKey(key, definition, configOptions)) {
+                    keysToPrompt.add(key);
+                    continue;
+                }
+                optionalConfiguredChoices.push({
+                    value: key,
+                    label: formatConfigKeyChoiceLabel(key, definition, configOptions),
+                });
+            }
+            if (optionalConfiguredChoices.length > 0) {
+                const body = optionalConfiguredChoices
+                    .map((choice, index) => formatChoice(choice, index, new Set()))
+                    .join('\n');
+                const selectedKeysAnswer = await ask(`选择要更新的 ${configOptions.pluginName} 配置项\n${body}\n选择编号，可用逗号分隔多个，直接回车跳过：`, { mode: 'menu', allowExit: true });
+                if (selectedKeysAnswer.action !== 'select') {
+                    return {
+                        selectedScope,
+                        updates: {},
+                        updatedKeys: [],
+                        removeKeys: [],
+                        cancelled: true,
+                    };
+                }
+                const selectedKeys = parseSelectionInput(selectedKeysAnswer.value, optionalConfiguredChoices, [], true);
+                for (const key of selectedKeys) {
+                    keysToPrompt.add(key);
+                }
+            }
+            for (const [key, definition] of Object.entries(configOptions.schema)) {
+                if (!keysToPrompt.has(key)) {
+                    continue;
+                }
+                const label = definition.label ?? key;
+                if (definition.enum && definition.enum.length > 0) {
+                    const selected = unwrapPromptResult(await select({
+                        message: label,
+                        choices: definition.enum.map((value) => ({
+                            value: String(value),
+                            label: String(value),
+                        })),
+                        defaultValue: configOptions.currentValues?.[key] === undefined
+                            ? undefined
+                            : String(configOptions.currentValues[key]),
+                    }));
+                    updates[key] = definition.enum.find((value) => String(value) === selected);
+                    continue;
+                }
+                if (definition.type === 'boolean') {
+                    updates[key] = await (async () => {
+                        const current = configOptions.currentValues?.[key];
+                        return unwrapPromptResult(current === undefined
+                            ? await confirm({ message: label, defaultValue: Boolean(definition.default) })
+                            : await confirm({ message: label, defaultValue: Boolean(current) }));
+                    })();
+                    continue;
+                }
+                const current = configOptions.currentValues?.[key];
+                const configured = current !== undefined || configOptions.configuredKeys?.includes(key) === true;
+                const suffix = !configured || definition.sensitive
+                    ? definition.sensitive && configured
+                        ? '（当前：已配置）'
+                        : ''
+                    : `（当前：${String(current)}）`;
+                const answer = await ask(`${label}${suffix}: `, {
+                    hidden: definition.sensitive && definition.type === 'string',
+                    mode: 'text',
+                });
+                if (answer.action !== 'select') {
+                    return {
+                        selectedScope,
+                        updates,
+                        updatedKeys: Object.keys(updates),
+                        removeKeys,
+                        cancelled: true,
+                    };
+                }
+                const parsed = parsePromptedConfigValue(key, definition, answer.value);
+                if (parsed !== undefined) {
+                    updates[key] = parsed;
+                }
+                else if (!definition.required && configured) {
+                    removeKeys.push(key);
+                }
+            }
+            const result = {
+                selectedScope,
+                updates,
+                updatedKeys: Object.keys(updates),
+                removeKeys,
+                cancelled: false,
+            };
+            return validateCliConfigPromptResult(configOptions, result);
+        },
+    };
+}
+function nativeEventIdentity(invocation) {
+    const executable = path.basename(invocation.command).toLowerCase().replace(/\.exe$/u, '');
+    const agent = executable === 'codex' || executable === 'claude' || executable === 'skills'
+        ? executable
+        : 'unknown';
+    const args = new Set(invocation.args.map((arg) => arg.toLowerCase()));
+    const operation = args.has('--version') || args.has('version')
+        ? 'version'
+        : args.has('marketplace') ? 'marketplace'
+            : args.has('plugin') || args.has('plugins') ? 'plugin'
+                : agent === 'skills' ? 'skill'
+                    : 'other';
+    return { agent, operation };
+}
+function serializeNativeError(error) {
+    if (error instanceof NativeCliError) {
+        return {
+            exitCode: error.exitCode,
+            reason: error.reason,
+        };
+    }
+    return { reason: 'runnerFailure' };
+}
+function createInstrumentedNativeCliRunner(options) {
+    return async (invocation) => {
+        const startedAt = Date.now();
+        const identity = nativeEventIdentity(invocation);
+        await emitRuntimeEvent(options, {
+            type: 'native:start',
+            commandName: options.diagnostics.commandName,
+            data: identity,
+        });
+        try {
+            const result = await options.baseRunner(invocation);
+            await emitRuntimeEvent(options, {
+                type: 'native:success',
+                commandName: options.diagnostics.commandName,
+                data: {
+                    ...identity,
+                    exitCode: result.exitCode,
+                    durationMs: Date.now() - startedAt,
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            await emitRuntimeEvent(options, {
+                type: 'native:error',
+                commandName: options.diagnostics.commandName,
+                data: {
+                    ...identity,
+                    ...serializeNativeError(error),
+                    durationMs: Date.now() - startedAt,
+                },
+            });
+            throw error;
+        }
+    };
+}
+async function emitRuntimeEvent(runtime, event) {
+    await Promise.allSettled([
+        Promise.resolve().then(() => runtime.reporter.event(event)),
+        Promise.resolve().then(() => runtime.debugLogger.log(event)),
+    ]);
+}
+export async function emitCommandEvent(context, event) {
+    await emitRuntimeEvent(context, {
+        commandName: context.diagnostics.commandName,
+        ...event,
+    });
+}
+export async function emitCommandNotice(context, notice) {
+    await Promise.allSettled([
+        Promise.resolve().then(() => context.reporter.notice(notice)),
+        Promise.resolve().then(() => context.debugLogger.log({
+            type: `notice:${notice.level}`,
+            commandName: context.diagnostics.commandName,
+            message: notice.message,
+            data: notice.identity ? { identity: notice.identity } : undefined,
+        })),
+    ]);
+}
+export function isCommandExecutionContext(input) {
+    return Boolean(input &&
+        typeof input.env === 'object' &&
+        typeof input.nativeCliRunner === 'function' &&
+        typeof input.reporter?.event === 'function' &&
+        typeof input.debugLogger?.log === 'function' &&
+        typeof input.diagnostics?.commandName === 'string');
+}
+export function createCommandExecutionContext(input = {}) {
+    if (isCommandExecutionContext(input)) {
+        return input;
+    }
+    const env = input.env ?? process.env;
+    const diagnostics = createCommandDiagnostics(input.diagnostics, env);
+    const reporter = input.reporter ?? createNoopReporter();
+    const debugLogger = input.debugLogger ?? createFileDebugLogger(diagnostics);
+    const baseRunner = input.nativeCliRunner ?? getDefaultNativeCliRunner();
+    const contextShell = {
+        reporter,
+        debugLogger,
+    };
+    return {
+        env,
+        nativeCliRunner: createInstrumentedNativeCliRunner({
+            baseRunner,
+            diagnostics,
+            ...contextShell,
+        }),
+        interactive: input.interactive ?? false,
+        prompt: input.prompt ?? createUnavailablePrompt(),
+        reporter,
+        debugLogger,
+        diagnostics,
+    };
+}
+export function createCliExecutionContext(input = {}) {
+    const cwd = input.cwd ?? process.cwd();
+    const env = input.env ?? process.env;
+    const io = {
+        ...createDefaultIo(),
+        ...input.io,
+    };
+    const stdin = input.stdin ?? process.stdin;
+    const stdout = input.stdout ?? process.stdout;
+    const promptOutputSink = input.promptOutputSink ?? process.stderr;
+    const stdinIsTty = Boolean(stdin.isTTY);
+    const stdoutIsTty = Boolean(stdout.isTTY);
+    const promptOutputIsTty = Boolean(promptOutputSink.isTTY);
+    const isTty = stdinIsTty && stdoutIsTty && promptOutputIsTty;
+    const isCi = isTruthy(env.CI);
+    const hasInjectedPrompt = Boolean(input.prompt);
+    const hasInjectedTuiRunner = Boolean(input.tuiRunner);
+    const requestedInteractive = input.interactive ?? (hasInjectedPrompt || hasInjectedTuiRunner ? true : isTty);
+    const interactive = requestedInteractive
+        && !isCi
+        && (isTty || hasInjectedPrompt || hasInjectedTuiRunner);
+    const diagnostics = createCommandDiagnostics({
+        ...input.diagnostics,
+        metadata: {
+            ...input.diagnostics?.metadata,
+            cwd,
+            awHome: resolveAwHome(env),
+            isTty,
+            isCi,
+            stdinIsTty,
+            stdoutIsTty,
+            promptOutputIsTty,
+            interactiveRequested: requestedInteractive,
+            interactiveEnabled: interactive,
+        },
+    }, env);
+    const reporter = createSessionAwareReporter(input.reporter ?? createIoReporter(io, diagnostics));
+    const debugLogger = input.debugLogger ?? createFileDebugLogger(diagnostics);
+    const prompt = input.prompt ?? (interactive
+        ? createInkPrompt({
+            input: stdin,
+            outputSink: promptOutputSink,
+        })
+        : createUnavailablePrompt());
+    const tuiRunner = input.tuiRunner ?? createInkTuiRunner();
+    const commandContext = createCommandExecutionContext({
+        ...input,
+        env,
+        interactive,
+        prompt,
+        reporter,
+        debugLogger,
+        diagnostics,
+    });
+    return {
+        ...commandContext,
+        cwd,
+        io,
+        stdin,
+        isTty,
+        isCi,
+        tuiRunner,
+        tuiOutput: promptOutputSink,
+    };
+}
+//# sourceMappingURL=runtime.js.map