@kbediako/codex-orchestrator 0.1.0

package/dist/packages/control-plane-schemas/src/run-request.js

@@ -0,0 +1,548 @@
+export const CONTROL_PLANE_RUN_REQUEST_SCHEMA = 'codex.control-plane.run-request';
+export const CONTROL_PLANE_RUN_REQUEST_VERSION = '2.0.0';
+const PRIVACY_LEVELS = new Set([
+    'standard',
+    'restricted',
+    'sensitive'
+]);
+const STAGE_KINDS = new Set(['command', 'subpipeline']);
+const SCHEDULE_STRATEGIES = new Set(['auto', 'manual']);
+export function validateRunRequestV2(payload) {
+    const errors = [];
+    if (!isPlainObject(payload)) {
+        errors.push({
+            path: '$',
+            message: 'Run request must be an object.',
+            value: payload
+        });
+        return { valid: false, errors };
+    }
+    const schema = requireString(payload, 'schema', '$.schema', errors, { minLength: 1 });
+    if (schema && schema !== CONTROL_PLANE_RUN_REQUEST_SCHEMA) {
+        errors.push({
+            path: '$.schema',
+            message: `Expected schema to equal ${CONTROL_PLANE_RUN_REQUEST_SCHEMA}.`,
+            value: schema,
+            expected: CONTROL_PLANE_RUN_REQUEST_SCHEMA
+        });
+    }
+    const version = requireString(payload, 'version', '$.version', errors, { minLength: 1 });
+    if (version && version !== CONTROL_PLANE_RUN_REQUEST_VERSION) {
+        errors.push({
+            path: '$.version',
+            message: `Expected version to equal ${CONTROL_PLANE_RUN_REQUEST_VERSION}.`,
+            value: version,
+            expected: CONTROL_PLANE_RUN_REQUEST_VERSION
+        });
+    }
+    const requestId = requireString(payload, 'requestId', '$.requestId', errors, { minLength: 1 });
+    const task = validateTask(payload, errors);
+    const pipeline = validatePipeline(payload, errors);
+    const schedule = validateSchedule(payload, errors);
+    const streaming = validateStreaming(payload, errors);
+    const constraints = validateConstraints(payload, errors);
+    const metrics = validateMetrics(payload, errors);
+    const requestedAt = requireString(payload, 'requestedAt', '$.requestedAt', errors, {
+        minLength: 1
+    });
+    if (requestedAt && Number.isNaN(Date.parse(requestedAt))) {
+        errors.push({
+            path: '$.requestedAt',
+            message: 'requestedAt must be an ISO 8601 timestamp.',
+            value: requestedAt
+        });
+    }
+    const requestedBy = validateRequestedBy(payload, errors);
+    const metadata = optionalRecord(payload, 'metadata', '$.metadata', errors);
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    return {
+        valid: true,
+        value: {
+            schema: CONTROL_PLANE_RUN_REQUEST_SCHEMA,
+            version: CONTROL_PLANE_RUN_REQUEST_VERSION,
+            requestId: requestId,
+            task: task,
+            pipeline: pipeline,
+            schedule: schedule,
+            streaming: streaming,
+            constraints: constraints,
+            metrics: metrics,
+            requestedAt: requestedAt,
+            requestedBy: requestedBy,
+            metadata: metadata ?? undefined
+        },
+        errors: []
+    };
+}
+function validateTask(payload, errors) {
+    const path = '$.task';
+    const value = requireRecord(payload, 'task', path, errors);
+    if (!value) {
+        return undefined;
+    }
+    const id = requireString(value, 'id', `${path}.id`, errors, { minLength: 1 });
+    const title = requireString(value, 'title', `${path}.title`, errors, { minLength: 1 });
+    const slug = optionalString(value, 'slug', `${path}.slug`, errors);
+    const description = optionalString(value, 'description', `${path}.description`, errors);
+    const metadata = optionalRecord(value, 'metadata', `${path}.metadata`, errors);
+    const tags = optionalStringArray(value, 'tags', `${path}.tags`, errors, { minLength: 1 });
+    if (!id || !title) {
+        return undefined;
+    }
+    return {
+        id,
+        title,
+        slug: slug ?? undefined,
+        description: description ?? undefined,
+        metadata: metadata ?? undefined,
+        tags: tags ?? undefined
+    };
+}
+function validatePipeline(payload, errors) {
+    const path = '$.pipeline';
+    const value = requireRecord(payload, 'pipeline', path, errors);
+    if (!value) {
+        return undefined;
+    }
+    const id = requireString(value, 'id', `${path}.id`, errors, { minLength: 1 });
+    const version = requireString(value, 'version', `${path}.version`, errors, { minLength: 1 });
+    const title = requireString(value, 'title', `${path}.title`, errors, { minLength: 1 });
+    const capabilities = requireStringArray(value, 'capabilities', `${path}.capabilities`, errors, {
+        minLength: 1,
+        allowEmpty: false
+    });
+    const stagesValue = requireArray(value, 'stages', `${path}.stages`, errors, {
+        minLength: 1
+    });
+    const stages = [];
+    if (stagesValue) {
+        stagesValue.forEach((stagePayload, index) => {
+            const stagePath = `${path}.stages[${index}]`;
+            if (!isPlainObject(stagePayload)) {
+                errors.push({
+                    path: stagePath,
+                    message: 'Stage entry must be an object.',
+                    value: stagePayload
+                });
+                return;
+            }
+            const stageId = requireString(stagePayload, 'id', `${stagePath}.id`, errors, { minLength: 1 });
+            const kind = requireString(stagePayload, 'kind', `${stagePath}.kind`, errors, {
+                minLength: 1
+            });
+            if (kind && !STAGE_KINDS.has(kind)) {
+                errors.push({
+                    path: `${stagePath}.kind`,
+                    message: "Stage kind must be 'command' or 'subpipeline'.",
+                    value: kind
+                });
+            }
+            const titleValue = requireString(stagePayload, 'title', `${stagePath}.title`, errors, {
+                minLength: 1
+            });
+            const optional = optionalBoolean(stagePayload, 'optional', `${stagePath}.optional`, errors);
+            const stageCapabilities = optionalStringArray(stagePayload, 'capabilities', `${stagePath}.capabilities`, errors, { minLength: 1 });
+            if (stageId && titleValue && kind && STAGE_KINDS.has(kind)) {
+                stages.push({
+                    id: stageId,
+                    title: titleValue,
+                    kind: kind,
+                    optional: optional ?? undefined,
+                    capabilities: stageCapabilities ?? undefined
+                });
+            }
+        });
+    }
+    if (!id || !version || !title || !capabilities || stages.length === 0) {
+        return undefined;
+    }
+    return {
+        id,
+        version,
+        title,
+        capabilities,
+        stages
+    };
+}
+function validateSchedule(payload, errors) {
+    const path = '$.schedule';
+    const value = requireRecord(payload, 'schedule', path, errors);
+    if (!value) {
+        return undefined;
+    }
+    const strategyValue = requireString(value, 'strategy', `${path}.strategy`, errors, {
+        minLength: 1
+    });
+    if (strategyValue && !SCHEDULE_STRATEGIES.has(strategyValue)) {
+        errors.push({
+            path: `${path}.strategy`,
+            message: "strategy must be 'auto' or 'manual'.",
+            value: strategyValue
+        });
+    }
+    const minInstances = requireInteger(value, 'minInstances', `${path}.minInstances`, errors, {
+        min: 1
+    });
+    const maxInstances = requireInteger(value, 'maxInstances', `${path}.maxInstances`, errors, {
+        min: 1
+    });
+    if (typeof minInstances === 'number' &&
+        typeof maxInstances === 'number' &&
+        maxInstances < minInstances) {
+        errors.push({
+            path: path,
+            message: 'maxInstances must be greater than or equal to minInstances.',
+            value: { minInstances, maxInstances }
+        });
+    }
+    const fanOutPayload = requireArray(value, 'fanOut', `${path}.fanOut`, errors, { minLength: 1 });
+    const fanOut = [];
+    if (fanOutPayload) {
+        fanOutPayload.forEach((entry, index) => {
+            const entryPath = `${path}.fanOut[${index}]`;
+            if (!isPlainObject(entry)) {
+                errors.push({
+                    path: entryPath,
+                    message: 'fanOut entries must be objects.',
+                    value: entry
+                });
+                return;
+            }
+            const capability = requireString(entry, 'capability', `${entryPath}.capability`, errors, {
+                minLength: 1
+            });
+            const weight = requireNumber(entry, 'weight', `${entryPath}.weight`, errors, {
+                min: 0,
+                exclusiveMin: true
+            });
+            const maxConcurrency = optionalInteger(entry, 'maxConcurrency', `${entryPath}.maxConcurrency`, errors, { min: 1 });
+            if (capability && typeof weight === 'number') {
+                fanOut.push({
+                    capability,
+                    weight,
+                    maxConcurrency: maxConcurrency ?? undefined
+                });
+            }
+        });
+    }
+    const recoveryPayload = requireRecord(value, 'recovery', `${path}.recovery`, errors);
+    let recovery;
+    if (recoveryPayload) {
+        const heartbeatIntervalSeconds = requireInteger(recoveryPayload, 'heartbeatIntervalSeconds', `${path}.recovery.heartbeatIntervalSeconds`, errors, { min: 1 });
+        const missingHeartbeatTimeoutSeconds = requireInteger(recoveryPayload, 'missingHeartbeatTimeoutSeconds', `${path}.recovery.missingHeartbeatTimeoutSeconds`, errors, { min: 1 });
+        const maxRetries = requireInteger(recoveryPayload, 'maxRetries', `${path}.recovery.maxRetries`, errors, { min: 0 });
+        if (typeof heartbeatIntervalSeconds === 'number' &&
+            typeof missingHeartbeatTimeoutSeconds === 'number' &&
+            typeof maxRetries === 'number') {
+            recovery = {
+                heartbeatIntervalSeconds,
+                missingHeartbeatTimeoutSeconds,
+                maxRetries
+            };
+        }
+    }
+    if (!strategyValue ||
+        typeof minInstances !== 'number' ||
+        typeof maxInstances !== 'number' ||
+        fanOut.length === 0 ||
+        !recovery) {
+        return undefined;
+    }
+    return {
+        strategy: strategyValue,
+        minInstances,
+        maxInstances,
+        fanOut,
+        recovery
+    };
+}
+function validateStreaming(payload, errors) {
+    const path = '$.streaming';
+    const value = requireRecord(payload, 'streaming', path, errors);
+    if (!value) {
+        return undefined;
+    }
+    const handles = requireBoolean(value, 'handles', `${path}.handles`, errors);
+    const resumeSupported = requireBoolean(value, 'resumeSupported', `${path}.resumeSupported`, errors);
+    const observersPayload = requireRecord(value, 'observers', `${path}.observers`, errors);
+    let observers;
+    if (observersPayload) {
+        const maxSubscribers = requireInteger(observersPayload, 'maxSubscribers', `${path}.observers.maxSubscribers`, errors, { min: 1 });
+        const defaultBackpressureMs = requireInteger(observersPayload, 'defaultBackpressureMs', `${path}.observers.defaultBackpressureMs`, errors, { min: 0 });
+        if (typeof maxSubscribers === 'number' && typeof defaultBackpressureMs === 'number') {
+            observers = { maxSubscribers, defaultBackpressureMs };
+        }
+    }
+    if (typeof handles !== 'boolean' || typeof resumeSupported !== 'boolean' || !observers) {
+        return undefined;
+    }
+    return {
+        handles,
+        resumeSupported,
+        observers
+    };
+}
+function validateConstraints(payload, errors) {
+    const path = '$.constraints';
+    const value = requireRecord(payload, 'constraints', path, errors);
+    if (!value) {
+        return undefined;
+    }
+    const privacyLevel = requireString(value, 'privacyLevel', `${path}.privacyLevel`, errors, {
+        minLength: 1
+    });
+    if (privacyLevel && !PRIVACY_LEVELS.has(privacyLevel)) {
+        errors.push({
+            path: `${path}.privacyLevel`,
+            message: "privacyLevel must be 'standard', 'restricted', or 'sensitive'.",
+            value: privacyLevel
+        });
+    }
+    const dataResidency = optionalString(value, 'dataResidency', `${path}.dataResidency`, errors);
+    const policyVersion = requireString(value, 'policyVersion', `${path}.policyVersion`, errors, {
+        minLength: 1
+    });
+    if (!privacyLevel || !policyVersion) {
+        return undefined;
+    }
+    return {
+        privacyLevel: privacyLevel,
+        dataResidency: dataResidency ?? undefined,
+        policyVersion
+    };
+}
+function validateMetrics(payload, errors) {
+    const path = '$.metrics';
+    const value = requireRecord(payload, 'metrics', path, errors);
+    if (!value) {
+        return undefined;
+    }
+    const emitIntervalSeconds = requireInteger(value, 'emitIntervalSeconds', `${path}.emitIntervalSeconds`, errors, { min: 1 });
+    const requiredDimensions = requireStringArray(value, 'requiredDimensions', `${path}.requiredDimensions`, errors, { minLength: 1, allowEmpty: false });
+    if (typeof emitIntervalSeconds !== 'number' || !requiredDimensions) {
+        return undefined;
+    }
+    return {
+        emitIntervalSeconds,
+        requiredDimensions
+    };
+}
+function validateRequestedBy(payload, errors) {
+    const path = '$.requestedBy';
+    const value = requireRecord(payload, 'requestedBy', path, errors);
+    if (!value) {
+        return undefined;
+    }
+    const actorId = requireString(value, 'actorId', `${path}.actorId`, errors, { minLength: 1 });
+    const channel = requireString(value, 'channel', `${path}.channel`, errors, { minLength: 1 });
+    const name = optionalString(value, 'name', `${path}.name`, errors);
+    if (!actorId || !channel) {
+        return undefined;
+    }
+    return {
+        actorId,
+        channel,
+        name: name ?? undefined
+    };
+}
+function requireString(record, key, path, errors, options = {}) {
+    const value = record[key];
+    if (typeof value !== 'string') {
+        errors.push({ path, message: 'Expected a string.', value });
+        return undefined;
+    }
+    if (typeof options.minLength === 'number' && value.length < options.minLength) {
+        errors.push({
+            path,
+            message: `String must be at least ${options.minLength} characters.`,
+            value
+        });
+        return undefined;
+    }
+    return value;
+}
+function optionalString(record, key, path, errors) {
+    if (!(key in record)) {
+        return null;
+    }
+    const value = record[key];
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    errors.push({ path, message: 'Expected a string.', value });
+    return null;
+}
+function requireNumber(record, key, path, errors, options = {}) {
+    const value = record[key];
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        errors.push({ path, message: 'Expected a number.', value });
+        return undefined;
+    }
+    if (typeof options.min === 'number') {
+        const compare = options.exclusiveMin ? value <= options.min : value < options.min;
+        if (compare) {
+            errors.push({
+                path,
+                message: options.exclusiveMin
+                    ? `Number must be greater than ${options.min}.`
+                    : `Number must be greater than or equal to ${options.min}.`,
+                value
+            });
+            return undefined;
+        }
+    }
+    return value;
+}
+function requireInteger(record, key, path, errors, options = {}) {
+    const value = requireNumber(record, key, path, errors, {
+        min: options.min,
+        exclusiveMin: false
+    });
+    if (typeof value === 'number' && !Number.isInteger(value)) {
+        errors.push({ path, message: 'Number must be an integer.', value });
+        return undefined;
+    }
+    return value;
+}
+function optionalInteger(record, key, path, errors, options = {}) {
+    if (!(key in record)) {
+        return null;
+    }
+    const value = record[key];
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        errors.push({ path, message: 'Expected a number.', value });
+        return null;
+    }
+    if (!Number.isInteger(value)) {
+        errors.push({ path, message: 'Number must be an integer.', value });
+        return null;
+    }
+    if (typeof options.min === 'number' && value < options.min) {
+        errors.push({
+            path,
+            message: `Number must be greater than or equal to ${options.min}.`,
+            value
+        });
+        return null;
+    }
+    return value;
+}
+function requireBoolean(record, key, path, errors) {
+    const value = record[key];
+    if (typeof value !== 'boolean') {
+        errors.push({ path, message: 'Expected a boolean.', value });
+        return undefined;
+    }
+    return value;
+}
+function optionalBoolean(record, key, path, errors) {
+    if (!(key in record)) {
+        return null;
+    }
+    const value = record[key];
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== 'boolean') {
+        errors.push({ path, message: 'Expected a boolean.', value });
+        return null;
+    }
+    return value;
+}
+function requireRecord(record, key, path, errors) {
+    const value = record[key];
+    if (!isPlainObject(value)) {
+        errors.push({ path, message: 'Expected an object.', value });
+        return undefined;
+    }
+    return value;
+}
+function optionalRecord(record, key, path, errors) {
+    if (!(key in record)) {
+        return null;
+    }
+    const value = record[key];
+    if (value === null) {
+        return null;
+    }
+    if (!isPlainObject(value)) {
+        errors.push({ path, message: 'Expected an object.', value });
+        return null;
+    }
+    return value;
+}
+function requireArray(record, key, path, errors, options = {}) {
+    const value = record[key];
+    if (!Array.isArray(value)) {
+        errors.push({ path, message: 'Expected an array.', value });
+        return undefined;
+    }
+    if (typeof options.minLength === 'number' && value.length < options.minLength) {
+        errors.push({
+            path,
+            message: `Array must contain at least ${options.minLength} item(s).`,
+            value
+        });
+        return undefined;
+    }
+    return value;
+}
+function optionalStringArray(record, key, path, errors, options = {}) {
+    if (!(key in record)) {
+        return null;
+    }
+    const value = record[key];
+    if (value === null) {
+        return null;
+    }
+    if (!Array.isArray(value)) {
+        errors.push({ path, message: 'Expected an array.', value });
+        return null;
+    }
+    const strings = [];
+    value.forEach((entry, index) => {
+        if (typeof entry !== 'string') {
+            errors.push({
+                path: `${path}[${index}]`,
+                message: 'Expected a string.',
+                value: entry
+            });
+            return;
+        }
+        if (typeof options.minLength === 'number' && entry.length < options.minLength) {
+            errors.push({
+                path: `${path}[${index}]`,
+                message: `String must be at least ${options.minLength} characters.`,
+                value: entry
+            });
+            return;
+        }
+        strings.push(entry);
+    });
+    return strings;
+}
+function requireStringArray(record, key, path, errors, options = {}) {
+    const value = optionalStringArray(record, key, path, errors, options);
+    if (!value) {
+        if (!(key in record)) {
+            errors.push({ path, message: 'Expected an array.', value: record[key] });
+        }
+        return undefined;
+    }
+    if (options.allowEmpty === false && value.length === 0) {
+        errors.push({ path, message: 'Array must not be empty.', value });
+        return undefined;
+    }
+    return value;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}