repowisestage 0.0.77 → 0.0.79

package/dist/bin/repowise.js

@@ -2382,7 +2382,9 @@ var init_service_installer = __esm({
 var sidecar_cache_exports = {};
 __export(sidecar_cache_exports, {
   loadMergedSidecar: () => loadMergedSidecar,
+  loadSidecarEtag: () => loadSidecarEtag,
   persistMergedSidecar: () => persistMergedSidecar,
+  persistSidecarEtag: () => persistSidecarEtag,
   sidecarCachePaths: () => sidecarCachePaths
 });
 import { mkdir as mkdir9, readFile as readFile9, readdir as readdir3, stat as stat2, unlink as unlink9, writeFile as writeFile10 } from "fs/promises";
@@ -2409,8 +2411,8 @@ async function persistMergedSidecar(repoId, commitSha, sidecar) {
   await mkdir9(repoDir, { recursive: true });
   const tmpPath = `${fullPath}.tmp`;
   await writeFile10(tmpPath, JSON.stringify(sidecar), "utf-8");
-  const { rename: rename8 } = await import("fs/promises");
-  await rename8(tmpPath, fullPath);
+  const { rename: rename9 } = await import("fs/promises");
+  await rename9(tmpPath, fullPath);
   try {
     await sweepSidecarDir(repoDir);
   } catch {
@@ -2438,9 +2440,32 @@ async function sweepSidecarDir(repoDir) {
         await unlink9(join21(repoDir, name));
       } catch {
       }
+      try {
+        await unlink9(join21(repoDir, `${name}.etag`));
+      } catch {
+      }
     }
   }
 }
+async function persistSidecarEtag(repoId, commitSha, etag) {
+  const { fullPath, repoDir } = sidecarCachePaths(repoId, commitSha);
+  await mkdir9(repoDir, { recursive: true });
+  const etagPath = `${fullPath}.etag`;
+  const tmpPath = `${etagPath}.tmp`;
+  await writeFile10(tmpPath, etag, "utf-8");
+  const { rename: rename9 } = await import("fs/promises");
+  await rename9(tmpPath, etagPath);
+}
+async function loadSidecarEtag(repoId, commitSha) {
+  try {
+    const { fullPath } = sidecarCachePaths(repoId, commitSha);
+    const body = await readFile9(`${fullPath}.etag`, "utf-8");
+    const trimmed = body.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
 function isValidSidecarEntry(e) {
   if (!e || typeof e !== "object")
     return false;
@@ -2576,22 +2601,28 @@ async function uploadSidecarLegacy(req, body, fetchImpl) {
 }
 async function downloadMergedSidecar(req, fetchImpl = fetch) {
   const url = `${req.apiUrl.replace(/\/$/, "")}/v1/repos/${encodeURIComponent(req.repoId)}/typed-resolution/${encodeURIComponent(req.commitSha)}`;
-  const res = await fetchImpl(url, {
-    method: "GET",
-    headers: { authorization: `Bearer ${req.authToken}` }
-  });
+  const headers = { authorization: `Bearer ${req.authToken}` };
+  if (req.ifNoneMatch)
+    headers["if-none-match"] = req.ifNoneMatch;
+  const res = await fetchImpl(url, { method: "GET", headers });
+  if (res.status === 304)
+    return { status: "not-modified" };
   if (res.status === 404)
-    return null;
+    return { status: "absent" };
   if (!res.ok) {
     throw new Error(`download failed: HTTP ${res.status.toString()}`);
   }
   const body = await res.json();
   if (typeof body.schemaVersion !== "number" || !ACCEPTED_TYPED_RESOLUTION_SCHEMA_VERSIONS.includes(body.schemaVersion)) {
-    return null;
+    return { status: "absent" };
   }
   if (!Array.isArray(body.resolutions))
-    return null;
-  return body;
+    return { status: "absent" };
+  return {
+    status: "sidecar",
+    sidecar: body,
+    etag: res.headers.get("etag")
+  };
 }
 function buildSidecarIndex(sidecar) {
   const map = /* @__PURE__ */ new Map();
@@ -6445,8 +6476,8 @@ function createFileKeyStore(keyPath) {
         encoding: "utf-8",
         mode: 384
       });
-      const { rename: rename8 } = await import("fs/promises");
-      await rename8(tmp, keyPath);
+      const { rename: rename9 } = await import("fs/promises");
+      await rename9(tmp, keyPath);
       cached = fresh;
       try {
         const s = await stat4(keyPath);
@@ -6695,9 +6726,9 @@ async function writePendingBatch(watermarkPath, batchId) {
   await writeFile14(pendingPath(watermarkPath), batchId, { encoding: "utf-8", mode: 384 });
 }
 async function clearPendingBatch(watermarkPath) {
-  const { unlink: unlink14 } = await import("fs/promises");
+  const { unlink: unlink15 } = await import("fs/promises");
   try {
-    await unlink14(pendingPath(watermarkPath));
+    await unlink15(pendingPath(watermarkPath));
   } catch {
   }
 }
@@ -6716,8 +6747,8 @@ async function writeWatermark(path, offset) {
   await mkdir13(dirname14(path), { recursive: true });
   const tmp = `${path}.tmp`;
   await writeFile14(tmp, offset.toString() + "\n", { encoding: "utf-8", mode: 384 });
-  const { rename: rename8 } = await import("fs/promises");
-  await rename8(tmp, path);
+  const { rename: rename9 } = await import("fs/promises");
+  await rename9(tmp, path);
 }
 async function isLocallyConsented(flagPath2) {
   try {
@@ -6732,9 +6763,37 @@ async function isLocallyConsented(flagPath2) {
 // ../listener/dist/mcp/mcp-server.js
 init_config_dir();
 import { createServer } from "http";
-import { mkdir as mkdir14, writeFile as writeFile15, unlink as unlink11 } from "fs/promises";
-import { dirname as dirname15, join as join23 } from "path";
-import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
+import { unlink as unlink12 } from "fs/promises";
+import { join as join23 } from "path";
+import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
+
+// ../listener/dist/lib/atomic-write.js
+import { mkdir as mkdir14, writeFile as writeFile15, chmod as chmod4, rename as rename6, unlink as unlink11, open as open5 } from "fs/promises";
+import { dirname as dirname15 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+async function writeFileAtomic(path, contents, opts = {}) {
+  const mode = opts.mode ?? 384;
+  await mkdir14(dirname15(path), { recursive: true });
+  const tmpPath = `${path}.${randomUUID3()}.tmp`;
+  try {
+    await writeFile15(tmpPath, contents, { encoding: "utf-8", mode });
+    await chmod4(tmpPath, mode);
+    let fh;
+    try {
+      fh = await open5(tmpPath, "r+");
+      await fh.datasync();
+    } finally {
+      await fh?.close();
+    }
+    await rename6(tmpPath, path);
+  } catch (err) {
+    try {
+      await unlink11(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
 
 // ../listener/dist/mcp/sanitize.js
 var MCP_RESPONSE_BYTE_CAP = 200 * 1024;
@@ -7768,6 +7827,25 @@ async function startMcpServer(options) {
   const clock = options.clock ?? Date.now;
   const requireAuth = options.requireAuth ?? true;
   const secretState = { value: createRotatingSecret(clock()) };
+  const endpointFilePath = options.endpointFilePath ?? defaultEndpointFile();
+  let endpointUrl = null;
+  let lastPersistedSecret = null;
+  let suspended = false;
+  let persisting = false;
+  let currentPersist = null;
+  const persistSecretIfStale = () => {
+    const live = secretState.value.current;
+    if (endpointUrl === null || suspended || persisting || live === lastPersistedSecret)
+      return;
+    persisting = true;
+    currentPersist = writeEndpointFileWithRetry(endpointFilePath, endpointUrl, live).then(() => {
+      lastPersistedSecret = live;
+    }).catch((err) => {
+      console.warn("[mcp] endpoint secret persist failed (will retry on next request):", err instanceof Error ? err.message : String(err));
+    }).finally(() => {
+      persisting = false;
+    });
+  };
   const server = createServer((req, res) => handleRequest(req, res, options, sessions, {
     getSecret: () => secretState.value,
     rotate: () => {
@@ -7775,6 +7853,7 @@ async function startMcpServer(options) {
       if (next !== secretState.value) {
         secretState.value = next;
       }
+      persistSecretIfStale();
       return secretState.value;
     },
     requireAuth,
@@ -7788,38 +7867,34 @@ async function startMcpServer(options) {
     });
   });
   const addr = server.address();
-  const endpoint = `http://127.0.0.1:${addr.port}`;
-  const endpointFilePath = options.endpointFilePath ?? defaultEndpointFile();
-  await writeEndpointFile(endpointFilePath, endpoint, secretState.value.current);
+  endpointUrl = `http://127.0.0.1:${addr.port}`;
+  await writeEndpointFileWithRetry(endpointFilePath, endpointUrl, secretState.value.current);
+  lastPersistedSecret = secretState.value.current;
   return {
-    endpoint,
+    endpoint: endpointUrl,
     port: addr.port,
     secret: secretState.value.current,
+    currentSecret: () => secretState.value.current,
     close: () => new Promise((resolve5, reject) => {
       server.close((err) => err ? reject(err) : resolve5());
     }),
     suspendEndpoint: async () => {
+      suspended = true;
+      await currentPersist?.catch(() => void 0);
+      lastPersistedSecret = null;
       try {
-        await unlink11(endpointFilePath);
+        await unlink12(endpointFilePath);
       } catch (err) {
         if (err.code !== "ENOENT")
           throw err;
       }
     },
     resumeEndpoint: async () => {
-      let lastErr;
-      for (let attempt = 1; attempt <= 3; attempt++) {
-        try {
-          await writeEndpointFile(endpointFilePath, endpoint, secretState.value.current);
-          return;
-        } catch (err) {
-          lastErr = err;
-          if (attempt < 3)
-            await new Promise((r) => setTimeout(r, 100 * attempt));
-        }
-      }
-      throw lastErr;
-    }
+      suspended = false;
+      await writeEndpointFileWithRetry(endpointFilePath, endpointUrl, secretState.value.current);
+      lastPersistedSecret = secretState.value.current;
+    },
+    retryPendingPersist: () => persistSecretIfStale()
   };
 }
 function handleRequest(req, res, options, sessions, secretCtx) {
@@ -7859,7 +7934,7 @@ function handleRequest(req, res, options, sessions, secretCtx) {
       if (!body?.repoId)
         return sendJson(res, 400, { error: "missing_repoId" });
       return options.graphCache.acquire(body.repoId).then(() => {
-        const sessionId = randomUUID3();
+        const sessionId = randomUUID4();
         sessions.set(sessionId, { repoId: body.repoId });
         return sendJson(res, 200, { sessionId });
       });
@@ -8352,11 +8427,21 @@ async function readJson(req) {
   }
 }
 async function writeEndpointFile(path, endpoint, secret) {
-  await mkdir14(dirname15(path), { recursive: true });
-  await writeFile15(path, formatEndpointFile({ endpoint, secret }), {
-    encoding: "utf-8",
-    mode: 384
-  });
+  await writeFileAtomic(path, formatEndpointFile({ endpoint, secret }), { mode: 384 });
+}
+async function writeEndpointFileWithRetry(path, endpoint, secret) {
+  let lastErr;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      await writeEndpointFile(path, endpoint, secret);
+      return;
+    } catch (err) {
+      lastErr = err;
+      if (attempt < 3)
+        await new Promise((r) => setTimeout(r, 100 * attempt));
+    }
+  }
+  throw lastErr;
 }
 function extractBearer(header) {
   const raw = Array.isArray(header) ? header[0] : header;
@@ -8432,6 +8517,7 @@ async function startMcp(options) {
     sink: createHeartbeatSink({
       apiUrl: heartbeatApiUrl,
       getAuthToken: options.getAuthToken,
+      ...options.getAuthTokenForceRefresh ? { getAuthTokenForceRefresh: options.getAuthTokenForceRefresh } : {},
       flagFilePath,
       ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
     }),
@@ -8584,6 +8670,7 @@ async function startMcp(options) {
     }
   };
 }
+var HEARTBEAT_UPLOAD_TIMEOUT_MS = 3e4;
 function createHeartbeatSink(deps) {
   const fetchImpl = deps.fetchImpl ?? fetch;
   return {
@@ -8598,21 +8685,35 @@ function createHeartbeatSink(deps) {
       try {
         token = await deps.getAuthToken();
       } catch {
-        return;
+        throw new Error("mcp-heartbeat: no auth token (transient \u2014 will retry)");
       }
       if (!token)
-        return;
-      const res = await fetchImpl(`${deps.apiUrl}/v1/listeners/mcp-heartbeat`, {
+        throw new Error("mcp-heartbeat: no auth token (transient \u2014 will retry)");
+      const doPost = (bearer) => fetchImpl(`${deps.apiUrl}/v1/listeners/mcp-heartbeat`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
+          Authorization: `Bearer ${bearer}`
         },
-        body: JSON.stringify(payload)
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(HEARTBEAT_UPLOAD_TIMEOUT_MS)
       });
-      if (res && !res.ok) {
-        console.warn(`[mcp-heartbeat] upload rejected (HTTP ${res.status}) \u2014 possible payload/contract drift`);
+      let res = await doPost(token);
+      if (res.status === 401 && deps.getAuthTokenForceRefresh) {
+        try {
+          const fresh = await deps.getAuthTokenForceRefresh();
+          if (fresh)
+            res = await doPost(fresh);
+        } catch {
+        }
       }
+      if (res.ok)
+        return;
+      const retryable = res.status >= 500 || res.status === 401 || res.status === 408 || res.status === 429;
+      if (retryable) {
+        throw new Error(`mcp-heartbeat: upload failed (HTTP ${res.status.toString()}) \u2014 will retry`);
+      }
+      console.warn(`[mcp-heartbeat] upload rejected (HTTP ${res.status.toString()}) \u2014 dropping (payload/contract or permission drift)`);
     }
   };
 }
@@ -10613,16 +10714,28 @@ async function runProducerCycle(input, fetchImpl = fetch) {
 async function runDownloaderCycle(input, fetchImpl = fetch) {
   if (isDisabled())
     return null;
-  const sidecar = await downloadMergedSidecar({
+  const cached = await loadMergedSidecar(input.repoId, input.commitSha);
+  const cachedEtag = cached ? await loadSidecarEtag(input.repoId, input.commitSha) : null;
+  const res = await downloadMergedSidecar({
     apiUrl: input.apiUrl,
     authToken: input.authToken,
     repoId: input.repoId,
-    commitSha: input.commitSha
+    commitSha: input.commitSha,
+    ...cachedEtag ? { ifNoneMatch: cachedEtag } : {}
   }, fetchImpl);
-  if (!sidecar)
+  if (res.status === "not-modified") {
+    if (!cached || !input.graph?.edges)
+      return { downloaded: false, edgesUpgraded: 0 };
+    const cachedResult = overlayMergedSidecar(input.graph.edges, cached);
+    return { downloaded: false, edgesUpgraded: cachedResult.edgesUpgraded };
+  }
+  if (res.status === "absent")
     return { downloaded: false, edgesUpgraded: 0 };
+  const sidecar = res.sidecar;
   try {
     await persistMergedSidecar(input.repoId, input.commitSha, sidecar);
+    if (res.etag)
+      await persistSidecarEtag(input.repoId, input.commitSha, res.etag);
   } catch (persistErr) {
     console.warn(`[typed-resolution] persist failed for ${input.repoId}: ${persistErr instanceof Error ? persistErr.message : String(persistErr)}`);
   }
@@ -11302,14 +11415,17 @@ async function runProducerHook(notif, localPath, ctx) {
     console.warn(`[typed-resolution] producer failed for ${notif.repoId}: ${prodErr instanceof Error ? prodErr.message : String(prodErr)}`);
   }
 }
-var processedSideEffectNotifs = /* @__PURE__ */ new Set();
+var processedSideEffectNotifs = /* @__PURE__ */ new Map();
 var MAX_PROCESSED_SIDE_EFFECT_NOTIFS = 512;
-function alreadyProcessedSideEffect(notificationId) {
-  if (processedSideEffectNotifs.has(notificationId))
+var SIDECAR_MERGED_RECHECK_MS = 5 * 60 * 1e3;
+function alreadyProcessedSideEffect(notificationId, ttlMs) {
+  const now = Date.now();
+  const expiresAt = processedSideEffectNotifs.get(notificationId);
+  if (expiresAt !== void 0 && now < expiresAt)
     return true;
-  processedSideEffectNotifs.add(notificationId);
+  processedSideEffectNotifs.set(notificationId, ttlMs === void 0 ? Infinity : now + ttlMs);
   if (processedSideEffectNotifs.size > MAX_PROCESSED_SIDE_EFFECT_NOTIFS) {
-    const oldest = processedSideEffectNotifs.values().next().value;
+    const oldest = processedSideEffectNotifs.keys().next().value;
     if (oldest !== void 0)
       processedSideEffectNotifs.delete(oldest);
   }
@@ -11346,6 +11462,8 @@ async function handleGraphReady(notif, ctx) {
 async function handleSidecarMerged(notif, ctx) {
   if (!ctx.typedResolutionHooks || !notif.commitSha)
     return;
+  if (alreadyProcessedSideEffect(notif.notificationId, SIDECAR_MERGED_RECHECK_MS))
+    return;
   try {
     await ctx.typedResolutionHooks.onSidecarMerged(notif.repoId, notif.commitSha);
   } catch (dlErr) {
@@ -11935,6 +12053,7 @@ async function startListener() {
         }
       }
     }
+    mcpRuntime?.server?.retryPendingPersist?.();
     let anyAuthError = null;
     let authErrorGroup = null;
     let minPollInterval = pollIntervalMs;
@@ -12342,7 +12461,7 @@ function getPackageName() {
 import chalk from "chalk";
 
 // src/lib/config.ts
-import { readFile as readFile15, writeFile as writeFile17, mkdir as mkdir17, rename as rename6, unlink as unlink12 } from "fs/promises";
+import { readFile as readFile15, writeFile as writeFile17, mkdir as mkdir17, rename as rename7, unlink as unlink13 } from "fs/promises";
 import { join as join44 } from "path";
 import lockfile6 from "proper-lockfile";
 async function getConfig() {
@@ -12360,10 +12479,10 @@ async function saveConfig(config2) {
   const tmpPath = path + ".tmp";
   try {
     await writeFile17(tmpPath, JSON.stringify(config2, null, 2));
-    await rename6(tmpPath, path);
+    await rename7(tmpPath, path);
   } catch (err) {
     try {
-      await unlink12(tmpPath);
+      await unlink13(tmpPath);
     } catch {
     }
     throw err;
@@ -12449,7 +12568,7 @@ import ora from "ora";
 
 // src/lib/auth.ts
 import { createHash as createHash6, randomBytes as randomBytes3 } from "crypto";
-import { readFile as readFile16, writeFile as writeFile18, mkdir as mkdir18, chmod as chmod4, unlink as unlink13, rename as rename7, open as open5 } from "fs/promises";
+import { readFile as readFile16, writeFile as writeFile18, mkdir as mkdir18, chmod as chmod5, unlink as unlink14, rename as rename8, open as open6 } from "fs/promises";
 import http from "http";
 import { join as join45 } from "path";
 import lockfile7 from "proper-lockfile";
@@ -12692,16 +12811,16 @@ async function storeCredentials2(credentials) {
       await writeFile18(tmpPath, JSON.stringify(credentials, null, 2), { mode: 384 });
       let fh;
       try {
-        fh = await open5(tmpPath, "r+");
+        fh = await open6(tmpPath, "r+");
         await fh.datasync();
       } finally {
         await fh?.close();
       }
-      await rename7(tmpPath, credPath);
-      await chmod4(credPath, 384);
+      await rename8(tmpPath, credPath);
+      await chmod5(credPath, 384);
     } catch (err) {
       try {
-        await unlink13(tmpPath);
+        await unlink14(tmpPath);
       } catch {
       }
       throw err;
@@ -12717,7 +12836,7 @@ async function storeCredentials2(credentials) {
 }
 async function clearCredentials() {
   try {
-    await unlink13(join45(getConfigDir2(), "credentials.json"));
+    await unlink14(join45(getConfigDir2(), "credentials.json"));
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -12758,8 +12877,8 @@ async function performLogin() {
   const authorizeUrl = getAuthorizeUrl(codeChallenge, state);
   const callbackPromise = startCallbackServer();
   try {
-    const open6 = (await import("open")).default;
-    await open6(authorizeUrl);
+    const open7 = (await import("open")).default;
+    await open7(authorizeUrl);
   } catch {
     console.log(`
 Open this URL in your browser to authenticate:
@@ -15217,8 +15336,8 @@ Waiting for authentication...`);
     } else {
       spinner.text = "Opening browser for authentication...";
       try {
-        const open6 = (await import("open")).default;
-        await open6(authorizeUrl);
+        const open7 = (await import("open")).default;
+        await open7(authorizeUrl);
         spinner.text = "Waiting for authentication in browser...";
       } catch {
         spinner.stop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repowisestage",
-  "version": "0.0.77",
+  "version": "0.0.79",
   "type": "module",
   "description": "AI-optimized codebase context generator",
   "bin": {