@kbediako/codex-orchestrator 0.1.38 → 0.2.1

package/dist/orchestrator/src/cli/control/controlRequestContext.js

@@ -0,0 +1,42 @@
+export function buildControlRequestContext(input) {
+    return {
+        req: input.req,
+        res: input.res,
+        token: input.token,
+        controlStore: input.controlStore,
+        confirmationStore: input.confirmationStore,
+        questionQueue: input.questionQueue,
+        delegationTokens: input.delegationTokens,
+        sessionTokens: input.sessionTokens,
+        config: input.config,
+        persist: input.persist,
+        clients: input.clients,
+        eventTransport: input.eventTransport,
+        paths: input.paths,
+        linearAdvisoryState: input.linearAdvisoryState,
+        providerIntakeState: input.providerIntakeState,
+        providerIssueHandoff: input.providerIssueHandoff,
+        runtime: input.runtime,
+        expiryLifecycle: input.expiryLifecycle
+    };
+}
+export function buildControlInternalContext(input) {
+    return buildControlRequestContext({
+        ...input,
+        req: null,
+        res: null,
+        expiryLifecycle: input.expiryLifecycle
+    });
+}
+export function buildControlPresenterRuntimeContext(input) {
+    const runtimeSnapshot = input.runtime.snapshot();
+    return {
+        runtimeSnapshot,
+        presenterContext: {
+            controlStore: input.controlStore,
+            paths: input.paths,
+            readSelectedRunSnapshot: () => runtimeSnapshot.readSelectedRunSnapshot(),
+            readCompatibilityProjection: () => runtimeSnapshot.readCompatibilityProjection()
+        }
+    };
+}

package/dist/orchestrator/src/cli/control/controlRequestController.js

@@ -0,0 +1,9 @@
+import { buildControlRequestRouteDispatchInput } from './controlRequestPredispatch.js';
+import { handleControlRequestRouteDispatch } from './controlRequestRouteDispatch.js';
+export async function handleControlRequest(context) {
+    const dispatchInput = buildControlRequestRouteDispatchInput(context);
+    if (!dispatchInput) {
+        return;
+    }
+    await handleControlRequestRouteDispatch(dispatchInput);
+}

package/dist/orchestrator/src/cli/control/controlRequestPredispatch.js

@@ -0,0 +1,17 @@
+import { buildControlPresenterRuntimeContext } from './controlRequestContext.js';
+export function buildControlRequestRouteDispatchInput(context) {
+    if (!context.req || !context.res) {
+        return null;
+    }
+    const url = new URL(context.req.url ?? '/', 'http://localhost');
+    const { runtimeSnapshot, presenterContext } = buildControlPresenterRuntimeContext(context);
+    return {
+        pathname: url.pathname,
+        search: url.search ? url.search : '',
+        req: context.req,
+        res: context.res,
+        context,
+        runtimeSnapshot,
+        presenterContext
+    };
+}

package/dist/orchestrator/src/cli/control/controlRequestRouteDispatch.js

@@ -0,0 +1,44 @@
+import { handleControlUiSessionAdmission } from './uiSessionController.js';
+import { handleLinearWebhookRequest } from './linearWebhookController.js';
+import { handleControlAuthenticatedRouteBranch } from './controlServerAuthenticatedRouteBranch.js';
+import { emitLinearWebhookAuditEvent } from './controlServerAuditAndErrorHelpers.js';
+import { handlePublicControlRoute } from './controlServerPublicRouteHelpers.js';
+import { readRawBody } from './controlServerRequestBodyHelpers.js';
+export async function handleControlRequestRouteDispatch(input) {
+    if (await handlePublicControlRoute({
+        pathname: input.pathname,
+        search: input.search,
+        res: input.res
+    })) {
+        return;
+    }
+    if (handleControlUiSessionAdmission({
+        req: input.req,
+        res: input.res,
+        allowedBindHosts: input.context.config.ui.allowedBindHosts,
+        issueSession: () => input.context.sessionTokens.issue()
+    })) {
+        return;
+    }
+    if (await handleLinearWebhookRequest({
+        req: input.req,
+        res: input.res,
+        linearAdvisoryState: input.context.linearAdvisoryState,
+        readRawBody,
+        persistLinearAdvisory: input.context.persist.linearAdvisory,
+        emitAuditEvent: (auditInput) => emitLinearWebhookAuditEvent(input.context, auditInput),
+        readFeatureToggles: () => input.context.controlStore.snapshot().feature_toggles,
+        providerIssueHandoff: input.context.providerIssueHandoff ?? null,
+        publishRuntime: () => input.context.runtime.publish({ source: 'linear.webhook' })
+    })) {
+        return;
+    }
+    await handleControlAuthenticatedRouteBranch({
+        pathname: input.pathname,
+        req: input.req,
+        res: input.res,
+        context: input.context,
+        runtimeSnapshot: input.runtimeSnapshot,
+        presenterContext: input.presenterContext
+    });
+}