@actiondock/core 2.5.1 → 2.7.0

package/dist/input/input-resolver.js

@@ -0,0 +1,254 @@
+import { inputConflict, inputLimitExceeded, invalidJson, InputError, FlatInputError, } from "./flat-errors.js";
+import { decodeFlatInput } from "./flat-decode.js";
+import { validateJsonValue, DEFAULT_MAX_JSON_DEPTH, } from "../json/value-validator.js";
+import { scanJsonDepth } from "./json-depth-scanner.js";
+import { decodeUtf8Strict, stripBom } from "./utf8.js";
+import { readRegularFileBounded, DEFAULT_MAX_INPUT_BYTES, } from "./file-input.js";
+import { readStdinBounded } from "./stdin-input.js";
+export { stripBom } from "./utf8.js";
+/**
+ * 从标准输入流中完整读取全部数据并转换为 UTF-8 字符串（保持历史接口兼容）。
+ *
+ * @param stream 标准输入可读流，默认为 process.stdin
+ */
+export async function readStdin(stream = process.stdin) {
+    return readStdinBounded(stream, { strictUtf8: false });
+}
+/**
+ * 针对面向 Agent 场景对结构化输入错误进行隐私脱敏。
+ *
+ * 脱敏准则：
+ * - details.source 严格收敛为稳定枚举："flat" | "inline-json" | "file" | "stdin"。
+ * - 严禁在错误信息和 details 中回显原始 token、原始 JSON 内容、文件绝对路径及异常堆栈。
+ * - INPUT_FILE_NOT_FOUND 输出固定为：code: "INPUT_FILE_NOT_FOUND", message: "Input file not found", details: { source: "file" }。
+ */
+function sanitizeError(err, source) {
+    if (err instanceof InputError) {
+        const code = err.code;
+        const rawDetails = err.details && typeof err.details === "object" && !Array.isArray(err.details)
+            ? err.details
+            : {};
+        const reason = rawDetails.reason ||
+            (code === "INPUT_FILE_NOT_FOUND" ? undefined : "SYNTAX_ERROR");
+        if (code === "INPUT_FILE_NOT_FOUND") {
+            return new InputError("INPUT_FILE_NOT_FOUND", "Input file not found", {
+                source: "file",
+            });
+        }
+        if (code === "INPUT_FILE_READ_FAILED") {
+            const msg = source === "stdin"
+                ? "Failed to read input from stdin"
+                : "Failed to read input file";
+            return new InputError("INPUT_FILE_READ_FAILED", msg, {
+                source,
+                ...(rawDetails.reason ? { reason: rawDetails.reason } : {}),
+            });
+        }
+        if (code === "INPUT_CONFLICT") {
+            return new InputError("INPUT_CONFLICT", "Input options conflict: multiple input modes specified", { reason: "MULTIPLE_INPUT_MODES" });
+        }
+        if (code === "INPUT_LIMIT_EXCEEDED") {
+            return new InputError("INPUT_LIMIT_EXCEEDED", "Input limit exceeded", {
+                source,
+                reason: rawDetails.reason || "MAX_INPUT_BYTES",
+            });
+        }
+        if (code === "FLAT_INPUT_LIMIT_EXCEEDED") {
+            return new FlatInputError("FLAT_INPUT_LIMIT_EXCEEDED", "Flat input limit exceeded", {
+                source: "flat",
+                reason: rawDetails.reason || "MAX_MATERIALIZED_BYTES",
+            });
+        }
+        if (code === "INVALID_FLAT_ARGUMENT") {
+            return new FlatInputError("INVALID_FLAT_ARGUMENT", "Invalid flat argument", {
+                source: "flat",
+                reason: rawDetails.reason || "INVALID_ARGUMENT",
+            });
+        }
+        if (code === "INPUT_PATH_CONFLICT") {
+            return new FlatInputError("INPUT_PATH_CONFLICT", "Input path conflict", {
+                source: "flat",
+                reason: rawDetails.reason || "PATH_CONFLICT",
+            });
+        }
+        if (code === "INVALID_JSON_LITERAL") {
+            return new FlatInputError("INVALID_JSON_LITERAL", "Invalid JSON literal", {
+                source: "flat",
+                reason: rawDetails.reason || "SYNTAX_ERROR",
+            });
+        }
+        if (code === "INVALID_JSON") {
+            let msg = "Invalid JSON syntax";
+            if (reason === "INVALID_UTF8") {
+                msg = "Invalid UTF-8 encoding in JSON input";
+            }
+            else if (reason === "MAX_JSON_DEPTH") {
+                msg = "Max JSON depth limit exceeded";
+            }
+            else if (reason === "NON_FINITE_NUMBER") {
+                msg = "Number is non-finite or NaN";
+            }
+            else if (reason === "INVALID_JSON_VALUE") {
+                msg = "Invalid JSON value";
+            }
+            return new InputError("INVALID_JSON", msg, {
+                source,
+                reason,
+            });
+        }
+        return new InputError(code, "Input validation failed", {
+            source,
+            ...(rawDetails.reason ? { reason: rawDetails.reason } : {}),
+        });
+    }
+    return err;
+}
+/**
+ * 解析完整 JSON 文档字符串。
+ * 若解析失败抛出 INVALID_JSON 异常。
+ *
+ * @param text 待解析文本
+ * @param source 输入源描述（如 --input、文件路径或 stdin）
+ * @param policy 解析策略选项
+ */
+export function parseJson(text, source, policy) {
+    const maxDepth = policy?.maxJsonDepth ?? DEFAULT_MAX_JSON_DEPTH;
+    const maxBytes = policy?.maxInputBytes ?? DEFAULT_MAX_INPUT_BYTES;
+    // 1. 检查原始字节长度
+    const byteLen = Buffer.byteLength(text, "utf8");
+    if (byteLen > maxBytes) {
+        throw inputLimitExceeded(`Input size (${byteLen} bytes) exceeds limit of ${maxBytes} bytes`, { reason: "MAX_INPUT_BYTES" });
+    }
+    // 2. 剥离单个开头的 BOM
+    const cleaned = stripBom(text);
+    // 3. 空白 / 纯 BOM / 空字符串显式判定为语法错误
+    if (cleaned.trim() === "") {
+        throw invalidJson(`Invalid JSON input from ${source}: Unexpected end of JSON input`, { source, reason: "SYNTAX_ERROR" });
+    }
+    // 4. JSON 结构深度预检
+    const depthRes = scanJsonDepth(cleaned, maxDepth);
+    if (!depthRes.valid) {
+        throw invalidJson(`Invalid JSON input from ${source}: Max JSON depth limit (${maxDepth}) exceeded`, { source, reason: "MAX_JSON_DEPTH" });
+    }
+    // 5. 完整 JSON 解析
+    let parsed;
+    try {
+        parsed = JSON.parse(cleaned);
+    }
+    catch (err) {
+        throw invalidJson(`Invalid JSON input from ${source}: ${err instanceof Error ? err.message : String(err)}`, { source, reason: "SYNTAX_ERROR" });
+    }
+    // 6. JSON 值结构有限性与合法性校验
+    const valRes = validateJsonValue(parsed, { maxDepth });
+    if (!valRes.valid) {
+        throw invalidJson(`Invalid JSON input from ${source}: ${valRes.reason}`, { source, reason: valRes.code, path: valRes.path });
+    }
+    return parsed;
+}
+/**
+ * 统一解析 Action 执行入参。
+ *
+ * 输入模式仲裁规则（Input Mode Arbitration）：
+ * - effectiveFlat: flatArgs 存在且 length > 0
+ * - hasInlineJson: options.input !== undefined（即使为 ""）
+ * - hasFileJson: options.inputFile !== undefined（包含 "-"）
+ * - 最多一个为 true；若超过一个，抛出 INPUT_CONFLICT（reason: "MULTIPLE_INPUT_MODES"）。
+ * - 若三个均为 false，返回默认 {}。
+ * - flatArgs = [] 视为未指定。
+ * - options.input === "" 为显式 Full JSON 模式，进入解析并得到 INVALID_JSON / SYNTAX_ERROR，不可退化为 {}。
+ * - 显式空 JSON 输入（--input ""、0 字节文件、空 stdin、纯空白、纯 BOM）统一返回 INVALID_JSON / SYNTAX_ERROR。
+ *
+ * @param options 输入解析选项
+ * @returns 解析后的 JSON 对象
+ */
+export async function resolveActionInput(options) {
+    const effectiveFlat = (options.flatArgs?.length ?? 0) > 0;
+    const hasInlineJson = options.input !== undefined;
+    const hasFileJson = options.inputFile !== undefined;
+    let modeCount = 0;
+    if (effectiveFlat)
+        modeCount++;
+    if (hasInlineJson)
+        modeCount++;
+    if (hasFileJson)
+        modeCount++;
+    if (modeCount > 1) {
+        const err = inputConflict("Input options conflict: flatArgs, input, and inputFile are mutually exclusive", {
+            reason: "MULTIPLE_INPUT_MODES",
+            hasFlatArgs: effectiveFlat,
+            hasInput: hasInlineJson,
+            hasInputFile: hasFileJson,
+        });
+        if (options.policy?.sanitizeInputErrors) {
+            throw sanitizeError(err, "flat");
+        }
+        throw err;
+    }
+    if (modeCount === 0) {
+        return {};
+    }
+    const policy = options.policy;
+    const maxBytes = policy?.maxInputBytes ?? DEFAULT_MAX_INPUT_BYTES;
+    // 1. 扁平入参模式
+    if (effectiveFlat) {
+        try {
+            return decodeFlatInput(options.flatArgs, options.flatOptions);
+        }
+        catch (err) {
+            if (policy?.sanitizeInputErrors) {
+                throw sanitizeError(err, "flat");
+            }
+            throw err;
+        }
+    }
+    // 2. 内联 JSON 模式
+    if (hasInlineJson) {
+        try {
+            return parseJson(options.input, "--input", policy);
+        }
+        catch (err) {
+            if (policy?.sanitizeInputErrors) {
+                throw sanitizeError(err, "inline-json");
+            }
+            throw err;
+        }
+    }
+    // 3. 文件 / 标准输入 JSON 模式
+    if (hasFileJson) {
+        const isStdin = options.inputFile === "-";
+        if (isStdin) {
+            try {
+                const text = await readStdinBounded(options.stdin || process.stdin, {
+                    maxInputBytes: maxBytes,
+                    signal: options.signal,
+                    byteStreamOnly: policy?.byteStreamOnly,
+                    strictUtf8: policy?.strictUtf8 ?? true,
+                });
+                return parseJson(text, "stdin", policy);
+            }
+            catch (err) {
+                if (policy?.sanitizeInputErrors) {
+                    throw sanitizeError(err, "stdin");
+                }
+                throw err;
+            }
+        }
+        try {
+            const fileBytes = await readRegularFileBounded(options.inputFile, {
+                maxInputBytes: maxBytes,
+                signal: options.signal,
+            });
+            const text = policy?.strictUtf8 ?? true
+                ? decodeUtf8Strict(fileBytes, "full-json-file")
+                : fileBytes.toString("utf8");
+            return parseJson(text, options.inputFile, policy);
+        }
+        catch (err) {
+            if (policy?.sanitizeInputErrors) {
+                throw sanitizeError(err, "file");
+            }
+            throw err;
+        }
+    }
+    return {};
+}

package/dist/input/json-depth-scanner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * JSON 结构深度预检器。
+ *
+ * 采用 O(n) 流式单趟字符扫描器，实时维护字符串状态（处理转义符 \" 与 \\）以及字符串外部的容器嵌套深度（{ } 与 [ ]）。
+ * 根容器深度记为 0，每深入一层嵌套加 1。当任意时刻深度超出 maxDepth 时，立即短路返回 MAX_JSON_DEPTH。
+ * 标量基础类型（字符串、数字、布尔、null）不增加容器深度。
+ *
+ * @param text 待扫描的原始 JSON 文本
+ * @param maxDepth 最大允许嵌套深度（默认为 256）
+ * @returns 校验通过返回 { valid: true }，超限返回 { valid: false, reason: "MAX_JSON_DEPTH" }
+ */
+export declare function scanJsonDepth(text: string, maxDepth?: number): {
+    valid: true;
+} | {
+    valid: false;
+    reason: string;
+};

package/dist/input/json-depth-scanner.js

@@ -0,0 +1,49 @@
+/**
+ * JSON 结构深度预检器。
+ *
+ * 采用 O(n) 流式单趟字符扫描器，实时维护字符串状态（处理转义符 \" 与 \\）以及字符串外部的容器嵌套深度（{ } 与 [ ]）。
+ * 根容器深度记为 0，每深入一层嵌套加 1。当任意时刻深度超出 maxDepth 时，立即短路返回 MAX_JSON_DEPTH。
+ * 标量基础类型（字符串、数字、布尔、null）不增加容器深度。
+ *
+ * @param text 待扫描的原始 JSON 文本
+ * @param maxDepth 最大允许嵌套深度（默认为 256）
+ * @returns 校验通过返回 { valid: true }，超限返回 { valid: false, reason: "MAX_JSON_DEPTH" }
+ */
+export function scanJsonDepth(text, maxDepth = 256) {
+    let inString = false;
+    let isEscaped = false;
+    let containerDepth = -1;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charCodeAt(i);
+        if (inString) {
+            if (isEscaped) {
+                isEscaped = false;
+            }
+            else if (ch === 0x5c /* \ */) {
+                isEscaped = true;
+            }
+            else if (ch === 0x22 /* " */) {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === 0x22 /* " */) {
+            inString = true;
+            continue;
+        }
+        if (ch === 0x7b /* { */ || ch === 0x5b /* [ */) {
+            containerDepth++;
+            if (containerDepth > maxDepth) {
+                return { valid: false, reason: "MAX_JSON_DEPTH" };
+            }
+            continue;
+        }
+        if (ch === 0x7d /* } */ || ch === 0x5d /* ] */) {
+            if (containerDepth >= 0) {
+                containerDepth--;
+            }
+            continue;
+        }
+    }
+    return { valid: true };
+}

package/dist/input/metadata.d.ts

@@ -0,0 +1,99 @@
+import { type CliInputAdviceV1 } from "./advice.js";
+/**
+ * CLI 输入传输机制元数据契约（v1）。
+ */
+export interface InputTransportV1 {
+    version: 1;
+    defaultInputMode: "empty-object";
+    fullJson: {
+        inlineOption: "--input";
+        fileOption: "--input-file";
+        stdinValue: "-";
+        preferredLargeInputMode: "stdin";
+        encoding: "utf-8";
+        maxInputBytes: number;
+        maxJsonDepth: number;
+    };
+}
+/**
+ * CLI 扁平编码规格元数据契约（v1）。
+ */
+export interface CliInputEncodingV1 {
+    name: "flat-json-value";
+    version: 1;
+    scope: "cli-argv";
+    root: "object";
+    operators: {
+        string: "=";
+        json: ":=";
+    };
+    limits: {
+        maxAssignments: number;
+        maxPathDepth: number;
+        maxPathBytes: number;
+        maxPropertyKeyBytes: number;
+        maxRawValueBytes: number;
+        maxJsonLiteralBytes: number;
+        maxTotalRawBytes: number;
+        maxArrayIndex: number;
+        maxMaterializedBytes: number;
+        maxJsonDepth: number;
+    };
+}
+/**
+ * CLI 输入安全策略元数据契约（v1）。
+ */
+export interface InputPolicyV1 {
+    version: 1;
+    scope: "cli-pre-target";
+    propertyScope: "recursive";
+    forbiddenPropertyNames: readonly string[];
+}
+/**
+ * CLI describe --json 输入元数据聚合契约（v1）。
+ */
+export interface CliDescribeInputMetadataV1 {
+    inputTransport: InputTransportV1;
+    inputEncoding: CliInputEncodingV1;
+    inputPolicy: InputPolicyV1;
+    inputAdvice: CliInputAdviceV1;
+}
+/**
+ * CLI 输入错误信封结构契约。
+ */
+export interface CliInputErrorEnvelope {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}
+/**
+ * 构造输入传输层元数据（v1）。
+ */
+export declare function buildInputTransportV1(): InputTransportV1;
+/**
+ * 构造 CLI 扁平输入编码元数据（v1）。
+ */
+export declare function buildCliInputEncodingV1(): CliInputEncodingV1;
+/**
+ * 构造输入策略元数据（v1）。
+ * 明确标注 scope 为 "cli-pre-target"，防止远端目标未隔离策略造成歧义。
+ */
+export declare function buildInputPolicyV1(): InputPolicyV1;
+/**
+ * 聚合构造 CLI describe --json 所需的完整输入元数据。
+ *
+ * @param schema Action 的 inputSchema 定义
+ * @returns 包含 transport、encoding、policy 与 advice 的聚合元数据对象
+ */
+export declare function buildCliDescribeInputMetadataV1(schema: unknown): CliDescribeInputMetadataV1;
+/**
+ * 格式化输入异常为 CLI 人类可读文本。
+ */
+export declare function formatInputErrorForCli(err: unknown): string;
+/**
+ * 将输入异常转换为统一的 CLI 错误信封结构。
+ */
+export declare function toCliInputErrorEnvelope(err: unknown): CliInputErrorEnvelope;

package/dist/input/metadata.js

@@ -0,0 +1,99 @@
+import { DEFAULT_MAX_INPUT_BYTES } from "./file-input.js";
+import { DEFAULT_MAX_JSON_DEPTH } from "../json/value-validator.js";
+import { DEFAULT_MAX_ASSIGNMENTS, DEFAULT_MAX_PATH_DEPTH, DEFAULT_MAX_PATH_LENGTH, DEFAULT_MAX_PROPERTY_KEY_LENGTH, DEFAULT_MAX_RAW_VALUE_LENGTH, DEFAULT_MAX_JSON_LITERAL_LENGTH, DEFAULT_MAX_TOTAL_RAW_BYTES, DEFAULT_MAX_ARRAY_INDEX, DEFAULT_MAX_MATERIALIZED_SIZE_BYTES, } from "./flat-parser.js";
+import { FORBIDDEN_ACTION_INPUT_PROPERTIES } from "./flat-predicates.js";
+import { buildCliInputAdviceV1 } from "./advice.js";
+/**
+ * 构造输入传输层元数据（v1）。
+ */
+export function buildInputTransportV1() {
+    return {
+        version: 1,
+        defaultInputMode: "empty-object",
+        fullJson: {
+            inlineOption: "--input",
+            fileOption: "--input-file",
+            stdinValue: "-",
+            preferredLargeInputMode: "stdin",
+            encoding: "utf-8",
+            maxInputBytes: DEFAULT_MAX_INPUT_BYTES,
+            maxJsonDepth: DEFAULT_MAX_JSON_DEPTH,
+        },
+    };
+}
+/**
+ * 构造 CLI 扁平输入编码元数据（v1）。
+ */
+export function buildCliInputEncodingV1() {
+    return {
+        name: "flat-json-value",
+        version: 1,
+        scope: "cli-argv",
+        root: "object",
+        operators: {
+            string: "=",
+            json: ":=",
+        },
+        limits: {
+            maxAssignments: DEFAULT_MAX_ASSIGNMENTS,
+            maxPathDepth: DEFAULT_MAX_PATH_DEPTH,
+            maxPathBytes: DEFAULT_MAX_PATH_LENGTH,
+            maxPropertyKeyBytes: DEFAULT_MAX_PROPERTY_KEY_LENGTH,
+            maxRawValueBytes: DEFAULT_MAX_RAW_VALUE_LENGTH,
+            maxJsonLiteralBytes: DEFAULT_MAX_JSON_LITERAL_LENGTH,
+            maxTotalRawBytes: DEFAULT_MAX_TOTAL_RAW_BYTES,
+            maxArrayIndex: DEFAULT_MAX_ARRAY_INDEX,
+            maxMaterializedBytes: DEFAULT_MAX_MATERIALIZED_SIZE_BYTES,
+            maxJsonDepth: DEFAULT_MAX_JSON_DEPTH,
+        },
+    };
+}
+/**
+ * 构造输入策略元数据（v1）。
+ * 明确标注 scope 为 "cli-pre-target"，防止远端目标未隔离策略造成歧义。
+ */
+export function buildInputPolicyV1() {
+    return {
+        version: 1,
+        scope: "cli-pre-target",
+        propertyScope: "recursive",
+        forbiddenPropertyNames: FORBIDDEN_ACTION_INPUT_PROPERTIES,
+    };
+}
+/**
+ * 聚合构造 CLI describe --json 所需的完整输入元数据。
+ *
+ * @param schema Action 的 inputSchema 定义
+ * @returns 包含 transport、encoding、policy 与 advice 的聚合元数据对象
+ */
+export function buildCliDescribeInputMetadataV1(schema) {
+    return {
+        inputTransport: buildInputTransportV1(),
+        inputEncoding: buildCliInputEncodingV1(),
+        inputPolicy: buildInputPolicyV1(),
+        inputAdvice: buildCliInputAdviceV1(schema),
+    };
+}
+/**
+ * 格式化输入异常为 CLI 人类可读文本。
+ */
+export function formatInputErrorForCli(err) {
+    const message = err?.message || String(err);
+    return `Error: ${message}`;
+}
+/**
+ * 将输入异常转换为统一的 CLI 错误信封结构。
+ */
+export function toCliInputErrorEnvelope(err) {
+    const code = err?.code || "INVALID_ARGUMENT";
+    const message = err?.message || String(err);
+    const details = err?.details;
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+            ...(details !== undefined ? { details } : {}),
+        },
+    };
+}

package/dist/input/stdin-input.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 标准输入有界读取选项。
+ */
+export interface ReadStdinBoundedOptions {
+    /** 最大允许输入字节数（默认 10MB） */
+    maxInputBytes?: number;
+    /** 可选的中断信号 */
+    signal?: AbortSignal;
+    /** 是否仅允许纯字节流（在 CLI 策略下开启，若接收到 string chunk 则立即报错） */
+    byteStreamOnly?: boolean;
+    /** 是否执行严格 UTF-8 校验与解码（默认 true） */
+    strictUtf8?: boolean;
+}
+/**
+ * 以有界大小限制从标准输入流中安全读取全部内容。
+ *
+ * 核心契约：
+ * - 纯字节流策略拦截：若启用 byteStreamOnly 且流发射 string chunk，抛出 INPUT_FILE_READ_FAILED（reason: "INVALID_STREAM_CHUNK_TYPE"）。
+ * - 终态竞态裁决（First Observed Terminal Event Wins）：EOF、limit、abort 谁先观测谁生效，后续事件仅执行清理，不篡改已确定的错误与结果。
+ * - 严格 UTF-8 校验：在 strictUtf8 下通过 decodeUtf8Strict 校验并抛出结构化 INVALID_JSON 异常。
+ *
+ * @param stream 标准输入可读流，默认为 process.stdin
+ * @param options 读取配置选项
+ * @returns 解码后的 UTF-8 文本
+ */
+export declare function readStdinBounded(stream?: NodeJS.ReadableStream, options?: ReadStdinBoundedOptions): Promise<string>;

package/dist/input/stdin-input.js

@@ -0,0 +1,125 @@
+import { inputFileReadFailed, inputLimitExceeded } from "./flat-errors.js";
+import { decodeUtf8Strict } from "./utf8.js";
+import { DEFAULT_MAX_INPUT_BYTES } from "./file-input.js";
+/**
+ * 以有界大小限制从标准输入流中安全读取全部内容。
+ *
+ * 核心契约：
+ * - 纯字节流策略拦截：若启用 byteStreamOnly 且流发射 string chunk，抛出 INPUT_FILE_READ_FAILED（reason: "INVALID_STREAM_CHUNK_TYPE"）。
+ * - 终态竞态裁决（First Observed Terminal Event Wins）：EOF、limit、abort 谁先观测谁生效，后续事件仅执行清理，不篡改已确定的错误与结果。
+ * - 严格 UTF-8 校验：在 strictUtf8 下通过 decodeUtf8Strict 校验并抛出结构化 INVALID_JSON 异常。
+ *
+ * @param stream 标准输入可读流，默认为 process.stdin
+ * @param options 读取配置选项
+ * @returns 解码后的 UTF-8 文本
+ */
+export async function readStdinBounded(stream = process.stdin, options) {
+    const maxBytes = options?.maxInputBytes ?? DEFAULT_MAX_INPUT_BYTES;
+    const signal = options?.signal;
+    const byteStreamOnly = options?.byteStreamOnly ?? false;
+    const strictUtf8 = options?.strictUtf8 ?? true;
+    // 启动前检查 abort
+    if (signal?.aborted) {
+        throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+    }
+    return new Promise((resolve, reject) => {
+        let terminalEvent = null;
+        let totalBytes = 0;
+        const chunks = [];
+        const cleanup = () => {
+            stream.removeListener("data", onData);
+            stream.removeListener("end", onEnd);
+            stream.removeListener("error", onError);
+            if (signal) {
+                signal.removeEventListener("abort", onAbort);
+            }
+            if (typeof stream.pause === "function") {
+                stream.pause();
+            }
+            if (typeof stream.destroy === "function") {
+                stream.destroy();
+            }
+        };
+        const onAbort = () => {
+            if (terminalEvent !== null)
+                return;
+            terminalEvent = "abort";
+            cleanup();
+            reject(signal?.reason ?? new DOMException("The operation was aborted", "AbortError"));
+        };
+        const onError = (err) => {
+            if (terminalEvent !== null)
+                return;
+            terminalEvent = "error";
+            cleanup();
+            reject(inputFileReadFailed("stdin", err));
+        };
+        const onData = (chunk) => {
+            if (terminalEvent !== null)
+                return;
+            if (typeof chunk === "string") {
+                if (byteStreamOnly) {
+                    terminalEvent = "error";
+                    cleanup();
+                    reject(inputFileReadFailed("stdin", new Error("Invalid stream chunk type: expected Buffer, got string"), { reason: "INVALID_STREAM_CHUNK_TYPE" }));
+                    return;
+                }
+                const buf = Buffer.from(chunk, "utf8");
+                totalBytes += buf.length;
+                if (totalBytes > maxBytes) {
+                    terminalEvent = "limit";
+                    cleanup();
+                    reject(inputLimitExceeded(`Stdin input exceeds maximum limit of ${maxBytes} bytes`, { reason: "MAX_INPUT_BYTES" }));
+                    return;
+                }
+                chunks.push(buf);
+                return;
+            }
+            if (!Buffer.isBuffer(chunk) && !(chunk instanceof Uint8Array)) {
+                terminalEvent = "error";
+                cleanup();
+                reject(inputFileReadFailed("stdin", new Error(`Invalid stream chunk type: expected Buffer, got ${typeof chunk}`), { reason: "INVALID_STREAM_CHUNK_TYPE" }));
+                return;
+            }
+            const buf = Buffer.isBuffer(chunk)
+                ? chunk
+                : Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+            totalBytes += buf.length;
+            if (totalBytes > maxBytes) {
+                terminalEvent = "limit";
+                cleanup();
+                reject(inputLimitExceeded(`Stdin input exceeds maximum limit of ${maxBytes} bytes`, { reason: "MAX_INPUT_BYTES" }));
+                return;
+            }
+            chunks.push(buf);
+        };
+        const onEnd = () => {
+            if (terminalEvent !== null)
+                return;
+            terminalEvent = "eof";
+            cleanup();
+            try {
+                const fullBuffer = Buffer.concat(chunks);
+                if (strictUtf8) {
+                    const text = decodeUtf8Strict(fullBuffer, "full-json-stdin");
+                    resolve(text);
+                }
+                else {
+                    resolve(fullBuffer.toString("utf8"));
+                }
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+        if (signal) {
+            signal.addEventListener("abort", onAbort, { once: true });
+        }
+        stream.on("data", onData);
+        stream.on("end", onEnd);
+        stream.on("error", onError);
+        if (typeof stream.resume === "function") {
+            stream.resume();
+        }
+    });
+}