@ganglion/xacpx 0.22.0 → 0.23.0-beta.0

package/dist/adapters/acp-output-guard-main.js

@@ -0,0 +1,563 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config/local-agent-bin.ts
+import { statSync } from "node:fs";
+import { delimiter, join, win32 as win32Path } from "node:path";
+function executableExtensions(platform, env) {
+  return platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter((e) => e.length > 0) : [""];
+}
+function defaultIsExecutableFile(p, platform = process.platform) {
+  try {
+    const st = statSync(p);
+    if (!st.isFile())
+      return false;
+    return platform === "win32" || (st.mode & 73) !== 0;
+  } catch {
+    return false;
+  }
+}
+function resolveExecutableOnPath(name, platform = process.platform, env = process.env, isExecutableFile) {
+  const pathValue = env.PATH ?? env.Path ?? "";
+  if (!pathValue)
+    return;
+  const pathJoin = platform === "win32" ? win32Path.join : join;
+  const pathEntries = pathValue.split(platform === "win32" ? ";" : delimiter).filter(Boolean);
+  const extensions = executableExtensions(platform, env);
+  const basename = name.slice(Math.max(name.lastIndexOf("/"), name.lastIndexOf("\\")) + 1);
+  const hasExtension = platform === "win32" && /\.[^\\/]+$/u.test(basename);
+  const hasPath = /[\\/]/u.test(name) || platform === "win32" && /^[A-Za-z]:/u.test(name);
+  const fileCheck = isExecutableFile ?? ((path) => defaultIsExecutableFile(path, platform));
+  for (const directory of hasPath ? [""] : pathEntries) {
+    const base = hasPath ? name : pathJoin(directory, name);
+    const candidates = hasExtension ? [base] : extensions.map((extension) => `${base}${extension}`);
+    for (const candidate of candidates) {
+      if (fileCheck(candidate))
+        return candidate;
+    }
+  }
+  return;
+}
+function isExecutableOnPath(name, env = process.env, isExecutableFile = defaultIsExecutableFile) {
+  return resolveExecutableOnPath(name, process.platform, env, isExecutableFile) !== undefined;
+}
+function resolveLocalAgentArgv(driver, onPath = (name) => isExecutableOnPath(name)) {
+  const spec = LOCAL_AGENT_BINS[driver];
+  if (!spec)
+    return;
+  if (!onPath(spec.bin))
+    return;
+  return [spec.bin, ...spec.args];
+}
+var LOCAL_AGENT_BINS;
+var init_local_agent_bin = __esm(() => {
+  LOCAL_AGENT_BINS = {
+    opencode: { bin: "opencode", args: ["acp"] },
+    kilocode: { bin: "kilocode", args: ["acp"] },
+    reasonix: { bin: "reasonix", args: ["acp"] },
+    omp: { bin: "omp", args: ["acp"] }
+  };
+});
+
+// src/adapters/acp-output-guard.ts
+import { fileURLToPath } from "node:url";
+async function pumpAcpStdout(source, onLine, maxRawLineBytes = MAX_RAW_ACP_LINE_BYTES) {
+  let pendingParts = [];
+  let pendingBytes = 0;
+  const append = (part) => {
+    if (part.length === 0)
+      return;
+    pendingParts.push(part);
+    pendingBytes += part.length;
+    if (pendingBytes > maxRawLineBytes) {
+      throw new AcpOutputGuardError(`raw ACP stdout line exceeded ${maxRawLineBytes} bytes`);
+    }
+  };
+  const reset = () => {
+    pendingParts = [];
+    pendingBytes = 0;
+  };
+  for await (const chunk of source) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    let offset = 0;
+    while (offset <= buffer.length) {
+      const newline = buffer.indexOf(10, offset);
+      const end = newline === -1 ? buffer.length : newline;
+      append(buffer.subarray(offset, end));
+      if (newline === -1)
+        break;
+      await onLine(Buffer.concat(pendingParts, pendingBytes));
+      reset();
+      offset = newline + 1;
+    }
+  }
+  if (pendingBytes > 0) {
+    await onLine(Buffer.concat(pendingParts, pendingBytes));
+  }
+}
+function buildAcpAgentSpawnSpec(commandArgv, platform = process.platform, comspec = process.env.ComSpec ?? process.env.COMSPEC ?? "cmd.exe", env = process.env, isExecutableFile) {
+  const command = commandArgv[0];
+  if (!command) {
+    throw new AcpOutputGuardError("missing agent command after --");
+  }
+  const args = [...commandArgv.slice(1)];
+  const resolvedCommand = platform === "win32" ? resolveExecutableOnPath(command, platform, env, isExecutableFile) : undefined;
+  const launcherCommand = resolvedCommand && isWindowsScriptLauncher(resolvedCommand) ? resolvedCommand : command;
+  if (platform !== "win32" || !isWindowsScriptLauncher(launcherCommand)) {
+    return { command, args, shell: false };
+  }
+  const commandLine = [
+    escapeWindowsCmdCommand(launcherCommand),
+    ...args.map(quoteWindowsCmdArg)
+  ].join(" ");
+  return {
+    command: comspec,
+    args: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
+    shell: false,
+    windowsVerbatimArguments: true
+  };
+}
+function isWindowsScriptLauncher(command) {
+  const basename = command.slice(Math.max(command.lastIndexOf("/"), command.lastIndexOf("\\")) + 1).toLowerCase();
+  return basename.endsWith(".cmd") || basename.endsWith(".bat");
+}
+function escapeWindowsCmdCommand(value) {
+  return value.replace(WINDOWS_CMD_META_CHARACTERS, "^$1");
+}
+function quoteWindowsCmdArg(value) {
+  let escaped = value.replace(/(?=(\\+?)?)\1"/gu, "$1$1\\\"").replace(/(?=(\\+?)?)\1$/gu, "$1$1");
+  escaped = `"${escaped}"`;
+  return escaped.replace(WINDOWS_CMD_META_CHARACTERS, "^$1");
+}
+function guardAcpStdoutLine(line, options = {}) {
+  const safeLimit = positiveOption(options.safeSerializedLimit, SAFE_ACP_LINE_CHARS);
+  if (line.length <= safeLimit) {
+    return [line];
+  }
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    throw new AcpOutputGuardError(`non-JSON ACP stdout line exceeded ${safeLimit} characters`);
+  }
+  if (!isRecord(message)) {
+    throw new AcpOutputGuardError(`oversized ACP stdout payload is not a JSON-RPC object (${line.length} characters)`);
+  }
+  const textUpdate = textUpdateParts(message);
+  if (textUpdate) {
+    const split = splitTextUpdate(message, textUpdate, options, safeLimit);
+    if (split) {
+      return split;
+    }
+  }
+  const bounded = markQueueTruncation(boundJsonValue(message, createBoundContext(options, safeLimit), 0, []), message, line.length);
+  const boundedLine = safeJsonStringify(bounded);
+  if (boundedLine !== undefined && boundedLine.length <= safeLimit) {
+    return [boundedLine];
+  }
+  const minimal = minimalAcpMessage(message, line.length);
+  const minimalLine = safeJsonStringify(minimal);
+  if (minimalLine !== undefined && minimalLine.length <= safeLimit) {
+    return [minimalLine];
+  }
+  throw new AcpOutputGuardError(`unable to bound ACP stdout payload below ${safeLimit} characters (${line.length} characters)`);
+}
+function resolveAcpOutputGuardEntry(moduleUrl = import.meta.url) {
+  if (moduleUrl.endsWith(".ts")) {
+    return fileURLToPath(new URL("./acp-output-guard-main.ts", moduleUrl));
+  }
+  const index = moduleUrl.lastIndexOf(DIST_MARKER);
+  if (index !== -1) {
+    return fileURLToPath(new URL(`${moduleUrl.slice(0, index + DIST_MARKER.length)}adapters/acp-output-guard-main.js`, moduleUrl));
+  }
+  return fileURLToPath(new URL("./acp-output-guard-main.js", moduleUrl));
+}
+function wrapAcpOutputGuardArgv(agentArgv, execPath = process.execPath, guardEntry = resolveAcpOutputGuardEntry()) {
+  if (isAcpOutputGuardArgv(agentArgv)) {
+    return [...agentArgv];
+  }
+  return [execPath, guardEntry, "--", ...agentArgv];
+}
+function isAcpOutputGuardArgv(argv) {
+  return argv.length >= 3 && argv[2] === "--" && (argv[1]?.includes("/acp-output-guard-main.") === true || argv[1]?.includes("\\acp-output-guard-main.") === true);
+}
+function textUpdateParts(message) {
+  if (message.method !== "session/update" || !isRecord(message.params))
+    return;
+  const update = message.params.update;
+  if (!isRecord(update))
+    return;
+  if (update.sessionUpdate !== "agent_message_chunk" && update.sessionUpdate !== "agent_thought_chunk") {
+    return;
+  }
+  if (!isRecord(update.content) || update.content.type !== "text" || typeof update.content.text !== "string") {
+    return;
+  }
+  return { params: message.params, update, content: update.content, text: update.content.text };
+}
+function splitTextUpdate(message, parts, options, safeLimit) {
+  const skeleton = boundJsonValue({
+    ...message,
+    params: {
+      ...parts.params,
+      update: {
+        ...parts.update,
+        content: { ...parts.content, text: "" }
+      }
+    }
+  }, createBoundContext(options, safeLimit), 0, []);
+  if (!isRecord(skeleton) || !isRecord(skeleton.params) || !isRecord(skeleton.params.update)) {
+    return;
+  }
+  const skeletonUpdate = skeleton.params.update;
+  const skeletonContent = isRecord(skeletonUpdate.content) ? skeletonUpdate.content : { type: "text" };
+  const textChunkChars = positiveOption(options.textChunkChars, TEXT_CHUNK_CHARS);
+  const output = [];
+  let offset = 0;
+  while (offset < parts.text.length) {
+    let end = safeTextBoundary(parts.text, Math.min(parts.text.length, offset + textChunkChars));
+    let accepted;
+    while (end > offset) {
+      const piece = parts.text.slice(offset, end);
+      const candidate = {
+        ...skeleton,
+        params: {
+          ...skeleton.params,
+          update: {
+            ...skeletonUpdate,
+            content: { ...skeletonContent, text: piece }
+          }
+        }
+      };
+      const encoded = safeJsonStringify(candidate);
+      if (encoded !== undefined && encoded.length <= safeLimit) {
+        accepted = encoded;
+        break;
+      }
+      end = safeTextBoundary(parts.text, offset + Math.floor((end - offset) / 2));
+    }
+    if (accepted === undefined) {
+      return;
+    }
+    output.push(accepted);
+    offset = end;
+  }
+  if (output.length === 0)
+    return;
+  return output;
+}
+function safeTextBoundary(text, proposed) {
+  if (proposed <= 0 || proposed >= text.length)
+    return Math.min(text.length, Math.max(0, proposed));
+  const code = text.charCodeAt(proposed - 1);
+  return code >= 55296 && code <= 56319 ? proposed - 1 : proposed;
+}
+function createBoundContext(options, safeLimit) {
+  return {
+    remaining: Math.min(512 * 1024, Math.max(1024, safeLimit - 1024)),
+    nodes: 0,
+    options: {
+      maxDepth: positiveOption(options.maxDepth, DEFAULT_MAX_DEPTH),
+      maxObjectKeys: positiveOption(options.maxObjectKeys, DEFAULT_MAX_OBJECT_KEYS),
+      maxArrayItems: positiveOption(options.maxArrayItems, DEFAULT_MAX_ARRAY_ITEMS),
+      maxStringChars: positiveOption(options.maxStringChars, DEFAULT_MAX_STRING_CHARS)
+    }
+  };
+}
+function boundJsonValue(value, context, depth, path) {
+  context.nodes += 1;
+  if (context.nodes > MAX_BOUND_NODES || context.remaining <= 0) {
+    return ACP_OUTPUT_GUARD_TRUNCATION_MARKER;
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    context.remaining -= 16;
+    return value;
+  }
+  if (typeof value === "string") {
+    return boundString(value, context, path.at(-1));
+  }
+  if (depth >= context.options.maxDepth) {
+    context.remaining -= ACP_OUTPUT_GUARD_TRUNCATION_MARKER.length;
+    return ACP_OUTPUT_GUARD_TRUNCATION_MARKER;
+  }
+  if (Array.isArray(value)) {
+    const result2 = [];
+    for (const item of value.slice(0, context.options.maxArrayItems)) {
+      result2.push(boundJsonValue(item, context, depth + 1, [...path, "[]"]));
+      if (context.remaining <= 0)
+        break;
+    }
+    if (value.length > result2.length && context.remaining > 0) {
+      result2.push(ACP_OUTPUT_GUARD_TRUNCATION_MARKER);
+    }
+    context.remaining -= 2;
+    return result2;
+  }
+  if (!isRecord(value)) {
+    return ACP_OUTPUT_GUARD_TRUNCATION_MARKER;
+  }
+  const result = {};
+  const keys = prioritizedKeys(Object.keys(value), path.at(-1));
+  for (const key of keys.slice(0, context.options.maxObjectKeys)) {
+    if (context.remaining <= 0)
+      break;
+    result[key] = boundJsonValue(value[key], context, depth + 1, [...path, key]);
+  }
+  if (keys.length > Object.keys(result).length && context.remaining > 0) {
+    result.__xacpxTruncated = true;
+  }
+  context.remaining -= 2;
+  return result;
+}
+function boundString(value, context, key) {
+  if (value.length <= context.options.maxStringChars) {
+    context.remaining -= value.length;
+    return value;
+  }
+  if (key?.toLowerCase() === "data" && looksBinaryLike(value)) {
+    context.remaining -= ACP_OUTPUT_GUARD_BINARY_MARKER.length;
+    return ACP_OUTPUT_GUARD_BINARY_MARKER;
+  }
+  const cap = Math.max(32, Math.min(context.options.maxStringChars, Math.max(32, context.remaining - 64)));
+  const marker = ACP_OUTPUT_GUARD_TRUNCATION_MARKER;
+  const lowerKey = key?.toLowerCase();
+  let result;
+  if (lowerKey === "stdout" || lowerKey === "stderr" || lowerKey?.includes("diff")) {
+    const available = Math.max(0, cap - marker.length);
+    const head = Math.min(16 * 1024, Math.floor(available / 2));
+    result = `${value.slice(0, head)}${marker}${value.slice(-Math.max(0, available - head))}`;
+  } else {
+    result = `${value.slice(0, Math.max(0, cap - marker.length))}${marker}`;
+  }
+  context.remaining -= result.length;
+  return result;
+}
+function prioritizedKeys(keys, parentKey) {
+  if (parentKey !== "_meta")
+    return keys;
+  const preferred = ["qoder", "codex", "claudeCode", "routing", "toolName", "parentToolUseId"];
+  return [...keys].sort((left, right) => {
+    const leftIndex = preferred.indexOf(left);
+    const rightIndex = preferred.indexOf(right);
+    return (leftIndex === -1 ? preferred.length : leftIndex) - (rightIndex === -1 ? preferred.length : rightIndex);
+  });
+}
+function markQueueTruncation(bounded, original, originalSerializedLength) {
+  if (!isRecord(bounded) || original.method !== "session/update" || !isRecord(bounded.params)) {
+    return bounded;
+  }
+  const boundedUpdate = isRecord(bounded.params.update) ? bounded.params.update : {};
+  const originalUpdate = isRecord(original.params) && isRecord(original.params.update) ? original.params.update : {};
+  return {
+    ...bounded,
+    params: {
+      ...bounded.params,
+      update: {
+        ...boundedUpdate,
+        _meta: {
+          ...isRecord(boundedUpdate._meta) ? boundedUpdate._meta : {},
+          acpx: {
+            ...isRecord(boundedUpdate._meta) && isRecord(boundedUpdate._meta.acpx) ? boundedUpdate._meta.acpx : {},
+            queueTruncated: true,
+            originalSerializedLength
+          }
+        },
+        ...originalUpdate.sessionUpdate ? { sessionUpdate: boundedUpdate.sessionUpdate ?? originalUpdate.sessionUpdate } : {}
+      }
+    }
+  };
+}
+function minimalAcpMessage(message, originalSerializedLength) {
+  const minimal = {};
+  for (const key of ["jsonrpc", "id", "method"]) {
+    if (key in message)
+      minimal[key] = message[key];
+  }
+  if (message.method === "session/update" && isRecord(message.params)) {
+    const update = isRecord(message.params.update) ? message.params.update : {};
+    const minimalUpdate = {
+      sessionUpdate: typeof update.sessionUpdate === "string" ? update.sessionUpdate : "unknown"
+    };
+    for (const key of ["toolCallId", "parentToolCallId", "status", "kind", "title", "locations", "messageId"]) {
+      if (key in update)
+        minimalUpdate[key] = key === "locations" ? boundJsonValue(update[key], createBoundContext({}, SAFE_ACP_LINE_CHARS), 0, [key]) : update[key];
+    }
+    minimalUpdate.content = { type: "text", text: ACP_OUTPUT_GUARD_TRUNCATION_MARKER };
+    minimalUpdate._meta = { acpx: { queueTruncated: true, originalSerializedLength } };
+    minimal.params = {
+      ...typeof message.params.sessionId === "string" ? { sessionId: message.params.sessionId } : {},
+      update: minimalUpdate
+    };
+  } else if ("id" in message) {
+    minimal.result = {};
+  } else if ("params" in message) {
+    minimal.params = { _meta: { acpx: { queueTruncated: true, originalSerializedLength } } };
+  }
+  return minimal;
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return;
+  }
+}
+function looksBinaryLike(value) {
+  return value.length > 4096 && /^[A-Za-z0-9+/=\s]+$/u.test(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function positiveOption(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+var SAFE_ACP_LINE_CHARS, TEXT_CHUNK_CHARS, MAX_RAW_ACP_LINE_BYTES, ACP_OUTPUT_GUARD_TRUNCATION_MARKER = "…(truncated by xacpx ACP output guard)", ACP_OUTPUT_GUARD_BINARY_MARKER = "[large binary payload omitted by xacpx ACP output guard]", ACP_OUTPUT_GUARD_ERROR_CODE = "ACPX_OUTPUT_GUARD_FRAME_TOO_LARGE", DEFAULT_MAX_DEPTH = 12, DEFAULT_MAX_OBJECT_KEYS = 128, DEFAULT_MAX_ARRAY_ITEMS = 64, DEFAULT_MAX_STRING_CHARS, MAX_BOUND_NODES = 1e5, DIST_MARKER = "/dist/", WINDOWS_CMD_META_CHARACTERS, AcpOutputGuardError;
+var init_acp_output_guard = __esm(() => {
+  init_local_agent_bin();
+  SAFE_ACP_LINE_CHARS = 2 * 1024 * 1024;
+  TEXT_CHUNK_CHARS = 256 * 1024;
+  MAX_RAW_ACP_LINE_BYTES = 64 * 1024 * 1024;
+  DEFAULT_MAX_STRING_CHARS = 64 * 1024;
+  WINDOWS_CMD_META_CHARACTERS = /([()\][%!^"`<>&|;, *?])/gu;
+  AcpOutputGuardError = class AcpOutputGuardError extends Error {
+    code = ACP_OUTPUT_GUARD_ERROR_CODE;
+    constructor(message) {
+      super(message);
+      this.name = "AcpOutputGuardError";
+    }
+  };
+});
+
+// src/adapters/acp-output-guard-main.ts
+init_acp_output_guard();
+import { spawn } from "node:child_process";
+import { constants as osConstants } from "node:os";
+var separator = process.argv.indexOf("--");
+var commandArgv = separator === -1 ? process.argv.slice(2) : process.argv.slice(separator + 1);
+if (commandArgv.length === 0) {
+  process.stderr.write(`[xacpx-acp-output-guard] missing agent command after --
+`);
+  process.exit(1);
+}
+var spawnSpec = buildAcpAgentSpawnSpec(commandArgv);
+var child = spawn(spawnSpec.command, spawnSpec.args, {
+  stdio: ["pipe", "pipe", "pipe"],
+  shell: spawnSpec.shell,
+  windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments
+});
+var stopping = false;
+var finalized = false;
+function writeStderr(chunk) {
+  process.stderr.write(chunk);
+}
+function failClosed(error) {
+  if (stopping)
+    return;
+  stopping = true;
+  const message = error instanceof AcpOutputGuardError ? `${error.code}: ${error.message}` : error instanceof Error ? error.message : String(error);
+  writeStderr(`[xacpx-acp-output-guard] ${message}
+`);
+  try {
+    child.stdin?.destroy();
+    child.kill("SIGTERM");
+  } catch {}
+  const forceKill = setTimeout(() => {
+    try {
+      child.kill("SIGKILL");
+    } catch {}
+  }, 5000);
+  forceKill.unref?.();
+}
+async function writeLine(line) {
+  if (process.stdout.write(`${line}
+`))
+    return;
+  await new Promise((resolve) => process.stdout.once("drain", resolve));
+}
+async function forwardLine(line) {
+  if (stopping)
+    return;
+  const safeLines = guardAcpStdoutLine(line.toString("utf8"));
+  for (const safeLine of safeLines) {
+    await writeLine(safeLine);
+  }
+}
+var stdoutPump = pumpAcpStdout(child.stdout, forwardLine, MAX_RAW_ACP_LINE_BYTES).catch((error) => {
+  failClosed(error);
+});
+async function finalize(code, signal) {
+  if (finalized)
+    return;
+  finalized = true;
+  try {
+    await stdoutPump;
+  } catch (error) {
+    failClosed(error);
+  }
+  if (stopping) {
+    process.exitCode = 1;
+  } else {
+    process.exitCode = signal ? 128 + (osConstants.signals[signal] ?? 0) : code ?? 0;
+  }
+}
+child.on("error", (error) => {
+  failClosed(new Error(`failed to spawn agent: ${error.message}`));
+});
+child.on("close", (code, signal) => {
+  finalize(code, signal);
+});
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+  process.on(signal, () => {
+    try {
+      child.kill(signal);
+    } catch {}
+  });
+}
+child.stdin?.on("error", () => {});
+process.stdin.pipe(child.stdin);
+child.stderr?.pipe(process.stderr);

package/dist/adapters/acp-output-guard.d.ts

@@ -0,0 +1,43 @@
+export declare const SAFE_ACP_LINE_CHARS: number;
+export declare const TEXT_CHUNK_CHARS: number;
+export declare const MAX_RAW_ACP_LINE_BYTES: number;
+export declare const ACP_OUTPUT_GUARD_TRUNCATION_MARKER = "\u2026(truncated by xacpx ACP output guard)";
+export declare const ACP_OUTPUT_GUARD_BINARY_MARKER = "[large binary payload omitted by xacpx ACP output guard]";
+export declare const ACP_OUTPUT_GUARD_ERROR_CODE: "ACPX_OUTPUT_GUARD_FRAME_TOO_LARGE";
+export interface GuardOptions {
+    safeSerializedLimit?: number;
+    textChunkChars?: number;
+    maxDepth?: number;
+    maxObjectKeys?: number;
+    maxArrayItems?: number;
+    maxStringChars?: number;
+}
+/**
+ * Read ACP stdout as a backpressure-aware async stream. The caller's line
+ * handler is awaited before the iterator is advanced, so a slow acpx stdout
+ * consumer pauses the child stdout source instead of accumulating a Promise
+ * chain in this process.
+ */
+export declare function pumpAcpStdout(source: AsyncIterable<Buffer | string>, onLine: (line: Buffer) => Promise<void>, maxRawLineBytes?: number): Promise<void>;
+export interface AcpAgentSpawnSpec {
+    command: string;
+    args: string[];
+    shell: false;
+    windowsVerbatimArguments?: boolean;
+}
+/** Keep real Windows executables on the exact argv path. cmd/bat launchers are
+ * the one case that needs an explicit cmd.exe boundary. */
+export declare function buildAcpAgentSpawnSpec(commandArgv: readonly string[], platform?: NodeJS.Platform, comspec?: string, env?: NodeJS.ProcessEnv, isExecutableFile?: (path: string) => boolean): AcpAgentSpawnSpec;
+export declare class AcpOutputGuardError extends Error {
+    readonly code: "ACPX_OUTPUT_GUARD_FRAME_TOO_LARGE";
+    constructor(message: string);
+}
+/**
+ * Bounds one complete ACP stdout line before it reaches acpx. Small lines take
+ * the exact passthrough path; only oversized lines are parsed and rewritten.
+ */
+export declare function guardAcpStdoutLine(line: string, options?: GuardOptions): string[];
+/** Resolve the built guard entry from either a source module or a dist bundle. */
+export declare function resolveAcpOutputGuardEntry(moduleUrl?: string): string;
+export declare function wrapAcpOutputGuardArgv(agentArgv: readonly string[], execPath?: string, guardEntry?: string): string[];
+export declare function isAcpOutputGuardArgv(argv: readonly string[]): boolean;