@jskit-ai/assistant-core 0.1.200 → 0.1.202

package/src/server/conversation/codexRuntimeLifecycle.js

@@ -0,0 +1,288 @@
+import { normalizeCodexRunText as normalizeText } from "./codexTurnState.js";
+
+// The original shared runtime shutdown and wellbeing lifecycle. This facet
+// uses the run/provider owners' existing collections; it does not own servers.
+export function createCodexRuntimeLifecycle({
+  runOwner,
+  providerSessions,
+  helperLifecycle,
+  captureContext,
+  runInContext,
+  debugLog,
+  debugError,
+  closingError = null
+}) {
+  const codexAppServerSessionClosures = new Map();
+  const codexAppServerWellbeingTimers = new Map();
+  const codexAppServerReconcileTasks = new Set();
+  let codexAppServerThreadReconcileGeneration = 0;
+  let codexAppServerServerClosing = false;
+  let codexAppServerShutdownPromise = null;
+
+  function assertOpen() {
+    if (!closingError) return providerSessions.assertOpen();
+    if (codexAppServerServerClosing) {
+      const error = new Error(closingError.message);
+      error.code = closingError.code;
+      error.retryable = closingError.retryable;
+      throw error;
+    }
+  }
+
+  function closeCodexAppServerProvider(providerKey = "", options = {}) {
+    const normalizedProviderKey = normalizeText(providerKey);
+    if (!providerSessions.owner.providers.get(normalizedProviderKey)) {
+      stopCodexAppServerWellbeing(normalizedProviderKey);
+      providerSessions.managed.delete(normalizedProviderKey);
+      return;
+    }
+    providerSessions.owner.closeProvider(normalizedProviderKey, options);
+  }
+
+  async function retireAndCloseCodexAppServerProviderUnlocked(providerKey = "", options = {}) {
+    const normalizedProviderKey = normalizeText(providerKey);
+    if (!providerSessions.owner.providers.get(normalizedProviderKey)) {
+      closeCodexAppServerProvider(normalizedProviderKey, options);
+      return;
+    }
+    return providerSessions.owner.retireAndCloseProvider(normalizedProviderKey, options);
+  }
+
+  function retireAndCloseCodexAppServerProvider(providerKey = "", options = {}) {
+    return providerSessions.owner.withLifecycle(
+      () => retireAndCloseCodexAppServerProviderUnlocked(providerKey, options)
+    );
+  }
+
+  function codexAppServerProviderResources(providerKey) {
+    const normalizedProviderKey = normalizeText(providerKey);
+    return {
+      retire: runOwner.helperThreads.retireProvider,
+      reconcileRetirement: runOwner.helperThreads.reconcileProviderRetirement,
+      release(provider) {
+        runOwner.helperThreads.assertProviderReleased(provider);
+        stopCodexAppServerWellbeing(normalizedProviderKey);
+        providerSessions.managed.delete(normalizedProviderKey);
+        const subscriptionPrefix = `${normalizedProviderKey}:`;
+        for (const key of [...runOwner.eventSubscriptions.keys()]) {
+          if (key.startsWith(subscriptionPrefix)) {
+            runOwner.unsubscribeEventSubscription(key);
+          }
+        }
+      }
+    };
+  }
+
+  async function invalidateCodexAppServerRuntimes(input = {}) {
+    const result = await providerSessions.owner.invalidateRuntimes(input);
+    debugLog("appServerRuntime.invalidate.done", {
+      failedCount: result.failed.length,
+      providerCount: result.providerCount,
+      reason: normalizeText(input.reason),
+      stopped: result.stopped,
+      toolHomeSource: normalizeText(input.toolHomeSource)
+    });
+    return result;
+  }
+
+  function shutdownCodexAppServerRuntimes(input = {}) {
+    beginCodexAppServerShutdown();
+    if (!codexAppServerShutdownPromise) {
+      codexAppServerShutdownPromise = (async () => {
+        const invalidation = invalidateCodexAppServerRuntimes({
+          ...input,
+          includeOwned: true,
+          reason: "server-shutdown",
+          requireVerifiedExit: true,
+          stopOwnedRuntimes: true
+        });
+        const drain = drainCodexAppServerControllerTasks();
+        const [invalidated, drained] = await Promise.allSettled([
+          invalidation,
+          drain
+        ]);
+        if (drained.status === "rejected") {
+          throw drained.reason;
+        }
+        const verified = await invalidateCodexAppServerRuntimes({
+          ...input,
+          includeOwned: true,
+          reason: "server-shutdown",
+          requireVerifiedExit: true,
+          stopOwnedRuntimes: true
+        });
+        if (invalidated.status === "rejected") {
+          throw invalidated.reason;
+        }
+        const initial = invalidated.value;
+        const resultsByProvider = new Map([
+          ...initial.results,
+          ...verified.results
+        ].map((result) => [normalizeText(result?.providerKey), result]));
+        const results = [...resultsByProvider.values()];
+        return {
+          ...verified,
+          providerCount: Math.max(initial.providerCount, verified.providerCount),
+          results,
+          stopped: results.filter((result) => result?.stopped === true).length
+        };
+      })();
+    }
+    return codexAppServerShutdownPromise;
+  }
+
+  function stopCodexAppServerWellbeing(providerKey = "") {
+    const normalizedProviderKey = normalizeText(providerKey);
+    const timer = codexAppServerWellbeingTimers.get(normalizedProviderKey);
+    if (timer) {
+      clearTimeout(timer);
+      codexAppServerWellbeingTimers.delete(normalizedProviderKey);
+    }
+  }
+
+  function beginCodexAppServerShutdown() {
+    if (codexAppServerServerClosing) {
+      return;
+    }
+    codexAppServerServerClosing = true;
+    providerSessions.owner.beginShutdown();
+    codexAppServerThreadReconcileGeneration += 1;
+    for (const providerKey of [...codexAppServerWellbeingTimers.keys()]) {
+      stopCodexAppServerWellbeing(providerKey);
+    }
+  }
+
+  async function drainCodexAppServerControllerTasks() {
+    while (true) {
+      const pending = new Set([
+        ...runOwner.conversationTurnStarts.values(),
+        ...helperLifecycle.projectOperations.values(),
+        ...helperLifecycle.cleanups.values(),
+        ...helperLifecycle.mutations.values(),
+        ...helperLifecycle.restores.values(),
+        ...helperLifecycle.turnStarts.values(),
+        ...runOwner.messageDeliveries.values(),
+        ...runOwner.reasoningPersistQueues.values(),
+        ...runOwner.resultFinalizations.values(),
+        ...providerSessions.owner.lifecycleTasks,
+        ...providerSessions.owner.runtimeAcquisitions,
+        ...codexAppServerReconcileTasks,
+        ...codexAppServerSessionClosures.values(),
+        ...runOwner.threadReconciliations.values(),
+        ...runOwner.notificationQueue.tasks.values()
+      ]);
+      if (pending.size === 0) {
+        return;
+      }
+      await Promise.allSettled([...pending]);
+    }
+  }
+
+  function scheduleCodexAppServerWellbeing(providerKey = "") {
+    const normalizedProviderKey = normalizeText(providerKey);
+    const managed = providerSessions.managed.get(normalizedProviderKey);
+    if (!managed || codexAppServerServerClosing) {
+      stopCodexAppServerWellbeing(normalizedProviderKey);
+      return;
+    }
+    stopCodexAppServerWellbeing(normalizedProviderKey);
+    const timer = setTimeout(() => {
+      void (async () => {
+        const current = providerSessions.managed.get(normalizedProviderKey);
+        if (!current) {
+          return;
+        }
+        await runInContext(current.projectContext, async () => {
+          await runOwner.checkManagedConnection(normalizedProviderKey);
+        });
+      })()
+        .catch((error) => {
+          debugLog("appServerDaemon.wellbeing.error", {
+            error: debugError(error),
+            providerKey: normalizedProviderKey,
+            sessionId: managed.sessionId
+          });
+        })
+        .finally(() => {
+          if (
+            !codexAppServerServerClosing &&
+            providerSessions.managed.has(normalizedProviderKey)
+          ) {
+            scheduleCodexAppServerWellbeing(normalizedProviderKey);
+          }
+        });
+    }, providerSessions.wellbeingMs);
+    timer.unref?.();
+    codexAppServerWellbeingTimers.set(normalizedProviderKey, timer);
+  }
+
+  function rememberCodexAppServerManagedSession(providerKey = "", {
+    providerOptions = {},
+    sessionId = "",
+    executionRoot = "",
+    threadId = "",
+    workdir = ""
+  } = {}) {
+    assertOpen();
+    const normalizedProviderKey = normalizeText(providerKey);
+    if (!normalizedProviderKey) {
+      return;
+    }
+    providerSessions.managed.set(normalizedProviderKey, {
+      projectContext: captureContext(),
+      providerOptions,
+      sessionId: normalizeText(sessionId),
+      executionRoot: normalizeText(executionRoot),
+      threadId: normalizeText(threadId),
+      workdir: normalizeText(workdir)
+    });
+    scheduleCodexAppServerWellbeing(normalizedProviderKey);
+  }
+
+  function invalidateRuntimes(input = {}, preparation) {
+    const serverShutdown = normalizeText(input?.reason) === "server-shutdown";
+    if (serverShutdown) {
+      beginCodexAppServerShutdown();
+    }
+    return (async () => {
+      if (!preparation.enabled) {
+        return preparation.disabledResult;
+      }
+      if (serverShutdown) {
+        return shutdownCodexAppServerRuntimes(input);
+      }
+      if (input.includeOwned === true) {
+        return invalidateCodexAppServerRuntimes({
+          ...input,
+          includeOwned: true,
+          requireVerifiedExit: true,
+          stopOwnedRuntimes: true
+        });
+      }
+      const helpers = await preparation.helpers;
+      helperLifecycle.assertRestored(
+        await helperLifecycle.restoreThreads(helpers.projectRuntimeRoot, helpers.context)
+      );
+      return invalidateCodexAppServerRuntimes({
+        ...input,
+        includeOwned: false,
+        requireVerifiedExit: false
+      });
+    })();
+  }
+
+  return {
+    get closing() { return codexAppServerServerClosing; },
+    assertOpen,
+    get reconcileGeneration() { return codexAppServerThreadReconcileGeneration; },
+    nextReconcileGeneration() { return ++codexAppServerThreadReconcileGeneration; },
+    reconcileTasks: codexAppServerReconcileTasks,
+    sessionClosures: codexAppServerSessionClosures,
+    invalidateRuntimes,
+    resources: codexAppServerProviderResources,
+    retireProvider: retireAndCloseCodexAppServerProvider,
+    rememberManagedSession: rememberCodexAppServerManagedSession,
+    managedSession: providerKey => providerSessions.managed.get(providerKey),
+    managedThreadId: providerKey => providerSessions.managed.get(providerKey)?.threadId
+  };
+}

package/src/server/conversation/codexSessionCleanup.js

@@ -0,0 +1,96 @@
+import { normalizeCodexRunText } from "./codexTurnState.js";
+
+// Cleanup of the existing run/provider/Helper owners. The application keeps
+// its authority and storage projections; all native coordination stays here.
+export function createCodexSessionCleanup({ namespace, runOwner, providerSessions, helperLifecycle, journal,
+  conversations, debugLog, debugError }) {
+  const providerOwner = providerSessions?.owner;
+
+  async function closeSession(sessionId, cleanup) {
+    const normalizedSessionId = normalizeCodexRunText(sessionId);
+    const sessionKey = cleanup.sessionKey;
+    const pendingClosures = cleanup.pending;
+    const restrictedClosures = cleanup.restrictedPending;
+    let pending = pendingClosures.get(sessionKey);
+    while (pending) {
+      const pendingIsRestricted = restrictedClosures.has(pending);
+      if (cleanup.restricted && !pendingIsRestricted) {
+        await pending.catch(() => null);
+        pending = pendingClosures.get(sessionKey);
+        continue;
+      }
+      if (!cleanup.restricted && pendingIsRestricted) {
+        await cleanup.assertPublicAccess();
+      }
+      return pending;
+    }
+    const closing = (async () => {
+      await providerOwner.drainThreadEnvironmentTasks(sessionKey);
+      journal.clearSessionRecoveryTimers(normalizedSessionId);
+      let prepared = null;
+      let session = null;
+      try {
+        prepared = await cleanup.read();
+        const restoration = await prepared.helpers;
+        helperLifecycle.assertRestored(await helperLifecycle.restoreThreads(
+          restoration.projectRuntimeRoot, restoration.context
+        ));
+        helperLifecycle.assertRetired(await helperLifecycle.retireAll({
+          projectRuntimeRoot: prepared.projectRuntimeRoot,
+          sessionId: normalizedSessionId
+        }));
+        session = prepared.session;
+      } catch (error) {
+        debugLog("appServerRuntime.closeSession.prepare.error", {
+          error: debugError(error),
+          sessionId: normalizedSessionId
+        });
+        throw error;
+      }
+      await conversations.closeCodexAppServerConversations(normalizedSessionId);
+      const { exitFailure } = await providerOwner.releaseSession(sessionKey, {
+        sessionId: normalizedSessionId,
+        runOwner,
+        get changeover() { return cleanup.changeover; },
+        preserveProcessExitProof: cleanup.preserveProcessExitProof,
+        get requireStopped() { return cleanup.requireStopped; },
+        session
+      });
+      await prepared.complete(exitFailure);
+    })();
+    pendingClosures.set(sessionKey, closing);
+    if (cleanup.restricted) {
+      restrictedClosures.add(closing);
+    }
+    try {
+      return await closing;
+    } finally {
+      if (pendingClosures.get(sessionKey) === closing) {
+        pendingClosures.delete(sessionKey);
+      }
+    }
+  }
+
+  async function closeProject(input = {}, preparation) {
+    const restoration = await preparation.helpers;
+    helperLifecycle.assertRestored(await helperLifecycle.restoreThreads(
+      restoration.projectRuntimeRoot, restoration.context
+    ));
+    const sessionNamespacePrefix = namespace("");
+    for (const sessionKey of [...conversations.codexAppServerConversations.keys()]) {
+      if (!sessionKey.startsWith(sessionNamespacePrefix)) {
+        continue;
+      }
+      await conversations.closeCodexAppServerConversations(
+        sessionKey.slice(sessionNamespacePrefix.length)
+      );
+    }
+    return providerOwner.stopProvidersForProject(input, {
+      managed: providerSessions.managed,
+      keyFields: providerSessions.keyFields,
+      helperThreads: helperLifecycle
+    });
+  }
+
+  return { closeSession, closeProject };
+}

package/src/server/conversation/codexSessionReconciliation.js

@@ -0,0 +1,284 @@
+import { normalizeCodexRunText as normalizeText, codexAppServerErrorMessage as errorMessage } from "./codexTurnState.js";
+import { isPlainObject as isRecord } from "./normalize.js";
+
+// Original batch restoration, prune and startup unsubscribe. The run owner's
+// existing lifecycle and per-thread readiness retain all state and coordination.
+export function createCodexSessionReconciliation({
+  runOwner, providerSessions, helperLifecycle, lifecycle, createRuntime,
+  namespace, turnState, sessionIdRequiredError, debugLog, debugError
+}) {
+  async function pruneCodexAppServerManagedSessions({
+    keepProviderKeys = new Set(),
+    projectContextRoot = ""
+  } = {}) {
+    const normalizedProjectContextRoot = normalizeText(projectContextRoot);
+    if (!normalizedProjectContextRoot) {
+      return;
+    }
+    for (const [providerKey, managed] of [...providerSessions.managed.entries()]) {
+      if (keepProviderKeys.has(providerKey)) {
+        continue;
+      }
+      if (providerSessions.owner.providers.get(providerKey)?.observationFailure) continue;
+      if (normalizeText(managed.projectContext?.targetRoot) === normalizedProjectContextRoot) {
+        await lifecycle.retireProvider(providerKey);
+      }
+    }
+  }
+
+  async function retireAndCloseCodexAppServerProviderForSession(sessionId = "", options = null) {
+    const normalizedSessionId = normalizeText(sessionId);
+    if (
+      !normalizedSessionId ||
+      !options ||
+      typeof options !== "object" ||
+      Array.isArray(options)
+    ) {
+      return;
+    }
+    await lifecycle.retireProvider(
+      providerSessions.context(normalizedSessionId, options).providerKey
+    );
+  }
+
+  function codexAppServerReconcileSessionId(value = {}) {
+    if (typeof value === "string") {
+      return normalizeText(value);
+    }
+    return normalizeText(value?.sessionId || value?.id);
+  }
+
+  async function unsubscribeCodexAppServerThreadForSession(sessionId = "", options, preparation) {
+    const normalizedSessionId = normalizeText(sessionId);
+    if (!normalizedSessionId) {
+      return { ok: true, sessionId: normalizedSessionId, status: "notSubscribed" };
+    }
+    const unsubscribeParameters = await preparation.session(normalizedSessionId, options);
+    if (!unsubscribeParameters.threadId) {
+      return {
+        ok: true,
+        providerOptions: unsubscribeParameters.providerOptions,
+        sessionId: normalizedSessionId,
+        status: "notSubscribed"
+      };
+    }
+    return providerSessions.owner.unsubscribeSessionThread(
+      namespace(normalizedSessionId), normalizedSessionId, { unsubscribeParameters }
+    );
+  }
+
+  async function unsubscribeCodexAppServerThreadsForSessions(sessions = [], preparation) {
+    const results = [];
+    const failed = [];
+    const seenSessionIds = new Set();
+    for (const session of Array.isArray(sessions) ? sessions : []) {
+      const sessionId = normalizeText(session?.sessionId || session?.id || session);
+      if (!sessionId || seenSessionIds.has(sessionId)) {
+        continue;
+      }
+      seenSessionIds.add(sessionId);
+      let providerOptions = null;
+      try {
+        const result = await unsubscribeCodexAppServerThreadForSession(sessionId, {
+          session: isRecord(session) ? session : null
+        }, preparation);
+        providerOptions = result?.providerOptions || null;
+        results.push(result);
+      } catch (error) {
+        failed.push({
+          error: errorMessage(error, preparation.failureMessage),
+          sessionId
+        });
+        debugLog("appServerThread.unsubscribeKnown.error", {
+          error: debugError(error),
+          sessionId
+        });
+      } finally {
+        if (providerOptions) {
+          try {
+            await retireAndCloseCodexAppServerProviderForSession(
+              sessionId,
+              providerOptions
+            );
+          } catch (error) {
+            failed.push({
+              code: normalizeText(error?.code),
+              error: errorMessage(error, preparation.cleanupFailureMessage),
+              retryable: error?.retryable === true,
+              sessionId
+            });
+          }
+        }
+      }
+    }
+    return {
+      failed,
+      ok: failed.length === 0,
+      results,
+      sessionCount: seenSessionIds.size
+    };
+  }
+
+  async function reconcileCodexAppServerThreadForSession(sessionId = "", {
+    agentSettings = {}
+  } = {}, preparation) {
+    providerSessions.assertOpen();
+    const normalizedSessionId = normalizeText(sessionId);
+    if (!normalizedSessionId) {
+      return { ok: false, error: sessionIdRequiredError };
+    }
+    const prepared = await preparation.session(normalizedSessionId, { agentSettings });
+    if (prepared.result) return prepared.result;
+    const { context } = prepared;
+    if (turnState(context.session).status === "observation_lost") {
+      const recovered = await prepared.recover(runOwner.recoverSessionObservationLoss);
+      const turn = turnState(recovered);
+      return prepared.stopped({
+        ok: !turn.active,
+        sessionId: normalizedSessionId,
+        status: turn.active ? "stopUnverified" : "stopped",
+        threadId: turn.threadId
+      }, recovered);
+    }
+    return runOwner.reconcileThread(normalizedSessionId, context, prepared.thread);
+  }
+
+  async function reconcileCodexAppServerThreads(sessions = [], {
+    agentSettings = {}
+  } = {}, preparation) {
+    providerSessions.assertOpen();
+    const runtime = await createRuntime();
+    providerSessions.assertOpen();
+    const projectContextRoot = normalizeText(runtime.projectContextRoot);
+    const helpers = await preparation.helperRestoration(runtime);
+    const helperRestore = await helperLifecycle.restoreThreads(helpers.projectRuntimeRoot, helpers.context);
+    const reconcileGeneration = lifecycle.nextReconcileGeneration();
+    const sessionIds = [...new Set((Array.isArray(sessions) ? sessions : [])
+      .map((session) => codexAppServerReconcileSessionId(session))
+      .filter(Boolean))];
+    const results = await Promise.all(sessionIds.map(async (sessionId) => {
+      try {
+        const session = await runtime.getSession(sessionId, { inspectSource: false });
+        let helperFailure = null;
+        let helperInventory = null;
+        if (helperRestore.ok !== false) {
+          try {
+            helperInventory = await helperLifecycle.withProjectOperation(runtime?.stateRoot, () => (
+              helperLifecycle.reconcileRuntimeUnlocked(preparation.helperInventory({ runtime, session }))
+            ));
+          } catch (error) {
+            helperFailure = helperLifecycle.failure({
+              projectRuntimeRoot: runtime.stateRoot,
+              sessionId
+            }, error);
+            debugLog("appServerHelper.reconcile.error", {
+              error: debugError(error),
+              sessionId
+            });
+          }
+        }
+        const result = await reconcileCodexAppServerThreadForSession(sessionId, {
+          agentSettings
+        }, preparation);
+        return {
+          ...result,
+          helperFailure,
+          helperInventory
+        };
+      } catch (error) {
+        debugLog("appServerThread.reconcile.error", {
+          error: debugError(error),
+          sessionId
+        });
+        const failure = {
+          ok: false,
+          error: errorMessage(error, preparation.failureMessage),
+          sessionId
+        };
+        if (error?.code === preparation.runtimeBusyCode) {
+          failure.code = error.code;
+          failure.retryable = true;
+          failure.status = "reconnecting";
+        }
+        return failure;
+      }
+    }));
+    const failed = [
+      ...helperRestore.failed,
+      ...results.flatMap((result) => [
+        result?.ok === false ? result : null,
+        result?.helperFailure || null
+      ].filter(Boolean))
+    ];
+    const keepProviderKeys = new Set();
+    const reconnectingSessionIds = new Set();
+    for (const result of results) {
+      const providerKey = normalizeText(result?.providerKey);
+      if (providerKey) {
+        keepProviderKeys.add(providerKey);
+      }
+      if (result.code === preparation.runtimeBusyCode) {
+        reconnectingSessionIds.add(result.sessionId);
+      }
+    }
+    for (const [providerKey, managed] of providerSessions.managed) {
+      if (reconnectingSessionIds.has(managed.sessionId)) {
+        keepProviderKeys.add(providerKey);
+      }
+    }
+    if (reconcileGeneration === lifecycle.reconcileGeneration) {
+      await runOwner.waitForThreadReconciliations({
+        keepProviderKeys,
+        projectContextRoot
+      });
+    }
+    if (reconcileGeneration === lifecycle.reconcileGeneration) {
+      await pruneCodexAppServerManagedSessions({
+        keepProviderKeys,
+        projectContextRoot
+      });
+    } else {
+      debugLog("appServerThread.reconcile.pruneSkipped", {
+        reason: "stale_reconcile",
+        sessionCount: sessionIds.length,
+        projectContextRoot
+      });
+    }
+    debugLog("appServerThread.reconcile.done", {
+      failedCount: failed.length,
+      sessionCount: sessionIds.length
+    });
+    return {
+      helperRestore,
+      failed,
+      ok: failed.length === 0,
+      results,
+      sessionCount: sessionIds.length
+    };
+  }
+
+  async function reconcileSessions(sessions = [], options = {}, preparation) {
+    if (!preparation.enabled) return preparation.disabledResult;
+    providerSessions.assertOpen();
+    const reconciliation = Promise.resolve().then(() => (
+      reconcileCodexAppServerThreads(sessions, options, preparation)
+    ));
+    lifecycle.reconcileTasks.add(reconciliation);
+    try {
+      return await reconciliation;
+    } finally {
+      lifecycle.reconcileTasks.delete(reconciliation);
+    }
+  }
+
+  async function unsubscribeSessions(sessions = [], preparation) {
+    if (!preparation.enabled) return preparation.disabledResult;
+    return unsubscribeCodexAppServerThreadsForSessions(sessions, preparation);
+  }
+
+  return {
+    reconcileSessions,
+    unsubscribeSessions,
+    retireProviderForSession: retireAndCloseCodexAppServerProviderForSession
+  };
+}