@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-JYXS47FQ.js

@@ -0,0 +1,951 @@
+import {
+  killTmuxSessionWithPaneFallback,
+  markTmuxSessionOrphaned,
+  registerTmuxSession,
+  unregisterTmuxSession
+} from "./chunk-B7PYTV72.js";
+import {
+  resolveReadOnlyWorkingDir
+} from "./chunk-GWHGTG37.js";
+import {
+  BUILD_PROCESS_GROUP_OWNER_ENV,
+  DEFAULT_TIMEOUT,
+  TMUX_COMPLETION_SIGNAL_GRACE_MS,
+  acquireProcessSlot,
+  assertProviderBypassHasBoundaryProof,
+  getProcessLifecycleManager,
+  recordVariantTmuxLaunch,
+  resolveProviderProcessGroupOwnership,
+  sandboxPathDenialError
+} from "./chunk-633XZ7UF.js";
+import {
+  globalProcessLimiter
+} from "./chunk-SF6YK3JI.js";
+import {
+  TIMEOUT_TERMINATION_EXIT_CODE,
+  formatTimeoutRemedyHint
+} from "./chunk-JBBB2Y47.js";
+import {
+  evaluateCpuTimeProgressStreak,
+  readCpuTimeSecondsAsync,
+  resolveIdleTimeoutsMs
+} from "./chunk-WJAL4JL3.js";
+import {
+  providerExecutionTransportStreamOptions,
+  sanitizeDiagnosticOutput
+} from "./chunk-RBKLOUXA.js";
+import {
+  createLogger
+} from "./chunk-3OPP2OZB.js";
+import {
+  wrapWithSandbox
+} from "./chunk-B7YRSULE.js";
+import {
+  mkBuildTempDir
+} from "./chunk-D6WTZMZB.js";
+import {
+  getProviderRuntimeQuirks
+} from "./chunk-Y733RB7T.js";
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+import {
+  ProviderExecutionError
+} from "./chunk-RRC5BL7B.js";
+import {
+  isSandboxAuthorityEnvVar
+} from "./chunk-WGQAXLNA.js";
+
+// src/core/providers/shared/execution-transport.ts
+import { randomBytes } from "crypto";
+import * as fs from "fs/promises";
+import { open as fsOpen } from "fs/promises";
+import * as path from "path";
+import { StringDecoder } from "string_decoder";
+import { execa as execa2 } from "execa";
+
+// src/core/providers/shared/tmux-pane-state.ts
+import { execa } from "execa";
+async function tmuxPaneDead(session, clientEnv) {
+  const result = await execa("tmux", ["display-message", "-p", "-t", session, "#{pane_dead}"], {
+    env: clientEnv,
+    reject: false,
+    timeout: 5e3
+  }).catch(() => void 0);
+  return result?.exitCode === 0 && String(result.stdout).trim() === "1";
+}
+
+// src/core/providers/shared/tmux-terminal-failure.ts
+var TMUX_TERMINAL_FAILURE_REASON = "provider_terminal_error";
+var TMUX_TERMINAL_FAILURE_QUIET_MS = 5e3;
+var MAX_PUBLIC_ERROR_TEXT_LENGTH = 500;
+function lastNonEmptyOutputLine(text) {
+  if (!text) return void 0;
+  const lines = text.split(/\r?\n/);
+  for (let index = lines.length - 1; index >= 0; index--) {
+    const line = lines[index]?.trim() ?? "";
+    if (line.length > 0) return line;
+  }
+  return void 0;
+}
+function buildTmuxTerminalFailureError(params) {
+  const publicErrorText = sanitizeDiagnosticOutput(params.errorText, MAX_PUBLIC_ERROR_TEXT_LENGTH) ?? "provider reported a terminal error";
+  return new ProviderExecutionError(
+    `[${params.providerName}] tmux-exec provider execution ended on a terminal provider error: ${publicErrorText}`,
+    {
+      retryable: false,
+      exitCode: 1,
+      reason: TMUX_TERMINAL_FAILURE_REASON,
+      ...providerExecutionTransportStreamOptions(params.stdout, params.stderr, {
+        maxPublicLength: 4096
+      })
+    }
+  );
+}
+function createTmuxTerminalFailureJudge(params) {
+  const quietMs = Math.max(0, params.quietMs ?? TMUX_TERMINAL_FAILURE_QUIET_MS);
+  const now = params.now ?? (() => Date.now());
+  let judgedActivityAt = null;
+  let candidate;
+  const readSnapshot = async () => ({
+    stdout: await params.readStdout(),
+    stderr: await params.readStderr()
+  });
+  const holdCandidate = (signal, snapshot, lastActivityAtMs) => {
+    let errorText;
+    try {
+      errorText = signal(snapshot);
+    } catch {
+      judgedActivityAt = lastActivityAtMs;
+      return void 0;
+    }
+    if (!errorText) {
+      judgedActivityAt = lastActivityAtMs;
+      return void 0;
+    }
+    candidate = {
+      errorText,
+      stdout: snapshot.stdout,
+      stderr: snapshot.stderr,
+      activityAtMs: lastActivityAtMs,
+      seenAtMs: now()
+    };
+    return void 0;
+  };
+  return async (lastActivityAtMs) => {
+    const signal = params.signal;
+    if (!signal) return void 0;
+    if (candidate !== void 0 && candidate.activityAtMs !== lastActivityAtMs) {
+      candidate = void 0;
+    }
+    if (candidate !== void 0) {
+      if (now() - candidate.seenAtMs < quietMs) return void 0;
+      const confirmed = await readSnapshot();
+      if (confirmed.stdout === candidate.stdout && confirmed.stderr === candidate.stderr) {
+        const errorText = candidate.errorText;
+        candidate = void 0;
+        judgedActivityAt = lastActivityAtMs;
+        return buildTmuxTerminalFailureError({
+          providerName: params.providerName,
+          errorText,
+          stdout: confirmed.stdout,
+          stderr: confirmed.stderr
+        });
+      }
+      candidate = void 0;
+      return holdCandidate(signal, confirmed, lastActivityAtMs);
+    }
+    if (judgedActivityAt === lastActivityAtMs) return void 0;
+    if (now() - lastActivityAtMs < quietMs) return void 0;
+    return holdCandidate(signal, await readSnapshot(), lastActivityAtMs);
+  };
+}
+
+// src/core/providers/shared/execution-transport.ts
+var transportLogger = createLogger("ExecutionTransport");
+var VALID_EXECUTION_TRANSPORT_MODES = [
+  "auto",
+  "headless",
+  "tmux-exec",
+  "interactive"
+];
+function isTmuxExecStatusAuthoritative(input) {
+  return input.statusPresent && (!input.sessionAlive || input.paneDead === true);
+}
+function parseExecutionTransportMode(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "interactive") {
+    return "tmux-exec";
+  }
+  if (VALID_EXECUTION_TRANSPORT_MODES.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+var tmuxAvailabilityProbe;
+async function isTmuxAvailable() {
+  if (tmuxAvailabilityProbe === void 0) {
+    tmuxAvailabilityProbe = (async () => {
+      try {
+        const result = await execa2("tmux", ["-V"], { reject: false });
+        return result.exitCode === 0;
+      } catch {
+        return false;
+      }
+    })();
+  }
+  return tmuxAvailabilityProbe;
+}
+function resolveRequestedTransportMode(options) {
+  const providerKey = options.provider?.trim().toUpperCase().replace(/[^A-Z0-9_]/g, "_");
+  const envRequested = (providerKey ? parseExecutionTransportMode(options.env?.[`BUILD_${providerKey}_EXECUTION_TRANSPORT`]) : void 0) ?? parseExecutionTransportMode(options.env?.BUILD_PROVIDER_EXECUTION_TRANSPORT) ?? parseExecutionTransportMode(options.env?.BUILD_EXECUTION_TRANSPORT);
+  const requested = options.requested ?? envRequested ?? options.configured ?? "headless";
+  return requested === "interactive" ? "tmux-exec" : requested;
+}
+async function resolveExecutionTransportMode(options) {
+  const normalizedRequested = resolveRequestedTransportMode({
+    requested: options.requested,
+    configured: options.configured,
+    env: options.env,
+    provider: options.provider
+  });
+  if (normalizedRequested === "headless") return "headless";
+  const available = await (options.tmuxAvailable ?? isTmuxAvailable)();
+  if (available) return "tmux-exec";
+  if (normalizedRequested === "tmux-exec") {
+    throw new ProviderExecutionError(
+      "tmux-exec provider execution transport requires tmux, but tmux was not found on PATH.",
+      { retryable: false, reason: "tmux_exec_transport_unavailable" }
+    );
+  }
+  return "headless";
+}
+async function resolveProviderTransportDecision(options) {
+  const quirks = getProviderRuntimeQuirks(options.provider);
+  const requestedMode = resolveRequestedTransportMode({
+    requested: options.requested,
+    configured: options.configured,
+    env: options.env,
+    provider: options.provider
+  });
+  if (options.forceHeadlessReason) {
+    const requested = requestedMode === "headless" ? "headless" : "tmux-exec";
+    return {
+      resolved: "headless",
+      requested,
+      downgradeReason: requested === "tmux-exec" ? options.forceHeadlessReason : void 0
+    };
+  }
+  const support = quirks?.tmuxExecSupport ?? "none";
+  if (support === "none") {
+    if (requestedMode === "tmux-exec") {
+      return {
+        resolved: "headless",
+        requested: "tmux-exec",
+        downgradeReason: `${options.provider} is not validated for tmux-exec under a pane pty; using headless`
+      };
+    }
+    return { resolved: "headless", requested: "headless" };
+  }
+  const resolved = await resolveExecutionTransportMode({
+    requested: options.requested,
+    configured: options.configured,
+    env: options.env,
+    provider: options.provider,
+    tmuxAvailable: options.tmuxAvailable
+  });
+  if (resolved !== "tmux-exec") {
+    return { resolved, requested: resolved };
+  }
+  if (support === "read-only") {
+    const isReadOnly = resolveReadOnlyWorkingDir(options);
+    if (!isReadOnly) {
+      return {
+        resolved: "headless",
+        requested: "tmux-exec",
+        downgradeReason: `${options.provider} supports tmux-exec only for analysis/read-only runs; using headless for this write-intent run`
+      };
+    }
+  }
+  return { resolved: "tmux-exec", requested: "tmux-exec" };
+}
+function reportTransportDecision(provider, decision, debug) {
+  if (decision.downgradeReason) {
+    transportLogger.warn(
+      `[${provider}] execution transport downgraded: ${decision.downgradeReason}`,
+      {
+        provider,
+        requested: decision.requested,
+        resolved: decision.resolved
+      }
+    );
+    return;
+  }
+  debug?.(`[${provider}] execution transport resolved to ${decision.resolved}`, {
+    provider,
+    resolved: decision.resolved
+  });
+}
+async function selectProviderExecutor(options) {
+  const decision = await resolveProviderTransportDecision(options);
+  options.onDecision?.(decision);
+  const execute = decision.resolved === "tmux-exec" ? executeProviderCommandTmuxExec : options.headless;
+  return { execute, decision };
+}
+function sessionName(providerName) {
+  const safeProvider = providerName.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
+  return `build-${safeProvider || "provider"}-${randomBytes(4).toString("hex")}`;
+}
+async function writePromptFile(tmpDir, input) {
+  if (input === void 0) return void 0;
+  const file = path.join(tmpDir, "prompt.txt");
+  await fs.writeFile(file, input, { mode: 384 });
+  return file;
+}
+async function writeEnvFile(tmpDir, argv, env) {
+  const ownership = resolveProviderProcessGroupOwnership();
+  const paneEnv = {
+    ...commandEnvironment(env),
+    [BUILD_PROCESS_GROUP_OWNER_ENV]: ownership.owner
+  };
+  const lines = Object.entries(commandEnvironment(paneEnv)).filter(
+    (entry) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(entry[0]) && typeof entry[1] === "string"
+  ).map(([key, value]) => `export ${key}=${quotePosixShellArg(value)}`);
+  lines.push(`set -- ${argv.map(quotePosixShellArg).join(" ")}`);
+  const file = path.join(tmpDir, "env.sh");
+  await fs.writeFile(file, `${lines.join("\n")}
+`, { mode: 384 });
+  return file;
+}
+function resolveCommandName(command) {
+  const posix2 = path.posix.basename(command);
+  const win322 = path.win32.basename(command);
+  const basename = posix2.length <= win322.length ? posix2 : win322;
+  return basename.replace(/\.(exe|cmd|bat|ps1)$/i, "").toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+}
+function commandEnvironment(env) {
+  const source = env ?? process.env;
+  const next = { ...source };
+  for (const key of Object.keys(next)) {
+    if (isSandboxAuthorityEnvVar(key)) {
+      delete next[key];
+    }
+  }
+  return next;
+}
+function buildTmuxShellCommand(options) {
+  const input = options.promptFile ? ` < ${quotePosixShellArg(options.promptFile)}` : " < /dev/null";
+  const output = ` > ${quotePosixShellArg(options.stdoutFile)} 2> ${quotePosixShellArg(options.stderrFile)}`;
+  const innerScript = [
+    `. ${quotePosixShellArg(options.envFile)}`,
+    `rm -f ${quotePosixShellArg(options.envFile)}`,
+    `exec "$@"${input}${output}`
+  ].join("; ");
+  const runner = `env -i sh -c ${quotePosixShellArg(innerScript)}`;
+  return [
+    runner,
+    "status=$?",
+    `printf '%s' "$status" > ${quotePosixShellArg(options.statusFile)}`,
+    'exit "$status"'
+  ].join("; ");
+}
+async function readTextIfPresent(file) {
+  try {
+    return await fs.readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+var OutputFileTail = class {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  offset = 0;
+  decoder = new StringDecoder("utf8");
+  /** Read any bytes appended since the last call (bytes + decoded text). */
+  async read() {
+    let handle;
+    try {
+      handle = await fsOpen(this.file, "r");
+      const { size } = await handle.stat();
+      if (size <= this.offset) {
+        if (size < this.offset) {
+          this.offset = 0;
+          this.decoder = new StringDecoder("utf8");
+        }
+        return { bytes: Buffer.alloc(0), text: "" };
+      }
+      const length = size - this.offset;
+      const buffer = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(buffer, 0, length, this.offset);
+      this.offset += bytesRead;
+      const bytes = Buffer.from(buffer.subarray(0, bytesRead));
+      const text = this.decoder.write(bytes);
+      return { bytes, text };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { bytes: Buffer.alloc(0), text: "" };
+      }
+      throw error;
+    } finally {
+      await handle?.close().catch(() => {
+      });
+    }
+  }
+  /**
+   * Flush incomplete multibyte sequence as presentation text only.
+   * Authoritative raw observers already received those bytes on the read that
+   * advanced the offset — do not re-deliver them as raw chunks.
+   */
+  flushText() {
+    return this.decoder.end();
+  }
+};
+function deliverRawBytes(observer, bytes) {
+  if (!observer || bytes.length === 0) {
+    return;
+  }
+  try {
+    observer(bytes);
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseTmuxPanePid(value) {
+  const text = value?.trim();
+  if (!text || !/^\d+$/.test(text)) return void 0;
+  const pid = Number.parseInt(text, 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+}
+function firstUsefulDiagnosticLine(text) {
+  return text.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? "no error output";
+}
+function tmuxTransportStreamOptions(fullStdout, fullStderr, options) {
+  return providerExecutionTransportStreamOptions(fullStdout, fullStderr, {
+    maxPublicLength: options?.maxPublicLength ?? 4096
+  });
+}
+function throwIfTmuxNonZeroExit(options, result, fullStreams, sandbox) {
+  if (result.exitCode === 0) {
+    return;
+  }
+  const full = { ...result, ...fullStreams };
+  const denial = sandboxPathDenialError(options.metadata, sandbox, full, 4096);
+  if (denial) throw denial;
+  const streams = tmuxTransportStreamOptions(full.stdout, full.stderr, { maxPublicLength: 4096 });
+  const diagnostic = firstUsefulDiagnosticLine(streams.stderr || streams.stdout || "");
+  throw new ProviderExecutionError(
+    `${options.metadata.name} CLI exited with code ${result.exitCode}: ${diagnostic}`,
+    {
+      retryable: false,
+      exitCode: result.exitCode,
+      reason: "non_zero_exit",
+      ...streams
+    }
+  );
+}
+async function tmuxSessionExists(session, env) {
+  const result = await execa2("tmux", ["has-session", "-t", session], {
+    env: tmuxClientEnv(env),
+    reject: false,
+    timeout: 5e3
+  }).catch(() => void 0);
+  return result?.exitCode === 0;
+}
+async function killTmuxSession(params) {
+  return killTmuxSessionWithPaneFallback({
+    session: params.session,
+    tmuxEnv: params.env,
+    panePid: params.panePid,
+    timeoutMs: 1e4
+  });
+}
+async function registerTmuxProcessLifecycle(params) {
+  const plm = getProcessLifecycleManager();
+  if (!plm) return void 0;
+  try {
+    return await plm.registerProcessWithOptions({
+      completionPromise: params.completionPromise,
+      terminateFn: async () => {
+        await params.terminate();
+      },
+      verificationFn: async () => true,
+      processType: "local",
+      timeoutMs: 0,
+      metadata: {
+        provider: params.options.metadata.name,
+        command: params.options.command,
+        args: params.options.args,
+        cwd: params.options.workingDir,
+        transport: "tmux-exec",
+        session: params.session,
+        ...params.panePid !== void 0 ? { panePid: params.panePid } : {},
+        startTime: Date.now()
+      }
+    });
+  } catch (error) {
+    transportLogger.warn("[tmux-exec] ProcessLifecycleManager registration failed", {
+      provider: params.options.metadata.name,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
+  }
+}
+function tmuxClientEnv(env) {
+  const source = env ?? process.env;
+  const allowList = ["PATH", "HOME", "TMUX", "TMUX_TMPDIR", "TMPDIR", "USER", "LOGNAME", "TERM"];
+  const minimal = {};
+  for (const key of [...allowList, "SHELL", "LANG", "LC_ALL", "LC_CTYPE"]) {
+    const value = source[key] ?? process.env[key];
+    if (typeof value === "string") {
+      minimal[key] = value;
+    }
+  }
+  return minimal;
+}
+async function removeTmpDir(tmpDir) {
+  await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+  });
+}
+async function executeProviderCommandTmuxExec(options) {
+  const session = sessionName(options.metadata.id ?? options.metadata.name);
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  const idleTimeouts = resolveIdleTimeoutsMs(options.command, options.args, timeout, {
+    idleWarnMs: options.idleWarnMs,
+    idleKillMs: options.idleKillMs
+  });
+  const tmpDir = await mkBuildTempDir("tmux-exec", { baseDir: "/var/tmp" });
+  const stdoutFile = path.join(tmpDir, "stdout.log");
+  const stderrFile = path.join(tmpDir, "stderr.log");
+  const statusFile = path.join(tmpDir, "status");
+  let shellCommand;
+  let sandboxed;
+  try {
+    const promptFile = await writePromptFile(tmpDir, options.input);
+    await fs.writeFile(stdoutFile, "");
+    await fs.writeFile(stderrFile, "");
+    sandboxed = options.disableBuildSandbox === true ? { command: options.command, args: options.args, sandboxed: false } : wrapWithSandbox({
+      workingDir: options.workingDir,
+      command: options.command,
+      args: options.args,
+      providerName: options.metadata.name,
+      extraWritePaths: options.extraWritePaths,
+      readOnlyWorkingDir: options.readOnlyWorkingDir,
+      // Provider execution path (tmux transport), so the same
+      // write-boundary requirement as base-runner applies. Read-only runs
+      // still pass readOnlyWorkingDir and stay exempt.
+      requiresBoundaryForWrites: true,
+      env: options.env,
+      providerId: options.metadata.id ?? resolveCommandName(options.command)
+    });
+    assertProviderBypassHasBoundaryProof(
+      options.metadata,
+      options.args,
+      sandboxed,
+      options.providerInternalSandboxBypass
+    );
+    shellCommand = buildTmuxShellCommand({
+      envFile: await writeEnvFile(tmpDir, [sandboxed.command, ...sandboxed.args], options.env),
+      promptFile,
+      stdoutFile,
+      stderrFile,
+      statusFile
+    });
+  } catch (error) {
+    await removeTmpDir(tmpDir);
+    throw error;
+  }
+  const readFullTerminalStdout = () => readTextIfPresent(stdoutFile);
+  const readFullTerminalStderr = () => readTextIfPresent(stderrFile);
+  const startedAt = Date.now();
+  let aborted = false;
+  let stdoutTail;
+  let stderrTail;
+  let firstOutputSeen = false;
+  let completionSignalSeen = false;
+  let completionSignalSeenAt = null;
+  let exitedForCompletionSignal = false;
+  let lastActivityAt = startedAt;
+  const completionSignalGraceMs = Math.max(
+    0,
+    options.completionSignalGraceMs ?? TMUX_COMPLETION_SIGNAL_GRACE_MS
+  );
+  const judgeTerminalFailure = createTmuxTerminalFailureJudge({
+    signal: options.terminalFailureSignal,
+    providerName: options.metadata.name,
+    quietMs: options.terminalFailureQuietMs,
+    readStdout: readFullTerminalStdout,
+    readStderr: readFullTerminalStderr
+  });
+  let tmuxPanePid;
+  let lastCpuTimeSeconds;
+  let consecutiveBusyCpuPolls = 0;
+  let nextCpuPollAt = 0;
+  const cpuPollMs = Math.max(250, Math.min(3e4, Math.floor((idleTimeouts?.warnMs ?? 0) / 2)));
+  const abort = async () => {
+    aborted = true;
+    return killTmuxSession({ session, env: options.env, panePid: tmuxPanePid });
+  };
+  const abortListener = () => {
+    void abort();
+  };
+  const limiterDescription = `${options.metadata.name} tmux-exec provider command: ${options.command}`.trim();
+  let reservation;
+  try {
+    stdoutTail = new OutputFileTail(stdoutFile);
+    stderrTail = new OutputFileTail(stderrFile);
+    if (options.abortSignal?.aborted) {
+      throw new ProviderExecutionError(`[${options.metadata.name}] Provider execution aborted`, {
+        retryable: false,
+        reason: "abort"
+      });
+    }
+    const reservationOrWait = acquireProcessSlot(limiterDescription, options.abortSignal);
+    reservation = reservationOrWait instanceof Promise ? await reservationOrWait : reservationOrWait;
+  } catch (error) {
+    await removeTmpDir(tmpDir);
+    throw error;
+  }
+  let activeReservationId = typeof reservation === "number" ? reservation : void 0;
+  const reservationRenewTimer = activeReservationId !== void 0 ? setInterval(() => {
+    if (activeReservationId === void 0) return;
+    if (globalProcessLimiter.renewReservation(activeReservationId)) return;
+    const replacement = globalProcessLimiter.reserve();
+    activeReservationId = typeof replacement === "number" ? replacement : void 0;
+  }, 1e4) : void 0;
+  reservationRenewTimer?.unref?.();
+  const releaseReservation = () => {
+    if (reservationRenewTimer) {
+      clearInterval(reservationRenewTimer);
+    }
+    if (activeReservationId !== void 0) {
+      globalProcessLimiter.cancelReservation(activeReservationId);
+      activeReservationId = void 0;
+    }
+  };
+  options.abortSignal?.addEventListener("abort", abortListener, { once: true });
+  let tmuxPlmProcessId;
+  let registryPersisted = false;
+  let sessionStarted = false;
+  let settleTmuxPlmCompletion;
+  try {
+    await registerTmuxSession(session, {
+      env: options.env,
+      category: "variant",
+      type: "spawned",
+      provider: options.metadata.id ?? options.metadata.name,
+      tmpDir
+    });
+    registryPersisted = true;
+    if (aborted || options.abortSignal?.aborted) {
+      throw new ProviderExecutionError(`[${options.metadata.name}] Provider execution aborted`, {
+        retryable: false,
+        reason: "abort",
+        ...tmuxTransportStreamOptions(
+          await readFullTerminalStdout(),
+          await readFullTerminalStderr()
+        )
+      });
+    }
+    options.beforeSpawn?.();
+    const tmuxLaunch = await execa2(
+      "tmux",
+      [
+        "new-session",
+        "-d",
+        "-P",
+        "-F",
+        "#{pane_pid}",
+        "-s",
+        session,
+        "-c",
+        options.workingDir,
+        // Separate argv: tmux execs /bin/sh, not the default shell (zsh, fish break the wrapper).
+        "/bin/sh",
+        "-c",
+        shellCommand
+      ],
+      {
+        // Minimal client env only; extendEnv:false keeps process.env out of tmux.
+        env: tmuxClientEnv(options.env),
+        extendEnv: false,
+        cancelSignal: options.abortSignal,
+        reject: true
+      }
+    );
+    sessionStarted = true;
+    recordVariantTmuxLaunch();
+    tmuxPanePid = parseTmuxPanePid(tmuxLaunch.stdout);
+    const tmuxPlmCompletion = new Promise((resolve, reject) => {
+      settleTmuxPlmCompletion = { resolve, reject, settled: false };
+    });
+    tmuxPlmCompletion.catch(() => {
+    });
+    tmuxPlmProcessId = await registerTmuxProcessLifecycle({
+      options,
+      session,
+      panePid: tmuxPanePid,
+      completionPromise: tmuxPlmCompletion,
+      terminate: abort
+    });
+    const drainUnreadRawTails = async () => {
+      const stdout = await stdoutTail.read();
+      const stderr = await stderrTail.read();
+      deliverRawBytes(options.onStdoutChunk, stdout.bytes);
+      deliverRawBytes(options.onStderrChunk, stderr.bytes);
+    };
+    while (!aborted) {
+      const stdoutChunk = await stdoutTail.read();
+      const stderrChunk = await stderrTail.read();
+      if (stdoutChunk.bytes.length > 0) {
+        const now = Date.now();
+        lastActivityAt = now;
+        options.onActivity?.({ source: "stdout", timestampMs: now });
+        if (!firstOutputSeen && stdoutChunk.text.trim().length > 0) {
+          firstOutputSeen = true;
+          options.onFirstOutput?.(now);
+        }
+        deliverRawBytes(options.onStdoutChunk, stdoutChunk.bytes);
+        if (stdoutChunk.text.length > 0) {
+          try {
+            if (options.completionSignal?.(stdoutChunk.text, "stdout") === true) {
+              completionSignalSeen = true;
+              completionSignalSeenAt ??= Date.now();
+            }
+          } catch {
+          }
+          if (options.streamOutput === true) {
+            options.onData?.(stdoutChunk.text);
+          }
+        }
+      }
+      if (stderrChunk.bytes.length > 0) {
+        const now = Date.now();
+        lastActivityAt = now;
+        options.onActivity?.({ source: "stderr", timestampMs: now });
+        deliverRawBytes(options.onStderrChunk, stderrChunk.bytes);
+        if (stderrChunk.text.length > 0) {
+          try {
+            if (options.completionSignal?.(stderrChunk.text, "stderr") === true) {
+              completionSignalSeen = true;
+              completionSignalSeenAt ??= Date.now();
+            }
+          } catch {
+          }
+          if (options.streamOutput === true) {
+            options.onErrorData?.(stderrChunk.text);
+          }
+        }
+      }
+      if (idleTimeouts) {
+        if (Date.now() >= nextCpuPollAt) {
+          nextCpuPollAt = Date.now() + cpuPollMs;
+          const currentCpuTimeSeconds = await readCpuTimeSecondsAsync(tmuxPanePid);
+          const cpuProgress = evaluateCpuTimeProgressStreak({
+            currentCpuSeconds: currentCpuTimeSeconds,
+            previousCpuSeconds: lastCpuTimeSeconds,
+            currentBusyPolls: consecutiveBusyCpuPolls
+          });
+          consecutiveBusyCpuPolls = cpuProgress.nextBusyPolls;
+          if (currentCpuTimeSeconds !== void 0) lastCpuTimeSeconds = currentCpuTimeSeconds;
+          if (cpuProgress.shouldCountAsActivity) {
+            const now = Date.now();
+            lastActivityAt = now;
+            options.onActivity?.({ source: "cpu", timestampMs: now });
+          }
+        }
+        const idleFor = Date.now() - lastActivityAt;
+        if (idleFor >= idleTimeouts.killMs) {
+          options.onIdleTermination?.();
+          const killResult = await abort();
+          await drainUnreadRawTails();
+          const fullStdout2 = await readFullTerminalStdout();
+          const fullStderr2 = await readFullTerminalStderr();
+          const stderrDetail = fullStderr2.trim().length > 0 ? " Recent stderr was captured privately." : "";
+          const killDetail = killResult.removed ? "" : " Tmux session removal failed after pane SIGTERM/SIGKILL fallback; registry retained for orphan cleanup.";
+          throw new ProviderExecutionError(
+            `[${options.metadata.name}] tmux-exec provider execution idle timed out after ${Math.round(
+              idleTimeouts.killMs / 1e3
+            )}s with no stdout/stderr activity.${stderrDetail}${killDetail}${formatTimeoutRemedyHint()}`,
+            {
+              retryable: false,
+              exitCode: TIMEOUT_TERMINATION_EXIT_CODE,
+              reason: "idle_timeout",
+              idleTerminated: true,
+              ...tmuxTransportStreamOptions(fullStdout2, fullStderr2)
+            }
+          );
+        }
+      }
+      const statusPresent = (await readTextIfPresent(statusFile)).trim().length > 0;
+      const sessionAlive = sessionStarted ? await tmuxSessionExists(session, options.env) : false;
+      const paneDead = statusPresent && sessionAlive && await tmuxPaneDead(session, tmuxClientEnv(options.env));
+      if (isTmuxExecStatusAuthoritative({ statusPresent, sessionAlive, paneDead })) {
+        break;
+      }
+      if (completionSignalSeen && completionSignalSeenAt !== null && Date.now() - completionSignalSeenAt >= completionSignalGraceMs) {
+        exitedForCompletionSignal = true;
+        await killTmuxSession({ session, env: options.env, panePid: tmuxPanePid });
+        break;
+      }
+      const terminalFailure = await judgeTerminalFailure(lastActivityAt);
+      if (terminalFailure) {
+        await abort();
+        await drainUnreadRawTails();
+        throw terminalFailure;
+      }
+      if (Date.now() - startedAt > timeout) {
+        const killResult = await abort();
+        await drainUnreadRawTails();
+        const killDetail = killResult.removed ? "" : "; tmux session removal failed after pane SIGTERM/SIGKILL fallback; registry retained for orphan cleanup";
+        throw new ProviderExecutionError(
+          `[${options.metadata.name}] tmux-exec provider execution timed out after ${timeout}ms${killDetail}.${formatTimeoutRemedyHint()}`,
+          {
+            retryable: false,
+            exitCode: TIMEOUT_TERMINATION_EXIT_CODE,
+            reason: "timeout",
+            ...tmuxTransportStreamOptions(
+              await readFullTerminalStdout(),
+              await readFullTerminalStderr()
+            )
+          }
+        );
+      }
+      await sleep(250);
+    }
+    if (aborted) {
+      await drainUnreadRawTails();
+      throw new ProviderExecutionError(`[${options.metadata.name}] Provider execution aborted`, {
+        retryable: false,
+        reason: "abort",
+        ...tmuxTransportStreamOptions(
+          await readFullTerminalStdout(),
+          await readFullTerminalStderr()
+        )
+      });
+    }
+    const finalStdout = await stdoutTail.read();
+    const finalStderr = await stderrTail.read();
+    const finalStdoutText = finalStdout.text + stdoutTail.flushText();
+    const finalStderrText = finalStderr.text + stderrTail.flushText();
+    deliverRawBytes(options.onStdoutChunk, finalStdout.bytes);
+    deliverRawBytes(options.onStderrChunk, finalStderr.bytes);
+    if (finalStdoutText.length > 0) {
+      try {
+        if (options.completionSignal?.(finalStdoutText, "stdout") === true) {
+          completionSignalSeen = true;
+          completionSignalSeenAt ??= Date.now();
+        }
+      } catch {
+      }
+    }
+    if (finalStderrText.length > 0) {
+      try {
+        if (options.completionSignal?.(finalStderrText, "stderr") === true) {
+          completionSignalSeen = true;
+          completionSignalSeenAt ??= Date.now();
+        }
+      } catch {
+      }
+    }
+    if (options.streamOutput === true) {
+      if (finalStdoutText) options.onData?.(finalStdoutText);
+      if (finalStderrText) options.onErrorData?.(finalStderrText);
+    }
+    const statusText = await readTextIfPresent(statusFile);
+    const trimmedStatus = statusText.trim();
+    const statusIsValid = /^-?\d+$/.test(trimmedStatus);
+    let resolvedExitCode;
+    if (statusIsValid) {
+      resolvedExitCode = Number.parseInt(trimmedStatus, 10);
+    } else if (exitedForCompletionSignal || completionSignalSeen) {
+      resolvedExitCode = 0;
+    } else {
+      resolvedExitCode = 1;
+      sandboxed = void 0;
+    }
+    const fullStdout = await readTextIfPresent(stdoutFile);
+    const fullStderr = await readTextIfPresent(stderrFile);
+    const dualPublic = resolvedExitCode === 0 ? void 0 : tmuxTransportStreamOptions(fullStdout, fullStderr, {
+      maxPublicLength: 4096
+    });
+    const publicStdout = resolvedExitCode === 0 ? fullStdout : dualPublic?.stdout ?? "";
+    const publicStderr = resolvedExitCode === 0 ? fullStderr : dualPublic?.stderr ?? "";
+    if (options.streamOutput !== true) {
+      if (publicStdout) options.onData?.(publicStdout);
+      if (publicStderr) options.onErrorData?.(publicStderr);
+    } else if (resolvedExitCode === 1 && !statusIsValid && !exitedForCompletionSignal && !completionSignalSeen) {
+      options.onErrorData?.(
+        `[${options.metadata.name}] tmux-exec produced no terminal exit status; treating as failure.`
+      );
+    }
+    const result = {
+      stdout: publicStdout,
+      stderr: publicStderr,
+      exitCode: resolvedExitCode,
+      ...tmuxPanePid !== void 0 ? { pid: tmuxPanePid } : {}
+    };
+    throwIfTmuxNonZeroExit(options, result, { stdout: fullStdout, stderr: fullStderr }, sandboxed);
+    if (settleTmuxPlmCompletion && !settleTmuxPlmCompletion.settled) {
+      settleTmuxPlmCompletion.settled = true;
+      settleTmuxPlmCompletion.resolve(result);
+    }
+    return result;
+  } catch (error) {
+    if (settleTmuxPlmCompletion && !settleTmuxPlmCompletion.settled) {
+      settleTmuxPlmCompletion.settled = true;
+      settleTmuxPlmCompletion.reject(error);
+    }
+    throw error;
+  } finally {
+    options.abortSignal?.removeEventListener("abort", abortListener);
+    releaseReservation();
+    let orphanHandoffSucceeded = false;
+    if (registryPersisted) {
+      try {
+        orphanHandoffSucceeded = await markTmuxSessionOrphaned(session);
+      } catch (error) {
+        transportLogger.warn("[tmux-exec] failed to mark retained tmux session orphaned", {
+          provider: options.metadata.name,
+          session,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    const killResult = registryPersisted || sessionStarted ? await killTmuxSession({ session, env: options.env, panePid: tmuxPanePid }) : { removed: true, killed: false };
+    if (killResult.removed) {
+      await unregisterTmuxSession(session);
+    }
+    if (killResult.removed) {
+      if (tmuxPlmProcessId) {
+        getProcessLifecycleManager()?.unregisterProcess(tmuxPlmProcessId);
+      }
+      await removeTmpDir(tmpDir);
+    } else {
+      if (orphanHandoffSucceeded && tmuxPlmProcessId) {
+        getProcessLifecycleManager()?.unregisterProcess(tmuxPlmProcessId);
+      }
+      transportLogger.warn("[tmux-exec] tmux session cleanup failed; retaining registry record", {
+        provider: options.metadata.name,
+        session,
+        ...tmuxPanePid !== void 0 ? { panePid: tmuxPanePid } : {},
+        registryOrphaned: orphanHandoffSucceeded
+      });
+    }
+  }
+}
+
+export {
+  TMUX_TERMINAL_FAILURE_REASON,
+  lastNonEmptyOutputLine,
+  resolveProviderTransportDecision,
+  reportTransportDecision,
+  selectProviderExecutor,
+  executeProviderCommandTmuxExec
+};
+//# sourceMappingURL=chunk-JYXS47FQ.js.map