ast-mcp-server 0.13.1 → 0.14.0

package/dist/services/operations.js

@@ -1,11 +1,13 @@
 import { createHash, randomUUID } from "node:crypto";
-import { lstatSync, realpathSync } from "node:fs";
-import { link, open, readFile, rename, stat, unlink } from "node:fs/promises";
+import { constants, lstatSync, realpathSync } from "node:fs";
+import { open, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { createTwoFilesPatch } from "diff";
 import { LanguageVariant, Node, ScriptTarget, SyntaxKind, ts } from "ts-morph";
-import { compareDiagnostics, normalizeDiagnostic, } from "./diagnostics.js";
+import { compareObservedDiagnostics, observeDiagnostic, } from "./diagnostics.js";
+import { probePublicationCapability, publishAuthenticated, removeOwnedPublicationEntry, rollbackOwnedCommit, snapshotHeldFile, } from "./authenticated-publication.js";
 import { createFreshProject, findDeclarationByName, getSourceFileOrThrow, invalidateProjectIfIdle, recordProjectMutationHistory, withProjectOperation, } from "./project.js";
+import { PublicOperationalError } from "./public-errors.js";
 import { NO_REQUEST_CONTEXT } from "./request-context.js";
 import { executableDeclaration } from "./symbols.js";
 import { buildClassScaffold } from "./scaffold.js";
@@ -25,9 +27,9 @@ let operationNow = () => Date.now();
 function hash(content) {
     return createHash("sha256").update(content).digest("hex");
 }
-function planHashFor(operation) {
+function planHashFor(operation, version = 2) {
     return hash(JSON.stringify({
-        version: 1,
+        version,
         operation_id: operation.operation_id,
         kind: operation.kind,
         project_root: operation.project_root,
@@ -62,8 +64,29 @@ function pruneOperations() {
         operations.delete(oldest);
     }
 }
-function normalizeProjectDiagnostics(project, projectRoot, requestContext) {
-    return [...project.getConfigFileParsingDiagnostics(), ...project.getPreEmitDiagnostics()].map((diagnostic) => normalizeDiagnostic(diagnostic, projectRoot, requestContext));
+function observeProjectDiagnostics(project, projectRoot, requestContext) {
+    return [...project.getConfigFileParsingDiagnostics(), ...project.getPreEmitDiagnostics()].map((diagnostic, ordinal) => observeDiagnostic(diagnostic, projectRoot, ordinal, requestContext));
+}
+function collectPlannedTextChanges(project, projectRoot, originals, requestContext) {
+    const updated = new Map(project
+        .getSourceFiles()
+        .map((sourceFile) => [sourceFile.getFilePath(), sourceFile.getFullText()]));
+    const paths = new Set([...originals.keys(), ...updated.keys()]);
+    const changes = [];
+    for (const absolutePath of paths) {
+        requestContext.checkpoint();
+        const beforeText = originals.get(absolutePath) ?? null;
+        const afterText = updated.get(absolutePath) ?? null;
+        if (beforeText === afterText)
+            continue;
+        changes.push({
+            absolutePath,
+            file: path.relative(projectRoot, absolutePath),
+            beforeText,
+            afterText,
+        });
+    }
+    return changes.sort((left, right) => left.file < right.file ? -1 : left.file > right.file ? 1 : 0);
 }
 function decodeSource(bytes, filePath) {
     if ((bytes[0] === 0xff && bytes[1] === 0xfe) || (bytes[0] === 0xfe && bytes[1] === 0xff)) {
@@ -164,7 +187,7 @@ async function createPlan(projectRootInput, kind, allowNewErrors, mutate, reques
         const context = createFreshProject(projectRootInput);
         const workspaceBefore = createWorkspaceSnapshot(context);
         operationContext.checkpoint();
-        const beforeDiagnostics = normalizeProjectDiagnostics(context.project, context.projectRoot, operationContext);
+        const beforeObservations = observeProjectDiagnostics(context.project, context.projectRoot, operationContext);
         const originals = new Map(context.project
             .getSourceFiles()
             .map((sourceFile) => [sourceFile.getFilePath(), sourceFile.getFullText()]));
@@ -180,37 +203,45 @@ async function createPlan(projectRootInput, kind, allowNewErrors, mutate, reques
         operationContext.checkpoint();
         const referenceCount = mutate(context.project, context.projectRoot);
         operationContext.checkpoint();
-        const afterDiagnostics = normalizeProjectDiagnostics(context.project, context.projectRoot, operationContext);
-        const diagnosticDelta = compareDiagnostics(beforeDiagnostics, afterDiagnostics, operationContext);
+        const afterObservations = observeProjectDiagnostics(context.project, context.projectRoot, operationContext);
+        const textChanges = collectPlannedTextChanges(context.project, context.projectRoot, originals, operationContext);
+        if (textChanges.length === 0) {
+            throw new Error("The structural operation produced no file changes.");
+        }
+        const comparisonWorkspace = createWorkspaceSnapshot(createFreshProject(context.tsConfigFilePath));
+        operationContext.checkpoint();
+        if (comparisonWorkspace.digest !== workspaceBefore.digest) {
+            throw new Error("Workspace changed while the operation was being prepared. Retry preparation.");
+        }
+        const diagnosticDelta = compareObservedDiagnostics(beforeObservations, afterObservations, textChanges, operationContext);
         const files = [];
-        for (const sourceFile of context.project.getSourceFiles()) {
+        for (const { absolutePath, file, beforeText, afterText } of textChanges) {
             operationContext.checkpoint();
-            const absolutePath = sourceFile.getFilePath();
-            const originalText = originals.get(absolutePath);
-            const updatedText = sourceFile.getFullText();
-            if (originalText === undefined) {
-                const file = path.relative(context.projectRoot, absolutePath);
+            if (afterText === null) {
+                throw new Error(`Structural operation deletion is unsupported: ${file}`);
+            }
+            if (beforeText === null) {
                 assertSafeNewOperationFile(context.projectRoot, absolutePath, file);
                 const originalBytes = Buffer.alloc(0);
-                const updatedBytes = Buffer.from(updatedText, "utf8");
+                const updatedBytes = Buffer.from(afterText, "utf8");
                 files.push({
                     absolutePath,
                     file,
                     originalHash: ABSENT_FILE_HASH,
                     updatedHash: hashBytes(updatedBytes),
                     originalText: "",
-                    updatedText,
+                    updatedText: afterText,
                     originalBytes,
                     updatedBytes,
-                    diff: createTwoFilesPatch("/dev/null", file, "", updatedText, "before", "after", {
+                    diff: createTwoFilesPatch("/dev/null", file, "", afterText, "before", "after", {
                         context: 3,
                     }),
                     mode: DEFAULT_NEW_FILE_MODE,
                 });
                 continue;
             }
-            if (updatedText === originalText)
-                continue;
+            const originalText = beforeText;
+            const updatedText = afterText;
             const originalBytes = await readFile(absolutePath);
             operationContext.checkpoint();
             if (decodeSource(originalBytes, absolutePath) !== originalText) {
@@ -219,7 +250,6 @@ async function createPlan(projectRootInput, kind, allowNewErrors, mutate, reques
             const updatedBytes = encodeUpdatedSource(originalBytes, updatedText);
             const fileStat = await stat(absolutePath);
             operationContext.checkpoint();
-            const file = path.relative(context.projectRoot, absolutePath);
             files.push({
                 absolutePath,
                 file,
@@ -235,10 +265,6 @@ async function createPlan(projectRootInput, kind, allowNewErrors, mutate, reques
                 mode: fileStat.mode,
             });
         }
-        files.sort((left, right) => left.file.localeCompare(right.file));
-        if (files.length === 0) {
-            throw new Error("The structural operation produced no file changes.");
-        }
         const postWorkspaceFiles = new Map(workspaceBefore.files);
         for (const file of files) {
             operationContext.checkpoint();
@@ -413,40 +439,106 @@ async function withWriteLock(key, requestContext, callback) {
             writeQueues.delete(key);
     }
 }
-async function safeUnlink(filePath) {
+function matchesPrepared(identity, sha256, mode) {
+    return identity.sha256 === sha256 && identity.mode === (mode & 0o777);
+}
+async function stageFile(file, operationId) {
+    const parentPath = path.dirname(file.absolutePath);
+    const destinationBasename = path.basename(file.absolutePath);
+    const stageBasename = `${destinationBasename}.ast-mcp-${operationId}-${randomUUID()}.tmp`;
+    const temporaryPath = path.join(parentPath, stageBasename);
+    const handles = [];
+    let directory;
+    let stage;
     try {
-        await unlink(filePath);
+        directory = await open(parentPath, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+        handles.push(directory);
+        const heldParent = await directory.stat({ bigint: true });
+        const namedParent = lstatSync(parentPath, { bigint: true });
+        if (!heldParent.isDirectory() ||
+            !namedParent.isDirectory() ||
+            heldParent.dev !== namedParent.dev ||
+            heldParent.ino !== namedParent.ino) {
+            throw new Error("Publication parent identity changed during staging.");
+        }
+        stage = await open(temporaryPath, "wx", file.mode);
+        handles.push(stage);
+        await stage.writeFile(file.updatedBytes);
+        await stage.chmod(file.mode & 0o777);
+        await stage.sync();
+        const stageIdentity = await snapshotHeldFile(stage);
+        if (!matchesPrepared(stageIdentity, file.updatedHash, file.mode)) {
+            throw new Error("Staged publication does not match the reviewed postimage.");
+        }
+        const plan = {
+            kind: isCreatedFile(file) ? "creation" : "replacement",
+            directory,
+            destinationBasename,
+            stage,
+            stageBasename,
+            stageIdentity,
+        };
+        if (!isCreatedFile(file)) {
+            const preimage = await open(`/proc/self/fd/${directory.fd}/${destinationBasename}`, constants.O_RDONLY | constants.O_NOFOLLOW);
+            handles.push(preimage);
+            const preimageIdentity = await snapshotHeldFile(preimage);
+            if (!matchesPrepared(preimageIdentity, file.originalHash, file.mode)) {
+                throw new Error(`Conflict: ${file.file} changed while publication was staged.`);
+            }
+            plan.preimage = preimage;
+            plan.preimageIdentity = preimageIdentity;
+        }
+        return {
+            plan,
+            handles,
+            parentPath,
+            parentDev: heldParent.dev,
+            parentIno: heldParent.ino,
+            cleanupIdentity: plan.stageIdentity,
+        };
     }
     catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
+        if (directory && stage) {
+            try {
+                const currentStage = await snapshotHeldFile(stage);
+                await removeOwnedPublicationEntry(directory, stageBasename, currentStage);
+            }
+            catch {
+                // Preserve the original staging error; cleanup remains best effort.
+            }
+        }
+        await Promise.allSettled(handles.map((handle) => handle.close()));
+        throw error;
     }
 }
-async function stageFile(file, operationId) {
-    const temporaryPath = `${file.absolutePath}.ast-mcp-${operationId}.tmp`;
-    await safeUnlink(temporaryPath);
-    const handle = await open(temporaryPath, "wx", file.mode);
-    try {
-        await handle.writeFile(file.updatedBytes);
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
+async function authenticateHeldParent(held) {
+    const current = lstatSync(held.parentPath, { bigint: true });
+    const opened = await held.plan.directory.stat({ bigint: true });
+    if (!current.isDirectory() ||
+        current.isSymbolicLink() ||
+        current.dev !== held.parentDev ||
+        current.ino !== held.parentIno ||
+        opened.dev !== held.parentDev ||
+        opened.ino !== held.parentIno) {
+        throw new Error("Conflict: publication parent identity changed before publication.");
     }
-    return temporaryPath;
 }
-async function restoreFile(file, operationId) {
-    const restorePath = `${file.absolutePath}.ast-mcp-${operationId}.restore`;
-    await safeUnlink(restorePath);
-    const handle = await open(restorePath, "wx", file.mode);
-    try {
-        await handle.writeFile(file.originalBytes);
-        await handle.sync();
+async function closeHeldPublication(held) {
+    await Promise.allSettled(held.handles.map((handle) => handle.close()));
+}
+async function cleanupHeldPublication(held) {
+    if (held.cleanupIdentity !== null) {
+        await removeOwnedPublicationEntry(held.plan.directory, held.plan.stageBasename, held.cleanupIdentity).catch(() => false);
     }
-    finally {
-        await handle.close();
+    await closeHeldPublication(held);
+}
+async function settleHeldPublications(held, preserveEntries = false) {
+    const publications = [...held];
+    if (preserveEntries) {
+        for (const publication of publications)
+            publication.cleanupIdentity = null;
     }
-    await rename(restorePath, file.absolutePath);
+    await Promise.all(publications.map(preserveEntries ? closeHeldPublication : cleanupHeldPublication));
 }
 async function syncDirectories(files) {
     const directories = new Set(files.map((file) => path.dirname(file.absolutePath)));
@@ -598,8 +690,25 @@ export async function applyOperation(operationId, planHash, requestContext = NO_
                             staged.set(file, await stageFile(file, operationId));
                             operationContext.checkpoint();
                         }
-                        for (const file of operation.files) {
+                        const probedParents = new Set();
+                        for (const [index, file] of operation.files.entries()) {
                             operationContext.checkpoint();
+                            try {
+                                await operationTestHooks.onFilePhase?.({
+                                    operationId,
+                                    file: file.file,
+                                    index,
+                                    phase: "capability-preflight",
+                                });
+                                const parent = path.dirname(file.absolutePath);
+                                if (!probedParents.has(parent)) {
+                                    await probePublicationCapability(parent);
+                                    probedParents.add(parent);
+                                }
+                            }
+                            catch (cause) {
+                                throw new PublicOperationalError("MUTATION_BLOCKED", "Authenticated publication capability is unavailable.", { cause });
+                            }
                             if (isCreatedFile(file)) {
                                 assertSafeNewOperationFile(operation.project_root, file.absolutePath, file.file);
                                 continue;
@@ -612,63 +721,98 @@ export async function applyOperation(operationId, planHash, requestContext = NO_
                         }
                         for (const [index, file] of operation.files.entries()) {
                             operationContext.checkpoint();
-                            await operationTestHooks.beforeReplace?.(file.file, index);
+                            await operationTestHooks.onFilePhase?.({
+                                operationId,
+                                file: file.file,
+                                index,
+                                phase: "before-publish",
+                            });
+                            const held = staged.get(file);
+                            await authenticateHeldParent(held);
                             if (!completionCritical) {
                                 operationContext.enterCompletionCritical();
                                 completionCritical = true;
                                 invalidateAfterCompletion = true;
                             }
-                            if (isCreatedFile(file)) {
-                                await link(staged.get(file), file.absolutePath);
-                                applied.push(file);
-                                await safeUnlink(staged.get(file));
-                                staged.delete(file);
+                            const publication = await publishAuthenticated(held.plan);
+                            if (publication.state === "pre_effect") {
+                                if (publication.reason === "unsupported") {
+                                    throw new PublicOperationalError("MUTATION_BLOCKED", "Authenticated publication capability is unavailable.");
+                                }
+                                throw new PublicOperationalError("CONFLICT", "Authenticated publication preserved a competing entry.");
                             }
-                            else {
-                                await rename(staged.get(file), file.absolutePath);
-                                staged.delete(file);
-                                applied.push(file);
+                            if (publication.state === "rolled_back") {
+                                held.cleanupIdentity = held.plan.stageIdentity;
+                                throw new PublicOperationalError("CONFLICT", "Authenticated publication preserved a competing entry.");
                             }
-                            await operationTestHooks.afterReplace?.(file.file, index);
+                            if (publication.state === "ambiguous") {
+                                held.cleanupIdentity = null;
+                                throw new PublicOperationalError("AMBIGUOUS_APPLY", "Authenticated publication ownership is ambiguous.");
+                            }
+                            held.committed = publication.token;
+                            held.cleanupIdentity =
+                                publication.token.kind === "replacement"
+                                    ? publication.token.displacedIdentity
+                                    : held.plan.stageIdentity;
+                            applied.push(file);
+                            await operationTestHooks.onFilePhase?.({
+                                operationId,
+                                file: file.file,
+                                index,
+                                phase: "after-commit",
+                            });
                             const writtenBytes = await readFile(file.absolutePath);
                             if (hashBytes(writtenBytes) !== file.updatedHash) {
                                 throw new Error(`Post-write verification failed for ${file.file}.`);
                             }
                         }
                         await syncDirectories(operation.files);
+                        await settleHeldPublications(staged.values());
+                        staged.clear();
                     }
                     catch (error) {
-                        const rollbackErrors = [];
+                        if (PublicOperationalError.is(error) && error.code === "AMBIGUOUS_APPLY") {
+                            await settleHeldPublications(staged.values(), true);
+                            staged.clear();
+                            throw error;
+                        }
+                        let rollbackAmbiguous = false;
                         for (const file of [...applied].reverse()) {
+                            const held = staged.get(file);
                             try {
-                                const currentBytes = await readFile(file.absolutePath);
-                                if (hashBytes(currentBytes) !== file.updatedHash) {
-                                    rollbackErrors.push(`${file.file}: current bytes no longer match this operation's postimage`);
-                                    continue;
-                                }
-                                if (isCreatedFile(file)) {
-                                    assertSafeOperationFile(operation.project_root, file.absolutePath, file.file);
-                                    await safeUnlink(file.absolutePath);
-                                }
-                                else {
-                                    await restoreFile(file, operationId);
+                                await operationTestHooks.onFilePhase?.({
+                                    operationId,
+                                    file: file.file,
+                                    index: operation.files.indexOf(file),
+                                    phase: "before-rollback",
+                                });
+                                const rollback = await rollbackOwnedCommit(held.committed);
+                                if (rollback.state !== "rolled_back") {
+                                    held.cleanupIdentity = null;
+                                    rollbackAmbiguous = true;
+                                    break;
                                 }
+                                held.cleanupIdentity = held.committed.destinationIdentity;
                             }
-                            catch (rollbackError) {
-                                rollbackErrors.push(`${file.file}: ${rollbackError instanceof Error
-                                    ? rollbackError.message
-                                    : String(rollbackError)}`);
+                            catch {
+                                held.cleanupIdentity = null;
+                                rollbackAmbiguous = true;
+                                break;
                             }
                         }
-                        for (const temporaryPath of staged.values())
-                            await safeUnlink(temporaryPath);
-                        if (applied.length > 0 && rollbackErrors.length === 0) {
+                        if (rollbackAmbiguous) {
+                            await settleHeldPublications(staged.values(), true);
+                            staged.clear();
+                            throw new PublicOperationalError("AMBIGUOUS_APPLY", "Authenticated rollback ownership is ambiguous.", { cause: error });
+                        }
+                        await settleHeldPublications(staged.values());
+                        staged.clear();
+                        if (applied.length > 0) {
                             await syncDirectories(applied);
+                            if (PublicOperationalError.is(error))
+                                throw error;
                             throw new Error(`Operation failed after replacing ${applied.length} file(s); rollback succeeded and original bytes were restored. Original error: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
                         }
-                        if (rollbackErrors.length > 0) {
-                            throw new Error(`Operation failed and rollback was incomplete: ${rollbackErrors.join("; ")}. Original error: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-                        }
                         throw error;
                     }
                     operation.status = "applied";
@@ -756,7 +900,7 @@ export function exportOperationRecord(operationId) {
         })),
     };
 }
-export function importOperationRecord(persisted, expectedPlanHash) {
+export function importOperationRecord(persisted, expectedPlanHash, planVersion = 2) {
     if (persisted.plan_hash !== expectedPlanHash) {
         throw new Error(`Plan hash mismatch for operation "${persisted.operation_id}". No files were written.`);
     }
@@ -838,7 +982,7 @@ export function importOperationRecord(persisted, expectedPlanHash) {
         tsConfigFilePath: context.tsConfigFilePath,
         files,
     };
-    if (planHashFor(record) !== expectedPlanHash) {
+    if (planHashFor(record, planVersion) !== expectedPlanHash) {
         throw new Error(`Persisted plan integrity mismatch for operation "${persisted.operation_id}". No files were written.`);
     }
     const existing = operations.get(record.operation_id);