freecodego 0.1.6-alpha.2

package/dist/workers/codex-worker.js

@@ -0,0 +1,1127 @@
+// packages/freecodego/runtime-codex/lib/worker.mjs
+import { access, copyFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { randomBytes, randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { effectiveSandboxMode, redactSecrets } from "@deepseek-ai/dsh-freecodego-native-runtime-protocol";
+var MAX_WORKER_FRAME_BYTES = 1e6;
+var MAX_TOOL_RESULT_TEXT_BYTES = 9e5;
+var FRAME_TOO_LARGE = "FRAME_TOO_LARGE";
+function bytesOf(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function boundToolResultText(text, budget = MAX_TOOL_RESULT_TEXT_BYTES) {
+  const limit = Number.isFinite(budget) && budget > 0 ? Math.max(256, Math.floor(budget)) : MAX_TOOL_RESULT_TEXT_BYTES;
+  if (bytesOf(text) <= limit) return text;
+  const marker = "\n\n\u2026 [result truncated: this output exceeded the transport limit; ask for a narrower range, a page, or a filter to see the rest]";
+  const markerBytes = bytesOf(marker);
+  let kept = "";
+  let used = 0;
+  for (const character of text) {
+    const size = bytesOf(character);
+    if (used + size + markerBytes > limit) break;
+    kept += character;
+    used += size;
+  }
+  return `${kept}${marker}`;
+}
+function workerFrame(message, maxBytes = MAX_WORKER_FRAME_BYTES) {
+  const ceiling = Number.isFinite(maxBytes) && maxBytes > 0 ? Math.max(256, Math.floor(maxBytes)) : MAX_WORKER_FRAME_BYTES;
+  const line = `${JSON.stringify(message) ?? "null"}
+`;
+  const originalBytes = bytesOf(line);
+  if (originalBytes <= ceiling) return {
+    line,
+    replaced: false,
+    originalBytes
+  };
+  const id = message?.id;
+  if (typeof id === "string") {
+    const reply2 = `${JSON.stringify({
+      id,
+      error: {
+        code: FRAME_TOO_LARGE,
+        message: `this reply is ${String(originalBytes)} bytes and the worker transport carries at most ${String(ceiling)}; ask for a narrower range, a page, or a filter and retry`
+      }
+    })}
+`;
+    if (bytesOf(reply2) <= ceiling) return {
+      line: reply2,
+      replaced: true,
+      originalBytes
+    };
+    return {
+      line: `${JSON.stringify({
+        id,
+        error: {
+          code: FRAME_TOO_LARGE,
+          message: "the reply exceeded the frame ceiling"
+        }
+      })}
+`,
+      replaced: true,
+      originalBytes
+    };
+  }
+  const method = message?.method;
+  const notice = `${JSON.stringify({
+    ...typeof method === "string" ? { method } : {},
+    params: {
+      truncated: true,
+      originalBytes,
+      reason: `this frame was ${String(originalBytes)} bytes, over the ${String(ceiling)}-byte ceiling this worker writes within, so its payload was dropped`
+    }
+  })}
+`;
+  if (bytesOf(notice) <= ceiling) return {
+    line: notice,
+    replaced: true,
+    originalBytes
+  };
+  return {
+    line: `${JSON.stringify({ params: {
+      truncated: true,
+      originalBytes
+    } })}
+`,
+    replaced: true,
+    originalBytes
+  };
+}
+function record$2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringify(value) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? null);
+}
+function mcpToolResult(value) {
+  const result = record$2(value);
+  const content = (Array.isArray(result.content) ? result.content : []).flatMap((block) => projectBlock(block)).map((block) => ({
+    type: "text",
+    text: boundToolResultText(block.text)
+  }));
+  return {
+    content: content.length === 0 ? [{
+      type: "text",
+      text: boundToolResultText(stringify(value))
+    }] : content,
+    ...isFailure(result) ? { isError: true } : {}
+  };
+}
+function isFailure(result) {
+  const error = result.error;
+  if (typeof error === "string" ? error !== "" : error !== void 0 && error !== null) return true;
+  const flag = result.isError;
+  if (flag === void 0 || flag === null || flag === false || flag === 0 || flag === "") return false;
+  return true;
+}
+function projectBlock(block) {
+  const candidate = record$2(block);
+  if (candidate.type === "text" && typeof candidate.text === "string") return [{
+    type: "text",
+    text: candidate.text
+  }];
+  if (candidate.type === "image") {
+    const attachment = record$2(candidate.attachment);
+    return [{
+      type: "text",
+      text: typeof attachment.attachmentId === "string" ? `Generated image attachment: ${attachment.attachmentId}` : "Generated image (unavailable to this transport)"
+    }];
+  }
+  try {
+    return [{
+      type: "text",
+      text: JSON.stringify(block)
+    }];
+  } catch {
+    return [{
+      type: "text",
+      text: String(block)
+    }];
+  }
+}
+var ACCEPT_DECLINE_METHODS = /* @__PURE__ */ new Set(["item/commandExecution/requestApproval", "item/fileChange/requestApproval"]);
+var APPROVED_DENIED_METHODS = /* @__PURE__ */ new Set(["applyPatchApproval", "execCommandApproval"]);
+var PERMISSIONS_METHOD = "item/permissions/requestApproval";
+function isApprovalMethod(method) {
+  return ACCEPT_DECLINE_METHODS.has(method) || APPROVED_DENIED_METHODS.has(method) || method === PERMISSIONS_METHOD;
+}
+function record$1(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function approvalResponse(method, response, params) {
+  const outcome = record$1(response);
+  const approved = outcome.type === "approved";
+  if (ACCEPT_DECLINE_METHODS.has(method)) return { decision: approved ? "accept" : "decline" };
+  if (APPROVED_DENIED_METHODS.has(method)) {
+    if (approved) return { decision: "approved" };
+    return { decision: { denied: { rejection: nonEmptyString(outcome.message) ?? "User denied this request" } } };
+  }
+  if (method === PERMISSIONS_METHOD) {
+    const requested = record$1(record$1(params).permissions);
+    return approved ? {
+      permissions: requested,
+      scope: "turn"
+    } : { permissions: {} };
+  }
+  return response;
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function questionResponse(answer) {
+  const entries = record(answer).answers;
+  const answers = {};
+  if (!Array.isArray(entries)) return { answers };
+  for (const entry of entries) {
+    const item = record(entry);
+    const id = typeof item.id === "string" ? item.id : "";
+    if (id === "") continue;
+    const selected = Array.isArray(item.selected) ? item.selected.filter((value) => typeof value === "string") : [];
+    const custom = typeof item.custom === "string" && item.custom !== "" ? [item.custom] : [];
+    const collected = [...selected, ...custom];
+    answers[id] = { answers: [...answers[id]?.answers ?? [], ...collected] };
+  }
+  return { answers };
+}
+function codexThreadSandboxParams(fields) {
+  const mode = effectiveSandboxMode(fields);
+  if (mode === void 0) return {};
+  if (mode !== "read-only") return { sandbox: mode };
+  return fields.readOnly === true ? {
+    sandbox: "read-only",
+    approvalPolicy: "never"
+  } : {
+    sandbox: "read-only",
+    approvalPolicy: "on-request"
+  };
+}
+function harnessMcpRoute(capabilities2, name) {
+  if (name === "freecodego_skill_discover" || name === "freecodego_skill_load") {
+    if (!capabilities2.skillEnabled) throw new Error(`Harness tool "${name}" is unavailable`);
+    return {
+      bridge: "skill",
+      op: name === "freecodego_skill_discover" ? "list" : "load"
+    };
+  }
+  if (capabilities2.mcpEnabled && capabilities2.mcpTools.some((tool) => tool.name === name)) return {
+    bridge: "mcp",
+    op: "execute"
+  };
+  if (!capabilities2.harnessTools.some((tool) => tool.name === name)) throw new Error(`Harness tool "${name}" is unavailable`);
+  return {
+    bridge: "tool",
+    op: "execute"
+  };
+}
+var sequence = 0;
+var rpcId = 0;
+var child;
+var threadId;
+var turnId;
+var harnessSessionId;
+var modelId;
+var modelProvider;
+var selectedProvider;
+var stderr = "";
+var pending = /* @__PURE__ */ new Map();
+var approvals = /* @__PURE__ */ new Map();
+var questions = /* @__PURE__ */ new Map();
+var pendingBridges = /* @__PURE__ */ new Map();
+var MANAGED_MCP_START = "# freecodego-managed-mcp:start";
+var MANAGED_MCP_END = "# freecodego-managed-mcp:end";
+var DISPOSE_GRACE_MS = 5e3;
+var capabilities = {
+  mcpEnabled: false,
+  skillEnabled: false,
+  skillRoots: [],
+  mcpTools: [],
+  harnessTools: []
+};
+var capabilityEnvironment = {};
+var harnessMcpServer;
+var harnessMcpUrl;
+var harnessMcpToken = randomBytes(32).toString("base64url");
+function explicitModel() {
+  return modelId === void 0 || modelId === "" || modelId === "codex-auto" ? void 0 : modelId;
+}
+function usesOpenAiBridge() {
+  return process.env.FREECODEGO_CODEX_PROVIDER_OVERRIDE === "openai";
+}
+function appServerProvider() {
+  return usesOpenAiBridge() ? "openai" : void 0;
+}
+function appServerModel(reasoningEffort) {
+  const model = explicitModel();
+  if (model === void 0 || !usesOpenAiBridge()) return model;
+  const provider = (selectedProvider ?? "freecodego").trim();
+  return `freecodego-route:${Buffer.from(provider, "utf8").toString("base64url")}.${Buffer.from(model, "utf8").toString("base64url")}${reasoningEffort === "off" || reasoningEffort === "low" || reasoningEffort === "medium" || reasoningEffort === "high" || reasoningEffort === "xhigh" || reasoningEffort === "max" ? `.${reasoningEffort}` : ""}`;
+}
+function selectedReasoningEffort(value) {
+  return value === "off" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max" ? value : "high";
+}
+function codexReasoningEffort(value) {
+  const effort = selectedReasoningEffort(value);
+  return effort === "off" ? "low" : effort;
+}
+function codexTurnStatus(value) {
+  const status = asString(value);
+  if (status === "completed") return "completed";
+  if (status === "interrupted") return "cancelled";
+  return "failed";
+}
+function appServerTurnFailure(error) {
+  const detail = asRecord(error);
+  const message = asString(detail.message) ?? "";
+  const additional = asString(detail.additionalDetails) ?? "";
+  if (message === "") return additional === "" ? "Codex turn failed" : redactAppServerDetail(additional);
+  return redactAppServerDetail(additional === "" || message.includes(additional) ? message : `${message} (${additional})`);
+}
+function codexConfig(systemPrompt, reasoningEffort) {
+  return {
+    model_reasoning_effort: reasoningEffort,
+    model_reasoning_summary: "detailed",
+    ...typeof systemPrompt === "string" && systemPrompt.trim() !== "" ? { developer_instructions: systemPrompt } : {}
+  };
+}
+function send(message) {
+  const frame = workerFrame(message);
+  if (frame.replaced) process.stderr.write(`freecodego-codex-worker: replaced an oversized frame (${String(frame.originalBytes)} bytes over the ${String(MAX_WORKER_FRAME_BYTES)}-byte ceiling)
+`);
+  process.stdout.write(frame.line);
+}
+function event(method, params = {}) {
+  if (threadId === void 0 || harnessSessionId === void 0) return;
+  send({
+    method,
+    params: {
+      runtimeSessionId: threadId,
+      harnessSessionId,
+      sequence: ++sequence,
+      ...params
+    }
+  });
+}
+function request(method, params) {
+  if (child === void 0) return Promise.reject(/* @__PURE__ */ new Error("Codex app-server is not running"));
+  const id = ++rpcId;
+  const promise = new Promise((resolve, reject) => pending.set(id, {
+    resolve,
+    reject
+  }));
+  try {
+    child.stdin.write(`${JSON.stringify({
+      id,
+      method,
+      params
+    })}
+`);
+  } catch (error) {
+    pending.delete(id);
+    return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+  }
+  return promise;
+}
+var CODEX_TURN_IDLE_MS = 15 * 6e4;
+function turnIdleMs() {
+  const override = Number(process.env.FREECODEGO_CODEX_TURN_IDLE_MS);
+  return Number.isFinite(override) && override > 0 ? override : CODEX_TURN_IDLE_MS;
+}
+function armTurnWatchdog() {
+  if (turnWatchdog !== void 0) clearTimeout(turnWatchdog);
+  turnWatchdog = setTimeout(() => {
+    turnWatchdog = void 0;
+    const hungTurn = turnId;
+    turnId = void 0;
+    const message = "Codex turn produced no events within the watchdog window";
+    clearPendingBridges(message);
+    event("session/completed", {
+      status: "failed",
+      message
+    });
+    if (hungTurn !== void 0 && threadId !== void 0) request("turn/interrupt", {
+      threadId,
+      turnId: hungTurn
+    }).catch(() => void 0);
+  }, turnIdleMs());
+}
+function disarmTurnWatchdog() {
+  if (turnWatchdog !== void 0) {
+    clearTimeout(turnWatchdog);
+    turnWatchdog = void 0;
+  }
+}
+function refreshTurnWatchdog() {
+  if (turnWatchdog === void 0 && turnId === void 0) return;
+  armTurnWatchdog();
+}
+var turnWatchdog;
+function reply(id, result, error) {
+  send(error === void 0 ? {
+    id,
+    result
+  } : {
+    id,
+    error: {
+      code: "CODEX_WORKER",
+      message: redactAppServerDetail(error.message)
+    }
+  });
+}
+function start() {
+  if (child !== void 0) return child;
+  const executable = process.env.FREECODEGO_CODEX_APP_SERVER;
+  if (executable === void 0 || executable.length === 0) throw new Error("FREECODEGO_CODEX_APP_SERVER is required and must be set from a verified runtime manifest");
+  const args = process.env.FREECODEGO_CODEX_APP_SERVER_ARGS?.split("").filter(Boolean) ?? [];
+  const codexHome = process.env.FREECODEGO_CODEX_HOME;
+  if (codexHome === void 0 || codexHome.length === 0) throw new Error("FREECODEGO_CODEX_HOME is required and must be a plugin-owned state directory");
+  child = spawn(executable, args, {
+    cwd: process.cwd(),
+    env: {
+      PATH: process.env.PATH ?? "",
+      CODEX_HOME: codexHome,
+      ...process.env.OPENAI_API_KEY === void 0 ? {} : { OPENAI_API_KEY: process.env.OPENAI_API_KEY },
+      ...process.env.OPENAI_BASE_URL === void 0 ? {} : { OPENAI_BASE_URL: process.env.OPENAI_BASE_URL },
+      ...capabilityEnvironment
+    },
+    windowsHide: true,
+    stdio: [
+      "pipe",
+      "pipe",
+      "pipe"
+    ]
+  });
+  createInterface({ input: child.stdout }).on("line", (line) => {
+    const trimmed = line.trim();
+    if (trimmed === "" || !(trimmed.startsWith("{") || trimmed.startsWith("["))) {
+      if (trimmed !== "") stderr = `${stderr}${trimmed}
+`.slice(-16 * 1024);
+      return;
+    }
+    try {
+      receiveRpc(JSON.parse(trimmed));
+    } catch (error) {
+      stderr = `${stderr}unparsable stdout frame: ${String(error)}
+`.slice(-16 * 1024);
+    }
+  });
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    stderr = `${stderr}${chunk}`.slice(-16 * 1024);
+  });
+  child.stdin.on("error", () => void 0);
+  const instance = child;
+  child.on("close", () => {
+    if (child !== instance) return;
+    disarmTurnWatchdog();
+    const detail = redactAppServerDetail(stderr.trim());
+    const error = /* @__PURE__ */ new Error(detail === "" ? "Codex app-server exited" : `Codex app-server exited: ${detail}`);
+    for (const entry of pending.values()) entry.reject(error);
+    pending.clear();
+    clearPendingBridges("Codex app-server exited");
+    child = void 0;
+    event("session/failed", { message: error.message });
+  });
+  return child;
+}
+async function prepareCodexHome() {
+  const target = process.env.FREECODEGO_CODEX_HOME;
+  if (!target) return;
+  await mkdir(target, { recursive: true });
+  if (process.env.FREECODEGO_CODEX_SYNC_GLOBAL_AUTH === "1") {
+    const home = process.env.CODEX_GLOBAL_HOME?.trim() || join(process.env.USERPROFILE || process.env.HOME || "", ".codex");
+    if (home && home !== target) for (const name of ["auth.json"]) {
+      const source = join(home, name);
+      const destination = join(target, name);
+      try {
+        await access(destination);
+        continue;
+      } catch {
+      }
+      try {
+        await copyFile(source, destination);
+      } catch {
+      }
+    }
+  }
+  await ensureHarnessMcpServer();
+  await writeManagedMcpConfig(target);
+}
+async function writeManagedMcpConfig(home) {
+  const target = join(home, "config.toml");
+  let existing = "";
+  try {
+    existing = await readFile(target, "utf8");
+  } catch {
+  }
+  const start2 = existing.indexOf(MANAGED_MCP_START);
+  const end = existing.indexOf(MANAGED_MCP_END);
+  const hasManagedSegment = start2 >= 0 && end >= start2;
+  if (hasManagedSegment) existing = `${existing.slice(0, start2)}${existing.slice(end + 28)}`.trimEnd();
+  existing = stripMcpServerTables(existing);
+  const rendered = renderManagedMcpConfig();
+  if (rendered === "" && !hasManagedSegment) return;
+  const temporary = `${target}.tmp-${process.pid}`;
+  await writeFile(temporary, `${existing}${existing === "" || rendered === "" ? "" : "\n\n"}${rendered}${rendered === "" ? "" : "\n"}`, "utf8");
+  await rename(temporary, target);
+}
+function renderManagedMcpConfig() {
+  capabilityEnvironment = {};
+  if (harnessMcpUrl === void 0) return "";
+  capabilityEnvironment.FREECODEGO_CODEX_HARNESS_MCP_TOKEN = harnessMcpToken;
+  return [
+    MANAGED_MCP_START,
+    "[mcp_servers.freecodego-harness]",
+    `url = ${tomlString(harnessMcpUrl)}`,
+    'bearer_token_env_var = "FREECODEGO_CODEX_HARNESS_MCP_TOKEN"',
+    MANAGED_MCP_END
+  ].join("\n\n");
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function stripMcpServerTables(value) {
+  let inMcpSection = false;
+  const retained = [];
+  for (const line of value.split(/\r?\n/)) {
+    const header = line.match(/^\s*\[\[?\s*([^\]]+?)\s*\]\]?\s*(?:#.*)?$/);
+    if (header !== null) {
+      inMcpSection = /^mcp_servers(?:\s*\.|$)/.test((header[1] ?? "").trim());
+      if (!inMcpSection) retained.push(line);
+      continue;
+    }
+    if (!inMcpSection && !/^\s*mcp_servers\s*(?:\.|=)/.test(line)) retained.push(line);
+  }
+  return retained.join("\n").trimEnd();
+}
+function readCapabilities(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return {
+    mcpEnabled: false,
+    skillEnabled: false,
+    skillRoots: [],
+    mcpTools: [],
+    harnessTools: []
+  };
+  const input = value;
+  return {
+    mcpEnabled: input.mcpEnabled === true,
+    skillEnabled: input.skillEnabled === true,
+    skillRoots: input.skillEnabled === true ? strings(input.skillRoots) : [],
+    mcpTools: input.mcpEnabled === true ? readHarnessTools(input.mcpTools) : [],
+    harnessTools: readHarnessTools(input.harnessTools)
+  };
+}
+function readHarnessTools(value) {
+  if (!Array.isArray(value)) return [];
+  const tools = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) continue;
+    const tool = item;
+    if (typeof tool.name !== "string" || !/^[A-Za-z0-9_-]{1,96}$/.test(tool.name) || names.has(tool.name)) continue;
+    names.add(tool.name);
+    tools.push({
+      name: tool.name,
+      description: typeof tool.description === "string" ? tool.description : tool.name,
+      parameters: typeof tool.parameters === "object" && tool.parameters !== null && !Array.isArray(tool.parameters) ? tool.parameters : {
+        type: "object",
+        properties: {}
+      }
+    });
+  }
+  return tools;
+}
+function strings(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim() !== "") : [];
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asMessage(value) {
+  const direct = asString(value);
+  if (direct !== void 0) return direct;
+  if (value === void 0 || value === null) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+async function configureCodexSkills() {
+  await request("skills/extraRoots/set", { extraRoots: capabilities.skillEnabled ? capabilities.skillRoots : [] });
+}
+async function ensureHarnessMcpServer() {
+  if (harnessMcpUrl !== void 0 || capabilities.harnessTools.length === 0 && capabilities.mcpTools.length === 0 && !capabilities.skillEnabled) return;
+  const server = createServer((request2, response) => {
+    handleHarnessMcpRequest(request2, response).catch((error) => {
+      mcpError(response, void 0, error);
+    });
+  });
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.close(() => void 0);
+      reject(error);
+    };
+    server.once("error", onError);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", onError);
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        server.close(() => void 0);
+        reject(/* @__PURE__ */ new Error("Codex Harness MCP server has no TCP address"));
+        return;
+      }
+      harnessMcpServer = server;
+      harnessMcpUrl = `http://127.0.0.1:${address.port}/mcp`;
+      resolve();
+    });
+  });
+}
+async function handleHarnessMcpRequest(request2, response) {
+  if (request2.method !== "POST" || request2.url !== "/mcp" || request2.headers.authorization !== `Bearer ${harnessMcpToken}`) {
+    response.writeHead(404);
+    response.end();
+    return;
+  }
+  const body = await readHttpBody(request2);
+  const message = JSON.parse(body);
+  if (message.id === void 0) {
+    response.writeHead(202);
+    response.end();
+    return;
+  }
+  if (message.method === "initialize") {
+    mcpResult(response, message.id, {
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: {} },
+      serverInfo: {
+        name: "freecodego-harness",
+        version: "1.0.0"
+      }
+    });
+    return;
+  }
+  if (message.method === "tools/list") {
+    mcpResult(response, message.id, { tools: harnessMcpTools() });
+    return;
+  }
+  if (message.method === "tools/call") {
+    const params = typeof message.params === "object" && message.params !== null && !Array.isArray(message.params) ? message.params : {};
+    const name = typeof params.name === "string" ? params.name : "";
+    const args = typeof params.arguments === "object" && params.arguments !== null && !Array.isArray(params.arguments) ? params.arguments : {};
+    try {
+      const result = await invokeHarnessMcpTool(name, args);
+      mcpResult(response, message.id, mcpToolResult(result));
+      return;
+    } catch (error) {
+      mcpResult(response, message.id, {
+        content: [{
+          type: "text",
+          text: redactAppServerDetail(error instanceof Error ? error.message : String(error))
+        }],
+        isError: true
+      });
+      return;
+    }
+  }
+  mcpError(response, message.id, /* @__PURE__ */ new Error(`unsupported Harness MCP method ${String(message.method)}`), -32601);
+}
+function harnessMcpTools() {
+  const mcpTools = capabilities.mcpEnabled ? capabilities.mcpTools : [];
+  const mcpNames = new Set(mcpTools.map((tool) => tool.name));
+  return [
+    ...capabilities.harnessTools.filter((tool) => !mcpNames.has(tool.name)).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.parameters
+    })),
+    ...mcpTools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.parameters
+    })),
+    ...capabilities.skillEnabled ? [{
+      name: "freecodego_skill_discover",
+      description: "List enabled DeepSeek Harness Skills.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    }, {
+      name: "freecodego_skill_load",
+      description: "Load one enabled DeepSeek Harness Skill.",
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string" } },
+        required: ["name"]
+      }
+    }] : []
+  ];
+}
+async function invokeHarnessMcpTool(name, args) {
+  const route = harnessMcpRoute(capabilities, name);
+  if (route.bridge === "skill") return await bridgeCall("skill", route.op, route.op === "load" ? { name: args.name } : {});
+  if (route.bridge === "mcp") return await bridgeCall("mcp", "execute", {
+    name,
+    arguments: args
+  });
+  return await bridgeCall("tool", "execute", {
+    name,
+    arguments: args
+  });
+}
+async function bridgeCall(bridge, op, input) {
+  const requestId = randomUUID();
+  const promise = Promise.withResolvers();
+  pendingBridges.set(requestId, promise);
+  event("bridge/requested", {
+    requestId,
+    bridge,
+    op,
+    input
+  });
+  return await promise.promise;
+}
+function clearPendingBridges(reason) {
+  for (const pending2 of pendingBridges.values()) pending2.reject(new Error(reason));
+  pendingBridges.clear();
+}
+function mcpResult(response, id, result) {
+  response.writeHead(200, { "content-type": "application/json" });
+  response.end(JSON.stringify({
+    jsonrpc: "2.0",
+    id: id ?? null,
+    result
+  }));
+}
+function mcpError(response, id, error, code = -32e3) {
+  response.writeHead(200, { "content-type": "application/json" });
+  response.end(JSON.stringify({
+    jsonrpc: "2.0",
+    id: id ?? null,
+    error: {
+      code,
+      message: redactAppServerDetail(error instanceof Error ? error.message : String(error))
+    }
+  }));
+}
+function readHttpBody(request2) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    request2.on("data", (chunk) => {
+      chunks.push(Buffer.from(chunk));
+    });
+    request2.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    request2.on("error", reject);
+  });
+}
+function receiveRpc(message) {
+  if (message.method === "turn/completed") disarmTurnWatchdog();
+  else refreshTurnWatchdog();
+  if (message.id !== void 0 && (message.result !== void 0 || message.error !== void 0)) {
+    const call = pending.get(message.id);
+    if (call === void 0) return;
+    pending.delete(message.id);
+    if (message.error === void 0) call.resolve(message.result);
+    else call.reject(new Error(redactAppServerDetail(message.error.message)));
+    return;
+  }
+  if (message.id !== void 0 && message.method !== void 0) {
+    const id = message.id;
+    const requestedQuestions = normalizeQuestions(message.params);
+    if (requestedQuestions !== void 0) {
+      const requestId = `question-${id}`;
+      questions.set(requestId, (value) => {
+        sendRpc({
+          id,
+          result: questionResponse(value)
+        });
+      });
+      event("question/requested", {
+        requestId,
+        request: { questions: requestedQuestions }
+      });
+      return;
+    }
+    const method = message.method;
+    if (!isApprovalMethod(method)) {
+      sendRpc({
+        id,
+        error: {
+          code: -32601,
+          message: `FreeCodeGo does not implement the Codex App Server request "${method}"`
+        }
+      });
+      return;
+    }
+    const approvalId = `approval-${id}`;
+    const requestParams = message.params;
+    approvals.set(approvalId, (value) => {
+      sendRpc({
+        id,
+        result: approvalResponse(method, value, requestParams)
+      });
+    });
+    event("permission/requested", {
+      approvalId,
+      method,
+      detail: message.params ?? {}
+    });
+    return;
+  }
+  const params = asRecord(message.params);
+  if (message.method === "item/agentMessage/delta") event("assistant/delta", { text: asString(params.delta) ?? "" });
+  else if (message.method === "item/reasoning/textDelta" || message.method === "item/reasoning/summaryTextDelta") event("assistant/reasoning/delta", {
+    text: asString(params.delta) ?? asString(params.text) ?? "",
+    source: "codex-app-server",
+    sourceLabel: "Codex App Server"
+  });
+  else if (message.method === "item/reasoning/summaryPartAdded") {
+    const part = asRecord(params.part);
+    const added = asString(part.text) ?? asString(part.content) ?? "";
+    if (added !== "") event("assistant/reasoning/delta", {
+      text: added,
+      source: "codex-app-server",
+      sourceLabel: "Codex App Server"
+    });
+  } else if (message.method === "item/completed" && asRecord(params.item).type === "agentMessage") event("assistant/final", { text: asString(asRecord(params.item).text) ?? "" });
+  else if (message.method === "item/completed" && asRecord(params.item).type === "reasoning") {
+    const item = asRecord(params.item);
+    const completed = typeof item.text === "string" ? item.text : Array.isArray(item.summary) ? item.summary.map((part) => asString(asRecord(part).text) ?? "").join("") : "";
+    if (completed !== "") event("assistant/reasoning/final", {
+      text: completed,
+      source: "codex-app-server",
+      sourceLabel: "Codex App Server"
+    });
+  } else if (message.method === "turn/started") turnId = asString(asRecord(params.turn).id) ?? turnId;
+  else if (message.method === "turn/completed") {
+    disarmTurnWatchdog();
+    clearPendingBridges("Codex turn completed");
+    turnId = void 0;
+    const status = codexTurnStatus(asRecord(params.turn).status);
+    const reason = status === "failed" ? appServerTurnFailure(asRecord(params.turn).error) : void 0;
+    event("session/completed", reason === void 0 ? { status } : {
+      status,
+      message: reason
+    });
+  } else if (message.method !== void 0) event("tool/progress", {
+    method: message.method,
+    detail: message.params ?? {}
+  });
+}
+function sendRpc(message) {
+  child?.stdin.write(`${JSON.stringify(message)}
+`);
+}
+function redactAppServerDetail(value) {
+  return redactSecrets(value, [
+    process.env.OPENAI_API_KEY,
+    harnessMcpToken,
+    ...Object.values(capabilityEnvironment)
+  ]);
+}
+function killAppServerTree(dying) {
+  if (process.platform === "win32" && dying.pid !== void 0) {
+    spawn("taskkill", [
+      "/pid",
+      String(dying.pid),
+      "/t",
+      "/f"
+    ], {
+      windowsHide: true,
+      stdio: "ignore"
+    }).on("error", () => void 0);
+    return;
+  }
+  dying.kill();
+}
+async function stopAppServer(dying) {
+  const exited = new Promise((resolve) => {
+    if (dying.exitCode !== null || dying.signalCode !== null) {
+      resolve();
+      return;
+    }
+    dying.once("close", () => {
+      resolve();
+    });
+  });
+  dying.stdin.end();
+  const deadline = setTimeout(() => {
+    killAppServerTree(dying);
+  }, DISPOSE_GRACE_MS);
+  try {
+    await exited;
+  } finally {
+    clearTimeout(deadline);
+  }
+}
+async function handle(message) {
+  if (message.method === "initialize") return {
+    protocolAbi: message.params.protocolVersion,
+    engines: ["codex"],
+    runtimeVersion: "codex-app-server-worker/1"
+  };
+  if (message.method === "host/configure") {
+    capabilities = readCapabilities(message.params);
+    if (child !== void 0) {
+      await ensureHarnessMcpServer();
+      const home = process.env.FREECODEGO_CODEX_HOME;
+      if (home !== void 0 && home !== "") await writeManagedMcpConfig(home);
+      await configureCodexSkills();
+    }
+    return null;
+  }
+  if (message.method === "session/create") {
+    await prepareCodexHome();
+    start();
+    harnessSessionId = asString(message.params.harnessSessionId);
+    modelId = asString(message.params.modelId);
+    selectedProvider = asString(message.params.provider);
+    modelProvider = appServerProvider();
+    const selectedEffort = selectedReasoningEffort(message.params.reasoningEffort);
+    await request("initialize", {
+      clientInfo: {
+        name: "DeepSeek Harness",
+        version: "1"
+      },
+      capabilities: {}
+    });
+    sendRpc({
+      method: "initialized",
+      params: {}
+    });
+    await configureCodexSkills();
+    const started = asRecord(await request("thread/start", {
+      cwd: message.params.workspace,
+      ...codexThreadSandboxParams(message.params),
+      ...appServerModel(selectedEffort) === void 0 ? {} : { model: appServerModel(selectedEffort) },
+      ...modelProvider ? { modelProvider } : {},
+      config: codexConfig(message.params.systemPrompt, codexReasoningEffort(selectedEffort))
+    }));
+    const startedThread = asRecord(started.thread);
+    const startedThreadId = startedThread.id;
+    if (typeof startedThreadId !== "string" || startedThreadId === "") throw new Error("Codex app-server returned no thread id for thread/start");
+    threadId = startedThreadId;
+    if (!usesOpenAiBridge()) {
+      modelId = asString(started.model) ?? asString(startedThread.model) ?? modelId;
+      modelProvider = asString(started.modelProvider) ?? asString(startedThread.modelProvider) ?? modelProvider;
+    }
+    event("session/started", {
+      model: modelId ?? "",
+      provider: selectedProvider ?? modelProvider ?? ""
+    });
+    return {
+      runtimeSessionId: threadId,
+      modelId,
+      provider: selectedProvider ?? modelProvider
+    };
+  }
+  if (message.method === "session/resume") {
+    await prepareCodexHome();
+    start();
+    harnessSessionId = asString(message.params.harnessSessionId);
+    modelId = asString(message.params.modelId);
+    selectedProvider = asString(message.params.provider);
+    modelProvider = appServerProvider();
+    const resumeId = message.params.runtimeSessionId;
+    if (typeof resumeId !== "string" || resumeId.length === 0) throw new Error("Codex resume requires a persisted runtimeSessionId");
+    const selectedEffort = selectedReasoningEffort(message.params.reasoningEffort);
+    await request("initialize", {
+      clientInfo: {
+        name: "DeepSeek Harness",
+        version: "1"
+      },
+      capabilities: {}
+    });
+    sendRpc({
+      method: "initialized",
+      params: {}
+    });
+    await configureCodexSkills();
+    const resumed = asRecord(await request("thread/resume", {
+      threadId: resumeId,
+      cwd: message.params.workspace,
+      ...codexThreadSandboxParams(message.params),
+      ...appServerModel(selectedEffort) === void 0 ? {} : { model: appServerModel(selectedEffort) },
+      ...modelProvider ? { modelProvider } : {},
+      config: codexConfig(message.params.systemPrompt, codexReasoningEffort(selectedEffort))
+    }));
+    const resumedThread = asRecord(resumed.thread);
+    threadId = asString(resumedThread.id) ?? resumeId;
+    if (!usesOpenAiBridge()) {
+      modelId = asString(resumed.model) ?? asString(resumedThread.model) ?? modelId;
+      modelProvider = asString(resumed.modelProvider) ?? asString(resumedThread.modelProvider) ?? modelProvider;
+    }
+    event("session/started", {
+      model: modelId ?? "",
+      provider: selectedProvider ?? modelProvider ?? ""
+    });
+    return {
+      runtimeSessionId: threadId,
+      modelId,
+      provider: selectedProvider ?? modelProvider
+    };
+  }
+  if (message.method === "session/prompt") {
+    if (!threadId) throw new Error("Codex session is not initialized");
+    if (typeof message.params.modelId === "string" && message.params.modelId.trim() !== "") modelId = message.params.modelId;
+    if (typeof message.params.provider === "string" && message.params.provider.trim() !== "") selectedProvider = message.params.provider;
+    const selectedEffort = selectedReasoningEffort(message.params.reasoningEffort);
+    armTurnWatchdog();
+    try {
+      turnId = asString(asRecord(asRecord(await request("turn/start", {
+        threadId,
+        input: [{
+          type: "text",
+          text: message.params.content,
+          text_elements: []
+        }],
+        ...message.params.workspace ? { cwd: message.params.workspace } : {},
+        ...appServerModel(selectedEffort) === void 0 ? {} : { model: appServerModel(selectedEffort) },
+        effort: codexReasoningEffort(selectedEffort),
+        summary: "detailed"
+      })).turn).id) ?? turnId;
+    } catch (error) {
+      disarmTurnWatchdog();
+      throw error;
+    }
+    return null;
+  }
+  if (message.method === "session/cancel") {
+    disarmTurnWatchdog();
+    clearPendingBridges("Codex turn cancelled");
+    if (turnId === void 0) {
+      event("session/completed", { status: "cancelled" });
+      return null;
+    }
+    try {
+      await request("turn/interrupt", {
+        threadId,
+        turnId
+      });
+    } catch (error) {
+      event("session/completed", {
+        status: "failed",
+        message: error instanceof Error ? redactAppServerDetail(error.message) : "Codex turn interrupt failed"
+      });
+      return null;
+    }
+    turnId = void 0;
+    disarmTurnWatchdog();
+    event("session/completed", { status: "cancelled" });
+    return null;
+  }
+  if (message.method === "permission/respond") {
+    const requestId = asString(message.params.requestId) ?? "";
+    const resolve = approvals.get(requestId);
+    if (resolve === void 0) throw new Error("unknown Codex approval request");
+    approvals.delete(requestId);
+    resolve(message.params.response);
+    return null;
+  }
+  if (message.method === "question/respond") {
+    const requestId = asString(message.params.requestId) ?? "";
+    const resolve = questions.get(requestId);
+    if (resolve === void 0) throw new Error("unknown Codex question request");
+    questions.delete(requestId);
+    resolve(message.params.response);
+    return null;
+  }
+  if (message.method === "bridge/respond") {
+    const bridgeId = asString(message.params.requestId) ?? "";
+    const pending2 = pendingBridges.get(bridgeId);
+    if (pending2 === void 0) return null;
+    pendingBridges.delete(bridgeId);
+    const failure = message.params.error;
+    if (failure !== void 0 && failure !== null) pending2.reject(new Error(asMessage(failure) || "bridge call failed"));
+    else pending2.resolve(message.params.result);
+    return null;
+  }
+  if (message.method === "session/dispose") {
+    disarmTurnWatchdog();
+    const dying = child;
+    child = void 0;
+    threadId = void 0;
+    harnessSessionId = void 0;
+    approvals.clear();
+    questions.clear();
+    clearPendingBridges("Codex session disposed");
+    const server = harnessMcpServer;
+    harnessMcpServer = void 0;
+    harnessMcpUrl = void 0;
+    if (dying !== void 0) await stopAppServer(dying);
+    await new Promise((resolve) => {
+      if (server === void 0) resolve();
+      else server.close(() => {
+        resolve();
+      });
+    });
+    return null;
+  }
+  throw new Error(`unsupported Codex worker method ${message.method}`);
+}
+createInterface({ input: process.stdin }).on("line", (line) => {
+  try {
+    const message = parseHostFrame(line);
+    if (message === void 0) throw new Error("Host frame is not a { id, method, params } request object");
+    handle(message).then((result) => {
+      reply(message.id, result);
+    }, (error) => {
+      reply(message.id, void 0, error instanceof Error ? error : new Error(String(error)));
+    });
+  } catch (error) {
+    send({ error: {
+      code: "INVALID_JSON",
+      message: String(error)
+    } });
+  }
+});
+function parseHostFrame(line) {
+  const parsed = JSON.parse(line);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+  const frame = parsed;
+  if (typeof frame.id !== "string" || typeof frame.method !== "string") return void 0;
+  const params = typeof frame.params === "object" && frame.params !== null && !Array.isArray(frame.params) ? frame.params : {};
+  return {
+    id: frame.id,
+    method: frame.method,
+    params
+  };
+}
+function normalizeQuestions(value) {
+  const candidate = typeof value === "object" && value !== null && !Array.isArray(value) ? value.questions : void 0;
+  if (!Array.isArray(candidate) || candidate.length === 0) return void 0;
+  const out = [];
+  for (const item of candidate) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) return void 0;
+    const record2 = item;
+    if (typeof record2.question !== "string" || record2.question.trim() === "") return void 0;
+    const options = Array.isArray(record2.options) ? record2.options.flatMap((option) => {
+      if (typeof option !== "object" || option === null || Array.isArray(option)) return [];
+      const value2 = option;
+      return typeof value2.label === "string" && value2.label.trim() !== "" ? [{
+        label: value2.label,
+        ...typeof value2.description === "string" ? { description: value2.description } : {}
+      }] : [];
+    }) : void 0;
+    out.push({
+      id: typeof record2.id === "string" && record2.id.trim() !== "" ? record2.id : `question-${out.length + 1}`,
+      question: record2.question,
+      ...typeof record2.header === "string" ? { header: record2.header } : {},
+      ...typeof record2.detail === "string" ? { detail: record2.detail } : {},
+      ...typeof record2.multiSelect === "boolean" ? { multiSelect: record2.multiSelect } : {},
+      ...options === void 0 || options.length === 0 ? {} : { options }
+    });
+  }
+  return out;
+}