agents-bridge 0.1.0 → 0.1.2

package/dist/agents/cli-runner.js

@@ -1,16 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { CLI_FRESH_WATCHDOG_DEFAULTS, CLI_RESUME_WATCHDOG_DEFAULTS, CLI_WATCHDOG_MIN_TIMEOUT_MS, normalizeProviderId, resolveCliBackendConfig, } from './cli-backends.js';
-import { CliSessionStore } from './cli-session-store.js';
+import { createCliOutputProbe, isSessionExpiredError, parseCliOutput, } from './cli-output.js';
+import { CodexAppServerRuntime, } from './codex-app-server-runtime.js';
+import { CliSessionStore, parseAgentSessionKey } from './cli-session-store.js';
 const CLI_RUN_QUEUES = new Map();
 const DEFAULT_TIMEOUT_MS = 15 * 60 * 1_000;
-const SESSION_EXPIRED_PATTERNS = [
-    /session expired/i,
-    /invalid session/i,
-    /conversation not found/i,
-    /thread not found/i,
-    /resume session not found/i,
-];
 class CliExecutionError extends Error {
     reason;
     stdout;
@@ -27,28 +22,41 @@ class CliExecutionError extends Error {
 }
 export class LocalCliTurnExecutor {
     options;
+    codexRuntime = null;
     constructor(options) {
         this.options = options;
     }
     async run(params) {
         const callbacks = params.callbacks ?? {};
         const providerId = normalizeProviderId(params.provider);
-        const backendResolved = resolveCliBackendConfig(providerId, this.options.config);
+        const backendResolved = resolveCliBackendConfig(providerId, this.options.config, params.cliBackends);
         if (!backendResolved) {
             throw new Error(`Unknown CLI backend: ${params.provider}`);
         }
         const sessionStore = this.options.sessionStore ?? new CliSessionStore();
         const envelope = params.envelope;
+        let existingSessionEntry = await sessionStore.get(envelope.sessionId);
+        const parsedAgentSession = parseAgentSessionKey(envelope.sessionId);
+        if (!existingSessionEntry && parsedAgentSession) {
+            existingSessionEntry = await sessionStore.getWithLegacyFallback(envelope.sessionId, parsedAgentSession.originalKey);
+        }
         const sessionEntry = await sessionStore.ensureSession(envelope.sessionId, {
             provider: providerId,
             model: params.model,
         });
         const existingCliSessionId = await sessionStore.getCliSessionId(envelope.sessionId, providerId);
+        if (providerId === 'codex-cli' && !existingCliSessionId && existingSessionEntry?.provider === providerId) {
+            this.options.logger.warn({
+                provider: providerId,
+                sessionId: envelope.sessionId,
+                runtimeSessionId: sessionEntry.runtimeSessionId,
+            }, 'No persisted Codex thread id found for existing botlink session; next turn will start fresh');
+        }
         await this.emitProcessing(callbacks);
         const queueKey = backendResolved.config.serialize === false
             ? `${backendResolved.id}:${randomUUID()}`
             : `${backendResolved.id}:${envelope.sessionId}`;
-        return enqueueCliRun(queueKey, async () => {
+        return enqueueCliRun(queueKey, async ({ queueWaitMs }) => {
             try {
                 const result = await this.executeTurn({
                     envelope,
@@ -59,13 +67,25 @@ export class LocalCliTurnExecutor {
                     systemPrompt: params.systemPrompt,
                     backend: backendResolved.config,
                     cliSessionId: existingCliSessionId,
+                    queueWaitMs,
                     runtimeSessionId: sessionEntry.runtimeSessionId,
+                    agentEnv: params.agentEnv,
+                    agentClearEnv: params.agentClearEnv,
                 });
                 if (result.cliSessionId) {
                     await sessionStore.setCliSessionId(envelope.sessionId, providerId, result.cliSessionId, {
                         model: params.model,
                     });
                 }
+                else if (providerId === 'codex-cli') {
+                    this.options.logger.warn({
+                        provider: providerId,
+                        sessionId: envelope.sessionId,
+                        runtimeSessionId: sessionEntry.runtimeSessionId,
+                        isResume: result.isResume,
+                        diagnostics: result.diagnostics,
+                    }, 'Codex turn completed without a persisted thread id; future turns will remain fresh');
+                }
                 else {
                     await sessionStore.ensureSession(envelope.sessionId, {
                         provider: providerId,
@@ -77,8 +97,8 @@ export class LocalCliTurnExecutor {
             catch (error) {
                 if (existingCliSessionId &&
                     isSessionExpiredError(error) &&
-                    backendResolved.config.resumeArgs &&
-                    backendResolved.config.resumeArgs.length > 0) {
+                    (providerId === 'codex-cli' ||
+                        Boolean(backendResolved.config.resumeArgs && backendResolved.config.resumeArgs.length > 0))) {
                     this.options.logger.warn({ provider: providerId, sessionId: envelope.sessionId }, 'CLI session expired, clearing provider mapping and retrying fresh turn');
                     await sessionStore.clearCliSessionId(envelope.sessionId, providerId, { model: params.model });
                     const retried = await this.executeTurn({
@@ -90,7 +110,10 @@ export class LocalCliTurnExecutor {
                         systemPrompt: params.systemPrompt,
                         backend: backendResolved.config,
                         cliSessionId: undefined,
+                        queueWaitMs,
                         runtimeSessionId: sessionEntry.runtimeSessionId,
+                        agentEnv: params.agentEnv,
+                        agentClearEnv: params.agentClearEnv,
                     });
                     if (retried.cliSessionId) {
                         await sessionStore.setCliSessionId(envelope.sessionId, providerId, retried.cliSessionId, {
@@ -107,6 +130,65 @@ export class LocalCliTurnExecutor {
         await callbacks.onProcessing?.();
     }
     async executeTurn(params) {
+        if (params.providerId === 'codex-cli' && params.backend.runtimeMode === 'app-server') {
+            return this.executeCodexAppServerTurn(params);
+        }
+        return this.executeCliExecTurn(params);
+    }
+    async teardown() {
+        await this.codexRuntime?.teardown();
+    }
+    getCodexRuntime(backend) {
+        if (!this.codexRuntime) {
+            this.codexRuntime = this.options.createCodexRuntime?.(backend) ?? new CodexAppServerRuntime({
+                backend,
+                logger: this.options.logger,
+            });
+        }
+        return this.codexRuntime;
+    }
+    async executeCodexAppServerTurn(params) {
+        const normalizedModel = normalizeCliModel(params.model, params.backend);
+        const existingCliSessionId = params.cliSessionId?.trim() || undefined;
+        const isResume = Boolean(existingCliSessionId);
+        const promptPayload = buildPromptPayload(params.envelope, params.backend, true);
+        this.options.logger.info({
+            provider: params.providerId,
+            model: normalizedModel,
+            sessionId: params.envelope.sessionId,
+            cliSessionId: existingCliSessionId,
+            runtimeSessionId: params.runtimeSessionId,
+            isResume,
+            runtimeMode: 'app-server',
+        }, 'Starting Codex app-server turn');
+        const runtime = this.getCodexRuntime(params.backend);
+        const result = await runtime.run({
+            sessionId: params.envelope.sessionId,
+            runtimeSessionId: params.runtimeSessionId,
+            existingThreadId: existingCliSessionId,
+            model: normalizedModel,
+            workspaceDir: params.workspaceDir,
+            timeoutMs: params.timeoutMs,
+            noProgressTimeoutMs: resolveCliNoOutputTimeoutMs(params.backend, params.timeoutMs, isResume),
+            systemPrompt: resolveAppServerSystemPrompt(params.backend, params.systemPrompt, !existingCliSessionId),
+            prompt: promptPayload.prompt,
+            imagePaths: promptPayload.imagePaths,
+        });
+        return {
+            text: result.text,
+            provider: params.providerId,
+            model: params.model,
+            cliSessionId: result.cliSessionId,
+            isResume: result.isResume,
+            usage: result.usage,
+            diagnostics: {
+                ...result.diagnostics,
+                queueWaitMs: params.queueWaitMs,
+                totalElapsedMs: result.diagnostics.totalElapsedMs + params.queueWaitMs,
+            },
+        };
+    }
+    async executeCliExecTurn(params) {
         const normalizedModel = normalizeCliModel(params.model, params.backend);
         const existingCliSessionId = params.cliSessionId?.trim() || undefined;
         const useResume = Boolean(existingCliSessionId &&
@@ -116,7 +198,7 @@ export class LocalCliTurnExecutor {
             backend: params.backend,
             cliSessionId: existingCliSessionId,
         });
-        const promptPayload = buildPromptPayload(params.envelope, params.backend);
+        const promptPayload = buildPromptPayload(params.envelope, params.backend, Boolean(params.backend.imageArg));
         const promptInput = resolvePromptInput({
             backend: params.backend,
             prompt: promptPayload.prompt,
@@ -148,10 +230,18 @@ export class LocalCliTurnExecutor {
             runtimeSessionId: params.runtimeSessionId,
             isResume: useResume,
         }, 'Starting CLI turn');
-        const env = { ...process.env, ...params.backend.env };
+        // Build env per design: process.env → backend.env → agent.env → clear
+        const env = { ...process.env, ...params.backend.env, ...(params.agentEnv ?? {}) };
         for (const key of params.backend.clearEnv ?? []) {
             delete env[key];
         }
+        for (const key of params.agentClearEnv ?? []) {
+            delete env[key];
+        }
+        const probe = createCliOutputProbe({
+            backend: params.backend,
+            mode: outputMode,
+        });
         const output = await executeCliCommand({
             command: params.backend.command,
             args,
@@ -160,22 +250,56 @@ export class LocalCliTurnExecutor {
             stdin: promptInput.stdin,
             timeoutMs: params.timeoutMs,
             noOutputTimeoutMs: resolveCliNoOutputTimeoutMs(params.backend, params.timeoutMs, useResume),
+            onStdoutChunk(chunk, atMs) {
+                probe.onStdout(chunk, atMs);
+            },
+            onStderrChunk(chunk, atMs) {
+                probe.onStderr(chunk, atMs);
+            },
         });
+        const probeSnapshot = probe.snapshot();
         const parsed = parseCliOutput(output.stdout.trim(), outputMode, params.backend) ?? {
-            text: output.stdout.trim(),
+            text: probeSnapshot.lastText ?? output.stdout.trim(),
+            cliSessionId: probeSnapshot.cliSessionId,
+            usage: probeSnapshot.usage,
         };
-        const cliSessionId = parsed.cliSessionId ?? existingCliSessionId ?? sessionIdToSend.sessionId;
+        const cliSessionId = parsed.cliSessionId ?? probeSnapshot.cliSessionId ?? existingCliSessionId ?? sessionIdToSend.sessionId;
+        const diagnostics = buildRunDiagnostics({
+            queueWaitMs: params.queueWaitMs,
+            commandElapsedMs: output.elapsedMs,
+            outputMode,
+            stdout: output.stdout,
+            stderr: output.stderr,
+            cliSessionId,
+            existingCliSessionId,
+            runtimeSessionId: sessionIdToSend.sessionId,
+            probe: probeSnapshot,
+        });
+        if (params.providerId === 'codex-cli' && !cliSessionId) {
+            this.options.logger.warn({
+                provider: params.providerId,
+                sessionId: params.envelope.sessionId,
+                runtimeSessionId: params.runtimeSessionId,
+                isResume: useResume,
+                diagnostics,
+                stdoutPreview: trimOutputPreview(output.stdout),
+                stderrPreview: trimOutputPreview(output.stderr),
+            }, 'Unable to extract Codex thread id from CLI output');
+        }
+        const text = parsed.text.trim() || probeSnapshot.lastText?.trim() || output.stdout.trim();
         return {
-            text: parsed.text.trim(),
+            text,
             provider: params.providerId,
             model: params.model,
             cliSessionId,
             isResume: useResume,
             usage: parsed.usage,
+            diagnostics,
         };
     }
 }
 async function enqueueCliRun(key, task) {
+    const queuedAt = Date.now();
     const previous = CLI_RUN_QUEUES.get(key) ?? Promise.resolve();
     let release;
     const current = new Promise((resolve) => {
@@ -185,7 +309,9 @@ async function enqueueCliRun(key, task) {
     CLI_RUN_QUEUES.set(key, tail);
     await previous.catch(() => undefined);
     try {
-        return await task();
+        return await task({
+            queueWaitMs: Date.now() - queuedAt,
+        });
     }
     finally {
         release();
@@ -216,6 +342,20 @@ function resolveSystemPrompt(backend, systemPrompt, isNewSession, useResume) {
     }
     return trimmed;
 }
+function resolveAppServerSystemPrompt(backend, systemPrompt, isNewThread) {
+    const trimmed = systemPrompt?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const when = backend.systemPromptWhen ?? 'first';
+    if (when === 'never') {
+        return undefined;
+    }
+    if (when === 'first' && !isNewThread) {
+        return undefined;
+    }
+    return trimmed;
+}
 function resolveSessionIdToSend(params) {
     const mode = params.backend.sessionMode ?? 'always';
     const existing = params.cliSessionId?.trim();
@@ -240,7 +380,7 @@ function resolvePromptInput(params) {
     }
     return { promptArg: params.prompt };
 }
-function buildPromptPayload(envelope, backend) {
+function buildPromptPayload(envelope, backend, useSeparateImageInputs = Boolean(backend.imageArg)) {
     const imagePaths = envelope.content.attachments
         .filter((attachment) => attachment.type === 'photo' && attachment.localPath)
         .map((attachment) => attachment.localPath);
@@ -249,14 +389,14 @@ function buildPromptPayload(envelope, backend) {
         return `Attachment: ${attachment.localPath}${name}`;
     });
     const promptParts = [envelope.content.text.trim()];
-    if (!backend.imageArg && imagePaths.length > 0) {
+    if (!useSeparateImageInputs && imagePaths.length > 0) {
         promptParts.push(...imagePaths.map((imagePath) => `Image: ${imagePath}`));
     }
     const nonImageFiles = fileLines.filter((line) => !imagePaths.some((imagePath) => line.includes(imagePath)));
     promptParts.push(...nonImageFiles);
     return {
         prompt: promptParts.filter(Boolean).join('\n\n').trim(),
-        imagePaths: backend.imageArg && imagePaths.length > 0 ? imagePaths : undefined,
+        imagePaths: useSeparateImageInputs && imagePaths.length > 0 ? imagePaths : undefined,
     };
 }
 function buildCliArgs(params) {
@@ -309,10 +449,11 @@ function resolveCliNoOutputTimeoutMs(backend, timeoutMs, useResume) {
 }
 async function executeCliCommand(params) {
     return new Promise((resolve, reject) => {
-        let stdout = '';
-        let stderr = '';
+        const stdoutChunks = [];
+        const stderrChunks = [];
         let settled = false;
         let timedOutReason = null;
+        const startedAt = Date.now();
         const child = spawn(params.command, params.args, {
             cwd: params.cwd,
             env: params.env,
@@ -330,7 +471,11 @@ async function executeCliCommand(params) {
                 reject(error);
                 return;
             }
-            resolve(result ?? { stdout, stderr });
+            resolve(result ?? {
+                stdout: decodeCliOutput(Buffer.concat(stdoutChunks)),
+                stderr: decodeCliOutput(Buffer.concat(stderrChunks)),
+                elapsedMs: Date.now() - startedAt,
+            });
         };
         const armNoOutputTimer = () => {
             clearTimeout(noOutputTimer);
@@ -346,21 +491,26 @@ async function executeCliCommand(params) {
         let noOutputTimer = setTimeout(() => undefined, params.noOutputTimeoutMs);
         armNoOutputTimer();
         child.on('error', (error) => {
-            finish(new CliExecutionError(error.message, 'spawn-error', stdout, stderr));
+            finish(new CliExecutionError(error.message, 'spawn-error', decodeCliOutput(Buffer.concat(stdoutChunks)), decodeCliOutput(Buffer.concat(stderrChunks))));
         });
-        child.stdout?.setEncoding('utf8');
-        child.stderr?.setEncoding('utf8');
         child.stdout?.on('data', (chunk) => {
-            stdout += chunk;
+            const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            stdoutChunks.push(buffer);
+            params.onStdoutChunk?.(decodeCliOutput(buffer), Date.now() - startedAt);
             armNoOutputTimer();
         });
         child.stderr?.on('data', (chunk) => {
-            stderr += chunk;
+            const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            stderrChunks.push(buffer);
+            params.onStderrChunk?.(decodeCliOutput(buffer), Date.now() - startedAt);
             armNoOutputTimer();
         });
         child.on('close', (code) => {
+            const stdout = decodeCliOutput(Buffer.concat(stdoutChunks));
+            const stderr = decodeCliOutput(Buffer.concat(stderrChunks));
             const trimmedStdout = stdout.trim();
             const trimmedStderr = stderr.trim();
+            const elapsedMs = Date.now() - startedAt;
             if (timedOutReason) {
                 const timeoutMessage = timedOutReason === 'overall-timeout'
                     ? `CLI exceeded timeout (${Math.round(params.timeoutMs / 1000)}s) and was terminated.`
@@ -372,7 +522,7 @@ async function executeCliCommand(params) {
                 finish(new CliExecutionError(trimmedStderr || trimmedStdout || `CLI failed with exit code ${code ?? 'unknown'}.`, 'exit', trimmedStdout, trimmedStderr, code));
                 return;
             }
-            finish(undefined, { stdout: trimmedStdout, stderr: trimmedStderr });
+            finish(undefined, { stdout: trimmedStdout, stderr: trimmedStderr, elapsedMs });
         });
         if (params.stdin !== undefined && child.stdin) {
             child.stdin.write(params.stdin);
@@ -380,145 +530,86 @@ async function executeCliCommand(params) {
         child.stdin?.end();
     });
 }
-function parseCliOutput(raw, mode, backend) {
-    if (!raw.trim()) {
-        return null;
+function decodeCliOutput(buffer) {
+    if (buffer.length === 0) {
+        return '';
+    }
+    const utf8 = buffer.toString('utf8');
+    if (!shouldTryWindowsLegacyDecode(utf8)) {
+        return utf8;
     }
-    if (mode === 'text') {
-        return { text: raw.trim() };
+    for (const encoding of ['gb18030', 'gbk']) {
+        const decoded = tryDecodeWithEncoding(buffer, encoding);
+        if (decoded && decoded !== utf8) {
+            return decoded;
+        }
+    }
+    return utf8;
+}
+function shouldTryWindowsLegacyDecode(decoded) {
+    if (process.platform !== 'win32') {
+        return false;
     }
-    if (mode === 'jsonl') {
-        return parseCliJsonl(raw, backend);
+    const replacementCount = (decoded.match(/\uFFFD/g) ?? []).length;
+    if (replacementCount > 0) {
+        return true;
     }
-    return parseCliJson(raw, backend);
+    // Common mojibake markers when UTF-8/Chinese text is decoded with the wrong code page.
+    return ['鈥', '銆', '锛', '鏈', '鍦', '浠', '闂'].some((marker) => decoded.includes(marker));
 }
-function parseCliJson(raw, backend) {
+function tryDecodeWithEncoding(buffer, encoding) {
     try {
-        const parsed = JSON.parse(raw);
-        if (!isRecord(parsed)) {
-            return null;
-        }
-        return {
-            text: (collectText(parsed.message) ||
-                collectText(parsed.content) ||
-                collectText(parsed.result) ||
-                collectText(parsed)).trim(),
-            cliSessionId: pickCliSessionId(parsed, backend),
-            usage: isRecord(parsed.usage) ? toUsage(parsed.usage) : undefined,
-        };
+        // TextDecoder coverage depends on the Node/ICU build; guard runtime support.
+        return new TextDecoder(encoding, { fatal: false }).decode(buffer);
     }
     catch {
         return null;
     }
 }
-function parseCliJsonl(raw, backend) {
-    const lines = raw
-        .split(/\r?\n/g)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    if (lines.length === 0) {
-        return null;
-    }
-    let cliSessionId;
-    let usage;
-    let lastText = '';
-    for (const line of lines) {
-        try {
-            const parsed = JSON.parse(line);
-            if (!isRecord(parsed)) {
-                continue;
-            }
-            cliSessionId = cliSessionId ?? pickCliSessionId(parsed, backend) ?? getString(parsed.thread_id);
-            if (isRecord(parsed.usage)) {
-                usage = toUsage(parsed.usage) ?? usage;
-            }
-            const candidate = (collectText(parsed.item) ||
-                collectText(parsed.message) ||
-                collectText(parsed.delta) ||
-                collectText(parsed.result)).trim();
-            if (candidate) {
-                lastText = candidate;
-            }
+function buildRunDiagnostics(params) {
+    let cliSessionIdSource;
+    if (params.cliSessionId) {
+        if (params.probe.cliSessionId && params.cliSessionId === params.probe.cliSessionId) {
+            cliSessionIdSource = 'stream';
         }
-        catch {
-            continue;
+        else if (params.existingCliSessionId && params.cliSessionId === params.existingCliSessionId) {
+            cliSessionIdSource = 'existing';
         }
-    }
-    if (!lastText) {
-        return null;
-    }
-    return { text: lastText, cliSessionId, usage };
-}
-function pickCliSessionId(parsed, backend) {
-    const fields = backend.sessionIdFields ?? ['session_id', 'sessionId', 'conversation_id', 'conversationId'];
-    for (const field of fields) {
-        const value = getString(parsed[field]);
-        if (value) {
-            return value;
+        else if (params.runtimeSessionId && params.cliSessionId === params.runtimeSessionId) {
+            cliSessionIdSource = 'runtime';
         }
-    }
-    return undefined;
-}
-function collectText(value) {
-    if (!value) {
-        return '';
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => collectText(entry)).filter(Boolean).join('\n');
-    }
-    if (!isRecord(value)) {
-        return '';
-    }
-    if (typeof value.text === 'string') {
-        return value.text;
-    }
-    if (typeof value.content === 'string') {
-        return value.content;
-    }
-    if (Array.isArray(value.content)) {
-        return value.content.map((entry) => collectText(entry)).filter(Boolean).join('\n');
-    }
-    if (isRecord(value.message)) {
-        return collectText(value.message);
-    }
-    if (isRecord(value.item)) {
-        return collectText(value.item);
-    }
-    return '';
-}
-function toUsage(raw) {
-    const pick = (...keys) => {
-        for (const key of keys) {
-            const value = raw[key];
-            if (typeof value === 'number' && value >= 0) {
-                return value;
-            }
+        else {
+            cliSessionIdSource = 'parsed';
         }
-        return undefined;
-    };
-    const usage = {
-        input: pick('input_tokens', 'inputTokens'),
-        output: pick('output_tokens', 'outputTokens'),
-        cacheRead: pick('cache_read_input_tokens', 'cached_input_tokens', 'cacheRead'),
-        cacheWrite: pick('cache_write_input_tokens', 'cacheWrite'),
-        total: pick('total_tokens', 'total'),
+    }
+    return {
+        queueWaitMs: params.queueWaitMs,
+        commandElapsedMs: params.commandElapsedMs,
+        totalElapsedMs: params.queueWaitMs + params.commandElapsedMs,
+        outputMode: params.outputMode,
+        runtimeMode: 'exec',
+        hadStdout: Boolean(params.stdout),
+        hadStderr: Boolean(params.stderr),
+        firstStdoutMs: params.probe.firstStdoutMs,
+        firstStderrMs: params.probe.firstStderrMs,
+        threadStartedMs: params.probe.threadStartedMs,
+        firstAgentMessageMs: params.probe.firstAgentMessageMs,
+        turnCompletedMs: params.probe.turnCompletedMs,
+        reconnectCount: params.probe.reconnectCount,
+        fellBackToHttps: params.probe.fellBackToHttps,
+        threadOperation: params.existingCliSessionId ? 'resume' : 'start',
+        threadOperationElapsedMs: params.probe.threadStartedMs,
+        cliSessionIdSource,
     };
-    if (Object.values(usage).every((value) => value === undefined)) {
+}
+function trimOutputPreview(raw, limit = 1200) {
+    const normalized = raw.trim();
+    if (!normalized) {
         return undefined;
     }
-    return usage;
-}
-function isSessionExpiredError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return SESSION_EXPIRED_PATTERNS.some((pattern) => pattern.test(message));
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function getString(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+    if (normalized.length <= limit) {
+        return normalized;
+    }
+    return `${normalized.slice(0, limit)}...`;
 }
 //# sourceMappingURL=cli-runner.js.map