codex-workflow-v2 2.0.0-beta.13.8 → 2.0.0-beta.14

package/src/lifecycle/schema-artifact.ts

@@ -0,0 +1,263 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+import { Ajv2020 } from 'ajv/dist/2020.js';
+
+import { hashCanonical } from './fingerprint.js';
+import { deepFreeze } from './immutable.js';
+import {
+  correctiveReplanCredentialSchemaArtifacts,
+  correctiveReplanCredentialSchemaValidators,
+} from './corrective-replan-credential-schema.js';
+import type {
+  SemanticRegistry,
+  PayloadSchemaArtifactBinding,
+  PayloadSchemaValidatorBinding,
+  TransitionSchemaArtifact,
+  VersionedRegistryEntry,
+} from './types.js';
+
+const schemaUrl = new URL('../../../schemas/transition-definition.schema.json', import.meta.url);
+const schemaBytes = readFileSync(schemaUrl);
+const schemaDocument = JSON.parse(schemaBytes.toString('utf8')) as object;
+const vocabularyDocument = extractVocabulary(schemaDocument);
+const ajv = new Ajv2020({ allErrors: true, strict: true, formats: { 'date-time': true } });
+if (!ajv.validateSchema(schemaDocument)) {
+  throw new TypeError(`Transition definition schema artifact is invalid: ${ajv.errorsText(ajv.errors)}`);
+}
+const validateSchemaDocument = ajv.compile(schemaDocument);
+const payloadSchemaUrl = new URL('../../../schemas/transition-payloads.schema.json', import.meta.url);
+const payloadSchemaBytes = readFileSync(payloadSchemaUrl);
+const payloadSchemaDocument = JSON.parse(payloadSchemaBytes.toString('utf8')) as {
+  readonly $id: string;
+  readonly $defs: Readonly<Record<string, unknown>>;
+};
+
+export const transitionDefinitionDocumentSha256 = createHash('sha256').update(schemaBytes).digest('hex');
+export const transitionDefinitionVocabularySha256 = hashCanonical(vocabularyDocument);
+
+const transitionDefinitionArtifact: PayloadSchemaArtifactBinding = {
+  id: 'schema.transition-definition',
+  version: 1,
+  implementationId: 'implementation.schema-artifact.transition-definition',
+  implementationVersion: 1,
+  documentSha256: transitionDefinitionDocumentSha256,
+  schemaPointer: '#',
+  subschemaSha256: hashCanonical(schemaDocument),
+  document: schemaDocument,
+};
+
+const transitionDefinitionValidator: PayloadSchemaValidatorBinding = {
+  id: transitionDefinitionArtifact.id,
+  version: transitionDefinitionArtifact.version,
+  implementationId: 'implementation.schema-validator.ajv-draft-2020-12.transition-definition',
+  implementationVersion: 1,
+  artifactSha256: transitionDefinitionArtifact.documentSha256,
+  subschemaSha256: transitionDefinitionArtifact.subschemaSha256,
+  callable: (raw: unknown) => validateSchemaDocument(raw) === true,
+};
+
+const payloadDefinitionBySchemaId = {
+  'schema.task-id': 'taskId',
+  'schema.expected-revision': 'expectedRevision',
+  'schema.task-plan-input': 'taskPlanInput',
+  'schema.plan-risk-audit-input': 'planRiskAuditInput',
+  'schema.corrective-replan-snapshot': 'correctiveReplanSnapshot',
+  'schema.corrective-replan-bindings': 'correctiveReplanBindings',
+  'schema.task-state-readback': 'taskStateReadback',
+} as const;
+
+export const transitionPayloadDocumentSha256 = createHash('sha256').update(payloadSchemaBytes).digest('hex');
+
+const payloadArtifactRows = Object.entries(payloadDefinitionBySchemaId).map(([id, definitionName]) => ({
+  id, version: 1,
+  implementationId: `implementation.schema-artifact.transition-payloads.${definitionName}`,
+  implementationVersion: 1,
+  documentSha256: transitionPayloadDocumentSha256,
+  schemaPointer: `#/$defs/${definitionName}`,
+  subschemaSha256: hashCanonical(payloadSchemaDocument.$defs[definitionName]),
+  document: payloadSchemaDocument,
+} as PayloadSchemaArtifactBinding));
+
+ajv.addSchema(payloadSchemaDocument, payloadSchemaDocument.$id);
+
+const payloadValidatorRows = payloadArtifactRows.map((artifact) => {
+  const definitionName = payloadDefinitionBySchemaId[artifact.id as keyof typeof payloadDefinitionBySchemaId];
+  const validate = ajv.compile({ $ref: `${payloadSchemaDocument.$id}#/$defs/${definitionName}` });
+  return {
+    id: artifact.id,
+    version: artifact.version,
+    implementationId: `implementation.schema-validator.ajv-draft-2020-12.${definitionName}`,
+    implementationVersion: 1,
+    artifactSha256: artifact.documentSha256,
+    subschemaSha256: artifact.subschemaSha256,
+    callable: (raw: unknown) => validate(raw) === true,
+  } as PayloadSchemaValidatorBinding;
+});
+
+const credentialPayloadIds = new Set([
+  'schema.corrective-replan-binding',
+  'schema.corrective-replan-plan-validation-attestation',
+  'schema.corrective-replan-receipt',
+]);
+const credentialPayloadArtifacts = correctiveReplanCredentialSchemaArtifacts
+  .filter((entry) => credentialPayloadIds.has(entry.id))
+  .map((entry) => ({
+    id: entry.id, version: entry.version, implementationId: entry.implementationId,
+    implementationVersion: entry.implementationVersion, documentSha256: entry.documentBytesSha256,
+    schemaPointer: entry.schemaPointer, subschemaSha256: entry.subschemaCanonicalSha256, document: entry.document,
+  } as PayloadSchemaArtifactBinding));
+const credentialPayloadValidators = correctiveReplanCredentialSchemaValidators
+  .filter((entry) => credentialPayloadIds.has(entry.id))
+  .map((entry) => ({
+    id: entry.id, version: entry.version, implementationId: entry.implementationId,
+    implementationVersion: entry.implementationVersion, artifactSha256: entry.artifactDocumentBytesSha256,
+    subschemaSha256: entry.subschemaCanonicalSha256, callable: entry.callable,
+  } as PayloadSchemaValidatorBinding));
+
+const taskTransactionUrl = new URL('../../../schemas/corrective-replan-task-transaction.private.schema.json', import.meta.url);
+const taskTransactionBytes = readFileSync(taskTransactionUrl);
+const taskTransactionDocument = JSON.parse(taskTransactionBytes.toString('utf8')) as object;
+const taskTransactionSha256 = createHash('sha256').update(taskTransactionBytes).digest('hex');
+const validateTaskTransaction = ajv.compile(taskTransactionDocument);
+const taskTransactionArtifact: PayloadSchemaArtifactBinding = {
+  id: 'schema.corrective-replan-task-transaction', version: 1,
+  implementationId: 'implementation.schema-artifact.corrective-replan-task-transaction', implementationVersion: 1,
+  documentSha256: taskTransactionSha256, schemaPointer: '#', subschemaSha256: hashCanonical(taskTransactionDocument),
+  document: taskTransactionDocument,
+};
+const taskTransactionValidator: PayloadSchemaValidatorBinding = {
+  id: taskTransactionArtifact.id, version: 1,
+  implementationId: 'implementation.schema-validator.ajv-draft-2020-12.corrective-replan-task-transaction', implementationVersion: 1,
+  artifactSha256: taskTransactionArtifact.documentSha256, subschemaSha256: taskTransactionArtifact.subschemaSha256,
+  callable: (raw: unknown) => validateTaskTransaction(raw) === true,
+};
+
+export const installedTransitionDefinitionArtifact = deepFreeze(transitionDefinitionArtifact);
+export const installedTransitionDefinitionValidator = deepFreeze(transitionDefinitionValidator);
+export const installedPayloadSchemaArtifacts: readonly PayloadSchemaArtifactBinding[] = deepFreeze([
+  ...payloadArtifactRows, ...credentialPayloadArtifacts, taskTransactionArtifact,
+]);
+export const installedPayloadSchemaValidators: readonly PayloadSchemaValidatorBinding[] = deepFreeze([
+  ...payloadValidatorRows, ...credentialPayloadValidators, taskTransactionValidator,
+]);
+
+export function createTransitionSchemaArtifact(registry: SemanticRegistry): TransitionSchemaArtifact {
+  if (registryVocabularySha256(registry) !== hashCanonical(vocabularyDocument)) {
+    throw new TypeError('Transition definition vocabulary artifact is stale for the installed semantic registry.');
+  }
+  validateSchemaReferenceVocabulary(schemaDocument, vocabularyDocument);
+  return {
+    documentSha256: transitionDefinitionDocumentSha256,
+    vocabularySha256: transitionDefinitionVocabularySha256,
+  };
+}
+
+export function registryVocabularySha256(registry: SemanticRegistry): string {
+  return hashCanonical(registryVocabulary(registry));
+}
+
+export function registryVocabulary(registry: SemanticRegistry): Readonly<Record<string, readonly string[]>> {
+  const entries = Object.fromEntries(
+    Object.entries(registry)
+      .filter((entry): entry is [string, readonly VersionedRegistryEntry<string>[]] =>
+        Array.isArray(entry[1])
+        && entry[1].every((candidate) => candidate !== null
+          && typeof candidate === 'object'
+          && typeof (candidate as { id?: unknown }).id === 'string'
+          && Number.isInteger((candidate as { version?: unknown }).version)))
+      .map(([category, entries]) => [
+        category,
+        entries.map((entry) => `${entry.id}@${entry.version}`).sort((left, right) => left.localeCompare(right)),
+      ] as const)
+      .sort(([left], [right]) => left.localeCompare(right)),
+  ) as Record<string, readonly string[]>;
+  return {
+    ...entries,
+    projectionFields: registry.projections
+      .flatMap((projection) => projection.fieldIds.map((fieldId) => `${projection.id}@${projection.version}:${fieldId}`))
+      .sort((left, right) => left.localeCompare(right)),
+  };
+}
+
+export function installedTransitionDefinitionVocabulary(): Readonly<Record<string, readonly string[]>> {
+  return vocabularyDocument;
+}
+
+function extractVocabulary(document: object): Readonly<Record<string, readonly string[]>> {
+  const candidate = document as {
+    $defs?: {
+      semanticRegistryVocabulary?: {
+        const?: unknown;
+      };
+    };
+  };
+  const vocabulary = candidate.$defs?.semanticRegistryVocabulary?.const;
+  if (vocabulary === null || typeof vocabulary !== 'object' || Array.isArray(vocabulary)) {
+    throw new TypeError('Transition definition schema has no embedded semantic registry vocabulary.');
+  }
+  for (const [category, entries] of Object.entries(vocabulary)) {
+    if (!Array.isArray(entries) || !entries.every((entry) => typeof entry === 'string')) {
+      throw new TypeError(`Transition definition schema vocabulary category ${category} is invalid.`);
+    }
+  }
+  return vocabulary as Readonly<Record<string, readonly string[]>>;
+}
+
+function validateSchemaReferenceVocabulary(
+  document: object,
+  vocabulary: Readonly<Record<string, readonly string[]>>,
+): void {
+  const definitionByCategory: Readonly<Record<string, string>> = {
+    inputs: 'inputRef',
+    projections: 'projectionRef',
+    hashPolicies: 'hashPolicyRef',
+    identities: 'identityRef',
+    identityComparators: 'identityComparatorRef',
+    principalBases: 'principalBasisRef',
+    capabilities: 'capabilityRef',
+    credentialPolicies: 'credentialPolicyRef',
+    credentialVerifiers: 'credentialVerifierRef',
+    delegationPolicies: 'delegationPolicyRef',
+    ownershipPolicies: 'ownershipPolicyRef',
+    guardEvaluators: 'guardEvaluatorRef',
+    effectAdapters: 'effectAdapterRef',
+    resources: 'resourceRef',
+    lockPolicies: 'lockPolicyRef',
+    executionKeyPolicies: 'executionKeyPolicyRef',
+    journalSchemas: 'journalSchemaRef',
+    journalAdapters: 'journalAdapterRef',
+    recoveryAdapters: 'recoveryAdapterRef',
+    readbackAdapters: 'readbackAdapterRef',
+    releaseProfiles: 'releaseProfileRef',
+    coverageProfiles: 'coverageProfileRef',
+    limitations: 'limitationRef',
+  };
+  for (const [category, definitionName] of Object.entries(definitionByCategory)) {
+    const registered = (vocabulary[category] ?? []).map((entry) => entry.slice(0, entry.lastIndexOf('@'))).sort();
+    const schemaIds = referenceIds(document, definitionName);
+    if (hashCanonical(registered) !== hashCanonical(schemaIds)) {
+      throw new TypeError(`Transition definition schema reference ${definitionName} is stale for ${category}.`);
+    }
+  }
+  const projectionFields = new Set((vocabulary.projectionFields ?? []).map((entry) => entry.slice(entry.indexOf(':') + 1)));
+  if (hashCanonical([...projectionFields].sort()) !== hashCanonical(referenceIds(document, 'fieldId'))) {
+    throw new TypeError('Transition definition schema field vocabulary is stale for registered projections.');
+  }
+}
+
+function referenceIds(document: object, definitionName: string): string[] {
+  const definition = (document as { $defs?: Record<string, unknown> }).$defs?.[definitionName] as {
+    enum?: unknown;
+    const?: unknown;
+    properties?: { id?: { enum?: unknown; const?: unknown }; version?: { const?: unknown } };
+  } | undefined;
+  const idSchema = definitionName === 'fieldId' ? definition : definition?.properties?.id;
+  const ids = Array.isArray(idSchema?.enum)
+    ? idSchema.enum.filter((entry): entry is string => typeof entry === 'string')
+    : typeof idSchema?.const === 'string' ? [idSchema.const] : [];
+  if (definitionName !== 'fieldId' && definition?.properties?.version?.const !== 1) {
+    throw new TypeError(`Transition definition schema reference ${definitionName} has no exact version binding.`);
+  }
+  return ids.sort((left, right) => left.localeCompare(right));
+}