@bitkyc08/opencodex 2.12.0 → 2.13.0

package/src/server/responses-custom-tool-repair.ts

@@ -0,0 +1,280 @@
+import type { TranslatorBudget } from "../lib/translator-budget";
+import {
+  customToolItemId,
+  restoreRoutedCustomCalls,
+  unwrapRoutedCustomToolArguments,
+} from "../responses/custom-tool-compat";
+import {
+  replaceSseDataPayload,
+  sseDataPayload,
+  type SseBlockRewrite,
+} from "./sse-payload-rewrite";
+
+/** Exact compact prefix used by our upstream rewriter; progressive matching also
+ *  tolerates insignificant JSON whitespace via FREEFORM_WRAP_PREFIX_RE. */
+const FREEFORM_WRAP_PREFIX = '{"input":"';
+const FREEFORM_WRAP_PREFIX_RE = /^\s*\{\s*"input"\s*:\s*"/;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Progressive decode of the freeform `{ "input": "…" }` wrapper.
+ * Returns null when the accumulated text does not (yet) match that wrapper so
+ * callers suppress deltas and rely on `response.custom_tool_call_input.done`.
+ */
+function partialCustomToolInput(argumentsText: string): string | null {
+  const match = FREEFORM_WRAP_PREFIX_RE.exec(argumentsText);
+  if (!match) return null;
+  const body = argumentsText.slice(match[0]!.length);
+  let output = "";
+  for (let index = 0; index < body.length; index++) {
+    const char = body[index];
+    if (char === '"') break;
+    if (char !== "\\") {
+      output += char;
+      continue;
+    }
+    const escaped = body[index + 1];
+    if (escaped === undefined) break;
+    index += 1;
+    if (escaped === "n") output += "\n";
+    else if (escaped === "t") output += "\t";
+    else if (escaped === "r") output += "\r";
+    else if (escaped === "b") output += "\b";
+    else if (escaped === "f") output += "\f";
+    else if (escaped === "u") {
+      const hex = body.slice(index + 1, index + 5);
+      if (hex.length !== 4 || !/^[0-9a-fA-F]{4}$/.test(hex)) break;
+      output += String.fromCharCode(Number.parseInt(hex, 16));
+      index += 4;
+    } else output += escaped;
+  }
+  return output;
+}
+
+function replaceSseEventName(block: string, type: string): string {
+  const newline = block.includes("\r\n") ? "\r\n" : "\n";
+  const lines = block.split(/\r?\n/);
+  let replaced = false;
+  const next = lines.map(line => {
+    if (!replaced && line.startsWith("event:")) {
+      replaced = true;
+      return `event: ${type}`;
+    }
+    return line;
+  });
+  return next.join(newline);
+}
+
+type OpenCustomCall = {
+  argumentsText: string;
+  emittedInput: string;
+  retainedBytes: number;
+};
+
+type PendingArgumentBlock = {
+  block: string;
+  itemId?: string;
+  outputIndex?: number;
+  retainedBytes: number;
+};
+
+export function createRoutedCustomToolRestoreBlockRewrite(
+  names: ReadonlySet<string>,
+  budget?: TranslatorBudget,
+): SseBlockRewrite {
+  const itemNames = new Map<string, string>();
+  const ordinaryItemIds = new Set<string>();
+  const openCalls = new Map<string, OpenCustomCall>();
+  let pendingArguments: PendingArgumentBlock[] = [];
+  let disposed = false;
+
+  const releaseCall = (itemId: string): void => {
+    const open = openCalls.get(itemId);
+    if (!open) return;
+    if (open.retainedBytes > 0) {
+      budget?.releaseRetained(open.retainedBytes, { kind: "retained_collectors" });
+    }
+    openCalls.delete(itemId);
+  };
+
+  const releaseAll = (): void => {
+    if (disposed) return;
+    disposed = true;
+    for (const itemId of openCalls.keys()) releaseCall(itemId);
+    const pendingBytes = pendingArguments.reduce((total, pending) => total + pending.retainedBytes, 0);
+    if (pendingBytes > 0) {
+      budget?.releaseRetained(pendingBytes, { kind: "retained_collectors" });
+    }
+    pendingArguments = [];
+    itemNames.clear();
+    ordinaryItemIds.clear();
+  };
+
+  const retainPendingArgument = (
+    block: string,
+    itemId: string | undefined,
+    outputIndex: number | undefined,
+  ): void => {
+    const retainedBytes = Buffer.byteLength(block, "utf8");
+    if (retainedBytes > 0) budget?.chargeRetained(retainedBytes, { kind: "retained_collectors" });
+    pendingArguments.push({ block, itemId, outputIndex, retainedBytes });
+  };
+
+  const takePendingArguments = (
+    itemId: string | undefined,
+    outputIndex: number | undefined,
+  ): string[] => {
+    const matched: PendingArgumentBlock[] = [];
+    const remaining: PendingArgumentBlock[] = [];
+    for (const pending of pendingArguments) {
+      const matches = pending.itemId !== undefined
+        ? itemId !== undefined && pending.itemId === itemId
+        : outputIndex !== undefined && pending.outputIndex === outputIndex;
+      (matches ? matched : remaining).push(pending);
+    }
+    pendingArguments = remaining;
+    const retainedBytes = matched.reduce((total, pending) => total + pending.retainedBytes, 0);
+    if (retainedBytes > 0) {
+      budget?.releaseRetained(retainedBytes, { kind: "retained_collectors" });
+    }
+    // Index-matched entries carry no item id. Stamp the resolved id so replay
+    // classifies the event instead of buffering it a second time.
+    return matched.map(pending => {
+      if (pending.itemId !== undefined || itemId === undefined) return pending.block;
+      const payload = sseDataPayload(pending.block);
+      if (payload === null) return pending.block;
+      try {
+        const parsed: unknown = JSON.parse(payload);
+        if (!isPlainObject(parsed)) return pending.block;
+        return replaceSseDataPayload(pending.block, JSON.stringify({ ...parsed, item_id: itemId }));
+      } catch {
+        return pending.block;
+      }
+    });
+  };
+
+  const rewrite: SseBlockRewrite = (block: string): readonly string[] => {
+    if (disposed) return [block];
+    const payload = sseDataPayload(block);
+    if (payload === null || payload === "[DONE]") return [block];
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      return [block];
+    }
+    if (!isPlainObject(parsed)) return [block];
+
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    const outputIndex = typeof parsed.output_index === "number"
+      && Number.isInteger(parsed.output_index)
+      && parsed.output_index >= 0
+      ? parsed.output_index
+      : undefined;
+    if (
+      (type === "response.output_item.added" || type === "response.output_item.done")
+      && isPlainObject(parsed.item)
+      && parsed.item.type === "function_call"
+      && typeof parsed.item.name === "string"
+    ) {
+      const upstreamItemId = typeof parsed.item.id === "string" ? parsed.item.id : undefined;
+      const routed = names.has(parsed.item.name);
+      if (upstreamItemId) {
+        if (routed) {
+          itemNames.set(upstreamItemId, parsed.item.name);
+          ordinaryItemIds.delete(upstreamItemId);
+        } else {
+          ordinaryItemIds.add(upstreamItemId);
+        }
+        if (routed && type === "response.output_item.added") {
+          openCalls.set(upstreamItemId, { argumentsText: "", emittedInput: "", retainedBytes: 0 });
+        }
+      }
+      const pending = takePendingArguments(upstreamItemId, outputIndex);
+      if (!routed) {
+        if (type === "response.output_item.done" && upstreamItemId) ordinaryItemIds.delete(upstreamItemId);
+        return [...pending, block];
+      }
+      if (upstreamItemId && pending.length > 0 && !openCalls.has(upstreamItemId)) {
+        openCalls.set(upstreamItemId, { argumentsText: "", emittedInput: "", retainedBytes: 0 });
+      }
+      const restored = restoreRoutedCustomCalls(parsed, names);
+      const restoredBlock = restored.changed
+        ? replaceSseDataPayload(block, JSON.stringify(restored.value))
+        : block;
+      const replayed = pending.flatMap(pendingBlock => rewrite(pendingBlock));
+      if (type === "response.output_item.done" && upstreamItemId) releaseCall(upstreamItemId);
+      return type === "response.output_item.added"
+        ? [restoredBlock, ...replayed]
+        : [...replayed, restoredBlock];
+    }
+
+    const upstreamItemId = typeof parsed.item_id === "string" ? parsed.item_id : undefined;
+    const argumentEvent = type === "response.function_call_arguments.delta"
+      || type === "response.function_call_arguments.done";
+    if (argumentEvent && (!upstreamItemId || (!itemNames.has(upstreamItemId) && !ordinaryItemIds.has(upstreamItemId)))) {
+      retainPendingArgument(block, upstreamItemId, outputIndex);
+      return [];
+    }
+    if (
+      type === "response.function_call_arguments.delta"
+      && upstreamItemId
+      && itemNames.has(upstreamItemId)
+    ) {
+      const open = openCalls.get(upstreamItemId) ?? { argumentsText: "", emittedInput: "", retainedBytes: 0 };
+      const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+      const deltaBytes = Buffer.byteLength(delta, "utf8");
+      if (deltaBytes > 0) budget?.chargeRetained(deltaBytes, { kind: "retained_collectors" });
+      open.argumentsText += delta;
+      open.retainedBytes += deltaBytes;
+      openCalls.set(upstreamItemId, open);
+      // Still accumulating toward the compact wrapper, or an unrecognized shape:
+      // suppress progressive emission and let the done event carry input.
+      if (FREEFORM_WRAP_PREFIX.startsWith(open.argumentsText)) return [];
+      const fullInput = partialCustomToolInput(open.argumentsText);
+      if (fullInput === null) return [];
+      if (!fullInput.startsWith(open.emittedInput) || fullInput.length === open.emittedInput.length) return [];
+      const inputDelta = fullInput.slice(open.emittedInput.length);
+      open.emittedInput = fullInput;
+      const nextType = "response.custom_tool_call_input.delta";
+      const next = {
+        ...parsed,
+        type: nextType,
+        item_id: customToolItemId(upstreamItemId),
+        delta: inputDelta,
+      };
+      return [replaceSseDataPayload(replaceSseEventName(block, nextType), JSON.stringify(next))];
+    }
+
+    if (
+      type === "response.function_call_arguments.done"
+      && upstreamItemId
+      && itemNames.has(upstreamItemId)
+    ) {
+      const nextType = "response.custom_tool_call_input.done";
+      const source = typeof parsed.arguments === "string"
+        ? parsed.arguments
+        : openCalls.get(upstreamItemId)?.argumentsText ?? "";
+      const { arguments: _arguments, ...rest } = parsed;
+      const next = {
+        ...rest,
+        type: nextType,
+        item_id: customToolItemId(upstreamItemId),
+        input: unwrapRoutedCustomToolArguments(source),
+      };
+      return [replaceSseDataPayload(replaceSseEventName(block, nextType), JSON.stringify(next))];
+    }
+
+    const restored = restoreRoutedCustomCalls(parsed, names);
+    const terminal = type === "response.completed" || type === "response.failed" || type === "response.incomplete";
+    if (terminal) releaseAll();
+    return restored.changed
+      ? [replaceSseDataPayload(block, JSON.stringify(restored.value))]
+      : [block];
+  };
+  rewrite.dispose = releaseAll;
+  return rewrite;
+}

package/src/server/responses-terminal-repair.ts

@@ -0,0 +1,342 @@
+import type { TranslatorBudget } from "../lib/translator-budget";
+import type { ResponsesTerminalRepairPolicy } from "../providers/registry";
+import { nextSseBlock, sseDataPayload } from "./sse-payload-rewrite";
+
+export interface ResponsesTerminalRepairScheduler {
+  nowMs(): number;
+  schedule(callback: () => void, delayMs: number): unknown;
+  cancel(handle: unknown): void;
+}
+
+const systemScheduler: ResponsesTerminalRepairScheduler = {
+  nowMs: () => Date.now(),
+  schedule(callback, delayMs) {
+    const handle = setTimeout(callback, delayMs);
+    (handle as { unref?: () => void }).unref?.();
+    return handle;
+  },
+  cancel(handle) { clearTimeout(handle as ReturnType<typeof setTimeout>); },
+};
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function outputIndex(value: unknown): number | null {
+  return Number.isInteger(value) && (value as number) >= 0 ? value as number : null;
+}
+
+function isCompleteItem(item: Record<string, unknown>): boolean {
+  if (item.status !== "completed") return false;
+  if (item.type === "reasoning") {
+    return typeof item.id === "string" && item.id.length > 0
+      && Array.isArray(item.content)
+      && item.content.every(part => isPlainRecord(part)
+        && part.type === "reasoning_text" && typeof part.text === "string");
+  }
+  if (item.type === "message") {
+    return typeof item.id === "string" && item.id.length > 0
+      && item.role === "assistant" && Array.isArray(item.content)
+      && item.content.every(part => isPlainRecord(part)
+        && part.type === "output_text" && typeof part.text === "string");
+  }
+  if (item.type === "function_call") {
+    if (typeof item.id !== "string" || item.id.length === 0) return false;
+    if (typeof item.call_id !== "string" || item.call_id.length === 0) return false;
+    if (typeof item.name !== "string" || item.name.length === 0) return false;
+    if (typeof item.arguments !== "string") return false;
+    try {
+      return isPlainRecord(JSON.parse(item.arguments));
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+/**
+ * Relay a native Responses SSE body while repairing the narrow DeepSeek shape where every
+ * output item is complete but the protocol terminal is missing or indefinitely delayed.
+ */
+export function relayResponsesSseWithTerminalRepair(
+  body: ReadableStream<Uint8Array>,
+  upstream: AbortController,
+  policy: ResponsesTerminalRepairPolicy,
+  budget: TranslatorBudget,
+  scheduler: ResponsesTerminalRepairScheduler = systemScheduler,
+): ReadableStream<Uint8Array> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const added = new Map<number, { type?: unknown; id?: unknown }>();
+  const completed = new Map<number, { item: Record<string, unknown>; bytes: number }>();
+  let created: Record<string, unknown> | null = null;
+  let createdBytes = 0;
+  let maxSequence = -1;
+  let buffer = "";
+  let bufferBytes = 0;
+  let timer: unknown;
+  let timerGeneration = 0;
+  let realTerminalSeen = false;
+  let tainted = false;
+  let disposed = false;
+  let controllerRef: ReadableStreamDefaultController<Uint8Array> | null = null;
+  let activeRead: Promise<void> | null = null;
+
+  const onUpstreamAbort = (): void => {
+    if (disposed) return;
+    dispose();
+    reader.cancel(upstream.signal.reason).catch(() => {});
+    try { controllerRef?.close(); } catch { /* already closed */ }
+  };
+
+  const releaseRetainedState = (): void => {
+    if (createdBytes > 0) budget.releaseRetained(createdBytes, { kind: "retained_collectors" });
+    createdBytes = 0;
+    for (const retained of completed.values()) {
+      budget.releaseRetained(retained.bytes, { kind: "retained_collectors" });
+    }
+    completed.clear();
+    created = null;
+  };
+
+  const releaseBuffer = (): void => {
+    if (bufferBytes > 0) budget.releaseRetained(bufferBytes, { kind: "live_transient" });
+    buffer = "";
+    bufferBytes = 0;
+  };
+
+  const cancelTimer = (): void => {
+    timerGeneration += 1;
+    if (timer !== undefined) scheduler.cancel(timer);
+    timer = undefined;
+  };
+
+  const dispose = (): void => {
+    if (disposed) return;
+    disposed = true;
+    upstream.signal.removeEventListener("abort", onUpstreamAbort);
+    cancelTimer();
+    releaseRetainedState();
+    releaseBuffer();
+  };
+
+  const replaceBuffer = (next: string): void => {
+    const nextBytes = encoder.encode(next).byteLength;
+    const reservation = budget.reserveTransient(nextBytes, { kind: "live_transient" });
+    reservation.commitRetained();
+    if (bufferBytes > 0) budget.releaseRetained(bufferBytes, { kind: "live_transient" });
+    buffer = next;
+    bufferBytes = nextBytes;
+  };
+
+  const appendBuffer = (fragment: string): void => {
+    if (!fragment) return;
+    replaceBuffer(buffer + fragment);
+  };
+
+  const retainCreated = (response: Record<string, unknown>): void => {
+    const bytes = encoder.encode(JSON.stringify(response)).byteLength;
+    budget.chargeRetained(bytes, { kind: "retained_collectors" });
+    if (createdBytes > 0) budget.releaseRetained(createdBytes, { kind: "retained_collectors" });
+    created = response;
+    createdBytes = bytes;
+  };
+
+  const retainCompleted = (index: number, item: Record<string, unknown>): void => {
+    const bytes = encoder.encode(JSON.stringify(item)).byteLength;
+    budget.chargeRetained(bytes, { kind: "retained_collectors" });
+    const previous = completed.get(index);
+    if (previous) budget.releaseRetained(previous.bytes, { kind: "retained_collectors" });
+    completed.set(index, { item, bytes });
+  };
+
+  const completeCandidate = (): boolean => {
+    if (realTerminalSeen || tainted || !created || completed.size === 0 || added.size !== completed.size) return false;
+    for (const index of added.keys()) {
+      const retained = completed.get(index);
+      if (!retained || !isCompleteItem(retained.item)) return false;
+    }
+    for (const index of completed.keys()) if (!added.has(index)) return false;
+    return true;
+  };
+
+  const syntheticTerminal = (kind: "completed" | "incomplete"): Uint8Array => {
+    const output = [...completed.entries()]
+      .sort(([left], [right]) => left - right)
+      .map(([, retained]) => retained.item);
+    const response = {
+      ...(created ?? {}),
+      status: kind,
+      completed_at: Math.floor(scheduler.nowMs() / 1_000),
+      output,
+      ...(kind === "incomplete"
+        ? { incomplete_details: { reason: "missing_terminal_event" } }
+        : {}),
+    };
+    const type = `response.${kind}`;
+    return encoder.encode(`event: ${type}\ndata: ${JSON.stringify({
+      type,
+      response,
+      sequence_number: maxSequence + 1,
+    })}\n\n`);
+  };
+
+  const emitSynthetic = (
+    kind: "completed" | "incomplete",
+    controller: ReadableStreamDefaultController<Uint8Array>,
+  ): boolean => {
+    if (disposed || realTerminalSeen) return false;
+    realTerminalSeen = true;
+    cancelTimer();
+    controller.enqueue(syntheticTerminal(kind));
+    releaseRetainedState();
+    return true;
+  };
+
+  const commitSynthetic = (generation: number): void => {
+    if (disposed || realTerminalSeen || generation !== timerGeneration || !completeCandidate()) return;
+    timer = undefined;
+    try {
+      if (controllerRef && emitSynthetic("completed", controllerRef)) controllerRef.close();
+    } catch {
+      /* downstream already closed */
+    }
+    reader.cancel("Responses terminal repaired after complete output").catch(() => {});
+    dispose();
+  };
+
+  const maybeArmTimer = (): void => {
+    if (!completeCandidate()) return;
+    const generation = timerGeneration;
+    timer = scheduler.schedule(() => commitSynthetic(generation), policy.graceMs);
+  };
+
+  const inspectPayload = (payload: string | null): "done" | "ordinary" => {
+    if (payload === "[DONE]") return "done";
+    if (!payload || realTerminalSeen) return "ordinary";
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      tainted = true;
+      return "ordinary";
+    }
+    if (!isPlainRecord(parsed)) {
+      tainted = true;
+      return "ordinary";
+    }
+    if (Number.isInteger(parsed.sequence_number)) {
+      maxSequence = Math.max(maxSequence, parsed.sequence_number as number);
+    }
+    const type = parsed.type;
+    if (type === "response.completed" || type === "response.failed" || type === "response.incomplete") {
+      realTerminalSeen = true;
+      cancelTimer();
+      releaseRetainedState();
+      return "ordinary";
+    }
+
+    cancelTimer();
+    if (type === "response.created" && isPlainRecord(parsed.response)) {
+      retainCreated(parsed.response);
+    } else if (type === "response.output_item.added") {
+      const index = outputIndex(parsed.output_index);
+      if (index === null || !isPlainRecord(parsed.item) || added.has(index) || completed.has(index)) {
+        tainted = true;
+      } else {
+        added.set(index, { type: parsed.item.type, id: parsed.item.id });
+      }
+    } else if (type === "response.output_item.done") {
+      const index = outputIndex(parsed.output_index);
+      if (index === null || !isPlainRecord(parsed.item) || !added.has(index) || completed.has(index)) {
+        tainted = true;
+      } else {
+        const opened = added.get(index)!;
+        if (opened.type !== parsed.item.type || opened.id !== parsed.item.id) tainted = true;
+        retainCompleted(index, parsed.item);
+      }
+    }
+    maybeArmTimer();
+    return "ordinary";
+  };
+
+  const emitBlocks = (
+    controller: ReadableStreamDefaultController<Uint8Array>,
+  ): { closed: boolean; emitted: boolean } => {
+    let next: ReturnType<typeof nextSseBlock>;
+    let emitted = false;
+    while ((next = nextSseBlock(buffer))) {
+      replaceBuffer(next.rest);
+      const kind = inspectPayload(sseDataPayload(next.block));
+      if (kind === "done" && !realTerminalSeen) {
+        emitSynthetic(completeCandidate() ? "completed" : "incomplete", controller);
+      }
+      controller.enqueue(encoder.encode(next.block + next.delimiter));
+      emitted = true;
+      if (kind === "done") {
+        reader.cancel("Responses stream ended with DONE").catch(() => {});
+        dispose();
+        controller.close();
+        return { closed: true, emitted };
+      }
+    }
+    return { closed: false, emitted };
+  };
+
+  const readOnce = async (controller: ReadableStreamDefaultController<Uint8Array>): Promise<void> => {
+    try {
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (disposed) return;
+        if (done) {
+          appendBuffer(decoder.decode());
+          if (buffer.length > 0) {
+            // A delimiter-less suffix is not a complete SSE event. Preserve the
+            // upstream bytes for passthrough compatibility, but never let a
+            // truncated lifecycle frame establish synthetic success.
+            tainted = true;
+            controller.enqueue(encoder.encode(buffer));
+          }
+          if (!realTerminalSeen) {
+            emitSynthetic(completeCandidate() ? "completed" : "incomplete", controller);
+          }
+          releaseBuffer();
+          dispose();
+          controller.close();
+          return;
+        }
+        appendBuffer(decoder.decode(value, { stream: true }));
+        const result = emitBlocks(controller);
+        if (result.closed || result.emitted) return;
+      }
+    } catch (error) {
+      if (disposed) return;
+      dispose();
+      controller.error(error);
+    }
+  };
+
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controllerRef = controller;
+      if (upstream.signal.aborted) {
+        onUpstreamAbort();
+        return;
+      }
+      upstream.signal.addEventListener("abort", onUpstreamAbort, { once: true });
+    },
+    pull(controller) {
+      if (disposed) return;
+      if (!activeRead) {
+        activeRead = readOnce(controller).finally(() => { activeRead = null; });
+      }
+      return activeRead;
+    },
+    cancel(reason) {
+      dispose();
+      upstream.abort(reason);
+      return reader.cancel(reason);
+    },
+  });
+}

package/src/server/startup-action-control.ts

@@ -164,10 +164,17 @@ function runCliInstall(
   const cli = join(import.meta.dir, "..", "cli", "index.ts");
   const argv = [cli, ...startupInstallArgv(action, options)];
   return new Promise((resolve, reject) => {
+    const timeout = process.platform === "win32" && action === "install-service"
+      ? 0
+      : 60_000;
     execFile(bun, argv, {
       encoding: "utf8",
       env: process.env,
-      timeout: 60_000,
+      // A fresh Windows scheduler install now owns its UAC prompt inside this CLI
+      // transaction. Killing only the CLI at 60s can orphan its elevated schtasks child,
+      // which may register the task after the Dashboard has reported failure. Keep the
+      // async request/attempt lock alive until Windows returns approval or cancellation.
+      timeout,
       windowsHide: true,
       maxBuffer: 256 * 1024,
     }, (error, stdout, stderr) => {