@gmickel/gno 1.31.0 → 1.33.0

package/src/serve/routes/api.ts

@@ -71,16 +71,14 @@ import {
   atomicWrite,
   copyFilePath,
   createFolderPath,
-  renameFilePath,
   revealFilePath,
   trashFilePath,
 } from "../../core/file-ops";
 import {
+  assertFileRefactorSyncConverged,
   buildRefactorWarnings,
   planCreateFolder,
   planDuplicateRefactor,
-  planMoveRefactor,
-  planRenameRefactor,
 } from "../../core/file-refactors";
 import {
   hasContentMutation,
@@ -166,6 +164,17 @@ import {
   resetDownloadState,
   type ServerContext,
 } from "../context";
+import {
+  applyCanonicalFileRefactor,
+  buildCanonicalRefactorPlan,
+  buildFileRefactorApplyDeps,
+  mapApplyResultToHttpSuccess,
+  parseRefactorApplyConfirmation,
+  resolveMoveTarget,
+  resolveRenameTarget,
+  toRefactorPlanResponse,
+  type FileRefactorHttpError,
+} from "../file-refactor-http";
 import { analyzeImportPath } from "../import-preview";
 import { getActiveJob, getJobStatus, startJob } from "../jobs";
 import {
@@ -465,12 +474,22 @@ export interface CreateCaptureRequestBody extends PublicCaptureInput {}
 export interface RenameDocRequestBody {
   name: string;
   uri?: string;
+  /** Exact plan digest from preview. */
+  planDigest: string;
+  /** Exact destructive confirmation token. */
+  confirmation: string;
+  schemaVersion: string;
 }
 
 export interface MoveDocRequestBody {
   folderPath: string;
   name?: string;
   uri?: string;
+  /** Exact plan digest from preview. */
+  planDigest: string;
+  /** Exact destructive confirmation token. */
+  confirmation: string;
+  schemaVersion: string;
 }
 
 export interface DuplicateDocRequestBody {
@@ -546,6 +565,10 @@ function errorResponse(
   );
 }
 
+function fileRefactorHttpErrorResponse(error: FileRefactorHttpError): Response {
+  return errorResponse(error.code, error.message, error.status, error.details);
+}
+
 interface RestTraceStart {
   session: RetrievalTraceSession | null;
   error: Response | null;
@@ -1257,7 +1280,7 @@ export async function handlePublishExport(
   }
 
   try {
-    const { artifact, warnings } = await exportPublishArtifact({
+    const { artifact, assetSummary, warnings } = await exportPublishArtifact({
       collections: config.collections,
       options: {
         encryptionPassphrase: body.encryptionPassphrase,
@@ -1272,6 +1295,7 @@ export async function handlePublishExport(
 
     return jsonResponse({
       artifact,
+      assetSummary,
       fileName: derivePublishArtifactFilename(artifact),
       uploadUrl: "https://gno.sh/studio",
       warnings,
@@ -2388,7 +2412,6 @@ export async function handleRenameDoc(
   docId: string,
   req: Request,
   deps?: {
-    renameFilePath?: typeof renameFilePath;
     syncCollection?: typeof defaultSyncService.syncCollection;
   }
 ): Promise<Response> {
@@ -2409,6 +2432,11 @@ export async function handleRenameDoc(
     return errorResponse("VALIDATION", "uri must be a string");
   }
 
+  const confirmation = parseRefactorApplyConfirmation(body);
+  if ("code" in confirmation) {
+    return fileRefactorHttpErrorResponse(confirmation);
+  }
+
   const docResult = await resolveDocumentReference(store, docId, body.uri);
   if (!docResult.ok) {
     return errorResponse("RUNTIME", docResult.error.message, 500);
@@ -2444,71 +2472,85 @@ export async function handleRenameDoc(
     return errorResponse("FILE_NOT_FOUND", "Source file no longer exists", 404);
   }
 
-  const nodePath = await import("node:path"); // no bun equivalent
-  const directory = nodePath.dirname(doc.relPath);
-  const currentExt = nodePath.extname(doc.relPath);
-  const targetName = nodePath.extname(body.name)
-    ? body.name
-    : `${body.name}${currentExt}`;
-  const nextRelPath =
-    directory === "." ? targetName : `${directory}/${targetName}`;
-  const nextFullPath = nodePath.join(collection.path, nextRelPath);
-
-  if (nextFullPath === fullPath) {
-    return errorResponse("VALIDATION", "New name matches current file");
-  }
-  if (await Bun.file(nextFullPath).exists()) {
+  let target;
+  try {
+    target = resolveRenameTarget({
+      collection: collection.name,
+      currentRelPath: doc.relPath,
+      nextName: body.name,
+    });
+  } catch (error) {
     return errorResponse(
-      "CONFLICT",
-      "A file with that name already exists",
-      409
+      "VALIDATION",
+      error instanceof Error ? error.message : "Invalid rename target"
     );
   }
 
+  if (target.nextRelPath === doc.relPath) {
+    return errorResponse("VALIDATION", "New name matches current file");
+  }
+
+  const nodePath = await import("node:path"); // no bun equivalent
+  const nextFullPath = nodePath.join(collection.path, target.nextRelPath);
+
   try {
+    const plan = await buildCanonicalRefactorPlan({
+      operation: "rename",
+      doc,
+      collection,
+      sourceFullPath: fullPath,
+      target,
+      store,
+      sourceEditable: capabilities.editable,
+    });
+
     const syncCollection =
       deps?.syncCollection ??
       ((collectionArg, storeArg, optionsArg) =>
         defaultSyncService.syncCollection(collectionArg, storeArg, optionsArg));
+
     ctxHolder.watchService?.suppress(fullPath);
     ctxHolder.watchService?.suppress(nextFullPath);
-    await (deps?.renameFilePath ?? renameFilePath)(fullPath, nextFullPath);
-    const nextUri = `gno://${collection.name}/${nextRelPath}`;
-    let warning: string | undefined;
-    try {
-      await syncResidentCollection(
-        ctxHolder,
+
+    const applyResult = await applyCanonicalFileRefactor({
+      plan,
+      confirmation,
+      deps: buildFileRefactorApplyDeps({
         collection,
         store,
-        withContentTypeRules({ runUpdateCmd: false }, ctxHolder.config),
-        syncCollection
-      );
-    } catch {
-      warning =
-        "File renamed on disk, but index refresh failed. Run Update All to reconcile the workspace.";
+        syncAfterCommit: async () => {
+          const syncResult = await syncResidentCollection(
+            ctxHolder,
+            collection,
+            store,
+            withContentTypeRules({ runUpdateCmd: false }, ctxHolder.config),
+            syncCollection
+          );
+          assertFileRefactorSyncConverged(syncResult);
+        },
+      }),
+      signal: req.signal,
+    });
+
+    const mapped = mapApplyResultToHttpSuccess({
+      plan,
+      result: applyResult,
+      targetFullPath: nextFullPath,
+      operationLabel: "renamed",
+    });
+    if ("code" in mapped) {
+      return fileRefactorHttpErrorResponse(mapped);
     }
+
     ctxHolder.eventBus?.emit({
       type: "document-changed",
-      uri: nextUri,
+      uri: mapped.uri,
       collection: collection.name,
-      relPath: nextRelPath,
+      relPath: mapped.relPath,
       origin: "save",
       changedAt: new Date().toISOString(),
     });
-    const refactorWarnings = buildRefactorWarnings(
-      await getRefactorSnapshot(store, doc.id),
-      {
-        filenameChanged: true,
-      }
-    );
-    return jsonResponse({
-      success: true,
-      uri: nextUri,
-      path: nextFullPath,
-      relPath: nextRelPath,
-      refactorWarnings,
-      warning,
-    });
+    return jsonResponse(mapped);
   } catch (error) {
     return errorResponse(
       "RUNTIME",
@@ -2550,7 +2592,6 @@ export async function handleRefactorPlan(
     );
   }
 
-  const snapshot = await getRefactorSnapshot(store, doc.id);
   const collection = getCollectionByName(
     ctxHolder.config.collections,
     doc.collection
@@ -2568,41 +2609,69 @@ export async function handleRefactorPlan(
       if (!body.name?.trim()) {
         return errorResponse("VALIDATION", "Missing or invalid name");
       }
-      const plan = planRenameRefactor({
+      const resolvedDocPath = await resolveAbsoluteDocPath(
+        ctxHolder.config.collections,
+        doc
+      );
+      if (!resolvedDocPath) {
+        return errorResponse(
+          "NOT_FOUND",
+          `Collection not found: ${doc.collection}`,
+          404
+        );
+      }
+      const target = resolveRenameTarget({
         collection: collection.name,
         currentRelPath: doc.relPath,
         nextName: body.name.trim(),
       });
-      return jsonResponse({
-        operation: body.operation,
-        ...plan,
-        refactorWarnings: buildRefactorWarnings(snapshot, {
-          filenameChanged: true,
-        }),
+      const plan = await buildCanonicalRefactorPlan({
+        operation: "rename",
+        doc,
+        collection,
+        sourceFullPath: resolvedDocPath.fullPath,
+        target,
+        store,
+        sourceEditable: capabilities.editable,
       });
+      return jsonResponse(toRefactorPlanResponse(plan));
     }
 
     if (body.operation === "move") {
       if (!body.folderPath?.trim()) {
         return errorResponse("VALIDATION", "Missing or invalid folderPath");
       }
-      const plan = planMoveRefactor({
+      const resolvedDocPath = await resolveAbsoluteDocPath(
+        ctxHolder.config.collections,
+        doc
+      );
+      if (!resolvedDocPath) {
+        return errorResponse(
+          "NOT_FOUND",
+          `Collection not found: ${doc.collection}`,
+          404
+        );
+      }
+      const target = resolveMoveTarget({
         collection: collection.name,
         currentRelPath: doc.relPath,
         folderPath: body.folderPath.trim(),
         nextName: body.name?.trim(),
       });
-      return jsonResponse({
-        operation: body.operation,
-        ...plan,
-        refactorWarnings: buildRefactorWarnings(snapshot, {
-          folderChanged: true,
-          filenameChanged: Boolean(body.name?.trim()),
-        }),
+      const plan = await buildCanonicalRefactorPlan({
+        operation: "move",
+        doc,
+        collection,
+        sourceFullPath: resolvedDocPath.fullPath,
+        target,
+        store,
+        sourceEditable: capabilities.editable,
       });
+      return jsonResponse(toRefactorPlanResponse(plan));
     }
 
     if (body.operation === "duplicate") {
+      const snapshot = await getRefactorSnapshot(store, doc.id);
       const plan = planDuplicateRefactor({
         collection: collection.name,
         currentRelPath: doc.relPath,
@@ -2731,7 +2800,10 @@ export async function handleMoveDoc(
   ctxHolder: ContextHolder,
   store: SqliteAdapter,
   docId: string,
-  req: Request
+  req: Request,
+  deps?: {
+    syncCollection?: typeof defaultSyncService.syncCollection;
+  }
 ): Promise<Response> {
   let body: MoveDocRequestBody;
   try {
@@ -2750,6 +2822,11 @@ export async function handleMoveDoc(
     return errorResponse("VALIDATION", "uri must be a string");
   }
 
+  const confirmation = parseRefactorApplyConfirmation(body);
+  if ("code" in confirmation) {
+    return fileRefactorHttpErrorResponse(confirmation);
+  }
+
   const docResult = await resolveDocumentReference(store, docId, body.uri);
   if (!docResult.ok) {
     return errorResponse("RUNTIME", docResult.error.message, 500);
@@ -2780,9 +2857,9 @@ export async function handleMoveDoc(
   }
   const { collection, fullPath } = resolvedDocPath;
 
-  let plan;
+  let target;
   try {
-    plan = planMoveRefactor({
+    target = resolveMoveTarget({
       collection: collection.name,
       currentRelPath: doc.relPath,
       folderPath: body.folderPath,
@@ -2796,55 +2873,66 @@ export async function handleMoveDoc(
   }
 
   const nodePath = await import("node:path"); // no bun equivalent
-  const nextFullPath = nodePath.join(collection.path, plan.nextRelPath);
-  if (await Bun.file(nextFullPath).exists()) {
-    return errorResponse(
-      "CONFLICT",
-      "A file with that name already exists at the destination",
-      409
-    );
-  }
+  const nextFullPath = nodePath.join(collection.path, target.nextRelPath);
 
   try {
+    const plan = await buildCanonicalRefactorPlan({
+      operation: "move",
+      doc,
+      collection,
+      sourceFullPath: fullPath,
+      target,
+      store,
+      sourceEditable: capabilities.editable,
+    });
+
+    const syncCollection =
+      deps?.syncCollection ??
+      ((collectionArg, storeArg, optionsArg) =>
+        defaultSyncService.syncCollection(collectionArg, storeArg, optionsArg));
+
     ctxHolder.watchService?.suppress(fullPath);
     ctxHolder.watchService?.suppress(nextFullPath);
-    const { mkdir } = await import("node:fs/promises"); // structure ops need fs
-    await mkdir(nodePath.dirname(nextFullPath), { recursive: true });
-    await renameFilePath(fullPath, nextFullPath);
-    let warning: string | undefined;
-    try {
-      await syncResidentCollection(
-        ctxHolder,
+
+    const applyResult = await applyCanonicalFileRefactor({
+      plan,
+      confirmation,
+      deps: buildFileRefactorApplyDeps({
         collection,
         store,
-        withContentTypeRules({ runUpdateCmd: false }, ctxHolder.config)
-      );
-    } catch {
-      warning =
-        "File moved on disk, but index refresh failed. Run Update All to reconcile the workspace.";
+        syncAfterCommit: async () => {
+          const syncResult = await syncResidentCollection(
+            ctxHolder,
+            collection,
+            store,
+            withContentTypeRules({ runUpdateCmd: false }, ctxHolder.config),
+            syncCollection
+          );
+          assertFileRefactorSyncConverged(syncResult);
+        },
+      }),
+      signal: req.signal,
+    });
+
+    const mapped = mapApplyResultToHttpSuccess({
+      plan,
+      result: applyResult,
+      targetFullPath: nextFullPath,
+      operationLabel: "moved",
+    });
+    if ("code" in mapped) {
+      return fileRefactorHttpErrorResponse(mapped);
     }
+
     ctxHolder.eventBus?.emit({
       type: "document-changed",
-      uri: plan.nextUri,
+      uri: mapped.uri,
       collection: collection.name,
-      relPath: plan.nextRelPath,
+      relPath: mapped.relPath,
       origin: "save",
       changedAt: new Date().toISOString(),
     });
-    return jsonResponse({
-      success: true,
-      uri: plan.nextUri,
-      path: nextFullPath,
-      relPath: plan.nextRelPath,
-      refactorWarnings: buildRefactorWarnings(
-        await getRefactorSnapshot(store, doc.id),
-        {
-          folderChanged: true,
-          filenameChanged: Boolean(body.name?.trim()),
-        }
-      ),
-      warning,
-    });
+    return jsonResponse(mapped);
   } catch (error) {
     return errorResponse(
       "RUNTIME",

package/src/store/migrations/026-file-refactor-recovery-journal.ts

@@ -0,0 +1,72 @@
+/**
+ * Migration: bounded, metadata-only file-refactor recovery journal.
+ *
+ * Stores IDs, plan digests, collection/relpaths, phase/state, timestamps,
+ * and fingerprints/status only. Never stores note bodies or replacements.
+ * Create prunes oldest terminal receipts under FILE_REFACTOR_JOURNAL_MAX_RECEIPTS.
+ *
+ * @module src/store/migrations/026-file-refactor-recovery-journal
+ */
+
+import type { Database } from "bun:sqlite";
+
+import type { Migration } from "./runner";
+
+export const migration: Migration = {
+  version: 26,
+  name: "file_refactor_recovery_journal",
+
+  up(db: Database): void {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS file_refactor_recovery_journal (
+        journal_id TEXT PRIMARY KEY,
+        plan_digest TEXT NOT NULL,
+        collection TEXT NOT NULL,
+        operation TEXT NOT NULL
+          CHECK (operation IN ('rename', 'move')),
+        source_rel_path TEXT NOT NULL,
+        target_rel_path TEXT NOT NULL,
+        phase TEXT NOT NULL
+          CHECK (phase IN (
+            'prepared', 'staging', 'committing', 'committed', 'sync_pending',
+            'converged', 'rolling_back', 'rolled_back', 'recovery_required',
+            'aborted'
+          )),
+        phase_ordinal INTEGER NOT NULL CHECK (phase_ordinal >= 0),
+        filesystem_state TEXT NOT NULL
+          CHECK (filesystem_state IN (
+            'unchanged', 'committed', 'rolled_back', 'recovery_required'
+          )),
+        index_state TEXT NOT NULL
+          CHECK (index_state IN (
+            'not_attempted', 'pending', 'converged', 'skipped'
+          )),
+        file_entries_json TEXT NOT NULL
+          CHECK (length(CAST(file_entries_json AS BLOB)) <= 65536),
+        created_at_ms INTEGER NOT NULL CHECK (created_at_ms >= 0),
+        updated_at_ms INTEGER NOT NULL CHECK (updated_at_ms >= 0),
+        CHECK (length(CAST(journal_id AS BLOB)) BETWEEN 1 AND 128),
+        CHECK (
+          length(plan_digest) = 64
+          AND plan_digest NOT GLOB '*[^0-9a-f]*'
+        ),
+        CHECK (length(CAST(collection AS BLOB)) BETWEEN 1 AND 256),
+        CHECK (length(CAST(source_rel_path AS BLOB)) BETWEEN 1 AND 4096),
+        CHECK (length(CAST(target_rel_path AS BLOB)) BETWEEN 1 AND 4096),
+        CHECK (updated_at_ms >= created_at_ms)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_file_refactor_journal_plan_digest
+        ON file_refactor_recovery_journal(plan_digest, updated_at_ms DESC, journal_id DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_file_refactor_journal_collection
+        ON file_refactor_recovery_journal(collection, updated_at_ms DESC);
+    `);
+  },
+
+  down(db: Database): void {
+    db.exec("DROP INDEX IF EXISTS idx_file_refactor_journal_collection");
+    db.exec("DROP INDEX IF EXISTS idx_file_refactor_journal_plan_digest");
+    db.exec("DROP TABLE IF EXISTS file_refactor_recovery_journal");
+  },
+};

package/src/store/migrations/index.ts

@@ -39,6 +39,7 @@ import { migration as m022 } from "./022-record-export-lineage";
 import { migration as m023 } from "./023-collection-egress-policy";
 import { migration as m024 } from "./024-egress-derived-lineage";
 import { migration as m025 } from "./025-collection-egress-policy-revision";
+import { migration as m026 } from "./026-file-refactor-recovery-journal";
 
 /** All migrations in order */
 export const migrations = [
@@ -67,4 +68,5 @@ export const migrations = [
   m023,
   m024,
   m025,
+  m026,
 ];