@jeffusion/bungee-core 5.23.2 → 5.24.0

package/dist/plugin-state-worker.js

@@ -14772,6 +14772,22 @@ var require_winston_daily_rotate_file = __commonJS(function(exports, module) {
 
 // src/plugin-state/worker.ts
 import { Database as Database2 } from "bun:sqlite";
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/plugin-state/operations.ts
+var reads = new Set(["get", "readStrict", "keys", "list", "receipt", "status", "inspect", "query", "current", "version", "read", "oldestSequence", "latestSequence", "prunedThrough", "checkpoint", "maintenanceStatus", "pendingRecoveryRequests", "recoveryScanComplete", "journalNamespaces", "atomicView", "executorProofPage", "executorHasPending", "probe"]);
+var creators = new Set(["durable", "storage", "secret", "communication", "event", "snapshot", "journal"]);
+function stateMethodClass(target, method, args) {
+  if (method === "close")
+    return "close";
+  if (method === "releaseCapability" || method === "secretRevoke" || target === "source" && method === "release" || target === "host" && method === "release")
+    return "cleanup";
+  if (target === "host" && (method === "open" || creators.has(method)))
+    return "resource";
+  if (target === "host" && method === "storageOperation")
+    return ["get", "readStrict", "keys"].includes(args[1]) ? "read" : "write";
+  return reads.has(method) ? "read" : "write";
+}
 
 // src/plugin-durable-state.ts
 var PLUGIN_DURABLE_STATE_SCHEMA_SQL = `
@@ -19392,6 +19408,106 @@ function initializePluginStateDatabase(db, plan = PLUGIN_STATE_MIGRATIONS) {
   }).immediate();
 }
 
+// src/plugin-state/executor-proof-store.ts
+import { createHash as createHash5 } from "crypto";
+
+// src/supervision/process-lifetime-guard.ts
+import { dirname, join, resolve } from "path";
+var PROCESS_LIFETIME_GUARD_DOMAIN = "bungee-local-flock";
+function parseProcessLifetimeGuardFacts(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new Error("process lifetime guard facts are malformed");
+  const facts = value;
+  const keys = ["schema", "identity", "process_instance_id", "path", "device", "inode", "host_boot_id", "domain"];
+  if (Object.keys(facts).length !== keys.length || keys.some((key) => !Object.hasOwn(facts, key)) || facts.schema !== "bungee-process-lifetime-guard-v1" || facts.domain !== PROCESS_LIFETIME_GUARD_DOMAIN || typeof facts.identity !== "string" || !isLowercaseUuid(facts.identity) || typeof facts.process_instance_id !== "string" || !isLowercaseUuid(facts.process_instance_id) || typeof facts.path !== "string" || facts.path !== resolve(facts.path) || typeof facts.device !== "string" || !/^\d+$/.test(facts.device) || typeof facts.inode !== "string" || !/^[1-9]\d*$/.test(facts.inode) || typeof facts.host_boot_id !== "string" || !/^(linux:[0-9a-f-]{36}|darwin:\d+:\d+)$/.test(facts.host_boot_id)) {
+    throw new Error("process lifetime guard facts are malformed");
+  }
+  return Object.freeze({ ...facts });
+}
+function parseHeldProcessLifetimeGuardFacts(value) {
+  if (typeof value !== "object" || value === null || value.held !== true)
+    throw new Error("process lifetime guard held acknowledgement is malformed");
+  const { held: _held, ...body } = value;
+  return Object.freeze({ ...parseProcessLifetimeGuardFacts(body), held: true });
+}
+var inheritedDescriptors = new Map;
+
+// src/plugin-services/peer-executor-proof.ts
+var UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+var MARKER = new RegExp(`^${UUID}$`);
+var BOOT = new RegExp(`^(?:linux:${UUID}|win32:${UUID}|darwin:[0-9]+:[0-9]+)$`);
+var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var text = (value, max) => typeof value === "string" && value.length > 0 && value.length <= max;
+function decodePluginExecutorProof(value) {
+  if (!object(value) || Object.keys(value).length !== 5 || !object(value.source) || !object(value.physical) || typeof value.retired !== "boolean" || !Object.hasOwn(value, "guard"))
+    return null;
+  const { source, physical, boot } = value;
+  if (Object.keys(source).length !== 4 || source.process !== "control" || !text(source.instance, 128) || !text(source.catalog, 256) || !Number.isSafeInteger(source.generation) || source.generation < 1 || Object.keys(physical).length !== 4 || !Number.isSafeInteger(physical.pid) || physical.pid <= 0 || !text(physical.startToken, 256) || !text(physical.executable, 4096) || !text(physical.processInstanceId, 36) || !MARKER.test(physical.processInstanceId) || typeof boot !== "string" || !BOOT.test(boot))
+    return null;
+  let guard;
+  try {
+    guard = value.guard === null ? null : parseHeldProcessLifetimeGuardFacts(value.guard);
+  } catch {
+    return null;
+  }
+  if (guard !== null && guard.process_instance_id !== physical.processInstanceId)
+    return null;
+  return Object.freeze({
+    source: Object.freeze({ process: "control", instance: source.instance, catalog: source.catalog, generation: source.generation }),
+    physical: Object.freeze({ pid: physical.pid, startToken: physical.startToken, executable: physical.executable, processInstanceId: physical.processInstanceId }),
+    boot,
+    guard,
+    retired: value.retired
+  });
+}
+
+// src/plugin-state/executor-proof-store.ts
+function retireExecutorProof(db, communication, id, expected) {
+  const proof = decodePluginExecutorProof(expected);
+  if (proof === null || createHash5("sha256").update(JSON.stringify([proof.source.process, proof.source.instance, proof.source.catalog, proof.source.generation])).digest("hex") !== id)
+    throw new Error("executor_proof_invalid");
+  db.transaction(() => {
+    const store = communication.forNamespace("host:rpc:executors");
+    const record = store.get(id);
+    const current = record === null ? null : decodePluginExecutorProof(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(record.payload)));
+    if (current === null || JSON.stringify({ ...current, retired: false }) !== JSON.stringify({ ...proof, retired: false }))
+      throw new Error("executor_proof_changed");
+    if (current.retired)
+      return;
+    store.ack(id);
+    store.put(id, new TextEncoder().encode(JSON.stringify({ ...current, retired: true })), { required: true });
+  }).immediate();
+}
+function prepareExecutorProofPage(db, communication, after) {
+  if (typeof after !== "string" || after.length > 128)
+    throw new Error("runtime_upgrade_cursor_invalid");
+  return db.transaction(() => {
+    const rows = db.query("SELECT key FROM plugin_communication_records WHERE namespace='host:rpc:executors' AND key>? ORDER BY key LIMIT 128").all(after);
+    const store = communication.forNamespace("host:rpc:executors");
+    let converted = 0;
+    for (const row of rows) {
+      const record = store.get(row.key);
+      if (record === null)
+        throw new Error("runtime_upgrade_record_missing");
+      const raw = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(record.payload));
+      if (decodePluginExecutorProof(raw) !== null)
+        continue;
+      if (!raw || typeof raw !== "object" || Array.isArray(raw) || Object.keys(raw).sort().join() !== "boot,physical,source")
+        throw new Error("runtime_upgrade_proof_invalid");
+      const proof = decodePluginExecutorProof({ ...raw, guard: null, retired: false });
+      if (proof === null)
+        throw new Error("runtime_upgrade_proof_invalid");
+      const key = createHash5("sha256").update(JSON.stringify([proof.source.process, proof.source.instance, proof.source.catalog, proof.source.generation])).digest("hex");
+      if (key !== row.key)
+        throw new Error("runtime_upgrade_identity_mismatch");
+      store.ack(row.key);
+      store.put(row.key, new TextEncoder().encode(JSON.stringify(proof)), { required: true });
+      converted++;
+    }
+    return { scanned: rows.length, converted, last_key: rows.at(-1)?.key ?? null };
+  }).immediate();
+}
+
 // src/plugin-state/worker.ts
 var db;
 var durable;
@@ -19403,25 +19519,33 @@ var handles = new Map;
 var durableNamespaces = new Map;
 var sources = new Map;
 var callbacks = new Map;
+var requests = new Map;
+var context = new AsyncLocalStorage;
+var closing = false;
+var offline = false;
+var drain = null;
 var nextCallback = 0;
 var callbackCapacity = 128;
+function physical(id) {
+  const active = requests.get(id);
+  if (!active?.responded || [...callbacks.values()].some((c) => c.requestId === id))
+    return;
+  requests.delete(id);
+  self.postMessage({ type: "physical-settled", id });
+  if (requests.size === 0 && callbacks.size === 0)
+    drain?.();
+}
 function callback(token, method, args) {
+  const request = context.getStore();
+  if (!request || closing || Date.now() >= request.deadlineAt)
+    return Promise.reject(new CommandJournalError("unknown"));
   if (callbacks.size >= callbackCapacity)
     return Promise.reject(new CommandJournalError("overloaded"));
   const id = ++nextCallback;
   return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      callbacks.delete(id);
-      reject(new CommandJournalError("unknown"));
-    }, 30000);
-    callbacks.set(id, { resolve: (value) => {
-      clearTimeout(timer);
-      resolve(value);
-    }, reject: (error) => {
-      clearTimeout(timer);
-      reject(error);
-    } });
-    self.postMessage({ type: "callback", id, token, method, args });
+    const timer = setTimeout(() => reject(new CommandJournalError("unknown")), Math.max(0, request.deadlineAt - Date.now()));
+    callbacks.set(id, { requestId: request.id, resolve, reject, timer });
+    self.postMessage({ type: "callback", id, requestId: request.id, deadlineAt: request.deadlineAt, token, method, args });
   });
 }
 function bind(value) {
@@ -19524,6 +19648,7 @@ async function dispatch(request) {
     if (db)
       throw new Error("plugin_state_already_open");
     const [path, options] = args;
+    offline = options.offline === true;
     db = new Database2(path, { create: options.initialize === true, strict: true });
     db.exec("PRAGMA foreign_keys=ON; PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA busy_timeout=5000;");
     if (options.initialize !== true && db.query("PRAGMA user_version").get().user_version === 0)
@@ -19543,6 +19668,13 @@ async function dispatch(request) {
   if (!db)
     throw new Error("plugin_state_not_open");
   if (target === "host") {
+    if (method === "retireExecutorProof")
+      return retireExecutorProof(db, communication, args[0], args[1]);
+    if (method === "prepareExecutorProofPage") {
+      if (!offline)
+        throw new Error("runtime_upgrade_requires_offline_session");
+      return prepareExecutorProofPage(db, communication, args[0]);
+    }
     if (method === "durable") {
       const id = bind(durable.forStorageNamespace(args[0]));
       durableNamespaces.set(id, args[0]);
@@ -19626,9 +19758,16 @@ async function dispatch(request) {
         });
       }).deferred();
     }
+    if (method === "probe")
+      return { database: db.query("SELECT 1 AS ok").get(), requests: requests.size, callbacks: callbacks.size, handles: handles.size, sources: sources.size };
     if (method === "close") {
+      if (requests.size || callbacks.size)
+        await new Promise((resolve) => {
+          drain = resolve;
+        });
+      drain = null;
       for (const s of sources.values())
-        s.release?.();
+        await s.release?.();
       sources.clear();
       handles.clear();
       kvStores.clear();
@@ -19650,7 +19789,7 @@ async function dispatch(request) {
     if (method === "read")
       return value.read(args[1], args[2]);
     if (method === "release") {
-      value.release?.();
+      await value.release?.();
       sources.delete(args[0]);
       return;
     }
@@ -19697,16 +19836,39 @@ self.onmessage = (event) => {
     if (!pending)
       return;
     callbacks.delete(message.id);
+    clearTimeout(pending.timer);
     if (message.error)
       pending.reject(new Error(message.error));
     else
       pending.resolve(message.value);
+    physical(pending.requestId);
     return;
   }
   if (message.type !== "request")
     return;
-  dispatch(message).then((value) => self.postMessage({ type: "response", id: message.id, value }), (error) => {
-    self.postMessage({ type: "response", id: message.id, error: { name: error?.name ?? "Error", message: error?.message ?? "plugin_state_failure", code: error?.code, operationId: error?.operationId } });
+  const kind = stateMethodClass(message.target, message.method, message.args);
+  if (closing && kind !== "cleanup" && message.method !== "probe") {
+    self.postMessage({ type: "response", id: message.id, error: { name: "Error", message: "plugin_state_closing" } });
+    self.postMessage({ type: "physical-settled", id: message.id });
+    return;
+  }
+  if (kind === "close")
+    closing = true;
+  else
+    requests.set(message.id, { request: message, responded: false });
+  context.run(message, () => dispatch(message)).then((value) => {
+    self.postMessage({ type: "response", id: message.id, physical: ![...callbacks.values()].some((c) => c.requestId === message.id), value });
+  }, (error) => {
+    self.postMessage({ type: "response", id: message.id, physical: ![...callbacks.values()].some((c) => c.requestId === message.id), error: { name: error?.name ?? "Error", message: error?.message ?? "plugin_state_failure", code: error?.code, operationId: error?.operationId } });
+  }).finally(() => {
+    if (kind === "close")
+      self.postMessage({ type: "physical-settled", id: message.id });
+    else {
+      const active = requests.get(message.id);
+      if (active)
+        active.responded = true;
+      physical(message.id);
+    }
   });
 };
 self.postMessage({ type: "ready" });

package/dist/plugins/chatgpt-oauth/index.js

@@ -1439,10 +1439,12 @@ var CODEX_RESPONSES_ORIGINATOR = "codex-tui";
 // plugins/chatgpt-oauth/server/adapter.ts
 var CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
 var RESPONSES_PATH = "/responses";
+var SEARCH_PATH = "/alpha/search";
 var SIWC_RESPONSES_PATH = "/v1/responses";
 var MODELS_PATH = "/v1/models";
 var CODEX_RESPONSES_PATH = "/backend-api/codex/responses";
 var CODEX_MODELS_PATH = "/backend-api/codex/models";
+var CODEX_SEARCH_PATH = "/backend-api/codex/alpha/search";
 function isResponsesRequest(url) {
   return url.pathname === RESPONSES_PATH;
 }
@@ -1879,6 +1881,10 @@ class ChatgptOauthAdapter {
       }));
       return context;
     }
+    if (context.method.toUpperCase() === "POST" && context.url.pathname === SEARCH_PATH) {
+      context.url.pathname = CODEX_SEARCH_PATH;
+      return context;
+    }
     if (context.url.pathname === CODEX_RESPONSES_PATH) {
       setCodexRoutingHint(context.headers, context.body);
       enforceCodexResponsesLite(context);
@@ -2128,4 +2134,4 @@ export {
   server_default as default
 };
 
-//# debugId=E48A263F3FBDCAF664756E2164756E21
+//# debugId=76D0FF2CAF8435B164756E2164756E21