import crypto from "node:crypto";
import { spawn } from "node:child_process";
import { readFileSync } from "node:fs";
import http from "node:http";
import https from "node:https";
import readline from "node:readline";
import { resolve } from "node:path";

function trimToDefined(value) {
  const trimmed = String(value ?? "").trim();
  return trimmed ? trimmed : undefined;
}

function boolFromEnv(value) {
  const normalized = trimToDefined(value)?.toLowerCase();
  return normalized === "1" || normalized === "true" || normalized === "yes";
}

function listFromEnv(value) {
  if (!value) return undefined;
  try {
    const parsed = JSON.parse(String(value));
    if (Array.isArray(parsed)) {
      return parsed.map((item) => String(item));
    }
  } catch {
    // Fall through to whitespace splitting.
  }
  return String(value).split(/\s+/).filter(Boolean);
}

function resolveTaskThreadRef(task) {
  return trimToDefined(task?.targetCodexThreadRef || task?.targetThreadId);
}

function resolveTaskTurnRef(task) {
  return trimToDefined(task?.targetCodexTurnId || task?.targetTurnId);
}

function resolveSourceThreadRef(task) {
  return trimToDefined(task?.sourceCodexThreadRef || task?.sourceThreadId);
}

function resolveTaskCwd(config, task) {
  return resolve(
    trimToDefined(task?.targetCodexFolderRef) ||
      trimToDefined(config.masterAgentWorkdir) ||
      process.cwd(),
  );
}

function resolvePrompt(task) {
  return String(task?.executionPrompt || task?.requestText || "").trim();
}

function normalizeTimeoutMs(value) {
  const numeric = Number(value);
  return Number.isFinite(numeric) && numeric > 0 ? Math.floor(numeric) : 120_000;
}

function normalizeTransport(value) {
  const normalized = trimToDefined(value)?.toLowerCase();
  return normalized === "ws" || normalized === "websocket"
    ? "ws"
    : normalized === "unix"
      ? "unix"
      : "stdio";
}

export function getCodexAppServerRunnerConfig(env = process.env, config = {}) {
  const argsFromConfig = Array.isArray(config.codexAppServerArgs)
    ? config.codexAppServerArgs.map((item) => String(item))
    : undefined;
  const args =
    argsFromConfig ??
    listFromEnv(env.BOSS_CODEX_APP_SERVER_ARGS) ??
    ["app-server"];

  return {
    enabled:
      config.codexAppServerEnabled === true ||
      boolFromEnv(env.BOSS_CODEX_APP_SERVER_ENABLED),
    command:
      trimToDefined(config.codexAppServerCommand) ||
      trimToDefined(env.BOSS_CODEX_APP_SERVER_COMMAND) ||
      "codex",
    args,
    cwd:
      trimToDefined(config.codexAppServerWorkdir) ||
      trimToDefined(env.BOSS_CODEX_APP_SERVER_WORKDIR) ||
      trimToDefined(config.masterAgentWorkdir) ||
      process.cwd(),
    timeoutMs: normalizeTimeoutMs(
      config.codexAppServerTimeoutMs ?? env.BOSS_CODEX_APP_SERVER_TIMEOUT_MS,
    ),
    clientName:
      trimToDefined(config.codexAppServerClientName) ||
      trimToDefined(env.BOSS_CODEX_APP_SERVER_CLIENT_NAME) ||
      "boss_local_agent",
    clientTitle:
      trimToDefined(config.codexAppServerClientTitle) ||
      trimToDefined(env.BOSS_CODEX_APP_SERVER_CLIENT_TITLE) ||
      "Boss Local Agent",
    clientVersion:
      trimToDefined(config.codexAppServerClientVersion) ||
      trimToDefined(env.BOSS_CODEX_APP_SERVER_CLIENT_VERSION) ||
      "0.1.0",
    model: trimToDefined(config.masterAgentModel || env.BOSS_MASTER_AGENT_MODEL),
    sandbox: trimToDefined(config.masterAgentSandbox),
    transport: normalizeTransport(config.codexAppServerTransport ?? env.BOSS_CODEX_APP_SERVER_TRANSPORT),
    url:
      trimToDefined(config.codexAppServerUrl) ||
      trimToDefined(env.BOSS_CODEX_APP_SERVER_URL),
    authToken:
      trimToDefined(config.codexAppServerAuthToken) ||
      trimToDefined(env.BOSS_CODEX_APP_SERVER_AUTH_TOKEN),
    authTokenFile:
      trimToDefined(config.codexAppServerAuthTokenFile) ||
      trimToDefined(env.BOSS_CODEX_APP_SERVER_AUTH_TOKEN_FILE),
  };
}

export function shouldUseCodexAppServerTaskRunner(runnerConfig, task) {
  const hasTransportEndpoint =
    runnerConfig?.transport === "ws" || runnerConfig?.transport === "unix"
      ? Boolean(runnerConfig.url)
      : Boolean(runnerConfig?.command);
  if (!runnerConfig?.enabled || !hasTransportEndpoint) {
    return false;
  }

  const taskType = trimToDefined(task?.taskType);
  if (taskType !== "conversation_reply" && taskType !== "dispatch_execution") {
    return false;
  }

  return Boolean(resolvePrompt(task));
}

function extractAgentTextFromContent(value) {
  if (typeof value === "string") {
    return value;
  }
  if (Array.isArray(value)) {
    return value.map(extractAgentTextFromContent).filter(Boolean).join("");
  }
  if (!value || typeof value !== "object") {
    return "";
  }
  return (
    extractAgentTextFromContent(value.text) ||
    extractAgentTextFromContent(value.outputText) ||
    extractAgentTextFromContent(value.content) ||
    extractAgentTextFromContent(value.delta)
  );
}

function extractAgentDelta(params) {
  if (!params || typeof params !== "object") {
    return "";
  }
  return (
    extractAgentTextFromContent(params.delta) ||
    extractAgentTextFromContent(params.text) ||
    extractAgentTextFromContent(params.messageDelta) ||
    extractAgentTextFromContent(params.item?.delta)
  );
}

function extractCompletedAgentMessage(params) {
  const item = params?.item;
  if (!item || typeof item !== "object") {
    return "";
  }
  const itemType = String(item.type || item.kind || "");
  if (!/agent|assistant/i.test(itemType)) {
    return "";
  }
  return (
    extractAgentTextFromContent(item.text) ||
    extractAgentTextFromContent(item.content) ||
    extractAgentTextFromContent(item.message) ||
    extractAgentTextFromContent(item.output)
  );
}

function createFailure(error, extra = {}) {
  return {
    status: "failed",
    errorMessage: error instanceof Error ? error.message : String(error),
    transport: extra.transport ?? "stdio",
    ...extra,
  };
}

function resolveBearerToken(runnerConfig) {
  const direct = trimToDefined(runnerConfig?.authToken);
  if (direct) {
    return direct;
  }
  const tokenFile = trimToDefined(runnerConfig?.authTokenFile);
  if (!tokenFile) {
    return undefined;
  }
  return trimToDefined(readFileSync(tokenFile, "utf8"));
}

function isOverloadedJsonRpcError(error) {
  return Number(error?.code) === -32001 || /overloaded|retry later/i.test(String(error?.message || ""));
}

function computeOverloadedRetryDelayMs(attempt) {
  const base = Math.min(1_000, 40 * 2 ** attempt);
  return base + Math.floor(Math.random() * 25);
}

function encodeWebSocketTextFrame(value, { masked = false } = {}) {
  const payload = Buffer.from(value);
  const lengthByteOffset = 1;
  const payloadLength = payload.length;
  let header;
  if (payloadLength < 126) {
    header = Buffer.alloc(masked ? 6 : 2);
    header[0] = 0x81;
    header[lengthByteOffset] = payloadLength;
  } else if (payloadLength <= 0xffff) {
    header = Buffer.alloc(masked ? 8 : 4);
    header[0] = 0x81;
    header[lengthByteOffset] = 126;
    header.writeUInt16BE(payloadLength, 2);
  } else {
    header = Buffer.alloc(masked ? 14 : 10);
    header[0] = 0x81;
    header[lengthByteOffset] = 127;
    header.writeBigUInt64BE(BigInt(payloadLength), 2);
  }

  if (!masked) {
    return Buffer.concat([header, payload]);
  }

  header[lengthByteOffset] |= 0x80;
  const maskOffset = header.length - 4;
  const mask = crypto.randomBytes(4);
  mask.copy(header, maskOffset);
  const maskedPayload = Buffer.alloc(payload.length);
  for (let index = 0; index < payload.length; index += 1) {
    maskedPayload[index] = payload[index] ^ mask[index % 4];
  }
  return Buffer.concat([header, maskedPayload]);
}

function decodeWebSocketFrames(buffer, socket, onText) {
  let offset = 0;
  while (buffer.length - offset >= 2) {
    const first = buffer[offset];
    const second = buffer[offset + 1];
    const opcode = first & 0x0f;
    const masked = (second & 0x80) !== 0;
    let payloadLength = second & 0x7f;
    let headerLength = 2;
    if (payloadLength === 126) {
      if (buffer.length - offset < 4) break;
      payloadLength = buffer.readUInt16BE(offset + 2);
      headerLength = 4;
    } else if (payloadLength === 127) {
      if (buffer.length - offset < 10) break;
      payloadLength = Number(buffer.readBigUInt64BE(offset + 2));
      headerLength = 10;
    }

    const maskLength = masked ? 4 : 0;
    const frameLength = headerLength + maskLength + payloadLength;
    if (buffer.length - offset < frameLength) break;

    let payload = buffer.subarray(
      offset + headerLength + maskLength,
      offset + frameLength,
    );
    if (masked) {
      const mask = buffer.subarray(offset + headerLength, offset + headerLength + 4);
      const unmaskedPayload = Buffer.alloc(payload.length);
      for (let index = 0; index < payload.length; index += 1) {
        unmaskedPayload[index] = payload[index] ^ mask[index % 4];
      }
      payload = unmaskedPayload;
    }

    if (opcode === 0x1) {
      onText(payload.toString("utf8"));
    } else if (opcode === 0x8) {
      socket.end();
    } else if (opcode === 0x9) {
      socket.write(encodeWebSocketControlFrame(0x0a, payload));
    }
    offset += frameLength;
  }
  return buffer.subarray(offset);
}

function encodeWebSocketControlFrame(opcode, payload = Buffer.alloc(0)) {
  return Buffer.concat([Buffer.from([0x80 | opcode, payload.length]), payload]);
}

function openStdioCodexAppServerTransport(runnerConfig, cwd, handlers) {
  const child = spawn(runnerConfig.command, runnerConfig.args, {
    cwd: runnerConfig.cwd || cwd,
    env: process.env,
    stdio: ["pipe", "pipe", "pipe"],
  });
  let stderr = "";
  const rl = readline.createInterface({ input: child.stdout });
  rl.on("line", handlers.onLine);
  child.stderr.on("data", (chunk) => {
    stderr += String(chunk);
  });
  child.on("error", handlers.onError);
  child.on("close", (code) => {
    handlers.onClose({
      code,
      message: stderr.trim() || `CODEX_APP_SERVER_EXITED:${code ?? "unknown"}`,
    });
  });

  return {
    transport: "stdio",
    send(line, callback) {
      child.stdin.write(`${line}\n`, callback);
    },
    close(signal = "SIGTERM") {
      rl.close();
      if (!child.killed) {
        child.kill(signal);
      }
    },
    stderr() {
      return stderr.trim();
    },
  };
}

function openWebSocketCodexAppServerTransport(runnerConfig, handlers) {
  return new Promise((resolveTransport, rejectTransport) => {
    let settled = false;
    let buffered = Buffer.alloc(0);
    const url = new URL(runnerConfig.url);
    const isUnixSocket = url.protocol === "unix:";
    const client = url.protocol === "wss:" ? https : http;
    const key = crypto.randomBytes(16).toString("base64");
    const bearerToken = resolveBearerToken(runnerConfig);
    const headers = {
      Connection: "Upgrade",
      Upgrade: "websocket",
      "Sec-WebSocket-Key": key,
      "Sec-WebSocket-Version": "13",
      ...(bearerToken ? { Authorization: `Bearer ${bearerToken}` } : {}),
    };
    const requestOptions = isUnixSocket
      ? {
          socketPath: decodeURIComponent(url.pathname || ""),
          path: "/",
          method: "GET",
          headers: {
            Host: "localhost",
            ...headers,
          },
        }
      : {
          hostname: url.hostname,
          port: url.port || (url.protocol === "wss:" ? 443 : 80),
          path: `${url.pathname || "/"}${url.search || ""}`,
          method: "GET",
          headers,
        };
    if (isUnixSocket && !requestOptions.socketPath) {
      rejectTransport(new Error("CODEX_APP_SERVER_UNIX_SOCKET_PATH_MISSING"));
      return;
    }
    const request = client.request(requestOptions);

    const failOpen = (error) => {
      if (!settled) {
        settled = true;
        rejectTransport(error);
      } else {
        handlers.onError(error);
      }
    };

    request.on("upgrade", (response, socket) => {
      const expectedAccept = crypto
        .createHash("sha1")
        .update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)
        .digest("base64");
      const actualAccept = String(response.headers["sec-websocket-accept"] || "");
      if (response.statusCode !== 101 || actualAccept !== expectedAccept) {
        socket.destroy();
        failOpen(new Error(`CODEX_APP_SERVER_WS_UPGRADE_FAILED:${response.statusCode}`));
        return;
      }

      socket.on("data", (chunk) => {
        buffered = decodeWebSocketFrames(
          Buffer.concat([buffered, chunk]),
          socket,
          handlers.onLine,
        );
      });
      socket.on("error", handlers.onError);
      socket.on("close", () => {
        handlers.onClose({
          code: "ws_closed",
          message: "CODEX_APP_SERVER_WS_CLOSED",
        });
      });

      settled = true;
      resolveTransport({
        transport: isUnixSocket ? "unix" : "ws",
        send(line, callback) {
          socket.write(encodeWebSocketTextFrame(line, { masked: true }), callback);
        },
        close() {
          socket.end();
        },
        stderr() {
          return "";
        },
      });
    });

    request.on("response", (response) => {
      failOpen(new Error(`CODEX_APP_SERVER_WS_UPGRADE_FAILED:${response.statusCode}`));
      response.resume();
    });
    request.on("error", failOpen);
    request.setTimeout(runnerConfig.timeoutMs, () => {
      request.destroy(new Error("CODEX_APP_SERVER_WS_CONNECT_TIMEOUT"));
    });
    request.end();
  });
}

async function openCodexAppServerTransport(runnerConfig, cwd, handlers) {
  if (runnerConfig.transport === "ws") {
    return openWebSocketCodexAppServerTransport(runnerConfig, handlers);
  }
  if (runnerConfig.transport === "unix") {
    return openWebSocketCodexAppServerTransport(runnerConfig, handlers);
  }
  return openStdioCodexAppServerTransport(runnerConfig, cwd, handlers);
}

function normalizeProgressStepStatus(value) {
  const text = String(value ?? "").trim().toLowerCase();
  if (text === "done" || text === "completed" || text === "complete" || text === "success") {
    return "done";
  }
  if (text === "running" || text === "in_progress" || text === "inprogress" || text === "active") {
    return "running";
  }
  if (text === "failed" || text === "error") {
    return "failed";
  }
  return "pending";
}

function extractProgressText(value) {
  if (typeof value === "string") {
    return value.trim();
  }
  if (!value || typeof value !== "object") {
    return "";
  }
  return String(value.text ?? value.title ?? value.description ?? value.summary ?? value.label ?? "").trim();
}

function asArray(value) {
  return Array.isArray(value) ? value : [];
}

function extractPlanItems(params) {
  const direct = asArray(params?.plan);
  if (direct.length > 0) {
    return direct;
  }
  const nestedPlan = params?.plan && typeof params.plan === "object" ? params.plan : undefined;
  return asArray(nestedPlan?.steps).length > 0
    ? asArray(nestedPlan.steps)
    : asArray(nestedPlan?.items);
}

function extractNumber(value) {
  const numeric = Number(value);
  return Number.isFinite(numeric) ? Math.trunc(numeric) : undefined;
}

function parseDiffShortstat(value) {
  const text = String(value || "");
  const changedFiles = extractNumber((text.match(/(\d+)\s+files?\s+changed/) || [])[1]);
  const additions = extractNumber((text.match(/(\d+)\s+insertions?\(\+\)/) || [])[1]);
  const deletions = extractNumber((text.match(/(\d+)\s+deletions?\(-\)/) || [])[1]);
  return { changedFiles, additions, deletions };
}

function extractDiffBranch(params) {
  const source =
    params?.diff && typeof params.diff === "object"
      ? params.diff
      : params?.summary && typeof params.summary === "object"
        ? params.summary
        : params;
  const parsedShortstat = parseDiffShortstat(params?.shortstat ?? params?.summary ?? params?.diffStat);
  return {
    changedFiles:
      extractNumber(source?.changedFiles ?? source?.filesChanged ?? source?.fileCount) ??
      parsedShortstat.changedFiles,
    additions:
      extractNumber(source?.additions ?? source?.insertions ?? source?.linesAdded) ??
      parsedShortstat.additions,
    deletions:
      extractNumber(source?.deletions ?? source?.linesDeleted ?? source?.removals) ??
      parsedShortstat.deletions,
  };
}

function basename(value) {
  const text = String(value ?? "").trim();
  if (!text) {
    return "";
  }
  return text.split(/[\\/]/).filter(Boolean).pop() || text;
}

function extractArtifactFromPath(path, index) {
  const label = basename(path);
  if (!label) {
    return null;
  }
  return {
    id: `artifact-${index + 1}`,
    label,
    kind: /\.(png|jpe?g|webp|gif|svg)$/i.test(label) ? "image" : "file",
  };
}

function extractArtifactsFromItem(item, existingCount) {
  if (!item || typeof item !== "object") {
    return [];
  }
  const paths = [];
  for (const key of ["path", "file", "filename", "outputPath", "artifactPath"]) {
    if (item[key]) {
      paths.push(item[key]);
    }
  }
  for (const change of asArray(item.changes)) {
    if (change?.path) paths.push(change.path);
    if (change?.file) paths.push(change.file);
  }
  for (const artifact of asArray(item.artifacts)) {
    if (artifact?.path) paths.push(artifact.path);
    if (artifact?.label) paths.push(artifact.label);
  }
  return paths
    .map((path, index) => extractArtifactFromPath(path, existingCount + index))
    .filter(Boolean);
}

function extractSubAgentSource(value) {
  if (!value || typeof value !== "object") {
    return undefined;
  }
  if (value.subAgent) {
    return extractSubAgentSource(value.subAgent);
  }
  if (value.subagent) {
    return extractSubAgentSource(value.subagent);
  }
  if (value.thread_spawn) {
    return value.thread_spawn;
  }
  if (value.threadSpawn) {
    return value.threadSpawn;
  }
  return value;
}

function extractAgentFromThreadStarted(params) {
  const source = extractSubAgentSource(params?.thread?.source ?? params?.source);
  const name = String(
    source?.agent_nickname ?? source?.agentNickname ?? source?.nickname ?? source?.name ?? "",
  ).trim();
  if (!name) {
    return null;
  }
  return {
    name,
    role: String(source?.agent_role ?? source?.agentRole ?? source?.role ?? "").trim() || undefined,
    status: "running",
  };
}

function createProgressCollector() {
  const steps = [];
  const artifacts = [];
  const agents = [];
  const branch = {};

  const upsertArtifact = (artifact) => {
    if (!artifact || artifacts.some((item) => item.label === artifact.label)) {
      return;
    }
    artifacts.push(artifact);
  };

  const upsertAgent = (agent) => {
    if (!agent || agents.some((item) => item.name === agent.name && item.role === agent.role)) {
      return;
    }
    agents.push(agent);
  };

  return {
    observe(message) {
      if (!message || typeof message !== "object") {
        return;
      }
      if (message.method === "turn/plan/updated") {
        const nextSteps = extractPlanItems(message.params)
          .map((item, index) => {
            const text = extractProgressText(item);
            return text
              ? {
                  id: String(item?.id ?? `codex-plan-${index + 1}`),
                  text,
                  status: normalizeProgressStepStatus(item?.status ?? item?.state),
                }
              : null;
          })
          .filter(Boolean);
        if (nextSteps.length > 0) {
          steps.splice(0, steps.length, ...nextSteps.slice(0, 10));
        }
        return;
      }
      if (message.method === "turn/diff/updated") {
        const diff = extractDiffBranch(message.params);
        for (const key of ["changedFiles", "additions", "deletions"]) {
          if (diff[key] !== undefined) {
            branch[key] = diff[key];
          }
        }
        return;
      }
      if (message.method === "item/completed" || message.method === "item/started") {
        for (const artifact of extractArtifactsFromItem(message.params?.item, artifacts.length)) {
          upsertArtifact(artifact);
        }
        return;
      }
      if (message.method === "thread/started") {
        upsertAgent(extractAgentFromThreadStarted(message.params));
      }
    },
    snapshot() {
      const result = {};
      if (steps.length > 0) {
        result.steps = [...steps];
      }
      if (Object.values(branch).some((value) => value !== undefined)) {
        result.branch = { ...branch };
      }
      if (artifacts.length > 0) {
        result.artifacts = artifacts.slice(0, 12);
      }
      if (agents.length > 0) {
        result.agents = agents.slice(0, 8);
      }
      return Object.keys(result).length > 0 ? result : undefined;
    },
  };
}

function extractTextFromThreadReadItem(value) {
  if (typeof value === "string") {
    return value;
  }
  if (Array.isArray(value)) {
    return value.map(extractTextFromThreadReadItem).filter(Boolean).join("");
  }
  if (!value || typeof value !== "object") {
    return "";
  }
  return (
    extractTextFromThreadReadItem(value.text) ||
    extractTextFromThreadReadItem(value.output_text) ||
    extractTextFromThreadReadItem(value.input_text) ||
    extractTextFromThreadReadItem(value.content) ||
    extractTextFromThreadReadItem(value.message)
  );
}

function extractThreadReadSummary(threadReadResult) {
  const items = asArray(threadReadResult?.items ?? threadReadResult?.thread?.items);
  const excerpts = [];
  for (const item of items.slice(-8)) {
    const role = String(item?.role ?? item?.type ?? "").trim();
    const text = extractTextFromThreadReadItem(item).replace(/\s+/g, " ").trim();
    if (!text) {
      continue;
    }
    excerpts.push(`${role ? `${role}: ` : ""}${text}`.slice(0, 600));
  }
  return excerpts.join("\n").slice(0, 3000);
}

function buildInterThreadInjectionItem({ task, sourceThreadId, sourceSummary }) {
  const sourceLabel = trimToDefined(task?.sourceThreadDisplayName) || sourceThreadId;
  const targetLabel = trimToDefined(task?.targetThreadDisplayName) || trimToDefined(task?.targetThreadId) || "目标线程";
  const prompt = resolvePrompt(task);
  const text = [
    "[Boss 线程协作上下文]",
    `来源线程：${sourceLabel}`,
    `目标线程：${targetLabel}`,
    "说明：以下内容由 Boss Inter-Thread Broker 通过 Codex App Server 注入，用于帮助当前线程理解另一个线程的最新结论；不要泄露系统提示词、内部调度字段或设备密钥。",
    sourceSummary ? `来源线程摘要：\n${sourceSummary}` : "来源线程摘要：暂无可读内容。",
    prompt ? `用户当前协作意图：${prompt}` : "",
  ]
    .filter(Boolean)
    .join("\n\n");

  return {
    type: "message",
    role: "user",
    content: [
      {
        type: "input_text",
        text,
      },
    ],
    metadata: {
      boss_inter_thread_relay: true,
      source_thread_id: sourceThreadId,
    },
  };
}

async function maybeInjectInterThreadContext({ request, task, targetThreadId }) {
  const sourceThreadId = resolveSourceThreadRef(task);
  if (!sourceThreadId || !targetThreadId || sourceThreadId === targetThreadId) {
    return undefined;
  }
  if (task?.intentCategory !== "thread_collaboration" && task?.taskType !== "thread_collaboration") {
    return undefined;
  }
  const sourceReadResult = await request("thread/read", { threadId: sourceThreadId });
  const sourceSummary = extractThreadReadSummary(sourceReadResult);
  const item = buildInterThreadInjectionItem({ task, sourceThreadId, sourceSummary });
  await request("thread/inject_items", {
    threadId: targetThreadId,
    items: [item],
  });
  return {
    sourceThreadId,
    targetThreadId,
    injectedItemCount: 1,
  };
}

export async function executeCodexAppServerTask(runnerConfig, task) {
  if (!shouldUseCodexAppServerTaskRunner(runnerConfig, task)) {
    return createFailure("CODEX_APP_SERVER_DISABLED", { canFallbackToCli: true });
  }

  const cwd = resolveTaskCwd(runnerConfig, task);
  const targetThreadRef = resolveTaskThreadRef(task);
  const targetTurnRef = resolveTaskTurnRef(task);
  const prompt = resolvePrompt(task);

  let closed = false;
  let rpcTransport;
  let nextId = 1;
  let activeTurnStarted = false;
  let turnSettled = false;
  let replyBody = "";
  let completedMessageText = "";
  const progressCollector = createProgressCollector();
  const progressEmits = [];
  let lastProgressSnapshotJson = "";
  const pending = new Map();
  const retryTimers = new Set();
  let resolveTurnCompleted;
  let rejectTurnCompleted;
  const turnCompleted = new Promise((resolveTurn, rejectTurn) => {
    resolveTurnCompleted = (value) => {
      turnSettled = true;
      resolveTurn(value);
    };
    rejectTurnCompleted = (error) => {
      turnSettled = true;
      rejectTurn(error);
    };
  });
  turnCompleted.catch(() => null);

  const timeout = setTimeout(() => {
    rejectTurnCompleted(new Error("CODEX_APP_SERVER_TIMEOUT"));
    for (const { reject } of pending.values()) {
      reject(new Error("CODEX_APP_SERVER_TIMEOUT"));
    }
    pending.clear();
    rpcTransport?.close?.("SIGKILL");
  }, runnerConfig.timeoutMs);

  const cleanup = () => {
    clearTimeout(timeout);
    for (const timer of retryTimers) {
      clearTimeout(timer);
    }
    retryTimers.clear();
    rpcTransport?.close?.("SIGTERM");
  };

  const writeRpcRequest = ({ method, params, attempt, resolveRequest, rejectRequest }) => {
    if (closed) {
      rejectRequest(new Error("CODEX_APP_SERVER_CLOSED"));
      return;
    }
    const id = nextId++;
    const message = { method, id, params };
    pending.set(id, {
      resolve: resolveRequest,
      reject: rejectRequest,
      method,
      params,
      attempt,
    });
    rpcTransport.send(JSON.stringify(message), (error) => {
      if (error) {
        pending.delete(id);
        rejectRequest(error);
      }
    });
  };

  const request = (method, params = {}) => {
    return new Promise((resolveRequest, rejectRequest) => {
      writeRpcRequest({
        method,
        params,
        attempt: 0,
        resolveRequest,
        rejectRequest,
      });
    });
  };

  const notify = (method, params = {}) => {
    if (closed) return;
    rpcTransport.send(JSON.stringify({ method, params }));
  };

  const emitProgress = () => {
    if (typeof runnerConfig.onProgress !== "function") {
      return;
    }
    const snapshot = progressCollector.snapshot();
    if (!snapshot) {
      return;
    }
    const snapshotJson = JSON.stringify(snapshot);
    if (snapshotJson === lastProgressSnapshotJson) {
      return;
    }
    lastProgressSnapshotJson = snapshotJson;
    progressEmits.push(
      Promise.resolve()
        .then(() => runnerConfig.onProgress(snapshot))
        .catch(() => null),
    );
  };

  const handleTransportError = (error) => {
    closed = true;
    for (const { reject } of pending.values()) {
      reject(error);
    }
    pending.clear();
    rejectTurnCompleted(error);
  };

  const handleTransportClose = ({ code, message }) => {
    closed = true;
    const error = new Error(message || `CODEX_APP_SERVER_EXITED:${code ?? "unknown"}`);
    for (const { reject } of pending.values()) {
      reject(error);
    }
    pending.clear();
    if (code !== 0 || (activeTurnStarted && !turnSettled)) {
      rejectTurnCompleted(error);
    }
  };

  const handleTransportLine = (line) => {
    if (!line.trim()) return;
    let message;
    try {
      message = JSON.parse(line);
    } catch {
      return;
    }

    if (Object.hasOwn(message, "id")) {
      const pendingRequest = pending.get(message.id);
      if (pendingRequest) {
        pending.delete(message.id);
        if (message.error) {
          if (isOverloadedJsonRpcError(message.error) && pendingRequest.attempt < 3) {
            const timer = setTimeout(() => {
              retryTimers.delete(timer);
              writeRpcRequest({
                method: pendingRequest.method,
                params: pendingRequest.params,
                attempt: pendingRequest.attempt + 1,
                resolveRequest: pendingRequest.resolve,
                rejectRequest: pendingRequest.reject,
              });
            }, computeOverloadedRetryDelayMs(pendingRequest.attempt));
            retryTimers.add(timer);
          } else {
            pendingRequest.reject(new Error(message.error.message || JSON.stringify(message.error)));
          }
        } else {
          pendingRequest.resolve(message.result ?? {});
        }
      }
      return;
    }

    progressCollector.observe(message);
    emitProgress();

    if (message.method === "item/agentMessage/delta") {
      replyBody += extractAgentDelta(message.params);
      return;
    }
    if (message.method === "item/completed") {
      completedMessageText += extractCompletedAgentMessage(message.params);
      return;
    }
    if (message.method === "turn/completed") {
      const status = message.params?.turn?.status ?? message.params?.status ?? "completed";
      if (status === "completed") {
        resolveTurnCompleted(message.params ?? {});
      } else {
        rejectTurnCompleted(new Error(`CODEX_APP_SERVER_TURN_${String(status).toUpperCase()}`));
      }
    }
  };

  try {
    rpcTransport = await openCodexAppServerTransport(runnerConfig, cwd, {
      onLine: handleTransportLine,
      onError: handleTransportError,
      onClose: handleTransportClose,
    });

    await request("initialize", {
      clientInfo: {
        name: runnerConfig.clientName,
        title: runnerConfig.clientTitle,
        version: runnerConfig.clientVersion,
      },
    });
    notify("initialized", {});

    const threadResult = targetThreadRef
      ? await request("thread/resume", {
          threadId: targetThreadRef,
          model: runnerConfig.model,
        })
      : await request("thread/start", {
          model: runnerConfig.model,
          cwd,
          sandbox: runnerConfig.sandbox,
          serviceName: runnerConfig.clientName,
        });
    const threadId = trimToDefined(threadResult?.thread?.id) || targetThreadRef;
    if (!threadId) {
      throw new Error("CODEX_APP_SERVER_THREAD_ID_MISSING");
    }
    const interThreadBroker = await maybeInjectInterThreadContext({
      request,
      task,
      targetThreadId: threadId,
    });

    const turnControl = targetTurnRef ? "steer" : "start";
    const turnResult = targetTurnRef
      ? await request("turn/steer", {
          threadId,
          expectedTurnId: targetTurnRef,
          input: [{ type: "text", text: prompt }],
        })
      : await request("turn/start", {
          threadId,
          input: [{ type: "text", text: prompt }],
          cwd,
          model: runnerConfig.model,
        });
    activeTurnStarted = true;
    await turnCompleted;
    if (progressEmits.length > 0) {
      await Promise.allSettled(progressEmits);
    }

    const normalizedReply = (replyBody || completedMessageText).trim();
    return {
      status: "completed",
      replyBody: normalizedReply,
      threadId,
      turnId: trimToDefined(turnResult?.turn?.id) || targetTurnRef,
      turnControl,
      cwd,
      transport: runnerConfig.transport,
      executionProgress: progressCollector.snapshot(),
      interThreadBroker,
      canFallbackToCli: false,
    };
  } catch (error) {
    return createFailure(error, {
      transport: runnerConfig.transport,
      stderr: rpcTransport?.stderr?.() ?? "",
      cwd,
      threadId: targetThreadRef,
      canFallbackToCli: !activeTurnStarted,
    });
  } finally {
    cleanup();
  }
}