changebook 0.4.6 → 0.4.7

package/dist/credentials.js

@@ -61,4 +61,75 @@ export function clearCredentials() {
         return false;
     }
 }
+const LOCK_FILE = path.join(DIR, "refresh.lock");
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Run `fn` while holding an exclusive, cross-process lock.
+ *
+ * Supabase rotates the refresh token on every use, and its reuse-detection
+ * revokes the WHOLE token family if a rotated token is ever replayed. The
+ * post-commit `analyze` runs detached in the background, so it can still be
+ * refreshing when the next commit's pre-commit `guard` (or another analyze)
+ * starts — two processes then spend the same stored refresh token and the
+ * account is logged out silently. A lockfile serializes the refresh across
+ * every process that shares the credentials file, so only one spends the token.
+ *
+ * Falls through and runs `fn` unlocked if the lock can't be taken within
+ * `timeoutMs` — a hung holder must never block a commit forever; that only
+ * degrades to the previous lock-less behavior. A stale lock left by a crashed
+ * holder (older than `staleMs`) is stolen.
+ */
+export async function withCredentialsLock(fn, opts = {}) {
+    const lockPath = opts.lockPath ?? LOCK_FILE;
+    const timeoutMs = opts.timeoutMs ?? 30_000;
+    const staleMs = opts.staleMs ?? 60_000;
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true, mode: 0o700 });
+    const deadline = Date.now() + timeoutMs;
+    let held = false;
+    for (;;) {
+        try {
+            const fd = fs.openSync(lockPath, "wx", 0o600);
+            fs.writeSync(fd, `${process.pid} ${new Date().toISOString()}\n`);
+            fs.closeSync(fd);
+            held = true;
+            break;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            // Held by another process. Steal it only if it is stale (crashed holder).
+            let stolen = false;
+            try {
+                if (Date.now() - fs.statSync(lockPath).mtimeMs > staleMs) {
+                    fs.rmSync(lockPath, { force: true });
+                    stolen = true;
+                }
+            }
+            catch {
+                // The lock vanished between open and stat: retry immediately.
+                stolen = true;
+            }
+            if (stolen)
+                continue;
+            if (Date.now() >= deadline)
+                break; // give up waiting; proceed unlocked
+            await sleep(50);
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        if (held) {
+            try {
+                fs.rmSync(lockPath, { force: true });
+            }
+            catch {
+                // Best-effort release; a leftover lock is stolen once it goes stale.
+            }
+        }
+    }
+}
 //# sourceMappingURL=credentials.js.map

package/dist/supabase.js

@@ -5,7 +5,7 @@
  * every query to the signed-in user. Refreshes the access token with the
  * refresh token when needed (refresh does not require a captcha).
  */
-import { loadCredentials, saveCredentials } from './credentials.js';
+import { loadCredentials, saveCredentials, withCredentialsLock, } from './credentials.js';
 import { slugifyProject } from './guard.js';
 // Public defaults — the anon key is the same public key the web app ships.
 const DEFAULT_URL = 'https://oyosihxkecspjkiligga.supabase.co';
@@ -22,6 +22,29 @@ variable (and optionally CHANGEBOOK_ACCESS_TOKEN). To extract it manually, sign
 in at https://changebook.app, open the browser console and run:
 
   JSON.parse(localStorage.getItem(Object.keys(localStorage).find(k => k.endsWith("-auth-token")))).refresh_token`;
+/**
+ * Decide what to do at the start of a refresh, given the refresh token this
+ * process held before it took the lock and whatever is on disk now.
+ *
+ * If another process refreshed while we waited for the lock, the stored refresh
+ * token differs from ours AND comes with a fresh access token: adopt those and
+ * never spend our own. Replaying a rotated token trips Supabase's
+ * reuse-detection and revokes the whole family — the silent logout this guards
+ * against. Otherwise spend the freshest refresh token available.
+ */
+export function decideRefresh(priorRefreshToken, stored) {
+    if (stored?.refresh_token &&
+        stored.refresh_token !== priorRefreshToken &&
+        stored.access_token) {
+        return {
+            kind: 'adopt',
+            access_token: stored.access_token,
+            refresh_token: stored.refresh_token,
+        };
+    }
+    const token = stored?.refresh_token ?? priorRefreshToken;
+    return token ? { kind: 'spend', refresh_token: token } : { kind: 'none' };
+}
 export class SupabaseError extends Error {
     status;
     constructor(message, status) {
@@ -264,30 +287,35 @@ export class Supabase {
         });
         return this.refreshing;
     }
-    async doRefresh() {
-        // The credentials file is shared across processes (the MCP server, the
-        // post-commit hook, a second editor window). Any of them may have rotated
-        // the token since we loaded it, so pick up the freshest one on disk before
-        // spending ours — otherwise we replay a stale token and get logged out.
-        if (this.persistRotation) {
-            const stored = loadCredentials();
-            if (stored?.refresh_token)
-                this.refreshToken = stored.refresh_token;
-        }
-        if (!this.refreshToken) {
+    doRefresh() {
+        // Env-var sessions aren't shared through the credentials file, so there is
+        // nothing to coordinate between processes: refresh in place.
+        if (!this.persistRotation)
+            return this.doRefreshInner();
+        // Disk-backed sessions (from `changebook login`) can be refreshed by
+        // several processes at once — the detached post-commit analyze, the
+        // pre-commit guard, a second editor window. Serialize under a cross-process
+        // lock so only one spends the rotating token; the others adopt its result
+        // instead of replaying a token Supabase has already rotated (which would
+        // trip reuse-detection and log the whole account out silently).
+        return withCredentialsLock(() => this.doRefreshInner());
+    }
+    async doRefreshInner() {
+        // Under the lock: re-read disk so a refresh another process just completed
+        // is picked up before we spend anything.
+        const stored = this.persistRotation ? loadCredentials() : null;
+        const plan = decideRefresh(this.refreshToken, stored);
+        if (plan.kind === 'none') {
             throw new SupabaseError(`Session expired. ${AUTH_HELP}`, 401);
         }
-        let res = await this.refreshOnce(this.refreshToken);
-        // If the refresh was rejected and the session came from disk, another
-        // process may have rotated the token in the tiny window since we read it;
-        // reload once and retry with the newest before giving up.
-        if (!res.ok && this.persistRotation) {
-            const stored = loadCredentials();
-            if (stored?.refresh_token && stored.refresh_token !== this.refreshToken) {
-                this.refreshToken = stored.refresh_token;
-                res = await this.refreshOnce(this.refreshToken);
-            }
+        if (plan.kind === 'adopt') {
+            // Another process refreshed while we waited: use its fresh tokens.
+            this.accessToken = plan.access_token;
+            this.refreshToken = plan.refresh_token;
+            return;
         }
+        this.refreshToken = plan.refresh_token;
+        const res = await this.refreshOnce(this.refreshToken);
         if (!res.ok) {
             const body = (await res.text()).slice(0, 300);
             throw new SupabaseError(`Could not refresh the ChangeBook session (${res.status}): ${body}\n\n${AUTH_HELP}`, res.status);

package/dist/tools.js

@@ -96,6 +96,31 @@ export function quotedInList(values) {
         .join(",");
 }
 export const FILES_CAP = 8;
+/**
+ * Reincidencia (espejo de supabase/functions/mcp/scope.ts::computeRecidivism —
+ * paridad en test/reincidenciaFileContext). Por módulo, nº de problemas de
+ * regresión DISTINTOS (count(distinct plain), all-time), solo los con
+ * antecedentes (>= 2). Plain distinto, no filas, para que el re-levantado no
+ * infle. No se refuta: cuenta historia, no vigencia.
+ */
+export function computeRecidivism(rows) {
+    const plainsByModule = new Map();
+    for (const r of rows) {
+        const m = (r.module ?? "").trim();
+        const p = (r.plain ?? "").trim();
+        if (!m || !p)
+            continue;
+        const set = plainsByModule.get(m) ?? new Set();
+        set.add(p);
+        plainsByModule.set(m, set);
+    }
+    const out = new Map();
+    for (const [m, set] of plainsByModule) {
+        if (set.size >= 2)
+            out.set(m, set.size);
+    }
+    return out;
+}
 export function filesUnionByChange(rows, cap = FILES_CAP) {
     const acc = new Map();
     for (const r of rows) {
@@ -631,7 +656,7 @@ Args:
   - files (required): 1-8 repo-relative paths.
   - project (recommended): the repo you are working in (folder name or slug). The atlas is per-project — always scope to your own project.
 
-Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_changed, last_note }], open_alerts, recent_commits: [{ commit, commit_aliases, date }], recent_commits_more, watched_values: [{ name, value, commit }] }] }`,
+Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_changed, last_note }], open_alerts, recidivism: [{ module, prior_regressions }], recent_commits: [{ commit, commit_aliases, date }], recent_commits_more, watched_values: [{ name, value, commit }] }] }`,
         inputSchema: {
             files: z.array(z.string().min(1).max(300)).min(1).max(8)
                 .describe("Repo-relative paths you are about to edit"),
@@ -710,7 +735,7 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
             for (const f of perFile) {
                 commitsByFile.set(f.file, recentCommitsForFile(f.changelogIds, commitById));
             }
-            const [alerts, watched] = await Promise.all([
+            const [alerts, watched, recidivismRows] = await Promise.all([
                 moduleNames.length
                     ? db.rest(`regression_alerts?select=module,plain,evidence_symbol,evidence_expect&resolved_at=is.null&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&order=created_at.desc&limit=10` +
                         pf)
@@ -723,6 +748,17 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                     .rest(`watched_values?select=file,name,value,commit_hash&file=in.(${encodeURIComponent(quotedInList(paths))})&order=name.asc&limit=40` +
                     pf)
                     .catch(() => []),
+                // Reincidencia (edit-time, espejo del hospedado): problemas de
+                // regresión de TODO el tiempo (sin filtro resolved) de los módulos
+                // tocados. Depende de moduleNames como las alertas → mismo Promise.all,
+                // sin ronda extra. Se cuenta distinct plain abajo (mismo criterio que
+                // el RPC del brief).
+                moduleNames.length
+                    ? db
+                        .rest(`regression_alerts?select=module,plain&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&limit=500` +
+                        pf)
+                        .catch(() => [])
+                    : Promise.resolve([]),
             ]);
             const watchedByFile = new Map();
             for (const w of watched) {
@@ -747,6 +783,10 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                     continue;
                 alertsByModule.set(m, [...(alertsByModule.get(m) ?? []), a.plain]);
             }
+            // Reincidencia: nº de problemas de regresión DISTINTOS por módulo
+            // (count(distinct plain), all-time), solo los con antecedentes (>= 2).
+            // Fuente única compartida (computeRecidivism) — antes 3 copias.
+            const recidivismByModule = computeRecidivism(recidivismRows);
             // Ancla temporal: el último commit analizado del proyecto vs el HEAD
             // de este árbol (misma puerta de proyecto que la refutación).
             // Best-effort: el ancla jamás rompe la lectura que ancla.
@@ -778,8 +818,10 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                     lines.push("No atlas history for this file yet (new or never analyzed).");
                 }
                 for (const m of f.modules) {
+                    const previas = recidivismByModule.get(m.module);
                     lines.push(`- Module **${m.module}** — ${m.changes} change(s), last ${m.last_changed}` +
-                        (m.risk ? `, risk: ${m.risk}` : ""));
+                        (m.risk ? `, risk: ${m.risk}` : "") +
+                        (previas ? ` · ⚠ ${previas} prior regressions` : ""));
                     if (m.last_note) {
                         // Con fecha: una nota es una observación fechada, no estado.
                         lines.push(`  - Note from last analysis (${m.last_changed}): ${m.last_note}`);
@@ -816,6 +858,12 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                         module: m.module,
                         plain,
                     }))),
+                    recidivism: f.modules
+                        .map((m) => ({
+                        module: m.module,
+                        prior_regressions: recidivismByModule.get(m.module) ?? 0,
+                    }))
+                        .filter((x) => x.prior_regressions >= 2),
                     watched_values: (watchedByFile.get(f.file) ?? []).map((w) => ({
                         name: w.name,
                         value: w.value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "changebook",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "mcpName": "io.github.raulbr90/changebook",
   "description": "ChangeBook for coding agents: MCP server (product memory for Claude Code/Codex) + CLI to sign in, analyze changes and sync the product map.",
   "type": "module",

package/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.raulbr90/changebook",
   "description": "Query your product's living memory: module map + analyzed change history. Read-only MCP tools.",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "websiteUrl": "https://changebook.dev",
   "remotes": [
     {
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "changebook",
-      "version": "0.4.6",
+      "version": "0.4.7",
       "transport": {
         "type": "stdio"
       }