@aviaratech/ai-delivery 0.3.11 → 0.3.13

package/dist/verification.js

@@ -1,7 +1,7 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
-import { closeSync, existsSync, fsyncSync, openSync, unlinkSync, lstatSync, mkdirSync, rmdirSync, renameSync, readFileSync, readdirSync, realpathSync, statfsSync, } from 'node:fs';
+import { closeSync, existsSync, fsyncSync, openSync, unlinkSync, lstatSync, mkdirSync, rmdirSync, renameSync, readFileSync, readlinkSync, readdirSync, realpathSync, statfsSync, } from 'node:fs';
 import { basename, dirname, join, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
@@ -400,8 +400,9 @@ class OutputObservationError extends DeliveryError {
         this.cause = cause;
     }
 }
-function scanOutputRoots(roots) {
+function scanOutputRoots(roots, links, commandRunning = false, onMissingTarget) {
     const files = new Map();
+    const observedLinks = new Map();
     const visit = (path) => {
         let metadata;
         try {
@@ -413,16 +414,113 @@ function scanOutputRoots(roots) {
             throw new OutputObservationError('Filesystem output lstat failed.', path, error);
         }
         if (metadata.isSymbolicLink()) {
+            let link;
+            try {
+                link = readlinkSync(path);
+            }
+            catch (error) {
+                throw new OutputObservationError('Filesystem output readlink failed.', path, error);
+            }
+            const identity = digestValue({
+                device: metadata.dev,
+                inode: metadata.ino,
+                changed: metadata.ctimeMs,
+                modified: metadata.mtimeMs,
+                link,
+            });
             let target;
+            let missing = false;
             try {
                 target = realpathSync(path);
             }
             catch (error) {
-                throw new OutputObservationError('Filesystem output observation encountered a broken or cyclic symbolic link.', path, error);
+                const failure = new OutputObservationError('Filesystem output observation encountered a broken or cyclic symbolic link.', path, error);
+                const previous = links.get(path);
+                if (previous !== undefined && previous.identity !== identity)
+                    throw new DeliveryError(`Filesystem output alias identity changed. Path ${JSON.stringify(path)}.`);
+                if (!commandRunning || failure.code !== 'ENOENT' || previous?.identity !== identity)
+                    throw failure;
+                // A validated alias contributes no physical file bytes. Resolve the missing suffix through
+                // its current existing ancestor, so an ancestor retarget cannot hide an escaping output.
+                let lexical = resolve(dirname(path), link);
+                let ancestor = lexical;
+                const expanded = new Set([path]);
+                for (;;) {
+                    try {
+                        target = join(realpathSync(ancestor), lexical.slice(ancestor.length));
+                        break;
+                    }
+                    catch (ancestorError) {
+                        if (ancestorError.code !== 'ENOENT' || dirname(ancestor) === ancestor)
+                            throw new OutputObservationError('Filesystem output ancestor resolution failed.', ancestor, ancestorError);
+                        let ancestorMetadata;
+                        try {
+                            ancestorMetadata = lstatSync(ancestor);
+                        }
+                        catch (metadataError) {
+                            if (metadataError.code !== 'ENOENT')
+                                throw new OutputObservationError('Filesystem output ancestor lstat failed.', ancestor, metadataError);
+                        }
+                        if (ancestorMetadata?.isSymbolicLink()) {
+                            let ancestorLink, currentAncestor;
+                            try {
+                                ancestorLink = readlinkSync(ancestor);
+                                currentAncestor = lstatSync(ancestor);
+                            }
+                            catch (aliasError) {
+                                throw new OutputObservationError('Filesystem output ancestor alias read failed.', ancestor, aliasError);
+                            }
+                            const ancestorIdentity = digestValue({
+                                device: ancestorMetadata.dev,
+                                inode: ancestorMetadata.ino,
+                                changed: ancestorMetadata.ctimeMs,
+                                modified: ancestorMetadata.mtimeMs,
+                                link: ancestorLink,
+                            });
+                            const previousAncestor = links.get(ancestor);
+                            if (previousAncestor === undefined)
+                                throw failure;
+                            if (expanded.has(ancestor) ||
+                                previousAncestor.identity !== ancestorIdentity ||
+                                !currentAncestor.isSymbolicLink() ||
+                                currentAncestor.dev !== ancestorMetadata.dev ||
+                                currentAncestor.ino !== ancestorMetadata.ino ||
+                                currentAncestor.ctimeMs !== ancestorMetadata.ctimeMs ||
+                                currentAncestor.mtimeMs !== ancestorMetadata.mtimeMs)
+                                throw new DeliveryError(`Filesystem output ancestor alias identity changed. Path ${JSON.stringify(ancestor)}.`);
+                            expanded.add(ancestor);
+                            lexical = join(resolve(dirname(ancestor), ancestorLink), lexical.slice(ancestor.length));
+                            ancestor = lexical;
+                            continue;
+                        }
+                        ancestor = dirname(ancestor);
+                    }
+                }
+                if (target !== previous.target)
+                    throw new DeliveryError(`Filesystem output alias target identity changed. Path ${JSON.stringify(path)}.`);
+                missing = true;
+                onMissingTarget?.(failure.message);
             }
+            const previous = links.get(path);
+            if (previous?.missing && (previous.identity !== identity || previous.target !== target))
+                throw new DeliveryError(`Filesystem output alias identity changed after target absence. Path ${JSON.stringify(path)}.`);
             if (!roots.some((root) => target === root || target.startsWith(`${root}${sep}`))) {
                 throw new DeliveryError(`Filesystem output observation encountered an escaping symbolic link. Path ${JSON.stringify(path)} resolves to ${JSON.stringify(target)}.`);
             }
+            let current;
+            try {
+                current = lstatSync(path);
+            }
+            catch (error) {
+                throw new OutputObservationError('Filesystem output alias identity readback failed.', path, error);
+            }
+            if (!current.isSymbolicLink() ||
+                current.dev !== metadata.dev ||
+                current.ino !== metadata.ino ||
+                current.ctimeMs !== metadata.ctimeMs ||
+                current.mtimeMs !== metadata.mtimeMs)
+                throw new DeliveryError(`Filesystem output alias identity changed during observation. Path ${JSON.stringify(path)}.`);
+            observedLinks.set(path, { identity, target, missing });
             // Observe physical targets through their declared root only, never traverse aliases.
             return;
         }
@@ -452,12 +550,17 @@ function scanOutputRoots(roots) {
             throw new DeliveryError('Filesystem output roots must not be symbolic links.');
         visit(root);
     }
+    // Publish alias identities only with the complete physical-file scan that validated them.
+    links.clear();
+    for (const [path, link] of observedLinks)
+        links.set(path, link);
     return files;
 }
 async function outputBaseline(repoRoot, common, classificationReceiptId, bounds, gate, signal) {
     if (bounds.outputRoots === undefined)
         return undefined;
     const roots = bounds.outputRoots.map((path) => resolve(repoRoot, path)).sort();
+    const links = new Map();
     for (let i = 1; i < roots.length; i++) {
         if (roots[i] === roots[i - 1] || roots[i].startsWith(`${roots[i - 1]}${sep}`)) {
             throw new DeliveryError('Filesystem output roots must not overlap.');
@@ -503,7 +606,7 @@ async function outputBaseline(repoRoot, common, classificationReceiptId, bounds,
     let checkpoint;
     if (state?.status !== 'complete') {
         const content = {
-            files: [...(await withOutputGateLock(gate, 'scan', () => scanOutputRoots(roots), signal))].sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)),
+            files: [...(await withOutputGateLock(gate, 'scan', () => scanOutputRoots(roots, links), signal))].sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)),
             inputId,
             roots,
             schemaVersion: 'ai-delivery.output-baseline@1',
@@ -528,15 +631,15 @@ async function outputBaseline(repoRoot, common, classificationReceiptId, bounds,
         checkpoint.files.some(([file], index) => (index > 0 && file <= checkpoint.files[index - 1][0]) ||
             !roots.some((root) => file === root || file.startsWith(`${root}${sep}`))))
         throw new DeliveryError('Filesystem output baseline checkpoint is corrupt or belongs to another input.');
-    return { baselineId, roots, files: new Map(checkpoint.files), ...(gate === undefined ? {} : { gate }) };
+    return { baselineId, roots, files: new Map(checkpoint.files), links, ...(gate === undefined ? {} : { gate }) };
 }
 async function positiveNewOutputBytes(baseline, signal, commandRunning = false, onUnavailable) {
     let files;
     let firstFailure;
     let lastFailure;
-    const started = Date.now();
+    let firstFailureAt;
     const assertObservationWindow = () => {
-        if (firstFailure !== undefined && Date.now() - started >= 1_000) {
+        if (firstFailureAt !== undefined && Date.now() - firstFailureAt >= 1_000) {
             throw new DeliveryError(`Filesystem output observation remained unavailable for 1 second. First observation: ${firstFailure.message} Last observation: ${lastFailure.message}`);
         }
     };
@@ -545,17 +648,18 @@ async function positiveNewOutputBytes(baseline, signal, commandRunning = false,
             throw new DeliveryError('Filesystem output observation cancelled.');
         assertObservationWindow();
         try {
-            files = await withOutputGateLock(baseline.gate, 'scan', () => scanOutputRoots(baseline.roots), signal);
+            files = await withOutputGateLock(baseline.gate, 'scan', () => scanOutputRoots(baseline.roots, baseline.links, commandRunning, onUnavailable), signal);
             assertObservationWindow();
             break;
         }
         catch (error) {
-            // Removal can unlink a physical target before its alias. Never accept an incomplete scan:
-            // retry ENOENT only during a command, with one bounded observation-stall window.
+            // Unvalidated aliases still prevent a complete scan. Retry only during a command,
+            // with the stall window starting at the first failed scan, not before that scan.
             if (!commandRunning || !(error instanceof OutputObservationError) || error.code !== 'ENOENT')
                 throw error;
             lastFailure = error;
             if (firstFailure === undefined) {
+                firstFailureAt = Date.now();
                 firstFailure = error;
                 onUnavailable?.(error.message);
             }
@@ -1201,12 +1305,13 @@ function runStageCommand(repoRoot, argv, abortSignal, onRunning, resourceBounds,
         let settled = false;
         let commandReleased = false;
         let firstOutputObservationFailure;
+        let lastOutputObservationFailure;
         let pendingOutput;
         const scanCancellation = new AbortController();
         const failedOutput = () => {
             const observation = firstOutputObservationFailure === undefined
                 ? ''
-                : ` First filesystem observation: ${firstOutputObservationFailure}`;
+                : ` First filesystem observation: ${firstOutputObservationFailure} Last filesystem observation: ${lastOutputObservationFailure}`;
             try {
                 const bytes = Buffer.concat([...stdout, ...stderr]);
                 return ` Command output ${writeRepositoryCommandOutput({ bytes, gitCommonDir: gitCommonDir(repoRoot) })}.${observation}`;
@@ -1334,6 +1439,7 @@ function runStageCommand(repoRoot, argv, abortSignal, onRunning, resourceBounds,
                         if (resourceBounds !== undefined && baseline !== undefined) {
                             const bytes = await positiveNewOutputBytes(baseline, scanCancellation.signal, commandReleased, (reason) => {
                                 firstOutputObservationFailure ??= reason;
+                                lastOutputObservationFailure = reason;
                                 onRunning?.(outputBytes, undefined, reason);
                             });
                             if (failure !== undefined)
@@ -1445,6 +1551,9 @@ async function verifyIssueOwned(input, writer, gate) {
         assertResourceBounds(input.resourceBounds);
     assertRegisteredIssue(root, input.issueNumber);
     const common = gitCommonDir(root);
+    if (existsSync(join(common, 'ai-delivery', 'merges', String(input.issueNumber), `${coordinate(root).sha}.json`))) {
+        throw new DeliveryError('Commit continuation work before verifying an already-merged issue head; retain its receipts.');
+    }
     const loaded = await loadDeliveryConfig(root, input.personalAuth === undefined ? {} : { personalAuth: input.personalAuth });
     const selected = await loadSelectedRepositoryPolicy({
         repoRoot: root,
@@ -1785,14 +1894,16 @@ export async function withRuntimeSetupWriter(root, operation) {
                         throw new DeliveryError('Filesystem output roots must not overlap.');
             }
             return withOutputObservationGate(root, roots !== undefined, async (gate) => {
+                const links = new Map();
                 const files = roots === undefined
                     ? undefined
-                    : await withOutputGateLock(gate, 'scan', () => scanOutputRoots(roots), signal);
+                    : await withOutputGateLock(gate, 'scan', () => scanOutputRoots(roots, links), signal);
                 const baseline = roots === undefined || files === undefined
                     ? undefined
                     : {
                         roots,
                         files,
+                        links,
                         baselineId: digestValue([...files]),
                         ...(gate === undefined ? {} : { gate }),
                     };