@kbediako/codex-orchestrator 0.1.37 → 0.2.0

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

@@ -0,0 +1,439 @@
+import { hasLinearApiCredentials, hasLinearSourceBinding, resolveLinearSourceSetup, resolveLiveLinearDispatchRecommendation } from './linearDispatchSource.js';
+export function evaluateTrackerDispatchPilot(input) {
+    const resolved = resolveDispatchPilotPolicy(input.featureToggles ?? null);
+    const enabled = readBooleanValue(resolved.policy, 'enabled') ?? false;
+    const killSwitch = readBooleanValue(resolved.policy, 'kill_switch', 'killSwitch') ?? false;
+    const source = parseDispatchPilotSource(resolved.policy, input.defaultIssueIdentifier ?? null);
+    if (!enabled) {
+        return buildDisabledEvaluation(resolved.configured, killSwitch);
+    }
+    if (killSwitch) {
+        return buildKillSwitchedEvaluation(resolved.configured, source);
+    }
+    if (source.kind === 'live_linear') {
+        const sourceSetup = resolveLinearSourceSetup(source.sourceSetup, input.env ?? process.env);
+        if (!hasLinearSourceBinding(sourceSetup)) {
+            return buildFailureEvaluation({
+                configured: resolved.configured,
+                sourceStatus: 'malformed',
+                reason: 'dispatch_source_binding_missing',
+                status: 422,
+                code: 'dispatch_source_malformed',
+                sourceSetup
+            });
+        }
+        if (!hasLinearApiCredentials(input.env)) {
+            return buildFailureEvaluation({
+                configured: resolved.configured,
+                sourceStatus: 'unavailable',
+                reason: 'dispatch_source_credentials_missing',
+                status: 503,
+                code: 'dispatch_source_unavailable',
+                sourceSetup
+            });
+        }
+        return buildFailureEvaluation({
+            configured: resolved.configured,
+            sourceStatus: 'unavailable',
+            reason: 'dispatch_source_live_requires_async_evaluation',
+            status: 503,
+            code: 'dispatch_source_unavailable',
+            sourceSetup
+        });
+    }
+    if (source.kind === 'unavailable') {
+        return buildFailureEvaluation({
+            configured: resolved.configured,
+            sourceStatus: 'unavailable',
+            reason: 'dispatch_source_unavailable',
+            status: 503,
+            code: 'dispatch_source_unavailable',
+            sourceSetup: null
+        });
+    }
+    if (source.kind === 'malformed') {
+        return buildFailureEvaluation({
+            configured: resolved.configured,
+            sourceStatus: 'malformed',
+            reason: source.reason,
+            status: 422,
+            code: 'dispatch_source_malformed',
+            sourceSetup: null
+        });
+    }
+    return buildReadyEvaluation({
+        configured: resolved.configured,
+        recommendation: source.recommendation,
+        sourceSetup: source.sourceSetup
+    });
+}
+export function summarizeTrackerDispatchPilotPolicy(input) {
+    const resolved = resolveDispatchPilotPolicy(input.featureToggles ?? null);
+    const enabled = readBooleanValue(resolved.policy, 'enabled') ?? false;
+    const killSwitch = readBooleanValue(resolved.policy, 'kill_switch', 'killSwitch') ?? false;
+    const source = parseDispatchPilotSource(resolved.policy, null);
+    if (!enabled) {
+        return buildDisabledSummary(resolved.configured, killSwitch);
+    }
+    if (killSwitch) {
+        return buildKillSwitchedSummary(resolved.configured, source);
+    }
+    if (source.kind === 'unavailable') {
+        return buildFailureSummary({
+            configured: resolved.configured,
+            sourceStatus: 'unavailable',
+            reason: 'dispatch_source_unavailable',
+            sourceSetup: null
+        });
+    }
+    if (source.kind === 'malformed') {
+        return buildFailureSummary({
+            configured: resolved.configured,
+            sourceStatus: 'malformed',
+            reason: source.reason,
+            sourceSetup: null
+        });
+    }
+    if (source.kind === 'live_linear') {
+        const sourceSetup = resolveLinearSourceSetup(source.sourceSetup, input.env ?? process.env);
+        if (!hasLinearSourceBinding(sourceSetup)) {
+            return buildFailureSummary({
+                configured: resolved.configured,
+                sourceStatus: 'malformed',
+                reason: 'dispatch_source_binding_missing',
+                sourceSetup
+            });
+        }
+        if (!hasLinearApiCredentials(input.env)) {
+            return buildFailureSummary({
+                configured: resolved.configured,
+                sourceStatus: 'unavailable',
+                reason: 'dispatch_source_credentials_missing',
+                sourceSetup
+            });
+        }
+        return buildReadySummary({
+            configured: resolved.configured,
+            sourceSetup,
+            reason: 'dispatch_source_live_deferred'
+        });
+    }
+    return buildReadySummary({
+        configured: resolved.configured,
+        sourceSetup: source.sourceSetup,
+        reason: 'recommendation_available'
+    });
+}
+export async function evaluateTrackerDispatchPilotAsync(input) {
+    const resolved = resolveDispatchPilotPolicy(input.featureToggles ?? null);
+    const enabled = readBooleanValue(resolved.policy, 'enabled') ?? false;
+    const killSwitch = readBooleanValue(resolved.policy, 'kill_switch', 'killSwitch') ?? false;
+    const source = parseDispatchPilotSource(resolved.policy, input.defaultIssueIdentifier ?? null);
+    if (!enabled) {
+        return buildDisabledEvaluation(resolved.configured, killSwitch);
+    }
+    if (killSwitch) {
+        return buildKillSwitchedEvaluation(resolved.configured, source);
+    }
+    if (source.kind === 'unavailable') {
+        return buildFailureEvaluation({
+            configured: resolved.configured,
+            sourceStatus: 'unavailable',
+            reason: 'dispatch_source_unavailable',
+            status: 503,
+            code: 'dispatch_source_unavailable',
+            sourceSetup: null
+        });
+    }
+    if (source.kind === 'malformed') {
+        return buildFailureEvaluation({
+            configured: resolved.configured,
+            sourceStatus: 'malformed',
+            reason: source.reason,
+            status: 422,
+            code: 'dispatch_source_malformed',
+            sourceSetup: null
+        });
+    }
+    if (source.kind === 'ready') {
+        return buildReadyEvaluation({
+            configured: resolved.configured,
+            recommendation: source.recommendation,
+            sourceSetup: source.sourceSetup
+        });
+    }
+    const liveResolution = await resolveLiveLinearDispatchRecommendation({
+        source: source.source,
+        sourceSetup: source.sourceSetup,
+        defaultIssueIdentifier: input.defaultIssueIdentifier ?? null,
+        env: input.env,
+        fetchImpl: input.fetchImpl
+    });
+    if (liveResolution.kind !== 'ready') {
+        if (liveResolution.kind === 'unavailable' &&
+            liveResolution.reason === 'dispatch_source_issue_not_found') {
+            return {
+                summary: buildReadySummary({
+                    configured: resolved.configured,
+                    sourceSetup: source.sourceSetup,
+                    reason: 'dispatch_source_no_eligible_issue'
+                }),
+                recommendation: null,
+                failure: null
+            };
+        }
+        return buildFailureEvaluation({
+            configured: resolved.configured,
+            sourceStatus: liveResolution.kind === 'malformed' ? 'malformed' : 'unavailable',
+            reason: liveResolution.reason,
+            status: liveResolution.status,
+            code: liveResolution.code,
+            sourceSetup: liveResolution.kind === 'malformed' ? source.sourceSetup : source.sourceSetup
+        });
+    }
+    return buildReadyEvaluation({
+        configured: resolved.configured,
+        sourceSetup: liveResolution.source_setup,
+        recommendation: {
+            issue_identifier: liveResolution.tracked_issue.identifier ?? input.defaultIssueIdentifier ?? null,
+            dispatch_id: liveResolution.dispatch_id,
+            summary: liveResolution.summary,
+            rationale: liveResolution.rationale,
+            confidence: liveResolution.confidence,
+            generated_at: liveResolution.generated_at,
+            source_setup: liveResolution.source_setup,
+            tracked_issue: liveResolution.tracked_issue
+        }
+    });
+}
+function buildDisabledEvaluation(configured, killSwitch) {
+    return {
+        summary: buildDisabledSummary(configured, killSwitch),
+        recommendation: null,
+        failure: null
+    };
+}
+function buildKillSwitchedEvaluation(configured, source) {
+    return {
+        summary: buildKillSwitchedSummary(configured, source),
+        recommendation: null,
+        failure: null
+    };
+}
+function buildReadyEvaluation(input) {
+    return {
+        summary: buildReadySummary({
+            configured: input.configured,
+            sourceSetup: input.sourceSetup,
+            reason: 'recommendation_available'
+        }),
+        recommendation: input.recommendation,
+        failure: null
+    };
+}
+function buildFailureEvaluation(input) {
+    return {
+        summary: buildFailureSummary({
+            configured: input.configured,
+            sourceStatus: input.sourceStatus,
+            reason: input.reason,
+            sourceSetup: input.sourceSetup
+        }),
+        recommendation: null,
+        failure: {
+            status: input.status,
+            code: input.code,
+            reason: input.reason
+        }
+    };
+}
+function buildDisabledSummary(configured, killSwitch) {
+    return {
+        advisory_only: true,
+        configured,
+        enabled: false,
+        kill_switch: killSwitch,
+        status: 'disabled',
+        source_status: 'disabled',
+        reason: 'pilot_disabled_default_off',
+        source_setup: null
+    };
+}
+function buildKillSwitchedSummary(configured, source) {
+    return {
+        advisory_only: true,
+        configured,
+        enabled: true,
+        kill_switch: true,
+        status: 'kill_switched',
+        source_status: 'blocked',
+        reason: 'pilot_kill_switch_enabled',
+        source_setup: source.kind === 'ready' || source.kind === 'live_linear' ? source.sourceSetup : null
+    };
+}
+function buildReadySummary(input) {
+    return {
+        advisory_only: true,
+        configured: input.configured,
+        enabled: true,
+        kill_switch: false,
+        status: 'ready',
+        source_status: 'ready',
+        reason: input.reason,
+        source_setup: input.sourceSetup
+    };
+}
+function buildFailureSummary(input) {
+    return {
+        advisory_only: true,
+        configured: input.configured,
+        enabled: true,
+        kill_switch: false,
+        status: input.sourceStatus === 'unavailable' ? 'source_unavailable' : 'source_malformed',
+        source_status: input.sourceStatus,
+        reason: input.reason,
+        source_setup: input.sourceSetup
+    };
+}
+function resolveDispatchPilotPolicy(featureToggles) {
+    const toggles = featureToggles ?? {};
+    const direct = readRecordValue(toggles, 'dispatch_pilot');
+    const coordinator = readRecordValue(toggles, 'coordinator');
+    const nested = coordinator ? readRecordValue(coordinator, 'dispatch_pilot') : undefined;
+    if (nested) {
+        return { policy: nested, configured: true };
+    }
+    if (direct) {
+        return { policy: direct, configured: true };
+    }
+    return { policy: {}, configured: false };
+}
+function parseDispatchPilotSource(policy, defaultIssueIdentifier) {
+    if (!Object.prototype.hasOwnProperty.call(policy, 'source')) {
+        return { kind: 'unavailable' };
+    }
+    const rawSource = policy.source;
+    if (!rawSource || typeof rawSource !== 'object' || Array.isArray(rawSource)) {
+        return { kind: 'malformed', reason: 'dispatch_source_not_object' };
+    }
+    const source = rawSource;
+    const provider = readStringValue(source, 'provider', 'source_provider', 'sourceProvider');
+    const normalizedProvider = normalizeDispatchSourceProvider(provider);
+    if (!normalizedProvider) {
+        return {
+            kind: 'malformed',
+            reason: provider ? 'dispatch_source_provider_unsupported' : 'dispatch_source_provider_missing'
+        };
+    }
+    const bindingSource = readRecordValue(source, 'linear') ?? source;
+    const sourceSetup = {
+        provider: normalizedProvider,
+        workspace_id: readStringValue(bindingSource, 'workspace_id', 'workspaceId') ?? null,
+        team_id: readStringValue(bindingSource, 'team_id', 'teamId') ?? null,
+        project_id: readStringValue(bindingSource, 'project_id', 'projectId') ?? null
+    };
+    const confidence = readNumberValue(source, 'confidence', 'score') ?? null;
+    if (confidence !== null && (confidence < 0 || confidence > 1)) {
+        return { kind: 'malformed', reason: 'dispatch_source_confidence_out_of_range' };
+    }
+    if (isLiveDispatchSource(source)) {
+        return {
+            kind: 'live_linear',
+            source,
+            sourceSetup
+        };
+    }
+    if (!sourceSetup.workspace_id && !sourceSetup.team_id && !sourceSetup.project_id) {
+        return {
+            kind: 'malformed',
+            reason: 'dispatch_source_binding_missing'
+        };
+    }
+    const summary = readStringValue(source, 'summary', 'dispatch_summary', 'dispatchSummary');
+    if (!summary) {
+        return { kind: 'malformed', reason: 'dispatch_source_summary_missing' };
+    }
+    const dispatchId = readStringValue(source, 'dispatch_id', 'dispatchId') ?? 'dispatch-advisory';
+    const issueIdentifier = readStringValue(source, 'issue_identifier', 'issueIdentifier') ?? defaultIssueIdentifier;
+    const rationale = readStringValue(source, 'rationale', 'reason') ?? null;
+    const generatedAtRaw = readStringValue(source, 'generated_at', 'generatedAt');
+    let generatedAt = null;
+    if (generatedAtRaw) {
+        const generatedAtMs = Date.parse(generatedAtRaw);
+        if (!Number.isFinite(generatedAtMs)) {
+            return { kind: 'malformed', reason: 'dispatch_source_generated_at_invalid' };
+        }
+        generatedAt = new Date(generatedAtMs).toISOString();
+    }
+    return {
+        kind: 'ready',
+        recommendation: {
+            issue_identifier: issueIdentifier ?? null,
+            dispatch_id: dispatchId,
+            summary,
+            rationale,
+            confidence,
+            generated_at: generatedAt,
+            source_setup: sourceSetup,
+            tracked_issue: null
+        },
+        sourceSetup
+    };
+}
+function isLiveDispatchSource(source) {
+    if (readBooleanValue(source, 'live')) {
+        return true;
+    }
+    const mode = readStringValue(source, 'mode', 'source_mode', 'sourceMode');
+    return Boolean(mode && mode.trim().toLowerCase() === 'live');
+}
+export function normalizeDispatchSourceProvider(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'linear' || normalized === 'linear_advisory') {
+        return 'linear';
+    }
+    return null;
+}
+function readStringValue(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function readBooleanValue(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'boolean') {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readNumberValue(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === 'string' && value.trim().length > 0) {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return undefined;
+}
+function readRecordValue(record, key) {
+    const value = record[key];
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return undefined;
+}

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

@@ -0,0 +1,34 @@
+import { readUiDataset } from './operatorDashboardPresenter.js';
+import { buildCompatibilityErrorResponse } from './observabilitySurface.js';
+const UI_DATA_PATH = '/ui/data.json';
+const JSON_NO_STORE_HEADERS = { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' };
+export async function handleUiDataRequest(context) {
+    const method = context.req.method ?? 'GET';
+    const pathname = new URL(context.req.url ?? '/', 'http://localhost').pathname;
+    if (pathname !== UI_DATA_PATH) {
+        return false;
+    }
+    if (method !== 'GET') {
+        writeUiDataResponse(context.res, buildCompatibilityErrorResponse({
+            status: 405,
+            code: 'method_not_allowed',
+            message: 'Method not allowed',
+            details: {
+                surface: 'ui',
+                route: UI_DATA_PATH,
+                allowed_method: 'GET'
+            }
+        }));
+        return true;
+    }
+    writeUiDataResponse(context.res, {
+        status: 200,
+        headers: JSON_NO_STORE_HEADERS,
+        body: await readUiDataset(context.presenterContext)
+    });
+    return true;
+}
+function writeUiDataResponse(res, response) {
+    res.writeHead(response.status, response.headers);
+    res.end(JSON.stringify(response.body));
+}

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

@@ -0,0 +1,100 @@
+const UI_SESSION_PATH = '/auth/session';
+const JSON_HEADERS = { 'Content-Type': 'application/json' };
+const JSON_NO_STORE_HEADERS = { ...JSON_HEADERS, 'Cache-Control': 'no-store' };
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '::1']);
+export function handleControlUiSessionAdmission(context) {
+    return handleUiSessionRequest({
+        req: context.req,
+        res: context.res,
+        allowedHosts: normalizeAllowedHosts(context.allowedBindHosts),
+        issueSession: context.issueSession,
+        isLoopbackAddress
+    });
+}
+export function handleUiSessionRequest(context) {
+    const method = context.req.method ?? 'GET';
+    const pathname = new URL(context.req.url ?? '/', 'http://localhost').pathname;
+    if (pathname !== UI_SESSION_PATH || (method !== 'GET' && method !== 'POST')) {
+        return false;
+    }
+    if (!context.isLoopbackAddress(context.req.socket.remoteAddress)) {
+        writeJsonResponse(context.res, 403, { error: 'loopback_only' });
+        return true;
+    }
+    const hostHeader = parseHostHeader(context.req.headers.host);
+    if (!hostHeader || !context.allowedHosts.has(hostHeader)) {
+        writeJsonResponse(context.res, 403, { error: 'host_not_allowed' });
+        return true;
+    }
+    const originHost = parseOriginHost(context.req.headers.origin);
+    if (originHost) {
+        if (!context.allowedHosts.has(originHost)) {
+            writeJsonResponse(context.res, 403, { error: 'origin_not_allowed' });
+            return true;
+        }
+    }
+    else if (method !== 'GET') {
+        writeJsonResponse(context.res, 403, { error: 'origin_required' });
+        return true;
+    }
+    const session = context.issueSession();
+    writeJsonResponse(context.res, 200, {
+        token: session.token,
+        expires_at: session.expiresAt
+    }, JSON_NO_STORE_HEADERS);
+    return true;
+}
+export function isLoopbackAddress(address) {
+    if (!address) {
+        return false;
+    }
+    if (LOOPBACK_HOSTS.has(address)) {
+        return true;
+    }
+    if (address.startsWith('::ffff:')) {
+        return address.slice(7) === '127.0.0.1';
+    }
+    return false;
+}
+function writeJsonResponse(res, statusCode, body, headers = JSON_HEADERS) {
+    res.writeHead(statusCode, headers);
+    res.end(JSON.stringify(body));
+}
+function parseHostHeader(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (trimmed.startsWith('[')) {
+        const end = trimmed.indexOf(']');
+        if (end === -1) {
+            return null;
+        }
+        return trimmed.slice(1, end).toLowerCase();
+    }
+    const parts = trimmed.split(':');
+    if (parts.length > 2) {
+        return trimmed.toLowerCase();
+    }
+    const host = parts[0]?.trim();
+    return host ? host.toLowerCase() : null;
+}
+function parseOriginHost(value) {
+    if (!value) {
+        return null;
+    }
+    try {
+        const parsed = new URL(value);
+        return parsed.hostname.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeAllowedHosts(allowedHosts) {
+    const values = allowedHosts && allowedHosts.length > 0 ? allowedHosts : Array.from(LOOPBACK_HOSTS);
+    return new Set(values.map((entry) => entry.toLowerCase()));
+}