@entrorove/skill 0.1.51 → 0.1.53

package/workflow-observation-wire.mjs

@@ -0,0 +1,69 @@
+import { createPublicKey, verify } from 'node:crypto';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationId14, mutationPaths14 } from './local-mutation-files.mjs';
+
+export const observationFail = message => { throw Object.assign(new Error(message), { code: 'ENTROROVE_LOCAL_OBSERVATION' }); };
+export const observationIdentityFields = ['taskId', 'flowId', 'stepId', 'leaseId', 'generation', 'settlementId'];
+export function observationExact(value, fields) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || canonical(Object.keys(value).sort()) !== canonical([...fields].sort())) observationFail('Local observation fields are invalid');
+}
+export function observationInput(input) {
+  observationExact(input, observationIdentityFields);
+  for (const field of observationIdentityFields.filter(field => field !== 'generation')) mutationId14(input[field], field);
+  if (!Number.isSafeInteger(input.generation) || input.generation < 1) observationFail('Local observation generation is invalid');
+  return input;
+}
+function command(value) {
+  observationExact(value, ['executable', 'executableSha256', 'args', 'environment', 'timeoutMs', 'maxOutputBytes', 'requiredExitCode']);
+  if (typeof value.executable !== 'string' || !value.executable.startsWith('/') || /[\u0000-\u001f\u007f]/.test(value.executable)
+    || !/^[a-f0-9]{64}$/.test(value.executableSha256) || !Array.isArray(value.args) || value.args.length > 128
+    || value.args.some(arg => typeof arg !== 'string' || arg.length > 4096 || arg.includes('\0'))
+    || !value.environment || typeof value.environment !== 'object' || Array.isArray(value.environment)
+    || Object.keys(value.environment).length > 64 || Object.entries(value.environment).some(([key, val]) =>
+      !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || typeof val !== 'string' || val.length > 16_384 || val.includes('\0'))
+    || !Number.isSafeInteger(value.timeoutMs) || value.timeoutMs < 1 || value.timeoutMs > 300_000
+    || !Number.isSafeInteger(value.maxOutputBytes) || value.maxOutputBytes < 1 || value.maxOutputBytes > 1_048_576
+    || value.requiredExitCode !== 0) observationFail('Local observation command differs from its bounded frozen policy');
+}
+function files(values, modes) {
+  if (!Array.isArray(values) || !values.length || values.length > (modes ? 512 : 2_000)) observationFail('Local observation manifest is invalid');
+  const paths = mutationPaths14(values.map(file => file.path));
+  if (canonical(paths) !== canonical(values.map(file => file.path))) observationFail('Local observation manifest must be sorted and unique');
+  for (const file of values) {
+    observationExact(file, ['path', 'sha256', ...(modes ? ['mode'] : [])]);
+    if (!/^[a-f0-9]{64}$/.test(file.sha256) || modes && file.mode !== null
+      && (!Number.isSafeInteger(file.mode) || file.mode < 0 || file.mode > 511)) observationFail('Local observation file baseline is invalid');
+  }
+}
+function signature(value) {
+  try {
+    const encoded = process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY, der = Buffer.from(encoded ?? '', 'base64');
+    const key = createPublicKey({ key: der, type: 'spki', format: 'der' }), receipt = value.authorityReceipt;
+    observationExact(receipt, ['schemaVersion', 'keyId', 'payloadDigest', 'signature']);
+    const { authorityReceipt: _, ...core } = value, bytes = Buffer.from(canonical(core));
+    const signed = Buffer.from(receipt.signature, 'base64url');
+    if (key.asymmetricKeyType !== 'ed25519' || key.export({ type: 'spki', format: 'der' }).toString('base64') !== encoded
+      || receipt.schemaVersion !== 'entrorove.workflow-authority-receipt/1.0' || receipt.keyId !== sha256(der)
+      || receipt.payloadDigest !== sha256(bytes) || bytes.length > 1_048_576
+      || signed.length !== 64 || signed.toString('base64url') !== receipt.signature || !verify(null, bytes, key, signed)) throw new Error();
+  } catch { observationFail('Local observation requires its original pinned public cloud admission signature'); }
+}
+export function observationAdmission(value, input, { allowExpired = false } = {}) {
+  observationExact(value, [...observationIdentityFields, 'schemaVersion', 'purpose', 'observationId', 'ownerId', 'taskDigest',
+    'chainDigest', 'epoch', 'planId', 'planDigest', 'executionPlanSha256', 'repositoryDigest', 'settlementDigest', 'command',
+    'sourceManifest', 'protectedFiles', 'issuedAt', 'expiresAt', 'authorityReceipt']);
+  signature(value);
+  const start = Date.parse(value.issuedAt), end = Date.parse(value.expiresAt);
+  if (value.schemaVersion !== 'entrorove.local-observation-admission/1.0' || value.purpose !== 'observe-approved-command'
+    || value.epoch !== 0 || observationIdentityFields.some(field => value[field] !== input[field])
+    || value.repositoryDigest !== sha256(input.repositoryRoot).slice(0, 32) || !Number.isFinite(start) || !Number.isFinite(end)
+    || start > Date.now() || end <= start || end - start > 600_000 || !allowExpired && end <= Date.now()
+    || !/^[a-f0-9-]{36}$/.test(value.ownerId)
+    || ['taskDigest', 'chainDigest', 'planDigest', 'executionPlanSha256', 'settlementDigest'].some(field => !/^[a-f0-9]{64}$/.test(value[field]))) {
+    observationFail('Local observation admission is expired or lost its original task, repository or settlement');
+  }
+  mutationId14(value.observationId, 'observationId'); mutationId14(value.planId, 'planId');
+  command(value.command); files(value.sourceManifest, true); files(value.protectedFiles, false);
+  return value;
+}