@pushary/codex-app-server 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,624 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  connect: () => connect,
+  createPusharyCodexHandler: () => createPusharyCodexHandler
+});
+module.exports = __toCommonJS(src_exports);
+var import_adapters2 = require("@pushary/server/adapters");
+
+// src/handler.ts
+var import_node_crypto = require("crypto");
+var import_server2 = require("@pushary/server");
+var import_adapters = require("@pushary/server/adapters");
+
+// src/protocol.ts
+var COMMAND = "item/commandExecution/requestApproval";
+var FILES = "item/fileChange/requestApproval";
+var QUESTIONS = "item/tool/requestUserInput";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isId = (value) => typeof value === "string" || typeof value === "number" && Number.isSafeInteger(value);
+var isText = (value) => typeof value === "string" && value.length > 0;
+var optionalText = (value) => value === void 0 || value === null || typeof value === "string";
+var onlyKeys = (value, keys) => Object.keys(value).every((key) => keys.includes(key));
+var identityOf = (id, method, params) => {
+  if (!isText(params.threadId) || !isText(params.turnId) || !isText(params.itemId) || !optionalText(params.approvalId)) return null;
+  return { id, method, threadId: params.threadId, turnId: params.turnId, itemId: params.itemId, approvalId: typeof params.approvalId === "string" ? params.approvalId : null };
+};
+var certifiedThread = (value) => {
+  if (!isRecord(value) || !isRecord(value.thread) || !isText(value.thread.id) || !isRecord(value.thread.status) || value.thread.status.type !== "idle") return null;
+  if (value.approvalPolicy !== "untrusted" && value.approvalPolicy !== "on-request" || value.approvalsReviewer !== "user" || !isRecord(value.sandbox)) return null;
+  const sandbox = value.sandbox;
+  if (sandbox.type !== "readOnly" && sandbox.type !== "workspaceWrite") return null;
+  if (!onlyKeys(sandbox, ["type", "networkAccess", "writableRoots", "excludeSlashTmp", "excludeTmpdirEnvVar"])) return null;
+  if (sandbox.networkAccess !== void 0 && typeof sandbox.networkAccess !== "boolean") return null;
+  if (sandbox.writableRoots !== void 0 && (!Array.isArray(sandbox.writableRoots) || !sandbox.writableRoots.every(isText))) return null;
+  if (["excludeSlashTmp", "excludeTmpdirEnvVar"].some((key) => sandbox[key] !== void 0 && typeof sandbox[key] !== "boolean")) return null;
+  if (value.activePermissionProfile !== void 0 && value.activePermissionProfile !== null) return null;
+  return value.thread.id;
+};
+var fileChangesOf = (value) => {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 128) return null;
+  const changes = [];
+  for (const change of value) {
+    if (!isRecord(change) || !onlyKeys(change, ["path", "kind", "diff"]) || !isText(change.path) || typeof change.diff !== "string" || !isRecord(change.kind)) return null;
+    const kind = change.kind;
+    if (!onlyKeys(kind, ["type", "move_path"]) || kind.type !== "add" && kind.type !== "delete" && kind.type !== "update") return null;
+    if (!optionalText(kind.move_path) || kind.type !== "update" && kind.move_path != null) return null;
+    changes.push({ path: change.path, operation: kind.type, movePath: typeof kind.move_path === "string" ? kind.move_path : null, diff: change.diff });
+  }
+  return changes;
+};
+var unsupported = (reason) => ({ kind: "unsupported", reason });
+var malformed = (reason) => ({ kind: "malformed", reason });
+var isKnownCommandDecision = (value) => {
+  if (typeof value === "string") return ["accept", "acceptForSession", "decline", "cancel"].includes(value);
+  if (!isRecord(value) || !onlyKeys(value, ["acceptWithExecpolicyAmendment"])) return false;
+  const amendment = value.acceptWithExecpolicyAmendment;
+  return isRecord(amendment) && onlyKeys(amendment, ["execpolicy_amendment"]) && Array.isArray(amendment.execpolicy_amendment) && amendment.execpolicy_amendment.every(isText);
+};
+var subjectOf = (method, params, changes, experimental) => {
+  if (method === COMMAND) {
+    if (!onlyKeys(params, ["threadId", "turnId", "itemId", "approvalId", "startedAtMs", "kind", "environmentId", "command", "cwd", "reason", "commandActions", "networkApprovalContext", "proposedExecpolicyAmendment", "proposedNetworkPolicyAmendments", "availableDecisions"])) return unsupported("Unknown command permission fields");
+    if (params.kind !== void 0 && params.kind !== "command" || params.environmentId != null && params.environmentId !== "local" || params.networkApprovalContext != null || params.proposedNetworkPolicyAmendments != null) return unsupported("Command needs native permission review");
+    if (params.proposedExecpolicyAmendment != null && (!Array.isArray(params.proposedExecpolicyAmendment) || !params.proposedExecpolicyAmendment.every(isText))) return malformed("Invalid policy suggestion");
+    if (params.availableDecisions != null && (!Array.isArray(params.availableDecisions) || !params.availableDecisions.includes("accept") || !params.availableDecisions.every(isKnownCommandDecision))) return unsupported("Unknown available approval decisions");
+    if (!isText(params.command) || !isText(params.cwd) || !optionalText(params.reason) || !Number.isSafeInteger(params.startedAtMs)) return malformed("Incomplete command subject");
+    return { kind: "supported", subject: { kind: "command", command: params.command, cwd: params.cwd, reason: typeof params.reason === "string" ? params.reason : null } };
+  }
+  if (method === FILES) {
+    if (!onlyKeys(params, ["threadId", "turnId", "itemId", "startedAtMs", "reason", "grantRoot"]) || params.grantRoot != null) return unsupported("File request widens permissions");
+    if (!optionalText(params.reason) || !Number.isSafeInteger(params.startedAtMs)) return malformed("Malformed file request");
+    if (!changes) return unsupported("Complete file patch unavailable");
+    return { kind: "supported", subject: { kind: "files", changes, reason: typeof params.reason === "string" ? params.reason : null } };
+  }
+  if (!experimental) return unsupported("Experimental questions disabled");
+  if (!onlyKeys(params, ["threadId", "turnId", "itemId", "questions", "isBlocking", "autoResolutionMs"]) || params.isBlocking !== true || params.autoResolutionMs != null) return unsupported("Question requires native handling");
+  if (!Array.isArray(params.questions) || params.questions.length < 1 || params.questions.length > 3) return malformed("Question count outside supported range");
+  const questions = [];
+  for (const question of params.questions) {
+    if (!isRecord(question) || !onlyKeys(question, ["id", "header", "question", "isOther", "isSecret", "options"])) return malformed("Malformed question");
+    if (question.isOther !== false || question.isSecret !== false) return unsupported("Secret or other-option question");
+    if (!isText(question.id) || !isText(question.header) || !isText(question.question) || questions.some((entry) => entry.id === question.id)) return malformed("Invalid question identity");
+    let options = null;
+    if (question.options !== null) {
+      if (!Array.isArray(question.options) || question.options.length < 2 || question.options.length > 20) return malformed("Invalid options");
+      const validated = [];
+      for (const option of question.options) {
+        if (!isRecord(option) || !onlyKeys(option, ["label", "description"]) || !isText(option.label) || option.label.length > 200 || typeof option.description !== "string" || validated.some((entry) => entry.label === option.label)) return malformed("Invalid option");
+        validated.push({ label: option.label, description: option.description });
+      }
+      options = validated;
+    }
+    questions.push({ id: question.id, header: question.header, question: question.question, options });
+  }
+  return { kind: "supported", subject: { kind: "questions", questions } };
+};
+
+// src/presentation.ts
+var visibleText = (text) => text.replace(/\\/g, "\\\\").replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (character) => `\\u{${character.codePointAt(0)?.toString(16)}}`);
+var bounded = (questions) => questions.every((question) => question.question.length <= 8e3 && question.context.length <= 2e3 && question.options?.some((option) => option.length > 200) !== true) ? questions : null;
+var presentSubject = (subject) => {
+  if (subject.kind === "command") return bounded([{ type: "confirm", question: `Approve this command once?
+
+${visibleText(subject.command)}
+
+Working directory: ${visibleText(subject.cwd)}
+Reason: ${visibleText(subject.reason ?? "(none)")}`, context: "Codex command approval. This approval applies only to this request." }]);
+  if (subject.kind === "files") {
+    const patches = subject.changes.map((change) => `${change.operation}: ${visibleText(change.path)}${change.movePath === null ? "" : ` -> ${visibleText(change.movePath)}`}
+${visibleText(change.diff)}`).join("\n\n");
+    return bounded([{ type: "confirm", question: `Approve these exact file changes once?
+
+${patches}
+
+Reason: ${visibleText(subject.reason ?? "(none)")}`, context: "Codex file approval. Includes every file and the complete patch." }]);
+  }
+  return bounded(subject.questions.map((question) => ({ questionId: question.id, type: question.options ? "select" : "input", question: `${visibleText(question.header)}
+${visibleText(question.question)}${question.options ? "\n\n" + question.options.map((option) => `${visibleText(option.label)}: ${visibleText(option.description)}`).join("\n") : ""}`, options: question.options?.map((option) => visibleText(option.label)), context: "Answer this Codex question. This answer does not grant tool permissions." })));
+};
+
+// src/partner-decisions.ts
+var import_server = require("@pushary/server");
+var decisionSnapshot = (value, type, expectedId) => {
+  if (!isRecord(value) || !isText(value.decisionId) || expectedId !== void 0 && value.decisionId !== expectedId || value.type !== type || typeof value.answered !== "boolean") throw new Error("Invalid decision response");
+  const status = value.status;
+  if (status !== "pending" && status !== "answered" && status !== "expired" && status !== "cancelled" && status !== "stopped") throw new Error("Unknown decision status");
+  if (status === "answered" !== value.answered || status === "answered" && typeof value.value !== "string" || status !== "answered" && value.value != null) throw new Error("Inconsistent decision response");
+  return { decisionId: value.decisionId, status, answered: value.answered, value: typeof value.value === "string" ? value.value : null, type };
+};
+var isRetryable = (error) => error instanceof import_server.PusharyApiError ? error.status === 429 || error.status >= 500 : error instanceof TypeError || error instanceof Error && error.name === "TimeoutError";
+var delay = (milliseconds, signal) => new Promise((resolve, reject) => {
+  if (signal.aborted) {
+    reject(signal.reason);
+    return;
+  }
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal.reason);
+  };
+  const timer = setTimeout(() => {
+    signal.removeEventListener("abort", onAbort);
+    resolve();
+  }, milliseconds);
+  signal.addEventListener("abort", onAbort, { once: true });
+});
+var withRetry = async (operation, signal) => {
+  for (let attempt = 0; ; attempt += 1) {
+    signal.throwIfAborted();
+    try {
+      return await operation();
+    } catch (error) {
+      if (signal.aborted || attempt >= 3 || !isRetryable(error)) throw error;
+      await delay(250 * 2 ** attempt + Math.floor(Math.random() * 101), signal);
+    }
+  }
+};
+var decisionFailureReason = (error) => {
+  if (error instanceof import_server.PusharyApiError) return `Partner HTTP ${error.status}`;
+  if (error instanceof TypeError) return "Decision transport unavailable";
+  if (error instanceof Error && error.name === "TimeoutError") return "Decision HTTP deadline elapsed";
+  return "Decision response invalid or unavailable";
+};
+
+// src/request-lifecycle.ts
+var transitionRequest = (state, completion, context) => {
+  if (state !== "pending") return null;
+  if (completion.kind === "reply") {
+    if (!context.replyAllowed || context.deadlineElapsed) return null;
+    const reply2 = completion.reply;
+    const accepted = "result" in reply2 && "decision" in reply2.result && reply2.result.decision === "accept";
+    return { state: accepted ? "accepted" : "closed", reply: reply2, interruption: null, abandonment: null };
+  }
+  if (completion.kind === "native") return { state: "closed", reply: null, interruption: null, abandonment: null };
+  if (completion.kind === "abandon" || !context.replyAllowed) return { state: "closed", reply: null, interruption: null, abandonment: completion.reason };
+  const reply = context.isQuestion ? { id: context.id, error: { code: -32e3, message: completion.reason } } : { id: context.id, result: { decision: "cancel" } };
+  return { state: "closed", reply, interruption: context.isQuestion || completion.kind === "conflict" ? completion.reason : null, abandonment: completion.reason };
+};
+
+// src/handler.ts
+var MAX_PENDING = 8;
+var MAX_THREADS = 32;
+var MAX_ITEMS = 128;
+var MAX_CACHE_BYTES = 4 * 1024 * 1024;
+var MAX_REQUESTS = 4096;
+var CLEANUP_MS = 5e3;
+var MIN_QUESTION_BUDGET_MS = 1e4;
+var itemKey = (threadId, turnId, itemId) => JSON.stringify([threadId, turnId, itemId]);
+var turnKey = (threadId, turnId) => JSON.stringify([threadId, turnId]);
+var rpcKey = (id) => JSON.stringify([typeof id, id]);
+var createPusharyCodexHandler = (configuration) => {
+  const config = Object.freeze({ ...configuration });
+  const timeoutMs = config.timeoutMs ?? 3e5;
+  if (config.codexVersion !== "0.160.1" || !Number.isInteger(timeoutMs) || timeoutMs < 6e4 || timeoutMs > 6e5 || !config.tenantId?.trim() || !config.externalId?.trim()) throw new TypeError("Invalid Codex adapter configuration");
+  if ([config.sendResponse, config.requestTurnInterrupt, config.onEvent, config.maySendSubject].some((callback) => typeof callback !== "function")) throw new TypeError("All host callbacks are required");
+  const decisions = (0, import_server2.createPusharyServer)({ apiKey: config.apiKey, baseUrl: config.baseUrl, requestTimeoutMs: 1e4 }).decisions;
+  const generation = (0, import_node_crypto.randomUUID)();
+  const threads = /* @__PURE__ */ new Set();
+  const requests = /* @__PURE__ */ new Map();
+  const closedRequestIds = /* @__PURE__ */ new Set();
+  const turns = /* @__PURE__ */ new Map();
+  const completedItems = /* @__PURE__ */ new Set();
+  const patches = /* @__PURE__ */ new Map();
+  const jobs = /* @__PURE__ */ new Set();
+  const cleanupFailures = [];
+  const cleanupControllers = /* @__PURE__ */ new Set();
+  let cacheBytes = 0;
+  let disposed = false;
+  let disposal;
+  let disposalDeadline = Infinity;
+  const emit = (event) => {
+    try {
+      config.onEvent(event);
+    } catch {
+      console.error("Pushary Codex onEvent callback failed");
+    }
+  };
+  const eventFor = (request, type, reason, decisionId) => emit({ type, requestId: request.identity.id, threadId: request.identity.threadId, turnId: request.identity.turnId, subjectDigest: request.digest, decisionId, reason });
+  const track = (job) => {
+    jobs.add(job);
+    void job.finally(() => jobs.delete(job)).catch(() => void 0);
+  };
+  const cleanupFailed = (request, id) => {
+    cleanupFailures.push(id);
+    eventFor(request, "cleanup_failed", "Decision cleanup not confirmed before deadline", id);
+  };
+  const cleanup = async (request, id) => {
+    if (request.cleanupIds.has(id)) return;
+    request.cleanupIds.add(id);
+    const remaining = Math.min(request.cleanupDeadline, disposalDeadline) - performance.now();
+    if (remaining <= 0) {
+      cleanupFailed(request, id);
+      return;
+    }
+    const controller = new AbortController();
+    cleanupControllers.add(controller);
+    const timer = setTimeout(() => controller.abort(), remaining);
+    try {
+      for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+          const result = await decisions.cancel(id, { signal: controller.signal });
+          if (!isRecord(result) || result.decisionId !== id || typeof result.cancelled !== "boolean") throw new Error("Invalid cancellation result");
+          if (result.cancelled) return;
+          const latest = await decisions.get(id, { signal: controller.signal });
+          if (isRecord(latest) && (latest.type === "confirm" || latest.type === "select" || latest.type === "input")) {
+            const snapshot = decisionSnapshot(latest, latest.type, id);
+            if (snapshot.status !== "pending") return;
+          }
+          throw new TypeError("Cancellation still pending");
+        } catch (error) {
+          if (controller.signal.aborted || attempt === 2 || !isRetryable(error)) throw error;
+          await delay(attempt === 0 ? 100 : 300, controller.signal);
+        }
+      }
+    } catch {
+      cleanupFailed(request, id);
+    } finally {
+      clearTimeout(timer);
+      cleanupControllers.delete(controller);
+    }
+  };
+  const beginCleanup = (request) => {
+    clearTimeout(request.timer);
+    request.cleanupDeadline = Math.min(performance.now() + CLEANUP_MS, disposalDeadline);
+    request.controller.abort();
+    for (const id of request.decisionIds) track(cleanup(request, id));
+  };
+  const completeRequest = (request, completion) => {
+    const transition = transitionRequest(request.state, completion, {
+      id: request.identity.id,
+      isQuestion: request.subject.kind === "questions",
+      replyAllowed: contextLive(request),
+      deadlineElapsed: performance.now() >= request.deadline
+    });
+    if (!transition) return;
+    request.state = transition.state;
+    beginCleanup(request);
+    if (transition.reply && contextLive(request)) {
+      const interrupted = transition.interruption === null || interrupt(request.identity, transition.interruption);
+      if (interrupted && contextLive(request)) {
+        try {
+          config.sendResponse(transition.reply);
+        } catch {
+          fatal("Response enqueue failed; close connection");
+        }
+      }
+    }
+    if (transition.abandonment !== null) eventFor(request, "request_abandoned", transition.abandonment);
+  };
+  const dispose = () => {
+    if (disposal) return disposal;
+    disposed = true;
+    disposalDeadline = performance.now() + CLEANUP_MS;
+    config.signal?.removeEventListener("abort", onAbort);
+    let resolveDisposal = () => void 0;
+    disposal = new Promise((resolve) => {
+      resolveDisposal = resolve;
+    });
+    threads.clear();
+    patches.clear();
+    cacheBytes = 0;
+    for (const request of requests.values()) completeRequest(request, { kind: "abandon", reason: "Connection disposed" });
+    const finish = async () => {
+      const controller = new AbortController();
+      const drain = async () => {
+        while (jobs.size > 0 && performance.now() < disposalDeadline) await Promise.allSettled([...jobs]);
+      };
+      await Promise.race([drain(), delay(CLEANUP_MS, controller.signal)]).catch(() => void 0);
+      controller.abort();
+      for (const cleanupController of cleanupControllers) cleanupController.abort();
+      await Promise.resolve();
+      resolveDisposal({ cleanupFailures: [...cleanupFailures] });
+    };
+    void finish();
+    return disposal;
+  };
+  const fatal = (reason) => {
+    void dispose();
+    emit({ type: "reply_failed", reason });
+  };
+  const overflow = () => {
+    void dispose();
+    emit({ type: "capacity_exceeded", reason: "Connection must close; bounded adapter capacity exceeded" });
+  };
+  const stateCount = () => requests.size + closedRequestIds.size + turns.size + completedItems.size;
+  const rememberTurn = (threadId, turnId, terminal) => {
+    const key = turnKey(threadId, turnId);
+    const previous = turns.get(key);
+    if (previous) {
+      previous.terminal || (previous.terminal = terminal);
+      return true;
+    }
+    if (stateCount() >= MAX_REQUESTS) {
+      overflow();
+      return false;
+    }
+    turns.set(key, { threadId, turnId, terminal });
+    return true;
+  };
+  const contextEnded = (identity) => turns.get(turnKey(identity.threadId, identity.turnId))?.terminal === true || completedItems.has(itemKey(identity.threadId, identity.turnId, identity.itemId));
+  const contextLive = (request) => !disposed && !contextEnded(request.identity) && threads.has(request.identity.threadId);
+  const live = (request) => request.state === "pending" && contextLive(request) && performance.now() < request.deadline;
+  const interrupt = (identity, reason) => {
+    try {
+      config.requestTurnInterrupt(identity.threadId, identity.turnId, reason);
+      return !disposed;
+    } catch {
+      fatal("Turn interrupt enqueue failed; close connection");
+      return false;
+    }
+  };
+  const fenceTurn = (threadId, turnId, reason) => {
+    if (!rememberTurn(threadId, turnId, true)) return;
+    for (const request of requests.values()) if (request.identity.threadId === threadId && request.identity.turnId === turnId) completeRequest(request, { kind: "abandon", reason });
+    for (const key of patches.keys()) {
+      if (key.startsWith(JSON.stringify([threadId, turnId]).slice(0, -1) + ",")) {
+        cacheBytes -= patches.get(key)?.bytes ?? 0;
+        patches.delete(key);
+      }
+    }
+  };
+  const invalidateTurn = (threadId, turnId, reason) => {
+    const accepted = [...requests.values()].find((request) => request.identity.threadId === threadId && request.identity.turnId === turnId && request.state === "accepted" && !contextEnded(request.identity));
+    fenceTurn(threadId, turnId, reason);
+    if (accepted) {
+      if (!disposed) interrupt(accepted.identity, reason);
+      eventFor(accepted, "request_abandoned", "Invalidated after acceptance enqueue; execution outcome unknown");
+    }
+  };
+  const unregisterThread = (threadId) => {
+    threads.delete(threadId);
+    for (const turn of turns.values()) if (turn.threadId === threadId) invalidateTurn(threadId, turn.turnId, "Thread unregistered");
+    for (const key of patches.keys()) if (key.startsWith(JSON.stringify([threadId]).slice(0, -1) + ",")) {
+      cacheBytes -= patches.get(key)?.bytes ?? 0;
+      patches.delete(key);
+    }
+  };
+  const createAndWait = async (request, phone, ordinal) => {
+    const payload = { question: phone.question, type: phone.type, options: phone.options, context: phone.context, externalId: config.externalId, agentName: config.agentName ?? "Codex", wait: false, requireReachable: true, expiresInSeconds: Math.ceil(timeoutMs / 1e3), idempotencyKey: (0, import_adapters.decisionFingerprint)({ tenantId: config.tenantId, externalId: config.externalId, generation, ...request.identity, subjectDigest: request.digest, ordinal, questionId: phone.questionId ?? null }) };
+    let raw;
+    try {
+      raw = await withRetry(() => decisions.create(payload, { signal: request.controller.signal }), request.controller.signal);
+    } catch (error) {
+      if (request.controller.signal.aborted || isRetryable(error)) eventFor(request, "create_outcome_unknown", "Create may have reached server; TTL bounds residual prompt");
+      throw error;
+    }
+    if (isRecord(raw) && isText(raw.decisionId)) {
+      request.decisionIds.add(raw.decisionId);
+      if (!live(request)) {
+        track(cleanup(request, raw.decisionId));
+        throw new Error("Request no longer live");
+      }
+    }
+    if (!isRecord(raw) || !isText(raw.decisionId)) eventFor(request, "create_outcome_unknown", "Create returned no usable decision ID");
+    let snapshot = decisionSnapshot(raw, phone.type);
+    eventFor(request, "decision_created", void 0, snapshot.decisionId);
+    while (snapshot.status === "pending") {
+      if (!live(request)) throw new Error("Request no longer live");
+      const next = await withRetry(() => decisions.get(snapshot.decisionId, { wait: 5, signal: request.controller.signal }), request.controller.signal);
+      snapshot = decisionSnapshot(next, phone.type, snapshot.decisionId);
+      if (snapshot.status === "pending") await delay(50, request.controller.signal);
+    }
+    request.decisionIds.delete(snapshot.decisionId);
+    eventFor(request, "decision_settled", snapshot.status, snapshot.decisionId);
+    return snapshot;
+  };
+  const runRequest = async (request, phones) => {
+    try {
+      const answers = /* @__PURE__ */ Object.create(null);
+      for (const [ordinal, phone] of phones.entries()) {
+        if (!live(request)) return;
+        if (ordinal > 0 && request.deadline - performance.now() < MIN_QUESTION_BUDGET_MS) {
+          completeRequest(request, { kind: "refuse", reason: "Insufficient time for another question" });
+          return;
+        }
+        const result = await createAndWait(request, phone, ordinal);
+        if (!live(request)) return;
+        if (request.subject.kind !== "questions") {
+          const approved = result.type === "confirm" && result.status === "answered" && (0, import_server2.isApproved)({ status: result.status, type: result.type, value: result.value });
+          completeRequest(request, { kind: "reply", reply: { id: request.identity.id, result: { decision: approved ? "accept" : request.declineDecision } } });
+          return;
+        }
+        if (!result.answered || !result.value?.trim() || result.value.length > 2e3 || phone.options && !phone.options.includes(result.value)) {
+          completeRequest(request, { kind: "refuse", reason: "Question did not receive a valid answer" });
+          return;
+        }
+        const question = request.subject.questions[ordinal];
+        if (!question || !phone.questionId) throw new Error("Question identity missing");
+        const selectedIndex = phone.options?.indexOf(result.value);
+        const answer = selectedIndex !== void 0 ? question.options?.[selectedIndex]?.label : result.value;
+        if (answer === void 0) throw new Error("Question option missing");
+        answers[phone.questionId] = { answers: [answer] };
+      }
+      completeRequest(request, { kind: "reply", reply: { id: request.identity.id, result: { answers } } });
+    } catch (error) {
+      if (live(request)) completeRequest(request, { kind: "refuse", reason: decisionFailureReason(error) });
+    }
+  };
+  const observe = (method, params) => {
+    if (method === "serverRequest/resolved" && isId(params.requestId)) {
+      const request = requests.get(rpcKey(params.requestId));
+      if (request && params.threadId === request.identity.threadId) completeRequest(request, { kind: "abandon", reason: "Server request resolved" });
+    }
+    if (isText(params.threadId)) {
+      if (threads.has(params.threadId) && isRecord(params.turn) && isText(params.turn.id) && method === "turn/started") rememberTurn(params.threadId, params.turn.id, false);
+      if (["thread/closed", "thread/archived", "thread/settings/updated"].includes(method)) unregisterThread(params.threadId);
+      if (isText(params.turnId) && ["turn/completed", "turn/interrupted", "turn/failed"].includes(method)) fenceTurn(params.threadId, params.turnId, method);
+      if (isRecord(params.turn) && isText(params.turn.id) && method === "turn/completed") fenceTurn(params.threadId, params.turn.id, method);
+      const itemId = isRecord(params.item) && isText(params.item.id) ? params.item.id : params.itemId;
+      if (isText(params.turnId) && isText(itemId)) {
+        const key = itemKey(params.threadId, params.turnId, itemId);
+        if (method === "item/completed") {
+          if (!completedItems.has(key) && stateCount() >= MAX_REQUESTS) {
+            overflow();
+            return { kind: "invalid", reason: "Terminal item capacity exceeded" };
+          }
+          completedItems.add(key);
+          for (const request of requests.values()) if (itemKey(request.identity.threadId, request.identity.turnId, request.identity.itemId) === key) completeRequest(request, { kind: "abandon", reason: "Item completed" });
+          cacheBytes -= patches.get(key)?.bytes ?? 0;
+          patches.delete(key);
+        }
+        if (threads.has(params.threadId) && !completedItems.has(key) && turns.get(turnKey(params.threadId, params.turnId))?.terminal !== true && (method === "item/fileChange/patchUpdated" || method === "item/started" && isRecord(params.item) && params.item.type === "fileChange")) {
+          if (!rememberTurn(params.threadId, params.turnId, false)) return { kind: "invalid", reason: "Turn capacity exceeded" };
+          const raw = method === "item/started" && isRecord(params.item) ? params.item.changes : params.changes;
+          const previous = patches.get(key);
+          const parsed = fileChangesOf(raw);
+          const digest = (0, import_adapters.decisionFingerprint)(parsed);
+          const conflict = previous !== void 0 && previous.digest !== digest;
+          const changes = method === "item/fileChange/patchUpdated" && !previous || method === "item/started" && conflict || previous?.changes === null ? null : parsed;
+          const bytes = Buffer.byteLength(JSON.stringify(changes));
+          if (!previous && patches.size >= MAX_ITEMS || cacheBytes - (previous?.bytes ?? 0) + bytes > MAX_CACHE_BYTES) {
+            overflow();
+            return { kind: "invalid", reason: "Patch capacity exceeded" };
+          }
+          patches.set(key, { changes, digest, bytes });
+          cacheBytes += bytes - (previous?.bytes ?? 0);
+          if (conflict || changes === null) {
+            for (const request of requests.values()) if (itemKey(request.identity.threadId, request.identity.turnId, request.identity.itemId) === key) {
+              if (request.state === "accepted" && !contextEnded(request.identity)) invalidateTurn(request.identity.threadId, request.identity.turnId, "Reviewed patch changed after acceptance");
+              else completeRequest(request, { kind: "refuse", reason: "Reviewed patch changed" });
+            }
+          }
+        }
+      }
+    }
+    return { kind: "observed" };
+  };
+  const delegateToNative = (id, reason) => {
+    if (stateCount() >= MAX_REQUESTS) {
+      overflow();
+      return { kind: "invalid", reason: "Request capacity exceeded" };
+    }
+    closedRequestIds.add(rpcKey(id));
+    emit({ type: "native_review_required", requestId: id, reason });
+    return disposed ? { kind: "invalid", reason: "Disposed during native handoff" } : { kind: "unhandled", reason };
+  };
+  const dispatch = (message) => {
+    if (disposed) return { kind: "invalid", reason: "Adapter disposed" };
+    if (!isRecord(message) || !isText(message.method) || !isRecord(message.params)) return { kind: "invalid", reason: "Invalid server envelope" };
+    if (message.id === void 0) return observe(message.method, message.params);
+    if (!isId(message.id)) return { kind: "invalid", reason: "Invalid RPC ID" };
+    if (closedRequestIds.has(rpcKey(message.id))) return { kind: "claimed" };
+    const previous = requests.get(rpcKey(message.id));
+    if (previous) {
+      if (previous.envelopeDigest !== (0, import_adapters.decisionFingerprint)({ method: message.method, params: message.params })) {
+        if (previous.state === "accepted") invalidateTurn(previous.identity.threadId, previous.identity.turnId, "Conflicting duplicate request");
+        else completeRequest(previous, { kind: "conflict", reason: "Conflicting duplicate request" });
+      }
+      return { kind: "claimed" };
+    }
+    if (![COMMAND, FILES, QUESTIONS].includes(message.method)) return delegateToNative(message.id, "Unsupported server method");
+    const identity = identityOf(message.id, message.method, message.params);
+    if (!identity) return { kind: "invalid", reason: "Malformed request identity; close connection" };
+    if (contextEnded(identity)) {
+      if (stateCount() >= MAX_REQUESTS) {
+        overflow();
+        return { kind: "invalid", reason: "Request capacity exceeded" };
+      }
+      closedRequestIds.add(rpcKey(identity.id));
+      if (identity.method === QUESTIONS && !interrupt(identity, "Request context has ended")) return { kind: "invalid", reason: "Interrupt failed" };
+      if (!disposed) config.sendResponse(identity.method === QUESTIONS ? { id: identity.id, error: { code: -32e3, message: "Request context has ended" } } : { id: identity.id, result: { decision: "cancel" } });
+      return { kind: "claimed" };
+    }
+    if (!threads.has(identity.threadId)) return delegateToNative(message.id, "Unregistered request context");
+    if (!rememberTurn(identity.threadId, identity.turnId, false)) return { kind: "invalid", reason: "Turn capacity exceeded" };
+    const subject = subjectOf(message.method, message.params, patches.get(itemKey(identity.threadId, identity.turnId, identity.itemId))?.changes ?? null, config.experimentalQuestions === true);
+    if (subject.kind === "malformed") {
+      if (stateCount() >= MAX_REQUESTS) {
+        overflow();
+        return { kind: "invalid", reason: "Request capacity exceeded" };
+      }
+      closedRequestIds.add(rpcKey(message.id));
+      if (message.method === QUESTIONS && !interrupt(identity, subject.reason)) return { kind: "invalid", reason: "Interrupt failed" };
+      try {
+        config.sendResponse({ id: message.id, error: { code: -32602, message: subject.reason } });
+      } catch {
+        fatal("Invalid-params response enqueue failed");
+      }
+      return { kind: "claimed" };
+    }
+    if (subject.kind === "unsupported") return delegateToNative(message.id, subject.reason);
+    const digest = (0, import_adapters.decisionFingerprint)(subject.subject);
+    const phones = presentSubject(subject.subject);
+    if (!phones) return delegateToNative(message.id, "Subject exceeds presentation limits");
+    if (stateCount() >= MAX_REQUESTS || [...requests.values()].filter((request2) => request2.state === "pending").length >= MAX_PENDING) {
+      overflow();
+      return { kind: "invalid", reason: "Request capacity exceeded" };
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+      const request2 = requests.get(rpcKey(identity.id));
+      if (request2) completeRequest(request2, { kind: "refuse", reason: "Decision deadline elapsed" });
+    }, timeoutMs);
+    const request = { identity, declineDecision: Array.isArray(message.params.availableDecisions) && !message.params.availableDecisions.includes("decline") ? "cancel" : "decline", digest, envelopeDigest: (0, import_adapters.decisionFingerprint)({ method: message.method, params: message.params }), subject: subject.subject, controller, deadline: performance.now() + timeoutMs, timer, decisionIds: /* @__PURE__ */ new Set(), cleanupIds: /* @__PURE__ */ new Set(), state: "pending", cleanupDeadline: Infinity };
+    requests.set(rpcKey(identity.id), request);
+    let allowed = false;
+    try {
+      allowed = config.maySendSubject(structuredClone(subject.subject)) === true;
+    } catch {
+      allowed = false;
+    }
+    if (disposed) return { kind: "invalid", reason: "Disposed during privacy review" };
+    if (!live(request)) return { kind: "claimed" };
+    if (!allowed) {
+      completeRequest(request, { kind: "native" });
+      requests.delete(rpcKey(identity.id));
+      return delegateToNative(message.id, "Subject rejected by privacy policy");
+    }
+    track(runRequest(request, phones));
+    return { kind: "claimed" };
+  };
+  const handle = (message) => {
+    try {
+      return dispatch(message);
+    } catch {
+      fatal("Invalid message or host callback; close connection");
+      return { kind: "invalid", reason: "Message could not be validated" };
+    }
+  };
+  const registerThread = (value) => {
+    if (disposed) throw new Error("Adapter disposed");
+    const id = certifiedThread(value);
+    if (!id) throw new TypeError("Thread requires user approvals and a certified sandbox");
+    if ([...requests.values()].some((request) => request.state === "pending" && request.identity.threadId === id)) throw new Error("Cannot replace thread policy while approval is pending");
+    if (!threads.has(id) && threads.size >= MAX_THREADS) {
+      overflow();
+      throw new Error("Thread capacity exceeded");
+    }
+    threads.add(id);
+  };
+  function onAbort() {
+    void dispose();
+  }
+  config.signal?.addEventListener("abort", onAbort, { once: true });
+  if (config.signal?.aborted) void dispose();
+  return { registerThread, unregisterThread, handle, invalidateTurn, dispose };
+};
+
+// src/index.ts
+var connect = (0, import_adapters2.createAdapterKernel)("Codex app-server").connect;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  connect,
+  createPusharyCodexHandler
+});
+//# sourceMappingURL=index.cjs.map