anhedral 0.8.6 → 0.9.0

package/dist/transaction.js

@@ -1,4 +1,5 @@
-import { closeSync, constants, fstatSync, cpSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmdirSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { readBoundedFile } from './bounded-file.js';
+import { closeSync, cpSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmdirSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
 import os from 'node:os';
 import path from 'node:path';
@@ -18,10 +19,10 @@ function assertRelativePath(relativePath) {
         normalized === '.' ||
         normalized === '..' ||
         normalized.startsWith(`..${path.sep}`) ||
-        normalized.split(path.sep).includes('..')
-        || rawSegments[0] === TRANSACTION_DIRECTORY
-        || rawSegments[0] === LOCK_FILE
-        || rawSegments[0] === JOURNAL_FILE) {
+        normalized.split(path.sep).includes('..') ||
+        rawSegments[0] === TRANSACTION_DIRECTORY ||
+        rawSegments[0] === LOCK_FILE ||
+        rawSegments[0] === JOURNAL_FILE) {
         throw new Error(`Unsafe transaction path: ${relativePath}`);
     }
 }
@@ -81,8 +82,8 @@ function normalizeTransactionPaths(rawCommitPaths, rawDeletePaths) {
     for (const written of commitPaths) {
         const deletedAncestor = ancestorInSet(written, deleteSet);
         if (deleteSet.has(written) || deletedAncestor || deleteAncestorPaths.has(written)) {
-            throw new Error(`Ambiguous transaction write/delete paths include ${written}`
-                + (deletedAncestor ? ` below ${deletedAncestor}` : ''));
+            throw new Error(`Ambiguous transaction write/delete paths include ${written}` +
+                (deletedAncestor ? ` below ${deletedAncestor}` : ''));
         }
     }
     const uniquePaths = [...commitPaths, ...deletePaths].sort();
@@ -100,7 +101,9 @@ function assertExactObjectKeys(value, expected, context) {
     const details = [
         missing.length > 0 ? `missing ${missing.join(', ')}` : null,
         unknown.length > 0 ? `unknown ${unknown.join(', ')}` : null,
-    ].filter((entry) => entry !== null).join('; ');
+    ]
+        .filter((entry) => entry !== null)
+        .join('; ');
     throw new Error(`Invalid ${context} fields (${details}).`);
 }
 function lstatIfPresent(target) {
@@ -232,42 +235,13 @@ function removeEntryDurably(target) {
     if (pathEntryExists(parent))
         syncDirectory(parent);
 }
-/** Reserved recovery metadata must never read devices, pipes or unbounded files. */
-function readRecoveryMetadata(filePath, maximumBytes) {
-    const stat = lstatSync(filePath);
-    if (!stat.isFile() || stat.isSymbolicLink())
-        throw new Error(`Recovery metadata must be a regular file: ${filePath}`);
-    const descriptor = openSync(filePath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
-    try {
-        const opened = fstatSync(descriptor);
-        if (!opened.isFile())
-            throw new Error(`Recovery metadata must be a regular file: ${filePath}`);
-        if (opened.size > maximumBytes)
-            throw new Error(`Recovery metadata exceeds size limit: ${filePath}`);
-        const chunks = [];
-        let total = 0;
-        for (;;) {
-            const chunk = Buffer.alloc(Math.min(8192, maximumBytes + 1 - total));
-            const length = readSync(descriptor, chunk, 0, chunk.length, null);
-            if (!length)
-                return Buffer.concat(chunks).toString('utf8');
-            total += length;
-            if (total > maximumBytes)
-                throw new Error(`Recovery metadata exceeds size limit: ${filePath}`);
-            chunks.push(chunk.subarray(0, length));
-        }
-    }
-    finally {
-        closeSync(descriptor);
-    }
-}
 function parseLockOwner(lockPath) {
     if (lstatSync(lockPath).isSymbolicLink()) {
         throw new Error(`Refusing symbolic-link transaction lock at ${lockPath}.`);
     }
     let value;
     try {
-        value = JSON.parse(readRecoveryMetadata(lockPath, 16 * 1024));
+        value = JSON.parse(readBoundedFile(lockPath, 16 * 1024).toString('utf8'));
     }
     catch (error) {
         throw new Error(`Cannot read transaction lock owner at ${lockPath}; remove it only after confirming no Anhedral process is running.`, { cause: error });
@@ -430,7 +404,11 @@ function acquireTransactionLock(root) {
         createdAt: new Date().toISOString(),
     };
     const temporaryPath = `${lockPath}.${owner.token}.tmp`;
-    writeFileSync(temporaryPath, JSON.stringify(owner) + '\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    writeFileSync(temporaryPath, JSON.stringify(owner) + '\n', {
+        encoding: 'utf8',
+        flag: 'wx',
+        mode: 0o600,
+    });
     try {
         for (let attempt = 0; attempt < 3; attempt += 1) {
             if (clearDeadReclaimer(lockPath, reclaimPath, owner)) {
@@ -518,13 +496,17 @@ function validateJournal(root, value) {
         throw new Error(`Cannot recover unsupported transaction journal at ${path.join(root, JOURNAL_FILE)}`);
     }
     assertExactObjectKeys(value, ['version', 'backupRoot', 'stageRoot', 'entries', 'createdDirectories'], 'transaction journal');
-    if (typeof value.backupRoot !== 'string' || typeof value.stageRoot !== 'string' || !Array.isArray(value.entries)) {
+    if (typeof value.backupRoot !== 'string' ||
+        typeof value.stageRoot !== 'string' ||
+        !Array.isArray(value.entries)) {
         throw new Error(`Invalid transaction journal at ${path.join(root, JOURNAL_FILE)}`);
     }
     assertJournalRoots(root, value.backupRoot, value.stageRoot);
     const seen = new Set();
     const entries = value.entries.map((entry, index) => {
-        if (!isRecord(entry) || typeof entry.relativePath !== 'string' || typeof entry.installed !== 'boolean') {
+        if (!isRecord(entry) ||
+            typeof entry.relativePath !== 'string' ||
+            typeof entry.installed !== 'boolean') {
             throw new Error(`Invalid transaction journal entry at index ${index}`);
         }
         assertExactObjectKeys(entry, ['relativePath', 'backupPath', 'installed', 'installedFingerprint'], `transaction journal entry at index ${index}`);
@@ -536,15 +518,16 @@ function validateJournal(root, value) {
             throw new Error(`Invalid transaction backup path at index ${index}`);
         }
         const installedFingerprint = entry.installedFingerprint;
-        if (installedFingerprint !== null
-            && (typeof installedFingerprint !== 'string' || !/^[a-f0-9]{64}$/.test(installedFingerprint))) {
+        if (installedFingerprint !== null &&
+            (typeof installedFingerprint !== 'string' || !/^[a-f0-9]{64}$/.test(installedFingerprint))) {
             throw new Error(`Invalid installed transaction fingerprint at index ${index}`);
         }
         if (entry.installed ? installedFingerprint === null : installedFingerprint !== null) {
             throw new Error(`Transaction journal entry fingerprint state is inconsistent at index ${index}`);
         }
         const expectedBackup = resolveTransactionPath(value.backupRoot, entry.relativePath);
-        if (entry.backupPath !== null && path.resolve(entry.backupPath) !== path.resolve(expectedBackup)) {
+        if (entry.backupPath !== null &&
+            path.resolve(entry.backupPath) !== path.resolve(expectedBackup)) {
             throw new Error(`Unsafe transaction backup path: ${entry.backupPath}`);
         }
         return {
@@ -573,7 +556,13 @@ function validateJournal(root, value) {
             throw new Error(`Transaction created directory is not a parent of any journal entry: ${directory}`);
         }
     }
-    return { version: JOURNAL_VERSION, backupRoot: value.backupRoot, stageRoot: value.stageRoot, entries, createdDirectories };
+    return {
+        version: JOURNAL_VERSION,
+        backupRoot: value.backupRoot,
+        stageRoot: value.stageRoot,
+        entries,
+        createdDirectories,
+    };
 }
 function writeJournal(root, journal) {
     const journalPath = path.join(root, JOURNAL_FILE);
@@ -646,13 +635,13 @@ function restoreInstalledEntry(root, journal, entry, target) {
     if (entry.installed) {
         if (pathEntryExists(target)) {
             if (entry.installedFingerprint === null) {
-                throw new Error(`Installed transaction path has no trusted fingerprint: ${entry.relativePath}. `
-                    + 'Recovery stopped without modifying it; inspect the journal, target, and backup manually.');
+                throw new Error(`Installed transaction path has no trusted fingerprint: ${entry.relativePath}. ` +
+                    'Recovery stopped without modifying it; inspect the journal, target, and backup manually.');
             }
             const actualFingerprint = fingerprintEntry(target);
             if (actualFingerprint !== entry.installedFingerprint) {
-                throw new Error(`Installed transaction path changed after an interrupted commit: ${entry.relativePath}. `
-                    + 'Recovery stopped without modifying it; inspect the journal, target, and backup manually.');
+                throw new Error(`Installed transaction path changed after an interrupted commit: ${entry.relativePath}. ` +
+                    'Recovery stopped without modifying it; inspect the journal, target, and backup manually.');
             }
         }
         removeEntryDurably(target);
@@ -679,8 +668,7 @@ function restoreJournal(root, journal) {
             writeJournal(root, journal);
         }
     }
-    for (const relativePath of [...journal.createdDirectories]
-        .sort((left, right) => right.split('/').length - left.split('/').length || right.localeCompare(left))) {
+    for (const relativePath of [...journal.createdDirectories].sort((left, right) => right.split('/').length - left.split('/').length || right.localeCompare(left))) {
         assertNoSymlinkComponents(root, relativePath);
         const target = resolveTransactionPath(root, relativePath);
         try {
@@ -705,7 +693,7 @@ function recoverInterruptedTransactionUnlocked(root) {
     if (lstatSync(journalPath).isSymbolicLink()) {
         throw new Error(`Refusing symbolic-link transaction journal at ${journalPath}.`);
     }
-    const journal = validateJournal(root, JSON.parse(readRecoveryMetadata(journalPath, 16 * 1024 * 1024)));
+    const journal = validateJournal(root, JSON.parse(readBoundedFile(journalPath, 16 * 1024 * 1024).toString('utf8')));
     restoreJournal(root, journal);
     return true;
 }
@@ -726,8 +714,8 @@ export class PostCommitError extends Error {
     committedPaths;
     constructor(committedPaths, cause) {
         const causeMessage = cause instanceof Error ? cause.message : String(cause);
-        super(`Generated files were saved, but the follow-up action failed: ${causeMessage}. `
-            + 'The generated files were kept; resolve the failure and rerun the failed command.', { cause });
+        super(`Changes were committed successfully, but the post-commit action failed: ${causeMessage}. ` +
+            'The generated files were kept; resolve the failure and rerun the post-commit command.', { cause });
         this.name = 'PostCommitError';
         this.committedPaths = Object.freeze([...committedPaths]);
     }
@@ -742,7 +730,10 @@ function assertTransactionNamespace(transactionDirectory) {
     for (const entry of readdirSync(transactionDirectory)) {
         const candidate = path.join(transactionDirectory, entry);
         const stat = lstatIfPresent(candidate);
-        if (!LOCAL_TRANSACTION_ROOT_PATTERN.test(entry) || !stat || stat.isSymbolicLink() || !stat.isDirectory()) {
+        if (!LOCAL_TRANSACTION_ROOT_PATTERN.test(entry) ||
+            !stat ||
+            stat.isSymbolicLink() ||
+            !stat.isDirectory()) {
             throw new Error(`Unknown or unsafe artifact in reserved transaction namespace requires manual inspection: ${candidate}`);
         }
     }
@@ -835,7 +826,7 @@ export async function runStagedTransaction(root, options) {
         recoverInterruptedTransactionUnlocked(root);
         if (!options.dryRun)
             cleanupOrphanTransactionRoots(root);
-        if (await options.prepare?.() === false)
+        if ((await options.prepare?.()) === false)
             return Object.freeze([]);
         assertTransactionNamespace(transactionDirectory);
         namespaceValidated = true;

package/dist/util.js

@@ -20,7 +20,13 @@ export function appendGitignore(root, lines) {
     const additions = [...new Set(lines)].filter((line) => !existingLines.has(line));
     if (additions.length === 0)
         return;
-    const newline = existing.includes('\r\n') ? '\r\n' : existing.includes('\n') ? '\n' : existing.includes('\r') ? '\r' : '\n';
+    const newline = existing.includes('\r\n')
+        ? '\r\n'
+        : existing.includes('\n')
+            ? '\n'
+            : existing.includes('\r')
+                ? '\r'
+                : '\n';
     const separator = existing.length > 0 && !/(?:\r\n|\n|\r)$/.test(existing) ? newline : '';
     writeFile(filePath, `${existing}${separator}${additions.join(newline)}${newline}`);
 }
@@ -56,7 +62,11 @@ export function execFile(executable, args, cwd) {
     const display = [executable, ...args].join(' ');
     if (process.env.ANHEDRAL_VERBOSE === '1' && !quiet) {
         console.log(`  $ ${display}`);
-        const result = spawnSync(invocation.command, invocation.args, { cwd, stdio: 'inherit', shell: false });
+        const result = spawnSync(invocation.command, invocation.args, {
+            cwd,
+            stdio: 'inherit',
+            shell: false,
+        });
         if (result.error || result.status !== 0) {
             throw new Error(`Command failed (exit ${result.status ?? '?'}): ${display}`, result.error ? { cause: result.error } : undefined);
         }

package/dist/vercel.d.ts

@@ -0,0 +1,98 @@
+import { type DeliveryRunner } from './project-state.js';
+interface WebProject {
+    schemaVersion: 1;
+    id: string;
+    name: string;
+    ownership: 'customer';
+    provider: 'vercel';
+    directory: 'apps/web';
+    teamId: string | null;
+    projectId: string | null;
+    scope: string | null;
+    audience: 'unconfigured' | 'public' | 'private';
+    use: 'unconfigured' | 'personal' | 'commercial';
+    repository?: {
+        repoId: number;
+        nameWithOwner: string;
+        productionBranch?: string;
+    };
+}
+interface WebRelease {
+    id: string;
+    commit: string;
+    operation: 'ship' | 'rollback' | 'adopt' | 'recover';
+    provenance?: 'cli' | 'git';
+    branch?: string;
+    state: 'running' | 'deployed' | 'failed';
+    startedAt: string;
+    deploymentId?: string;
+    url?: string;
+    deploymentUrl?: string;
+    restoredReleaseId?: string;
+    verification?: {
+        state: 'passed' | 'failed';
+        checkedAt: string;
+    };
+}
+export declare function registerVercelApplication(root: string): WebProject;
+export declare function connectVercelApplication(root: string, options: {
+    scope?: string;
+    audience: 'public' | 'private';
+    use: 'personal' | 'commercial';
+    create?: boolean;
+    git?: boolean;
+}, run?: DeliveryRunner): Promise<{
+    project: WebProject;
+    plan: any;
+    planActivated: boolean;
+}>;
+export declare function adoptVercelApplication(root: string, run?: DeliveryRunner): Promise<{
+    projectId: string;
+    release: WebRelease;
+    adopted: boolean;
+    productVerification: string;
+}>;
+export declare function recoverVercelApplication(root: string, run?: DeliveryRunner): Promise<{
+    projectId: string;
+    release: WebRelease;
+    adopted: boolean;
+    productVerification: string;
+}>;
+export declare function planVercelDelivery(root: string): {
+    project: WebProject;
+    checks: string[];
+    deployment: string[];
+    cloudflareServices: string;
+    mutation: boolean;
+};
+export declare function vercelApplicationStatus(root: string, refresh?: boolean, run?: DeliveryRunner): Promise<{
+    project: WebProject;
+    releases: WebRelease[];
+    activeRecordedVersion: boolean | undefined;
+    evidence: string;
+    productVerification: string;
+    management: string | null;
+}>;
+export declare function shipVercelApplication(root: string, run?: DeliveryRunner): Promise<{
+    projectId: string;
+    release: WebRelease;
+    productVerification: string;
+}>;
+export declare function verifyVercelApplication(root: string, run?: DeliveryRunner): Promise<{
+    projectId: string;
+    releaseId: string;
+    verification: {
+        state: "passed" | "failed";
+        checkedAt: string;
+    };
+}>;
+export declare function rollbackVercelApplication(root: string, releaseId: string, dataCompatible: boolean, run?: DeliveryRunner): Promise<{
+    projectId: string;
+    release: WebRelease;
+    dataRestored: boolean;
+    productVerification: string;
+    automaticProductionUpdates: string;
+    nextAction: string;
+}>;
+export declare function writeVercelOverview(root: string, snapshot: Awaited<ReturnType<typeof vercelApplicationStatus>>): string;
+export {};