@coderule/mcp 2.0.2 → 2.1.0

package/dist/index.js

@@ -524,7 +524,10 @@ var FilesRepo = class {
       `UPDATE files
      SET content_sha256 = ?, service_file_hash = ?, hash_state = 'clean',
          hash_owner = NULL, hash_lease_expires_at = NULL, hash_started_at = NULL
-     WHERE id = ?`
+     WHERE id = ?
+       AND hash_state = 'hashing'
+       AND hash_owner = ?
+       AND hash_started_at = ?`
     );
     this.requeueExpiredHashingStmt = this.db.prepare(
       `UPDATE files
@@ -655,13 +658,30 @@ var FilesRepo = class {
     tx(ids);
   }
   applyHashResults(results) {
-    if (!results.length) return;
+    if (!results.length) return 0;
+    let applied = 0;
     const tx = this.db.transaction((batch) => {
-      for (const { id, contentSha256, serviceFileHash } of batch) {
-        this.applyHashesStmt.run(contentSha256, serviceFileHash, id);
+      for (const {
+        id,
+        contentSha256,
+        serviceFileHash,
+        hashOwner,
+        hashStartedAt
+      } of batch) {
+        const result = this.applyHashesStmt.run(
+          contentSha256,
+          serviceFileHash,
+          id,
+          hashOwner,
+          hashStartedAt
+        );
+        if ((result.changes ?? 0) > 0) {
+          applied += 1;
+        }
       }
     });
     tx(results);
+    return applied;
   }
   getCleanFilesForSnapshot() {
     return this.selectCleanSnapshotStmt.all();
@@ -711,7 +731,7 @@ var Outbox = class {
     this.log = logger2.child({ scope: "outbox" });
     this.queue = new Qulite(db, {
       logger: this.log,
-      defaultLeaseMs: 3e4,
+      defaultLeaseMs: 6e5,
       defaultMaxAttempts: 10
     });
     this.markKindStmt = db.prepare(
@@ -769,7 +789,7 @@ var Outbox = class {
       this.log.debug({ rootId }, "Enqueued heartbeat job");
     }
   }
-  claimFsControlJob(leaseOwner, leaseMs = 3e4) {
+  claimFsControlJob(leaseOwner, leaseMs = 6e5) {
     return this.queue.claimNext({ type: "fs_control", leaseOwner, leaseMs });
   }
   ack(jobId, leaseOwner) {
@@ -1085,7 +1105,9 @@ var Hasher = class {
         successes.push({
           id: record.id,
           contentSha256: result.contentSha256,
-          serviceFileHash: result.serviceFileHash
+          serviceFileHash: result.serviceFileHash,
+          hashOwner: record.hash_owner ?? this.ownerId,
+          hashStartedAt: record.hash_started_at ?? 0
         });
       } catch (error) {
         if (error?.code === "ENOENT") {
@@ -1244,6 +1266,42 @@ async function runInventory(opts) {
 async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+var SnapshotStaleError = class extends Error {
+  constructor(message = "snapshot became stale") {
+    super(message);
+    this.name = "SnapshotStaleError";
+  }
+};
+function assertNotStale(opts) {
+  if (opts?.isStale?.()) {
+    throw new SnapshotStaleError();
+  }
+}
+function assertBeforeDeadline(opts) {
+  if (opts?.deadlineMs !== void 0 && Date.now() >= opts.deadlineMs) {
+    throw new Error("snapshot publish deadline exceeded");
+  }
+}
+function assertValid(opts) {
+  assertNotStale(opts);
+  assertBeforeDeadline(opts);
+}
+function withDeadline(promise, opts) {
+  if (opts?.deadlineMs === void 0) return promise;
+  const remaining = opts.deadlineMs - Date.now();
+  if (remaining <= 0) {
+    return Promise.reject(new Error("snapshot publish deadline exceeded"));
+  }
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(
+        () => reject(new Error("snapshot publish deadline exceeded")),
+        remaining
+      )
+    )
+  ]);
+}
 function computeSnapshot(filesRepo) {
   const files = filesRepo.getCleanFilesForSnapshot();
   const hashes = files.map((file) => file.service_file_hash).filter((hash) => typeof hash === "string");
@@ -1259,12 +1317,17 @@ function computeSnapshot(filesRepo) {
     totalSize
   };
 }
-async function withRetries(op, logger2, context, maxAttempts) {
+async function withRetries(op, logger2, context, maxAttempts, opts) {
   let attempt = 0;
   while (true) {
+    assertValid(opts);
     try {
-      return await op();
+      return await withDeadline(op(), opts);
     } catch (err) {
+      if (err instanceof SnapshotStaleError) throw err;
+      if (typeof err?.message === "string" && err.message.includes("deadline exceeded")) {
+        throw err;
+      }
       attempt += 1;
       if (attempt >= maxAttempts) {
         logger2.error(
@@ -1282,7 +1345,14 @@ async function withRetries(op, logger2, context, maxAttempts) {
     }
   }
 }
-async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts, chunkSize = 1) {
+function computeServiceFileHash(relPath, content) {
+  const hash = createHash("sha256");
+  hash.update(relPath);
+  hash.update("\n");
+  hash.update(content);
+  return hash.digest("hex");
+}
+async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts, chunkSize = 1, opts) {
   if (!missing || missing.length === 0) return;
   const total = missing.length;
   const chunks = [];
@@ -1290,17 +1360,36 @@ async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts
     chunks.push(missing.slice(i, i + chunkSize));
   }
   for (let idx = 0; idx < chunks.length; idx++) {
+    assertValid(opts);
     const list = chunks[idx];
     const map = /* @__PURE__ */ new Map();
     for (const missingFile of list) {
       const absPath = path2.join(rootPath, missingFile.file_path);
       try {
         const buffer = await fs5.readFile(absPath);
+        const serviceHash = computeServiceFileHash(
+          missingFile.file_path,
+          buffer
+        );
+        if (serviceHash !== missingFile.file_hash) {
+          logger2.warn(
+            {
+              relPath: missingFile.file_path,
+              expected: missingFile.file_hash,
+              got: serviceHash
+            },
+            "File content changed during upload; snapshot is stale"
+          );
+          throw new SnapshotStaleError(
+            `file hash mismatch for ${missingFile.file_path}`
+          );
+        }
         map.set(missingFile.file_hash, {
           path: missingFile.file_path,
           content: buffer
         });
       } catch (error) {
+        if (error instanceof SnapshotStaleError) throw error;
         logger2.warn(
           { err: error, relPath: missingFile.file_path },
           "Failed to read missing file content"
@@ -1308,6 +1397,7 @@ async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts
       }
     }
     if (map.size === 0) continue;
+    assertValid(opts);
     await withRetries(
       () => syncClient.uploadFileContent(map),
       logger2,
@@ -1317,65 +1407,76 @@ async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts
         chunks: chunks.length,
         files: map.size
       },
-      maxAttempts
+      maxAttempts,
+      opts
     );
   }
 }
-async function ensureSnapshotCreated(rootPath, computation, syncClient, logger2, options) {
+async function ensureSnapshotCreated(rootPath, computation, syncClient, logger2, opts) {
   const { snapshotHash, files } = computation;
-  const maxAttempts = options?.maxAttempts ?? 5;
-  const uploadChunkSize = options?.uploadChunkSize ?? 1;
+  const maxAttempts = opts?.maxAttempts ?? 5;
+  const uploadChunkSize = opts?.uploadChunkSize ?? 1;
+  assertValid(opts);
   let status = await withRetries(
     () => syncClient.checkSnapshotStatus(snapshotHash),
     logger2,
     { op: "checkSnapshotStatus", snapshotHash },
-    maxAttempts
+    maxAttempts,
+    opts
   );
   if (status.status === "READY") {
     logger2.info({ snapshotHash }, "Snapshot already READY");
     return;
   }
-  if (status.status === "NOT_FOUND" || status.status === "MISSING_CONTENT") {
-    status = await withRetries(
-      () => syncClient.createSnapshot(snapshotHash, files),
-      logger2,
-      { op: "createSnapshot", snapshotHash },
-      maxAttempts
-    );
-  }
-  if (status.status === "MISSING_CONTENT" && status.missing_files?.length) {
-    logger2.info(
-      { missing: status.missing_files.length },
-      "Uploading missing file content"
-    );
-    await uploadMissing(
-      rootPath,
-      status.missing_files,
-      syncClient,
-      logger2,
-      maxAttempts,
-      uploadChunkSize
-    );
-    status = await withRetries(
-      () => syncClient.createSnapshot(snapshotHash, files),
-      logger2,
-      { op: "createSnapshot", snapshotHash },
-      maxAttempts
-    );
-  }
   let attempt = 0;
   while (status.status !== "READY") {
+    assertValid(opts);
     if (status.status === "FAILED") {
       throw new Error(`Snapshot failed processing: ${JSON.stringify(status)}`);
     }
+    if (status.status === "NOT_FOUND" || status.status === "MISSING_CONTENT") {
+      status = await withRetries(
+        () => syncClient.createSnapshot(snapshotHash, files),
+        logger2,
+        { op: "createSnapshot", snapshotHash },
+        maxAttempts,
+        opts
+      );
+    }
+    if (status.status === "MISSING_CONTENT" && status.missing_files?.length) {
+      logger2.info(
+        { missing: status.missing_files.length },
+        "Uploading missing file content"
+      );
+      await uploadMissing(
+        rootPath,
+        status.missing_files,
+        syncClient,
+        logger2,
+        maxAttempts,
+        uploadChunkSize,
+        opts
+      );
+      status = await withRetries(
+        () => syncClient.createSnapshot(snapshotHash, files),
+        logger2,
+        { op: "createSnapshot", snapshotHash },
+        maxAttempts,
+        opts
+      );
+      continue;
+    }
+    if (status.status === "READY") break;
     const delay = Math.min(5e3, 1e3 * Math.max(1, 2 ** attempt));
     await sleep(delay);
     attempt += 1;
+    assertValid(opts);
     status = await withRetries(
       () => syncClient.checkSnapshotStatus(snapshotHash),
       logger2,
       { op: "checkSnapshotStatus", snapshotHash },
-      maxAttempts
+      maxAttempts,
+      opts
     );
   }
   logger2.info({ snapshotHash }, "Snapshot READY");
@@ -1542,12 +1643,14 @@ async function sendHeartbeat(rootId, snapshotsRepo, syncClient, logger2) {
 // src/service/State.ts
 var ServiceState = class {
   constructor() {
+    this.changeSeq = 0;
     this.lastChangeAt = Date.now();
     this.lastSnapshotReadyAt = Date.now();
     this.lastHeartbeatEnqueuedAt = 0;
   }
   updateChange(timestamp = Date.now()) {
     this.lastChangeAt = timestamp;
+    this.changeSeq += 1;
   }
   updateSnapshotReady(timestamp = Date.now()) {
     this.lastSnapshotReadyAt = timestamp;
@@ -1573,6 +1676,7 @@ function computeBackoff(attempts) {
   const delay = 1e3 * 2 ** base;
   return Math.min(delay, 6e4);
 }
+var PUBLISH_MAX_MS = 5 * 6e4;
 async function readSymlinkTarget2(absPath) {
   try {
     return await fs5.readlink(absPath);
@@ -1851,9 +1955,10 @@ var ServiceRunner = class {
     if (this.runtime.filesRepo.countByState("dirty") > 0 || this.runtime.filesRepo.countByState("hashing") > 0) {
       const delay = computeBackoff(job.attempts);
       this.runtime.outbox.retry(job.id, this.fsControlLeaseOwner, delay);
-      await sleep2(200);
       return;
     }
+    const publishSeq = this.state.changeSeq;
+    const isStale = () => this.state.changeSeq !== publishSeq || this.runtime.filesRepo.countByState("dirty") > 0 || this.runtime.filesRepo.countByState("hashing") > 0;
     try {
       const result = await publishSnapshot(
         this.runtime.config.rootPath,
@@ -1863,17 +1968,40 @@ var ServiceRunner = class {
         log,
         {
           maxAttempts: this.runtime.config.maxSnapshotAttempts,
-          uploadChunkSize: this.runtime.config.uploadChunkSize
+          uploadChunkSize: this.runtime.config.uploadChunkSize,
+          deadlineMs: Date.now() + PUBLISH_MAX_MS,
+          isStale
         }
       );
-      this.runtime.outbox.ack(job.id, this.fsControlLeaseOwner);
+      const acked = this.runtime.outbox.ack(job.id, this.fsControlLeaseOwner);
+      if (!acked) {
+        log.warn(
+          { jobId: job.id },
+          "Snapshot job ack failed (lease may have expired)"
+        );
+      }
       this.state.updateSnapshotReady(result.createdAt);
       log.info({ snapshotHash: result.snapshotHash }, "Snapshot job completed");
+      if (this.runtime.filesRepo.countByState("dirty") > 0 || this.runtime.filesRepo.countByState("hashing") > 0) {
+        this.runtime.outbox.enqueueSnapshot(this.runtime.config.rootId, 0);
+        return;
+      }
+      const nowHash = computeSnapshot(this.runtime.filesRepo).snapshotHash;
+      if (nowHash !== result.snapshotHash) {
+        this.runtime.outbox.enqueueSnapshot(this.runtime.config.rootId, 0);
+      }
     } catch (error) {
+      if (error instanceof SnapshotStaleError) {
+        log.debug(
+          { err: error },
+          "Snapshot publish aborted (stale); quick retry"
+        );
+        this.runtime.outbox.retry(job.id, this.fsControlLeaseOwner, 250);
+        return;
+      }
       log.warn({ err: error }, "Snapshot job failed");
       const delay = computeBackoff(job.attempts);
       this.runtime.outbox.retry(job.id, this.fsControlLeaseOwner, delay);
-      await sleep2(delay);
     }
   }
   async handleHeartbeatJob(job, log) {