@kbediako/codex-orchestrator 0.1.38 → 0.2.1

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

@@ -0,0 +1,86 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { logger } from '../../logger.js';
+import { isoTimestamp } from '../utils/time.js';
+const UI_ASSET_PATHS = {
+    '/ui': 'index.html',
+    '/ui/': 'index.html',
+    '/ui/app.js': 'app.js',
+    '/ui/styles.css': 'styles.css',
+    '/ui/favicon.svg': 'favicon.svg'
+};
+const UI_ROOT = resolveUiRoot();
+export async function handlePublicControlRoute(context) {
+    if (context.pathname === '/health') {
+        context.res.writeHead(200, { 'Content-Type': 'application/json' });
+        context.res.end(JSON.stringify({ status: 'ok', timestamp: isoTimestamp() }));
+        return true;
+    }
+    if (context.pathname === '/' || context.pathname === '') {
+        context.res.writeHead(302, { Location: `/ui${context.search}` });
+        context.res.end();
+        return true;
+    }
+    const uiAsset = resolveUiAssetPath(context.pathname);
+    if (!uiAsset) {
+        return false;
+    }
+    await serveUiAsset(uiAsset, context.res);
+    return true;
+}
+function resolveUiRoot() {
+    const candidates = [
+        resolve(process.cwd(), 'packages', 'orchestrator-status-ui'),
+        resolve(process.cwd(), '..', 'packages', 'orchestrator-status-ui'),
+        resolve(process.cwd(), '..', '..', 'packages', 'orchestrator-status-ui'),
+        resolve(fileURLToPath(new URL('../../../../packages/orchestrator-status-ui', import.meta.url)))
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(join(candidate, 'index.html'))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function resolveUiAssetPath(pathname) {
+    if (!UI_ROOT) {
+        return null;
+    }
+    const asset = UI_ASSET_PATHS[pathname];
+    if (!asset) {
+        return null;
+    }
+    return resolve(UI_ROOT, asset);
+}
+async function serveUiAsset(assetPath, res) {
+    try {
+        const payload = await readFile(assetPath);
+        res.writeHead(200, {
+            'Content-Type': resolveUiContentType(assetPath),
+            'Cache-Control': 'no-store'
+        });
+        res.end(payload);
+    }
+    catch (error) {
+        logger.warn(`Failed to serve UI asset ${assetPath}: ${error?.message ?? error}`);
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Not found');
+    }
+}
+function resolveUiContentType(assetPath) {
+    if (assetPath.endsWith('.html')) {
+        return 'text/html; charset=utf-8';
+    }
+    if (assetPath.endsWith('.css')) {
+        return 'text/css; charset=utf-8';
+    }
+    if (assetPath.endsWith('.js')) {
+        return 'application/javascript; charset=utf-8';
+    }
+    if (assetPath.endsWith('.svg')) {
+        return 'image/svg+xml';
+    }
+    return 'application/octet-stream';
+}

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

@@ -0,0 +1,25 @@
+import { assertControlServerBootstrapAssemblyPublished, closeControlServerOwnedRuntime, createControlServerOwnedRuntime } from './controlServerOwnedRuntimeLifecycle.js';
+import { startControlServerReadyInstanceStartup } from './controlServerReadyInstanceStartup.js';
+export async function startControlServerReadyInstanceLifecycle(options) {
+    const ownedRuntime = createControlServerOwnedRuntime(options.requestContextShared);
+    const baseUrl = await startControlServerReadyInstanceStartup({
+        server: ownedRuntime.server,
+        requestContextShared: ownedRuntime.requestContextShared,
+        intervalMs: options.intervalMs,
+        host: options.host,
+        controlToken: options.controlToken,
+        onBootstrapAssembly: ownedRuntime.publishBootstrapAssembly,
+        closeOnFailure: () => closeControlServerOwnedRuntime({
+            server: ownedRuntime.server,
+            requestContextShared: ownedRuntime.requestContextShared,
+            lifecycleState: ownedRuntime.lifecycleState
+        })
+    });
+    assertControlServerBootstrapAssemblyPublished(ownedRuntime.lifecycleState);
+    return {
+        server: ownedRuntime.server,
+        baseUrl,
+        lifecycleState: ownedRuntime.lifecycleState
+    };
+}
+export { beginClosingControlServerHttpServer, closeControlServerOwnedRuntime } from './controlServerOwnedRuntimeLifecycle.js';

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

@@ -0,0 +1,18 @@
+import { createControlBootstrapAssembly } from './controlBootstrapAssembly.js';
+import { emitDispatchPilotAuditEvents } from './controlServerAuditAndErrorHelpers.js';
+import { startControlServerStartupSequence } from './controlServerStartupSequence.js';
+export async function startControlServerReadyInstanceStartup(options) {
+    const bootstrapAssembly = createControlBootstrapAssembly({
+        intervalMs: options.intervalMs,
+        requestContextShared: options.requestContextShared,
+        emitDispatchPilotAuditEvents
+    });
+    options.onBootstrapAssembly(bootstrapAssembly);
+    return startControlServerStartupSequence({
+        server: options.server,
+        host: options.host,
+        bootstrapLifecycle: bootstrapAssembly.bootstrapLifecycle,
+        controlToken: options.controlToken,
+        closeOnFailure: options.closeOnFailure
+    });
+}

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

@@ -0,0 +1,37 @@
+const MAX_BODY_BYTES = 1024 * 1024;
+class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export async function readRawBody(req) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of req) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += buf.length;
+        if (totalBytes > MAX_BODY_BYTES) {
+            throw new HttpError(413, 'request_body_too_large');
+        }
+        chunks.push(buf);
+    }
+    return Buffer.concat(chunks);
+}
+export async function readJsonBody(req) {
+    const rawBuffer = await readRawBody(req);
+    if (rawBuffer.length === 0) {
+        return {};
+    }
+    const raw = rawBuffer.toString('utf8');
+    if (!raw.trim()) {
+        return {};
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new HttpError(400, 'invalid_json');
+    }
+}

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

@@ -0,0 +1,40 @@
+import http from 'node:http';
+import { buildControlRequestContext } from './controlRequestContext.js';
+export function createControlServerRequestShell(options) {
+    return http.createServer((req, res) => {
+        const runtime = options.readRuntime();
+        if (!runtime) {
+            writeControlServerUnavailable(res);
+            return;
+        }
+        options
+            .handleRequest(buildLiveControlRequestContext(runtime, req, res))
+            .catch((error) => writeTopLevelControlRequestError(res, error));
+    });
+}
+function buildLiveControlRequestContext(runtime, req, res) {
+    return buildControlRequestContext({
+        ...runtime.requestContextShared,
+        req,
+        res,
+        expiryLifecycle: runtime.expiryLifecycle
+    });
+}
+function writeControlServerUnavailable(res) {
+    res.writeHead(503, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'control_server_unavailable' }));
+}
+function writeTopLevelControlRequestError(res, error) {
+    const status = readErrorStatus(error);
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+}
+function readErrorStatus(error) {
+    if (error &&
+        typeof error === 'object' &&
+        'status' in error &&
+        typeof error.status === 'number') {
+        return error.status;
+    }
+    return 500;
+}

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

@@ -0,0 +1,17 @@
+import { handleControlRequest } from './controlRequestController.js';
+import { createControlServerRequestShell } from './controlServerRequestShell.js';
+export function createBoundControlServerRequestShell(options) {
+    return createControlServerRequestShell({
+        readRuntime: () => {
+            const requestContextShared = options.readRequestContextShared();
+            if (!requestContextShared) {
+                return null;
+            }
+            return {
+                requestContextShared,
+                expiryLifecycle: options.readExpiryLifecycle()
+            };
+        },
+        handleRequest: handleControlRequest
+    });
+}

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

@@ -0,0 +1,27 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { logger } from '../../logger.js';
+import { LINEAR_ADVISORY_STATE_FILE, PROVIDER_INTAKE_STATE_FILE } from './controlPersistenceFiles.js';
+export async function readControlServerSeeds(paths) {
+    return {
+        controlSeed: await readJsonFile(paths.controlPath),
+        confirmationsSeed: await readJsonFile(paths.confirmationsPath),
+        questionsSeed: await readJsonFile(paths.questionsPath),
+        delegationSeed: await readJsonFile(paths.delegationTokensPath),
+        linearAdvisorySeed: await readJsonFile(join(paths.runDir, LINEAR_ADVISORY_STATE_FILE)),
+        providerIntakeSeed: await readJsonFile(join(paths.runDir, PROVIDER_INTAKE_STATE_FILE))
+    };
+}
+async function readJsonFile(path) {
+    try {
+        const raw = await readFile(path, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        logger.warn(`Failed to read JSON file ${path}: ${error?.message ?? error}`);
+        return null;
+    }
+}

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

@@ -0,0 +1,186 @@
+import { randomBytes } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { writeJsonAtomic } from '../utils/fs.js';
+import { isoTimestamp } from '../utils/time.js';
+import { ControlStateStore } from './controlState.js';
+import { ConfirmationStore } from './confirmations.js';
+import { QuestionQueue } from './questions.js';
+import { DelegationTokenStore } from './delegationTokens.js';
+import { createControlRuntime } from './controlRuntime.js';
+import { createControlEventTransport } from './controlEventTransport.js';
+import { markLinearAdvisoryStateStaleFromProviderIntake, normalizeLinearAdvisoryState } from './linearWebhookController.js';
+import { isRecordLike, normalizeProviderIntakeState } from './providerIntakeState.js';
+import { LINEAR_ADVISORY_STATE_FILE, PROVIDER_INTAKE_STATE_FILE } from './controlPersistenceFiles.js';
+class SessionTokenStore {
+    ttlMs;
+    tokens = new Map();
+    constructor(ttlMs) {
+        this.ttlMs = ttlMs;
+    }
+    issue() {
+        this.prune();
+        const token = randomBytes(24).toString('hex');
+        const expiresAt = Date.now() + this.ttlMs;
+        this.tokens.set(token, expiresAt);
+        return { token, expiresAt: new Date(expiresAt).toISOString() };
+    }
+    validate(token) {
+        this.prune();
+        const expiresAt = this.tokens.get(token);
+        if (!expiresAt) {
+            return false;
+        }
+        if (expiresAt <= Date.now()) {
+            this.tokens.delete(token);
+            return false;
+        }
+        return true;
+    }
+    prune() {
+        const now = Date.now();
+        for (const [token, expiresAt] of this.tokens.entries()) {
+            if (expiresAt <= now) {
+                this.tokens.delete(token);
+            }
+        }
+    }
+}
+export function createControlServerSeededRuntimeAssembly(options) {
+    const controlStore = new ControlStateStore({
+        runId: options.runId,
+        controlSeq: options.controlSeed?.control_seq ?? 0,
+        latestAction: options.controlSeed?.latest_action ?? null,
+        featureToggles: options.controlSeed?.feature_toggles ?? null,
+        transportMutation: options.controlSeed?.transport_mutation ?? null
+    });
+    const defaultToggles = options.controlSeed?.feature_toggles ?? {};
+    if (!('rlm' in defaultToggles)) {
+        controlStore.updateFeatureToggles({ rlm: { policy: options.config.rlm.policy } });
+    }
+    const confirmationStore = new ConfirmationStore({
+        runId: options.runId,
+        expiresInMs: options.config.confirm.expiresInMs,
+        maxPending: options.config.confirm.maxPending,
+        seed: {
+            pending: options.confirmationsSeed?.pending ?? [],
+            issued: options.confirmationsSeed?.issued ?? [],
+            consumed_nonce_ids: options.confirmationsSeed?.consumed_nonce_ids ?? []
+        }
+    });
+    const questionQueue = new QuestionQueue({ seed: options.questionsSeed?.questions ?? [] });
+    const delegationTokens = new DelegationTokenStore({ seed: options.delegationSeed?.tokens ?? [] });
+    const sessionTokens = new SessionTokenStore(options.sessionTtlMs);
+    const linearAdvisoryState = normalizeLinearAdvisoryState(options.linearAdvisorySeed);
+    const providerIntakeState = normalizeProviderIntakeState(options.providerIntakeSeed);
+    let linearAdvisoryStaleWritePending = markLinearAdvisoryStateStaleFromProviderIntake(linearAdvisoryState, providerIntakeState);
+    let providerIssueHandoff = null;
+    const controlRuntime = createControlRuntime({
+        controlStore,
+        questionQueue,
+        paths: options.paths,
+        linearAdvisoryState,
+        providerIntakeState,
+        providerWorkflowConfigStore: options.providerWorkflowConfigStore,
+        readProviderIssueHandoff: () => providerIssueHandoff
+    });
+    const clients = new Set();
+    const eventTransport = createControlEventTransport({
+        eventStream: options.eventStream,
+        clients,
+        runtime: controlRuntime
+    });
+    const linearAdvisoryStatePath = join(options.paths.runDir, LINEAR_ADVISORY_STATE_FILE);
+    const providerIntakeStatePath = join(options.paths.runDir, PROVIDER_INTAKE_STATE_FILE);
+    let providerIntakePersistChain = Promise.resolve();
+    const queueProviderIntakePersist = async (operation) => {
+        const nextOperation = providerIntakePersistChain.then(operation, operation);
+        providerIntakePersistChain = nextOperation.then(() => undefined, () => undefined);
+        return await nextOperation;
+    };
+    const readPersistedProviderIntakeState = async () => {
+        try {
+            return normalizeProviderIntakeState(JSON.parse(await readFile(providerIntakeStatePath, 'utf8')));
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    };
+    const persist = {
+        control: async () => writeJsonAtomic(options.paths.controlPath, controlStore.snapshot()),
+        confirmations: async () => writeJsonAtomic(options.paths.confirmationsPath, confirmationStore.snapshot()),
+        questions: async () => writeJsonAtomic(options.paths.questionsPath, { questions: questionQueue.list() }),
+        delegationTokens: async () => writeJsonAtomic(options.paths.delegationTokensPath, { tokens: delegationTokens.list() }),
+        linearAdvisory: async () => {
+            await writeJsonAtomic(linearAdvisoryStatePath, linearAdvisoryState);
+            linearAdvisoryStaleWritePending = false;
+        },
+        providerIntake: async () => await queueProviderIntakePersist(async () => {
+            await writeJsonAtomic(providerIntakeStatePath, providerIntakeState);
+            const linearAdvisoryMarkedStale = markLinearAdvisoryStateStaleFromProviderIntake(linearAdvisoryState, providerIntakeState);
+            if (linearAdvisoryStaleWritePending || linearAdvisoryMarkedStale) {
+                await writeJsonAtomic(linearAdvisoryStatePath, linearAdvisoryState);
+                linearAdvisoryStaleWritePending = false;
+                controlRuntime.publish({ source: 'linear-advisory.stale-source' });
+            }
+        }),
+        providerIntakePolling: async (polling, updatedAt) => await queueProviderIntakePersist(async () => {
+            const nextState = (await readPersistedProviderIntakeState()) ?? normalizeProviderIntakeState(null);
+            const nextPolling = isRecordLike(polling) ? { ...polling } : null;
+            nextState.polling = nextPolling;
+            const nextPollingUpdatedAt = typeof nextPolling?.updated_at === 'string' && nextPolling.updated_at.trim().length > 0
+                ? nextPolling.updated_at
+                : isoTimestamp();
+            const nextStateUpdatedAt = typeof updatedAt === 'string' && updatedAt.trim().length > 0 ? updatedAt : nextPollingUpdatedAt;
+            nextState.updated_at = pickLatestTimestamp(nextState.updated_at, nextStateUpdatedAt);
+            await writeJsonAtomic(providerIntakeStatePath, nextState);
+            const linearAdvisoryMarkedStale = markLinearAdvisoryStateStaleFromProviderIntake(linearAdvisoryState, nextState);
+            if (linearAdvisoryStaleWritePending || linearAdvisoryMarkedStale) {
+                await writeJsonAtomic(linearAdvisoryStatePath, linearAdvisoryState);
+                linearAdvisoryStaleWritePending = false;
+                controlRuntime.publish({ source: 'linear-advisory.stale-source' });
+            }
+        })
+    };
+    providerIssueHandoff =
+        options.createProviderIssueHandoff?.({
+            providerIntakeState,
+            persistProviderIntake: persist.providerIntake,
+            publishRuntime: (source) => controlRuntime.publish({ source }),
+            readFeatureToggles: () => controlStore.snapshot().feature_toggles
+        }) ?? null;
+    const requestContextShared = {
+        token: options.token,
+        controlStore,
+        confirmationStore,
+        questionQueue,
+        delegationTokens,
+        sessionTokens,
+        config: options.config,
+        persist,
+        clients,
+        eventTransport,
+        paths: options.paths,
+        linearAdvisoryState,
+        providerIntakeState,
+        providerIssueHandoff,
+        runtime: controlRuntime
+    };
+    return {
+        requestContextShared
+    };
+}
+function pickLatestTimestamp(currentIso, candidateIso) {
+    const currentMs = Date.parse(currentIso ?? '');
+    const candidateMs = Date.parse(candidateIso);
+    if (!Number.isFinite(currentMs)) {
+        return candidateIso;
+    }
+    if (!Number.isFinite(candidateMs)) {
+        return currentIso ?? candidateIso;
+    }
+    return candidateMs >= currentMs ? candidateIso : currentIso ?? candidateIso;
+}

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

@@ -0,0 +1,31 @@
+import { randomBytes } from 'node:crypto';
+import { readControlServerSeeds } from './controlServerSeedLoading.js';
+import { createControlServerSeededRuntimeAssembly } from './controlServerSeededRuntimeAssembly.js';
+export async function prepareControlServerStartupInputs(options) {
+    const controlToken = randomBytes(24).toString('hex');
+    const { controlSeed, confirmationsSeed, questionsSeed, delegationSeed, linearAdvisorySeed, providerIntakeSeed } = await readControlServerSeeds(options.paths);
+    const { requestContextShared } = createControlServerSeededRuntimeAssembly({
+        runId: options.runId,
+        token: controlToken,
+        config: options.config,
+        paths: options.paths,
+        eventStream: options.eventStream,
+        sessionTtlMs: options.sessionTtlMs,
+        controlSeed,
+        confirmationsSeed,
+        questionsSeed,
+        delegationSeed,
+        linearAdvisorySeed,
+        providerIntakeSeed,
+        providerWorkflowConfigStore: options.providerWorkflowConfigStore,
+        createProviderIssueHandoff: options.createProviderIssueHandoff
+    });
+    if (requestContextShared.linearAdvisoryState.stale_source) {
+        await requestContextShared.persist.linearAdvisory();
+    }
+    return {
+        requestContextShared,
+        host: options.config.ui.bindHost,
+        controlToken
+    };
+}

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

@@ -0,0 +1,49 @@
+import { logger } from '../../logger.js';
+export async function startControlServerStartupSequence(options) {
+    await bindControlServer(options.server, options.host);
+    const baseUrl = resolveControlServerBaseUrl(options.server, options.host);
+    options.server.on('error', (error) => {
+        logger.error(`Control server error: ${error?.message ?? String(error)}`);
+    });
+    try {
+        await options.bootstrapLifecycle.start({
+            baseUrl,
+            controlToken: options.controlToken
+        });
+    }
+    catch (error) {
+        await options.closeOnFailure();
+        throw error;
+    }
+    return baseUrl;
+}
+async function bindControlServer(server, host) {
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off('error', onError);
+            try {
+                server.close(() => undefined);
+            }
+            catch {
+                // Ignore close errors on a server that failed to bind.
+            }
+            reject(error);
+        };
+        server.once('error', onError);
+        server.listen(0, host, () => {
+            server.off('error', onError);
+            resolve();
+        });
+    });
+}
+function resolveControlServerBaseUrl(server, host) {
+    const address = server.address();
+    const port = typeof address === 'string' || !address ? 0 : address.port;
+    return `http://${formatHostForUrl(host)}:${port}`;
+}
+export function formatHostForUrl(host) {
+    if (host.includes(':') && !host.startsWith('[')) {
+        return `[${host}]`;
+    }
+    return host;
+}