@kbediako/codex-orchestrator 0.1.38 → 0.2.1

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

@@ -0,0 +1,115 @@
+import { basename, dirname } from 'node:path';
+export async function emitLinearWebhookAuditEvent(context, input) {
+    await context.eventTransport.emitControlEvent({
+        event: 'linear_advisory_webhook_processed',
+        actor: 'runner',
+        payload: {
+            delivery_id: input.deliveryId,
+            event_name: input.event,
+            action: input.action,
+            issue_id: input.issueId,
+            outcome: input.outcome,
+            reason: input.reason,
+            advisory_only: true
+        }
+    });
+}
+export async function emitDispatchPilotAuditEvents(context, input) {
+    const snapshot = context.controlStore.snapshot();
+    const decision = input.evaluation.failure
+        ? 'fail_closed'
+        : input.evaluation.summary.status === 'ready'
+            ? 'ready'
+            : 'blocked';
+    const statusCode = input.evaluation.failure?.status ?? 200;
+    const eventPayload = {
+        surface: input.surface,
+        advisory_only: true,
+        issue_identifier: input.issueIdentifier,
+        task_id: resolveTaskIdFromManifestPath(context.paths.manifestPath),
+        run_id: snapshot.run_id,
+        control_seq: snapshot.control_seq,
+        decision,
+        status: input.evaluation.summary.status,
+        source_status: input.evaluation.summary.source_status,
+        reason: input.evaluation.failure?.reason ?? input.evaluation.summary.reason
+    };
+    await context.eventTransport.emitControlEvent({
+        event: 'dispatch_pilot_evaluated',
+        actor: 'runner',
+        payload: eventPayload
+    });
+    await context.eventTransport.emitControlEvent({
+        event: 'dispatch_pilot_viewed',
+        actor: 'runner',
+        payload: {
+            ...eventPayload,
+            http_status: statusCode,
+            recommendation_available: Boolean(input.evaluation.recommendation)
+        }
+    });
+}
+export function writeControlError(res, status, error, traceability) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(traceability ? { error, traceability } : { error }));
+}
+export async function emitControlActionAuditEvent(context, input) {
+    await context.eventTransport.emitControlEvent({
+        event: input.outcome === 'replayed' ? 'control_action_replayed' : 'control_action_applied',
+        actor: 'runner',
+        payload: {
+            idempotent_replay: input.outcome === 'replayed',
+            ...buildControlActionTracePayload(context, input),
+            ...(input.traceability ? { traceability: input.traceability } : {})
+        }
+    });
+}
+function buildControlActionTracePayload(context, input) {
+    const latestAction = input.snapshot.latest_action;
+    const traceability = input.traceability ?? null;
+    const traceTransport = traceability && Object.prototype.hasOwnProperty.call(traceability, 'transport')
+        ? typeof traceability.transport === 'string'
+            ? traceability.transport
+            : null
+        : undefined;
+    const traceActorId = traceability && Object.prototype.hasOwnProperty.call(traceability, 'actor_id')
+        ? typeof traceability.actor_id === 'string'
+            ? traceability.actor_id
+            : null
+        : undefined;
+    const traceActorSource = traceability && Object.prototype.hasOwnProperty.call(traceability, 'actor_source')
+        ? typeof traceability.actor_source === 'string'
+            ? traceability.actor_source
+            : null
+        : undefined;
+    const tracePrincipal = traceability && Object.prototype.hasOwnProperty.call(traceability, 'transport_principal')
+        ? typeof traceability.transport_principal === 'string'
+            ? traceability.transport_principal
+            : null
+        : undefined;
+    return {
+        action: input.action,
+        request_id: input.requestId,
+        intent_id: input.intentId,
+        requested_by: input.requestedBy,
+        requested_reason: input.reason,
+        control_seq: input.snapshot.control_seq,
+        task_id: resolveTaskIdFromManifestPath(context.paths.manifestPath),
+        run_id: input.snapshot.run_id,
+        manifest_path: context.paths.manifestPath,
+        transport: traceTransport !== undefined ? traceTransport : latestAction?.transport ?? null,
+        actor_id: traceActorId !== undefined ? traceActorId : latestAction?.actor_id ?? null,
+        actor_source: traceActorSource !== undefined ? traceActorSource : latestAction?.actor_source ?? null,
+        transport_principal: tracePrincipal !== undefined ? tracePrincipal : latestAction?.transport_principal ?? null
+    };
+}
+function resolveTaskIdFromManifestPath(manifestPath) {
+    const runDir = dirname(manifestPath);
+    const cliDir = dirname(runDir);
+    if (basename(cliDir) !== 'cli') {
+        return null;
+    }
+    const taskDir = dirname(cliDir);
+    const taskId = basename(taskDir);
+    return taskId || null;
+}

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

@@ -0,0 +1,29 @@
+import { admitAuthenticatedControlRoute } from './authenticatedControlRouteGate.js';
+import { handleAuthenticatedRouteRequest } from './authenticatedRouteController.js';
+import { createControlAuthenticatedRouteContext } from './controlAuthenticatedRouteHandoff.js';
+export async function handleControlAuthenticatedRouteBranch(input) {
+    const auth = admitAuthenticatedControlRoute({
+        req: input.req,
+        res: input.res,
+        pathname: input.pathname,
+        controlToken: input.context.token,
+        isSessionTokenValid: (token) => input.context.sessionTokens.validate(token)
+    });
+    if (!auth) {
+        return;
+    }
+    const handled = await handleAuthenticatedRouteRequest(createControlAuthenticatedRouteContext({
+        pathname: input.pathname,
+        authKind: auth.kind,
+        req: input.req,
+        res: input.res,
+        context: input.context,
+        runtimeSnapshot: input.runtimeSnapshot,
+        presenterContext: input.presenterContext
+    }));
+    if (handled) {
+        return;
+    }
+    input.res.writeHead(404, { 'Content-Type': 'application/json' });
+    input.res.end(JSON.stringify({ error: 'not_found' }));
+}

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

@@ -0,0 +1,30 @@
+import { runControlServerBootstrapStartSequence } from './controlServerBootstrapStartSequence.js';
+export function createControlServerBootstrapLifecycle(options) {
+    return new ControlServerBootstrapLifecycleRuntime(options);
+}
+class ControlServerBootstrapLifecycleRuntime {
+    paths;
+    persistControl;
+    startExpiryLifecycle;
+    telegramBridgeLifecycle;
+    constructor(options) {
+        this.paths = options.paths;
+        this.persistControl = options.persistControl;
+        this.startExpiryLifecycle = options.startExpiryLifecycle ?? (() => undefined);
+        this.telegramBridgeLifecycle = options.telegramBridgeLifecycle ?? null;
+    }
+    async start(options) {
+        await runControlServerBootstrapStartSequence({
+            paths: this.paths,
+            persistControl: this.persistControl,
+            startExpiryLifecycle: this.startExpiryLifecycle,
+            telegramBridgeLifecycle: this.telegramBridgeLifecycle
+        }, {
+            baseUrl: options.baseUrl,
+            controlToken: options.controlToken
+        });
+    }
+    async close() {
+        await this.telegramBridgeLifecycle?.close();
+    }
+}

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

@@ -0,0 +1,21 @@
+import { logger } from '../../logger.js';
+import { persistControlBootstrapMetadata } from './controlBootstrapMetadataPersistence.js';
+export async function runControlServerBootstrapStartSequence(context, input) {
+    await persistControlBootstrapMetadata({
+        paths: context.paths,
+        persistControl: context.persistControl
+    }, {
+        baseUrl: input.baseUrl,
+        controlToken: input.controlToken
+    });
+    await context.startExpiryLifecycle();
+    try {
+        await context.telegramBridgeLifecycle?.start({
+            baseUrl: input.baseUrl,
+            controlToken: input.controlToken
+        });
+    }
+    catch (error) {
+        logger.warn(`Failed to start Telegram oversight bridge: ${error?.message ?? String(error)}`);
+    }
+}

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

@@ -0,0 +1,67 @@
+import { createBoundControlServerRequestShell } from './controlServerRequestShellBinding.js';
+export function createControlServerOwnedRuntime(requestContextShared) {
+    const lifecycleState = {
+        expiryLifecycle: null,
+        bootstrapLifecycle: null
+    };
+    const ownedRuntime = {
+        server: null,
+        requestContextShared,
+        lifecycleState,
+        publishBootstrapAssembly(assembly) {
+            lifecycleState.expiryLifecycle = assembly.expiryLifecycle;
+            lifecycleState.bootstrapLifecycle = assembly.bootstrapLifecycle;
+        }
+    };
+    ownedRuntime.server = createBoundControlServerRequestShell({
+        readRequestContextShared: () => ownedRuntime.requestContextShared,
+        readExpiryLifecycle: () => ownedRuntime.lifecycleState.expiryLifecycle
+    });
+    return ownedRuntime;
+}
+export function assertControlServerBootstrapAssemblyPublished(lifecycleState) {
+    if (!lifecycleState.expiryLifecycle || !lifecycleState.bootstrapLifecycle) {
+        throw new Error('Control server ready instance startup did not publish bootstrap assembly');
+    }
+}
+export async function closeControlServerOwnedRuntime(options) {
+    const expiryLifecycle = options.lifecycleState.expiryLifecycle;
+    expiryLifecycle?.close();
+    options.lifecycleState.expiryLifecycle = null;
+    const bootstrapLifecycle = options.lifecycleState.bootstrapLifecycle;
+    await bootstrapLifecycle?.close();
+    options.lifecycleState.bootstrapLifecycle = null;
+    for (const client of options.requestContextShared.clients) {
+        client.end();
+    }
+    await (options.serverClosePromise ?? beginClosingControlServerHttpServer(options.server));
+}
+export function beginClosingControlServerHttpServer(server) {
+    if (!server.listening) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const settleError = (error) => {
+            const code = error?.code;
+            if (code === 'ERR_SERVER_NOT_RUNNING') {
+                resolve();
+                return;
+            }
+            reject(error);
+        };
+        try {
+            server.close((error) => {
+                if (error) {
+                    settleError(error);
+                    return;
+                }
+                resolve();
+            });
+            server.closeIdleConnections?.();
+            server.closeAllConnections?.();
+        }
+        catch (error) {
+            settleError(error);
+        }
+    });
+}