@casecore/release-agent 0.1.4 → 0.1.7

package/dist/publication-terminal.mjs

@@ -0,0 +1,251 @@
+import assert from 'node:assert/strict';
+import { ProducerState } from './producer-state.mjs';
+import { assertProducerOperation } from './exclusive-operation.mjs';
+import { canonical, hash } from './protocol-internals.mjs';
+import { acceptedProduction, sameIdentity, validateExpectedSource } from './protocol.mjs';
+import { verifyPublicationDelivery } from './producer-delivery.mjs';
+import { validatePublicationFailureReadback } from './producer-publication-failure.mjs';
+import { validateOriginalDelivery } from './producer-support.mjs';
+import {
+  createPublicationTerminalReceipt,
+  verifyPublicationTerminalReceipt,
+} from './publication-terminal-receipt.mjs';
+export { verifyPublicationTerminalReceipt } from './publication-terminal-receipt.mjs';
+
+const authorities = new WeakMap();
+
+/** The capability is valid only inside the engine's terminal callback. */
+export function readPublicationTerminalAuthority(authority, bindings) {
+  const record = authorities.get(authority);
+  assert.ok(record && Date.now() <= record.expiresAt, 'PUBLICATION_TERMINAL_AUTHORITY_REQUIRED');
+  assert.equal(
+    canonical(bindings),
+    canonical(record.proof.bindings),
+    'PUBLICATION_TERMINAL_BINDINGS_CHANGED'
+  );
+  return structuredClone(record.proof);
+}
+
+/** DEP-TERMINAL-V1: mint only inside the genuine current engine callback. */
+export async function sealPublicationTerminalReceipt(authority, bindings, token) {
+  const proof = readPublicationTerminalAuthority(authority, bindings);
+  const record = authorities.get(authority);
+  assertProducerOperation(record.producer);
+  assert.equal(
+    canonical(record.producer.journal.read().commands[bindings.commandId]),
+    canonical(record.item),
+    'PUBLICATION_TERMINAL_NOT_DURABLE'
+  );
+  assert.equal(
+    canonical(record.producer.journal.read().runs.find((run) => run.id === bindings.runId)),
+    record.durableRun,
+    'PUBLICATION_TERMINAL_NOT_DURABLE'
+  );
+  const receipt = createPublicationTerminalReceipt(proof, token);
+  const prior = record.item.deliveryTerminalReceipt;
+  if (prior) {
+    const existing = verifyPublicationTerminalReceipt(prior, token).proof;
+    for (const key of ['bindings', 'status', 'completedAt', 'artifactIdentity', 'failure'])
+      assert.equal(
+        canonical({ value: existing[key] }),
+        canonical({ value: proof[key] }),
+        'PUBLICATION_TERMINAL_RESULT_CHANGED'
+      );
+  }
+  record.item.deliveryTerminalReceipt = structuredClone(receipt);
+  await record.producer.save();
+  readPublicationTerminalAuthority(authority, bindings);
+  return structuredClone(receipt);
+}
+
+const fresh = (readback, now) =>
+  [readback.observedAt, readback.functionalSmoke.checkedAt].every((value) => {
+    const age = now.getTime() - Date.parse(value);
+    return age >= 0 && age <= 300000;
+  });
+
+// Internal issuance is deliberately absent from the package public exports.
+export async function notifyPublicationTerminal(producer, item, run) {
+  if (
+    !['publish', 'deploy'].includes(item.command.action) ||
+    (item.command.action === 'deploy' && !item.deliveryExecution) ||
+    typeof producer.provider.publicationTerminal !== 'function'
+  )
+    return;
+  if (!['deployed', 'failed'].includes(run.status) || run.recoveryState !== 'verified') return;
+  assert.ok(ProducerState.isEngineInstance(producer), 'PUBLICATION_ENGINE_INSTANCE_REQUIRED');
+  assertProducerOperation(producer);
+  let authority;
+  let controller;
+  let timer;
+  try {
+    controller = new AbortController();
+    const expiresAt = Date.now() + 30000;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        reject(Error('PUBLICATION_TERMINAL_CALLBACK_TIMEOUT'));
+      }, 30000);
+    });
+    const bounded = (operation) => Promise.race([operation, timeout]);
+    assert.ok(
+      Date.parse(run.completedAt) >= Date.parse(item.command.requestedAt) &&
+        Date.parse(run.completedAt) <= producer.now().getTime(),
+      'PUBLICATION_TERMINAL_COMPLETION_REQUIRED'
+    );
+    if (run.status === 'deployed')
+      assert.ok(
+        Date.parse(run.completedAt) <= Date.parse(item.deliveryExecution.deadlineAt),
+        'PUBLICATION_TERMINAL_COMPLETION_LATE'
+      );
+    const verification = {
+      signal: controller.signal,
+      completedAt: run.completedAt,
+      status: run.status,
+      artifactIdentity: item.artifactIdentity ?? item.command.expectedIdentity,
+    };
+    let source;
+    const artifactIdentity =
+      item.command.action === 'publish' ? item.artifactIdentity : item.command.expectedIdentity;
+    if (item.command.action === 'publish') {
+      source = item.command.expectedSource;
+      await bounded(
+        verifyPublicationDelivery(producer, item.command, item.deliveryExecution, {
+          fresh: false,
+          verification,
+        })
+      );
+    } else {
+      validateOriginalDelivery(item.deliveryExecution);
+      assert.equal(
+        Date.parse(item.command.requestedAt),
+        Date.parse(item.deliveryExecution.requestedAt)
+      );
+      assert.equal(
+        Date.parse(item.command.deadlineAt),
+        Date.parse(item.deliveryExecution.deadlineAt)
+      );
+      assert.equal(item.ack.state, 'accepted');
+      assert.equal(item.fingerprint, hash(canonical(item.command)));
+      assert.ok(
+        item.artifactCandidate && sameIdentity(item.artifactCandidate.identity, artifactIdentity),
+        'PUBLICATION_ARTIFACT_CANDIDATE_REQUIRED'
+      );
+      source = {
+        repository: item.artifactCandidate.source.repository,
+        ref: item.artifactCandidate.source.ref,
+        sourceCommit: artifactIdentity.sourceCommit,
+      };
+      assert.ok(producer.sourcePolicy?.repository, 'PUBLICATION_ARTIFACT_REPOSITORY_REQUIRED');
+      assert.match(source.ref, /^[\w./-]{1,200}$/);
+      // A feature branch admission policy does not describe the signed artifact's
+      // real main/tag source. The mandatory product verifier owns that lineage.
+      validateExpectedSource(source, {
+        repository: producer.sourcePolicy.repository,
+        ref: source.ref,
+      });
+      assert.equal(
+        typeof producer.provider.verifyArtifactDelivery,
+        'function',
+        'PUBLICATION_ARTIFACT_DELIVERY_VERIFIER_REQUIRED'
+      );
+      assert.equal(
+        await bounded(
+          producer.provider.verifyArtifactDelivery(
+            item.command,
+            artifactIdentity,
+            item.deliveryExecution,
+            structuredClone(source),
+            verification
+          )
+        ),
+        true,
+        'PUBLICATION_LINEAGE_REQUIRED'
+      );
+    }
+    const saved = producer.journal.read();
+    assert.equal(
+      canonical(saved.commands[item.command.commandId]),
+      canonical(item),
+      'PUBLICATION_TERMINAL_NOT_DURABLE'
+    );
+    assert.equal(
+      canonical(saved.runs.find((value) => value.id === run.id)),
+      canonical(run),
+      'PUBLICATION_TERMINAL_NOT_DURABLE'
+    );
+    if (run.status === 'deployed') {
+      assert.ok(artifactIdentity, 'PUBLICATION_ARTIFACT_REQUIRED');
+      assert.ok(
+        acceptedProduction(run.readback, producer.resolvedCommand(item.command), producer.now()),
+        'PUBLICATION_TERMINAL_READBACK_REQUIRED'
+      );
+      assert.ok(fresh(run.readback, producer.now()), 'PUBLICATION_TERMINAL_READBACK_STALE');
+      if (item.command.action === 'publish')
+        assert.equal(
+          await bounded(
+            producer.provider.verifyPublicationArtifact(
+              item.command,
+              artifactIdentity,
+              item.deliveryExecution,
+              verification
+            )
+          ),
+          true,
+          'PUBLICATION_LINEAGE_REQUIRED'
+        );
+    } else {
+      // The existing independently owned pre-install failure guard remains the
+      // sole failure authority until artifact recovery has an equivalent guard.
+      assert.equal(
+        item.publicationFailureReconciliation?.state,
+        'settled',
+        'PUBLICATION_FAILURE_NOT_SETTLED'
+      );
+      validatePublicationFailureReadback(run.readback, item.command, item.baseline, producer.now());
+    }
+    const bindings = {
+      action: item.command.action,
+      commandId: item.command.commandId,
+      runId: run.id,
+      installationKey: item.command.installationKey,
+      repository: source.repository,
+      ref: source.ref,
+      provider: item.command.executionProvider,
+      candidateId: item.command.candidateId,
+      delivery: structuredClone(item.deliveryExecution),
+    };
+    const proof = {
+      schema: 1,
+      bindings,
+      status: run.status,
+      completedAt: run.completedAt,
+      artifactIdentity: structuredClone(artifactIdentity ?? null),
+      readback: structuredClone(run.readback),
+      failure: structuredClone(item.publicationFailureReconciliation?.fact ?? null),
+    };
+    authority = Object.freeze(Object.create(null));
+    controller.signal.throwIfAborted();
+    authorities.set(authority, { proof, expiresAt, producer, item, durableRun: canonical(run) });
+    await bounded(
+      Promise.resolve().then(() =>
+        producer.provider.publicationTerminal(structuredClone(item.command), {
+          authority,
+          bindings: structuredClone(bindings),
+          signal: controller.signal,
+        })
+      )
+    );
+  } catch (error) {
+    // The deployment result remains truthful. Product origin closure is unproven
+    // and must retry through fresh official reconciliation, never a raw snapshot.
+    producer.diagnostic(run.id, null, error);
+    await producer.save();
+    return false;
+  } finally {
+    if (authority) authorities.delete(authority);
+    controller?.abort();
+    clearTimeout(timer);
+  }
+  return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@casecore/release-agent",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "Общий движок поставки CaseCore с адаптерами продуктов",
   "license": "UNLICENSED",
   "repository": {