@dsh-enhanced/plugin-control-plane 0.1.31 → 0.1.34

package/lib/release.js

@@ -1,9 +1,9 @@
-import { spawn } from 'node:child_process';
 import { createHash, createPublicKey, verify } from 'node:crypto';
 import { constants as fsConstants } from 'node:fs';
 import { lstat, open, realpath } from 'node:fs/promises';
 import { dirname, isAbsolute, posix, resolve } from 'node:path';
 import { catalogAdmissionId, parseCatalog } from './catalog.js';
+import { ControlledProcessError, executeControlledProcess } from './adapter-process.js';
 import { ControlPlaneStoreError } from './store.js';
 import { inheritedReleaseAdapterEnvironment, openTrustedExecutable, verifyOpenTrustedExecutable } from './trust.js';
 const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u;
@@ -273,7 +273,7 @@ export function parseSourcePublishReconciliationRequest(value) {
     }
     return request;
 }
-function parseSourcePublishReconciliationEvidence(value) {
+function parseSourcePublishReconciliationEvidenceV1(value) {
     const item = record(value, 'source publish reconciliation evidence');
     exact(item, ['kind', 'outcome', 'registryId', 'registryReference', 'packageName', 'packageVersion', 'expectedTarballSha256',
         'expectedTarballIntegrity', 'expectedArtifactStatementDigest', 'expectedArtifactSignatureDigest',
@@ -326,17 +326,90 @@ function parseSourcePublishReconciliationEvidence(value) {
     }
     return Object.freeze(evidence);
 }
+function bareHttpsUrl(value, label, allowEncodedSlash = false) {
+    const raw = opaqueLine(value, label);
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        throw new ControlPlaneStoreError('invalid-input', `${label} is invalid`);
+    }
+    const canonical = raw === parsed.href || (parsed.pathname === '/' && raw === parsed.href.slice(0, -1));
+    if (parsed.protocol !== 'https:' || parsed.username !== '' || parsed.password !== '' || parsed.search !== '' || parsed.hash !== ''
+        || !canonical || /%(?:25|5c|2e)|%(?![a-f0-9]{2})/iu.test(parsed.pathname) || (!allowEncodedSlash && /%2f/iu.test(parsed.pathname))
+        || parsed.pathname.includes('//')) {
+        throw new ControlPlaneStoreError('invalid-input', `${label} is not a bare canonical HTTPS URL`);
+    }
+    return raw;
+}
+function parseSourceNpmPublishReconciliationEvidence(value) {
+    const item = record(value, 'npm publish reconciliation evidence');
+    exact(item, ['kind', 'outcome', 'registryId', 'registryReference', 'packageName', 'packageVersion', 'expectedTarballSha256',
+        'expectedTarballIntegrity', 'expectedArtifactStatementDigest', 'expectedArtifactSignatureDigest', 'observedTarballSha256',
+        'observedTarballIntegrity', 'ambiguousPublishOperationId', 'ambiguousPublishReceiptDigest', 'detailDigest',
+        'metadataReference', 'metadataIntegrity', 'downloadedBytes'], 'npm publish reconciliation evidence');
+    if (item.kind !== 'npm-publish-reconciliation' || !['exists-match', 'unknown', 'digest-conflict'].includes(String(item.outcome))) {
+        throw new ControlPlaneStoreError('invalid-input', 'npm publish reconciliation evidence outcome is invalid');
+    }
+    const nullableDigest = (raw, label) => raw === null ? null : digestText(raw, label);
+    const nullableIntegrity = (raw, label) => raw === null ? null : integrity(raw, label);
+    const nullableUrl = (raw, label, allowEncodedSlash = false) => raw === null ? null
+        : bareHttpsUrl(raw, label, allowEncodedSlash);
+    const evidence = {
+        kind: 'npm-publish-reconciliation',
+        outcome: item.outcome,
+        registryId: text(item.registryId, 'registryId'), registryReference: nullableUrl(item.registryReference, 'registryReference'),
+        packageName: text(item.packageName, 'packageName', PACKAGE), packageVersion: text(item.packageVersion, 'packageVersion', VERSION),
+        expectedTarballSha256: digestText(item.expectedTarballSha256, 'expectedTarballSha256'),
+        expectedTarballIntegrity: integrity(item.expectedTarballIntegrity, 'expectedTarballIntegrity'),
+        expectedArtifactStatementDigest: digestText(item.expectedArtifactStatementDigest, 'expectedArtifactStatementDigest'),
+        expectedArtifactSignatureDigest: digestText(item.expectedArtifactSignatureDigest, 'expectedArtifactSignatureDigest'),
+        observedTarballSha256: nullableDigest(item.observedTarballSha256, 'observedTarballSha256'),
+        observedTarballIntegrity: nullableIntegrity(item.observedTarballIntegrity, 'observedTarballIntegrity'),
+        ambiguousPublishOperationId: text(item.ambiguousPublishOperationId, 'ambiguousPublishOperationId'),
+        ambiguousPublishReceiptDigest: digestText(item.ambiguousPublishReceiptDigest, 'ambiguousPublishReceiptDigest'),
+        detailDigest: digestText(item.detailDigest, 'detailDigest'), metadataReference: nullableUrl(item.metadataReference, 'metadataReference', true),
+        metadataIntegrity: nullableIntegrity(item.metadataIntegrity, 'metadataIntegrity'),
+        downloadedBytes: item.downloadedBytes === null ? null : integer(item.downloadedBytes, 'downloadedBytes', 1),
+    };
+    if (evidence.downloadedBytes !== null && evidence.downloadedBytes > 268_435_456) {
+        throw new ControlPlaneStoreError('invalid-input', 'downloadedBytes must be a bounded integer');
+    }
+    const fullyObserved = evidence.registryReference !== null && evidence.metadataReference !== null && evidence.metadataIntegrity !== null
+        && evidence.downloadedBytes !== null && evidence.observedTarballSha256 !== null && evidence.observedTarballIntegrity !== null
+        && evidence.metadataIntegrity === evidence.observedTarballIntegrity;
+    if (evidence.outcome === 'exists-match' && (!fullyObserved || evidence.observedTarballSha256 !== evidence.expectedTarballSha256
+        || evidence.observedTarballIntegrity !== evidence.expectedTarballIntegrity)) {
+        throw new ControlPlaneStoreError('invalid-input', 'npm exists-match reconciliation does not prove the exact artifact');
+    }
+    if (evidence.outcome === 'digest-conflict' && (!fullyObserved || (evidence.observedTarballSha256 === evidence.expectedTarballSha256
+        && evidence.observedTarballIntegrity === evidence.expectedTarballIntegrity))) {
+        throw new ControlPlaneStoreError('invalid-input', 'npm digest-conflict reconciliation does not prove a conflicting artifact');
+    }
+    if (evidence.outcome === 'unknown' && (evidence.registryReference !== null || evidence.metadataReference !== null
+        || evidence.metadataIntegrity !== null || evidence.downloadedBytes !== null || evidence.observedTarballSha256 !== null
+        || evidence.observedTarballIntegrity !== null)) {
+        throw new ControlPlaneStoreError('invalid-input', 'npm unknown reconciliation contains observed registry state');
+    }
+    return Object.freeze(evidence);
+}
 export function sourcePublishReconciliationRequestDigest(value) { return digest(value); }
 export function sourcePublishReconciliationEvidenceDigest(value) { return digest(value); }
 export function parseSourcePublishReconciliationReceipt(value) {
     const item = record(value, 'source publish reconciliation receipt');
     exact(item, ['schemaVersion', 'kind', 'receiptId', 'authority', 'keyId', 'installationId', 'planId', 'planDigest', 'releaseId',
         'fence', 'operationId', 'requestDigest', 'evidence', 'evidenceDigest', 'observedAt', 'expiresAt', 'signature'], 'source publish reconciliation receipt');
-    if (item.schemaVersion !== 1 || item.kind !== 'dsh-source-publish-reconciliation-receipt') {
+    if ((item.schemaVersion !== 1 && item.schemaVersion !== 2) || item.kind !== 'dsh-source-publish-reconciliation-receipt') {
         throw new ControlPlaneStoreError('invalid-input', 'unsupported source publish reconciliation receipt schema');
     }
-    const evidence = parseSourcePublishReconciliationEvidence(item.evidence);
-    const receipt = { schemaVersion: 1, kind: 'dsh-source-publish-reconciliation-receipt',
+    const evidence = item.schemaVersion === 1 ? parseSourcePublishReconciliationEvidenceV1(item.evidence)
+        : parseSourceNpmPublishReconciliationEvidence(item.evidence);
+    if ((item.schemaVersion === 1 && evidence.kind !== 'publish-reconciliation')
+        || (item.schemaVersion === 2 && evidence.kind !== 'npm-publish-reconciliation')) {
+        throw new ControlPlaneStoreError('invalid-input', 'publish reconciliation receipt schema and evidence kind disagree');
+    }
+    const receipt = { schemaVersion: item.schemaVersion, kind: 'dsh-source-publish-reconciliation-receipt',
         receiptId: text(item.receiptId, 'receiptId'), authority: text(item.authority, 'authority'), keyId: text(item.keyId, 'keyId'),
         installationId: text(item.installationId, 'installationId', /^[a-f0-9-]{36}$/u), planId: text(item.planId, 'planId'),
         planDigest: digestText(item.planDigest, 'planDigest'), releaseId: text(item.releaseId, 'releaseId'), fence: integer(item.fence, 'fence', 1),
@@ -355,6 +428,19 @@ function canonicalReconciliationReceipt(receipt) {
 export function sourcePublishReconciliationSigningPayload(receipt) {
     return canonicalReconciliationReceipt({ ...receipt, signature: '' });
 }
+function npmRegistryBase(locator) {
+    const raw = bareHttpsUrl(locator, 'registry.locator');
+    const parsed = new URL(raw);
+    if (!parsed.pathname.endsWith('/'))
+        parsed.pathname = `${parsed.pathname}/`;
+    return parsed;
+}
+function npmUrlUnderBase(reference, base, label) {
+    const parsed = new URL(reference);
+    if (parsed.origin !== base.origin || !parsed.pathname.startsWith(base.pathname)) {
+        throw new ControlPlaneStoreError('conflict', `${label} is not under the configured npm registry`);
+    }
+}
 export class Ed25519SourcePublishReconciliationAuthority {
     publicKey;
     expectedAuthority;
@@ -384,8 +470,9 @@ export class Ed25519SourcePublishReconciliationAuthority {
             || evidence.expectedTarballIntegrity !== request.artifact.tarballIntegrity
             || evidence.expectedArtifactStatementDigest !== request.expectedArtifactStatementDigest
             || evidence.expectedArtifactSignatureDigest !== request.expectedArtifactSignatureDigest
-            || (evidence.outcome === 'exists-match' && (evidence.observedArtifactStatementDigest !== request.expectedArtifactStatementDigest
-                || evidence.observedArtifactSignatureDigest !== request.expectedArtifactSignatureDigest))
+            || (evidence.kind === 'publish-reconciliation' && evidence.outcome === 'exists-match'
+                && (evidence.observedArtifactStatementDigest !== request.expectedArtifactStatementDigest
+                    || evidence.observedArtifactSignatureDigest !== request.expectedArtifactSignatureDigest))
             || evidence.ambiguousPublishOperationId !== request.ambiguousPublish.operationId
             || evidence.ambiguousPublishReceiptDigest !== request.ambiguousPublish.receiptDigest
             || (evidence.registryReference !== null && evidence.registryReference !== request.expectedRegistryReference)) {
@@ -396,6 +483,18 @@ export class Ed25519SourcePublishReconciliationAuthority {
             || receipt.expiresAt - receipt.observedAt > request.receiptTtlMs) {
             throw new ControlPlaneStoreError('expired', 'publish reconciliation receipt is outside its request-bound validity interval');
         }
+        if (evidence.kind === 'npm-publish-reconciliation') {
+            const base = npmRegistryBase(request.registry.locator);
+            const metadataReference = `${base.href}${encodeURIComponent(request.artifact.packageName)}/${request.artifact.packageVersion}`;
+            if (evidence.registryReference !== null)
+                npmUrlUnderBase(evidence.registryReference, base, 'registryReference');
+            if (evidence.metadataReference !== null)
+                npmUrlUnderBase(evidence.metadataReference, base, 'metadataReference');
+            if ((evidence.registryReference !== null && evidence.registryReference !== request.expectedRegistryReference)
+                || (evidence.metadataReference !== null && evidence.metadataReference !== metadataReference)) {
+                throw new ControlPlaneStoreError('conflict', 'npm reconciliation receipt is not bound to the exact npm registry URLs');
+            }
+        }
         const signatureBytes = Buffer.from(receipt.signature, 'base64');
         if (!verify(null, Buffer.from(canonicalReconciliationReceipt(receipt)), createPublicKey(this.publicKey), signatureBytes)) {
             throw new ControlPlaneStoreError('invalid-input', 'publish reconciliation receipt signature is invalid');
@@ -1035,7 +1134,8 @@ export class ReleaseAdapterError extends Error {
         this.name = 'ReleaseAdapterError';
     }
 }
-async function executePinned(executable, interpreter, args, environment, timeoutMs, stdin, maximumOutput, phase, inherited = []) {
+async function executePinned(executable, interpreter, args, environment, timeoutMs, stdin, maximumOutput, phase, inherited = [], signal) {
+    signal?.throwIfAborted();
     if (process.platform !== 'linux')
         throw new ReleaseAdapterError('FAILED', phase, 'descriptor-pinned adapters require Linux');
     try {
@@ -1044,50 +1144,32 @@ async function executePinned(executable, interpreter, args, environment, timeout
     catch {
         throw new ReleaseAdapterError('FAILED', phase, 'descriptor-pinned adapters require /proc/self/fd');
     }
-    return new Promise((resolvePromise, reject) => {
-        const executableFd = 3 + inherited.length;
-        const interpreterFd = interpreter === undefined ? undefined : executableFd + 1;
-        const command = `/proc/self/fd/${interpreterFd ?? executableFd}`;
-        const commandArguments = interpreter === undefined ? [...args] : [`/proc/self/fd/${executableFd}`, ...args];
-        const stdio = ['pipe', 'pipe', 'ignore', ...inherited.map(handle => handle.fd), executable.handle.fd];
-        if (interpreter !== undefined)
-            stdio.push(interpreter.handle.fd);
-        const child = spawn(command, commandArguments, { env: environment, shell: false, stdio });
-        const chunks = [];
-        let bytes = 0;
-        let timedOut = false;
-        let outputLimit = false;
-        let settled = false;
-        child.stdout.on('data', (chunk) => { bytes += chunk.length; if (bytes > maximumOutput) {
-            outputLimit = true;
-            child.kill('SIGKILL');
-        }
-        else
-            chunks.push(chunk); });
-        child.once('error', () => { if (!settled) {
-            settled = true;
-            reject(new ReleaseAdapterError('FAILED', phase, 'adapter could not start'));
-        } });
-        child.once('close', code => {
-            if (settled)
-                return;
-            settled = true;
-            if (timedOut)
-                reject(new ReleaseAdapterError('TIMEOUT', phase, 'adapter exceeded its deadline'));
-            else if (outputLimit)
-                reject(new ReleaseAdapterError('OUTPUT_LIMIT', phase, 'adapter exceeded its output bound'));
-            else if (code !== 0)
-                reject(new ReleaseAdapterError('FAILED', phase, 'adapter returned a non-zero status'));
-            else
-                resolvePromise(Buffer.concat(chunks).toString('utf8'));
-        });
-        const timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, timeoutMs);
-        child.once('close', () => clearTimeout(timer));
-        child.stdin.end(stdin, 'utf8');
-    });
+    const executableFd = 3 + inherited.length;
+    const interpreterFd = interpreter === undefined ? undefined : executableFd + 1;
+    const command = `/proc/self/fd/${interpreterFd ?? executableFd}`;
+    const commandArguments = interpreter === undefined ? [...args] : [`/proc/self/fd/${executableFd}`, ...args];
+    const stdio = ['pipe', 'pipe', 'ignore', ...inherited.map(handle => handle.fd), executable.handle.fd];
+    if (interpreter !== undefined)
+        stdio.push(interpreter.handle.fd);
+    try {
+        return await executeControlledProcess({ command, args: commandArguments, env: environment, stdio,
+            stdin, timeoutMs, maximumOutput, ...(signal ? { signal } : {}) });
+    }
+    catch (error) {
+        if (!(error instanceof ControlledProcessError))
+            throw error;
+        if (error.code === 'ABORTED')
+            throw new ReleaseAdapterError('ABORTED', phase, 'adapter cancelled');
+        if (error.code === 'TIMEOUT')
+            throw new ReleaseAdapterError('TIMEOUT', phase, 'adapter exceeded its deadline');
+        if (error.code === 'OUTPUT_LIMIT')
+            throw new ReleaseAdapterError('OUTPUT_LIMIT', phase, 'adapter exceeded its output bound');
+        throw new ReleaseAdapterError('FAILED', phase, error.code === 'NON_ZERO'
+            ? 'adapter returned a non-zero status' : 'adapter could not be safely reclaimed');
+    }
 }
-async function assertPinnedAdapterCapabilities(executable, interpreter, adapter, phase, environment) {
-    const source = await executePinned(executable, interpreter, ['--capabilities'], environment, adapter.timeoutMs, undefined, 1_024, phase);
+async function assertPinnedAdapterCapabilities(executable, interpreter, adapter, phase, environment, signal) {
+    const source = await executePinned(executable, interpreter, ['--capabilities'], environment, adapter.timeoutMs, undefined, 1_024, phase, [], signal);
     let value;
     try {
         value = JSON.parse(source);
@@ -1122,7 +1204,8 @@ async function withPinnedAdapter(adapter, phase, action) {
         await executable.handle.close();
     }
 }
-export async function invokeSourceReleaseAdapter(trust, request) {
+export async function invokeSourceReleaseAdapter(trust, request, signal) {
+    signal?.throwIfAborted();
     const parsedRequest = parseSourceReleaseRequest(request);
     const adapter = trust.releaseAdapters?.[parsedRequest.phase];
     if (adapter === undefined)
@@ -1131,17 +1214,17 @@ export async function invokeSourceReleaseAdapter(trust, request) {
         interpreter: adapter.interpreter, authority: adapter.authority, keyId: adapter.keyId };
     if (digest(identity) !== digest(parsedRequest.adapter))
         throw new ReleaseAdapterError('FAILED', parsedRequest.phase, 'durable request is not bound to the configured adapter');
-    return withPinnedAdapter(adapter, parsedRequest.phase, async (executable, interpreter) => {
+    const receipt = await withPinnedAdapter(adapter, parsedRequest.phase, async (executable, interpreter) => {
         const environment = inheritedReleaseAdapterEnvironment(trust, parsedRequest.phase);
-        const version = (await executePinned(executable, interpreter, ['--version'], environment, adapter.timeoutMs, undefined, 1_024, parsedRequest.phase)).trim();
+        const version = (await executePinned(executable, interpreter, ['--version'], environment, adapter.timeoutMs, undefined, 1_024, parsedRequest.phase, [], signal)).trim();
         if (version !== adapter.version)
             throw new ReleaseAdapterError('VERSION_MISMATCH', parsedRequest.phase, 'adapter reported a different version');
-        await assertPinnedAdapterCapabilities(executable, interpreter, adapter, parsedRequest.phase, environment);
+        await assertPinnedAdapterCapabilities(executable, interpreter, adapter, parsedRequest.phase, environment, signal);
         const artifact = 'artifact' in parsedRequest.input ? await openArtifactSnapshot(parsedRequest.input.artifact) : undefined;
         try {
             const artifactEnvironment = artifact === undefined ? environment : { ...environment, DSH_RELEASE_TARBALL_FD: '3',
                 DSH_RELEASE_SBOM_FD: '4', DSH_RELEASE_PROVENANCE_FD: '5' };
-            const source = await executePinned(executable, interpreter, ['release'], artifactEnvironment, adapter.timeoutMs, `${JSON.stringify(parsedRequest)}\n`, 262_144, parsedRequest.phase, artifact?.handles ?? []);
+            const source = await executePinned(executable, interpreter, ['release'], artifactEnvironment, adapter.timeoutMs, `${JSON.stringify(parsedRequest)}\n`, 262_144, parsedRequest.phase, artifact?.handles ?? [], signal);
             if (artifact !== undefined)
                 await verifyOpenArtifactSnapshot(artifact);
             let value;
@@ -1151,6 +1234,7 @@ export async function invokeSourceReleaseAdapter(trust, request) {
             catch {
                 throw new ReleaseAdapterError('FAILED', parsedRequest.phase, 'adapter did not return one JSON receipt');
             }
+            signal?.throwIfAborted();
             return parseSourceReleaseReceipt(value);
         }
         finally {
@@ -1158,6 +1242,8 @@ export async function invokeSourceReleaseAdapter(trust, request) {
                 await Promise.all(artifact.handles.map(async (handle) => handle.close()));
         }
     });
+    signal?.throwIfAborted();
+    return receipt;
 }
 export async function invokeSourcePublishReconciliationAdapter(trust, request) {
     const parsedRequest = parseSourcePublishReconciliationRequest(request);