@fenglimg/fabric-server 1.1.0 → 1.3.0

package/dist/{chunk-U3IQH5H6.js → chunk-DQ7RCYKB.js}

@@ -1,13 +1,97 @@
+// src/constants.ts
+var AGENTS_MD_RESOURCE_URI = "fabric://agents-md";
+
+// src/cache.ts
+var ContextCache = class {
+  constructor(defaultTtlMs = 5e3) {
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  defaultTtlMs;
+  // Slot 1: raw AgentsMeta keyed by projectRoot
+  metaSlot = /* @__PURE__ */ new Map();
+  // Slot 2: GetRulesContext keyed by projectRoot
+  contextSlot = /* @__PURE__ */ new Map();
+  // Slot 3: audit sliding-window cursor keyed by projectRoot
+  auditSlot = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Generic get / set / invalidate
+  // ---------------------------------------------------------------------------
+  get(slot, key) {
+    const store = this.slotStore(slot);
+    const entry = store.get(key);
+    if (entry === void 0) {
+      return void 0;
+    }
+    if (entry.expiresAt !== 0 && Date.now() > entry.expiresAt) {
+      store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(slot, key, value, ttlMs) {
+    const store = this.slotStore(slot);
+    const resolvedTtl = ttlMs ?? this.defaultTtlMs;
+    const expiresAt = resolvedTtl > 0 ? Date.now() + resolvedTtl : 0;
+    store.set(key, { value, expiresAt });
+  }
+  // ---------------------------------------------------------------------------
+  // Audit cursor (separate API — not TTL-based)
+  // ---------------------------------------------------------------------------
+  getAuditCursor(projectRoot) {
+    return this.auditSlot.get(projectRoot);
+  }
+  setAuditCursor(projectRoot, cursor) {
+    this.auditSlot.set(projectRoot, cursor);
+  }
+  resetAuditCursor(projectRoot) {
+    this.auditSlot.delete(projectRoot);
+  }
+  // ---------------------------------------------------------------------------
+  // Invalidation
+  // ---------------------------------------------------------------------------
+  /**
+   * Invalidate cache slots based on what changed.
+   *
+   * @param reason  "meta_write"  — only the meta slot for this projectRoot
+   *                "file_watch"  — meta + context slots (AGENTS.md may have changed)
+   * @param projectRoot  Optional; if omitted, clears ALL keys in affected slots.
+   */
+  invalidate(reason, projectRoot) {
+    if (reason === "meta_write") {
+      if (projectRoot !== void 0) {
+        this.metaSlot.delete(projectRoot);
+      } else {
+        this.metaSlot.clear();
+      }
+      return;
+    }
+    if (projectRoot !== void 0) {
+      this.metaSlot.delete(projectRoot);
+      this.contextSlot.delete(projectRoot);
+    } else {
+      this.metaSlot.clear();
+      this.contextSlot.clear();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  slotStore(slot) {
+    return slot === "meta" ? this.metaSlot : this.contextSlot;
+  }
+};
+var contextCache = new ContextCache(5e3);
+
 // src/services/doctor.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { readFile as readFile4 } from "fs/promises";
 import { isAbsolute as isAbsolute2, join as join5, posix as posix2, resolve as resolve3 } from "path";
 import { forensicReportSchema } from "@fenglimg/fabric-shared";
 import { detectFramework } from "@fenglimg/fabric-shared/node";
 
 // src/meta-reader.ts
-import { readFileSync } from "fs";
+import { readFile } from "fs/promises";
 import { join } from "path";
 import { agentsMetaSchema } from "@fenglimg/fabric-shared";
 import { agentsMetaNodeSchema, agentsMetaSchema as agentsMetaSchema2 } from "@fenglimg/fabric-shared";
@@ -36,26 +120,33 @@ function getAgentsMetaPath(projectRoot) {
 function resolveProjectRoot() {
   return process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
 }
-function readAgentsMeta(projectRoot) {
+async function readAgentsMeta(projectRoot) {
+  const cached = contextCache.get("meta", projectRoot);
+  if (cached !== void 0) {
+    return cached;
+  }
   const metaPath = getAgentsMetaPath(projectRoot);
   let raw;
   try {
-    raw = readFileSync(metaPath, "utf8");
+    raw = await readFile(metaPath, "utf8");
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
       throw new AgentsMetaFileMissingError(metaPath);
     }
     throw error;
   }
+  let parsed;
   try {
-    return agentsMetaSchema.parse(JSON.parse(raw));
+    parsed = agentsMetaSchema.parse(JSON.parse(raw));
   } catch (error) {
     throw new AgentsMetaInvalidError(metaPath, error);
   }
+  contextCache.set("meta", projectRoot, parsed);
+  return parsed;
 }
 
 // src/services/audit-log.ts
-import { appendFile, mkdir, readFile } from "fs/promises";
+import { appendFile, mkdir, open, stat } from "fs/promises";
 import { isAbsolute, join as join2, posix, relative, resolve as resolve2 } from "path";
 
 // src/services/_shared.ts
@@ -103,7 +194,9 @@ async function appendGetRulesAuditEvent(projectRoot, input) {
 async function appendEditIntentAuditEvents(projectRoot, input) {
   const ts = input.ts ?? Date.now();
   const windowMs = input.window_ms ?? DEFAULT_AUDIT_WINDOW_MS;
-  const getRulesEntries = (await readAuditLog(projectRoot)).filter(isGetRulesAuditEntry);
+  const getRulesEntries = (await readAuditLog(projectRoot, { windowMs, ts })).filter(
+    isGetRulesAuditEntry
+  );
   const entries = input.affected_paths.map((affectedPath) => {
     const path = normalizeAuditPath(projectRoot, affectedPath);
     const matchedGetRules = findPrecedingGetRulesEvent(getRulesEntries, path, ts, windowMs);
@@ -119,23 +212,93 @@ async function appendEditIntentAuditEvents(projectRoot, input) {
       window_ms: windowMs
     };
   });
+  const compliance = {
+    compliant: entries.length === 0 || entries.every((e) => e.compliant),
+    matched_get_rules_ts: entries.length > 0 && entries[0].matched_get_rules_ts !== null ? new Date(entries[0].matched_get_rules_ts).toISOString() : null,
+    window_ms: windowMs
+  };
   if (entries.length === 0) {
-    return [];
+    return { entries, compliance };
   }
   await appendAuditLogEntries(projectRoot, entries);
-  return entries;
+  return { entries, compliance };
 }
-async function readAuditLog(projectRoot) {
+async function readAuditLog(projectRoot, opts) {
+  if (opts === void 0) {
+    return readAuditLogFull(projectRoot);
+  }
+  return readAuditLogWindowed(projectRoot, opts.ts, opts.windowMs);
+}
+async function readAuditLogFull(projectRoot) {
   const auditPath = join2(projectRoot, AUDIT_LOG_FILE);
   let raw;
   try {
-    raw = await readFile(auditPath, "utf8");
+    const fileStat = await stat(auditPath);
+    const handle = await open(auditPath, "r");
+    try {
+      const buffer = Buffer.alloc(fileStat.size);
+      await handle.read(buffer, 0, fileStat.size, 0);
+      raw = buffer.toString("utf8");
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  return parseAuditLogText(raw);
+}
+async function readAuditLogWindowed(projectRoot, ts, windowMs) {
+  const auditPath = join2(projectRoot, AUDIT_LOG_FILE);
+  let fileSize;
+  try {
+    const fileStat = await stat(auditPath);
+    fileSize = fileStat.size;
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return [];
     }
     throw error;
   }
+  const cursor = contextCache.getAuditCursor(projectRoot);
+  const startOffset = cursor !== void 0 && cursor.offset <= fileSize ? cursor.offset : 0;
+  const priorRemainder = startOffset > 0 && cursor !== void 0 ? cursor.remainder : "";
+  const effectiveStart = cursor !== void 0 && cursor.offset > fileSize ? 0 : startOffset;
+  let newEntries = [];
+  if (fileSize > effectiveStart) {
+    const length = fileSize - effectiveStart;
+    let chunk;
+    try {
+      const handle = await open(auditPath, "r");
+      try {
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, effectiveStart);
+        chunk = `${priorRemainder}${buffer.toString("utf8")}`;
+      } finally {
+        await handle.close();
+      }
+    } catch (error) {
+      contextCache.resetAuditCursor(projectRoot);
+      return readAuditLogFull(projectRoot);
+    }
+    const lines = chunk.split(/\r?\n/);
+    const remainder = chunk.endsWith("\n") ? "" : lines.pop() ?? "";
+    contextCache.setAuditCursor(projectRoot, { offset: fileSize, remainder });
+    newEntries = parseAuditLogText(lines.join("\n"));
+  } else {
+    contextCache.setAuditCursor(projectRoot, {
+      offset: fileSize,
+      remainder: cursor?.remainder ?? ""
+    });
+  }
+  if (effectiveStart === 0 && cursor !== void 0 && cursor.offset > fileSize) {
+    return newEntries.filter((e) => ts - e.ts <= windowMs);
+  }
+  return newEntries.filter((e) => ts - e.ts <= windowMs && e.ts <= ts);
+}
+function parseAuditLogText(raw) {
   return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map(parseAuditLogLine).filter((entry) => entry !== null);
 }
 function findPrecedingGetRulesEvent(entries, path, ts, windowMs) {
@@ -174,6 +337,7 @@ async function appendAuditLogEntries(projectRoot, entries) {
   await mkdir(auditDir, { recursive: true });
   await appendFile(auditPath, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}
 `, "utf8");
+  contextCache.resetAuditCursor(projectRoot);
 }
 function parseAuditLogLine(line) {
   try {
@@ -583,7 +747,7 @@ async function readSavedForensic(projectRoot) {
 }
 async function inspectMetaRevision(projectRoot) {
   try {
-    const meta = readAgentsMeta(projectRoot);
+    const meta = await readAgentsMeta(projectRoot);
     const entries = Object.entries(meta.nodes).sort(([left], [right]) => left.localeCompare(right));
     const missingFiles = [];
     let driftCount = 0;
@@ -594,7 +758,7 @@ async function inspectMetaRevision(projectRoot) {
         driftCount += 1;
         return "missing";
       }
-      const actualHash = sha2562(readFileSync2(absolutePath, "utf8"));
+      const actualHash = sha2562(readFileSync(absolutePath, "utf8"));
       if (actualHash !== node.hash) {
         driftCount += 1;
       }
@@ -694,7 +858,7 @@ function findLatestGetRulesTs(entries, path, ts) {
 function readDoctorAuditMode(projectRoot) {
   const configPath = join5(projectRoot, "fabric.config.json");
   try {
-    const parsed = JSON.parse(readFileSync2(configPath, "utf8"));
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       return "off";
     }
@@ -830,6 +994,8 @@ function isMissingFileError(error) {
 }
 
 export {
+  AGENTS_MD_RESOURCE_URI,
+  contextCache,
   AgentsMetaFileMissingError,
   AgentsMetaInvalidError,
   resolveProjectRoot,

package/dist/{http-FL3MB4L2.js → http-YPXWM5QS.js}

@@ -1,9 +1,11 @@
 import {
+  AGENTS_MD_RESOURCE_URI,
   AgentsMetaFileMissingError,
   AgentsMetaInvalidError,
   appendLedgerEntry,
   assertPathWithinProjectRoot,
   atomicWriteText,
+  contextCache,
   hashHumanLockedContent,
   readAgentsMeta,
   readHumanLock,
@@ -11,16 +13,17 @@ import {
   readHumanLockEntry,
   readLedger,
   runDoctorReport
-} from "./chunk-U3IQH5H6.js";
+} from "./chunk-DQ7RCYKB.js";
 
 // src/http.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 import { appendFile, readFile as readFile2 } from "fs/promises";
 import { join as join3 } from "path";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
 import {
   StreamableHTTPServerTransport
 } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import chokidar2 from "chokidar";
 
 // src/api/_error.ts
 function sendError(res, status, code, message, details) {
@@ -111,7 +114,7 @@ function registerDoctorApi(app, projectRoot) {
 }
 
 // src/api/events.ts
-import { createHash, randomUUID } from "crypto";
+import { createHash } from "crypto";
 import { open, readFile, stat } from "fs/promises";
 import { join } from "path";
 import {
@@ -130,6 +133,36 @@ var WATCHED_PATHS = [AGENTS_META_PATH, HUMAN_LOCK_PATH, FORENSIC_PATH, LEDGER_PA
 var CONNECTION_LIMIT = 10;
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var WATCH_DEBOUNCE_MS = 75;
+var RING_BUFFER_CAPACITY = 50;
+var RingBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.buf = new Array(capacity).fill(void 0);
+  }
+  capacity;
+  buf;
+  head = 0;
+  count = 0;
+  push(event) {
+    this.buf[this.head] = event;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) {
+      this.count++;
+    }
+  }
+  replayFrom(afterId) {
+    const result = [];
+    const total = this.count;
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < total; i++) {
+      const entry = this.buf[(start + i) % this.capacity];
+      if (entry !== void 0 && entry.id > afterId) {
+        result.push(entry);
+      }
+    }
+    return result;
+  }
+};
 function createEventsHandler(options) {
   const { projectRoot } = options;
   const state = {
@@ -137,7 +170,9 @@ function createEventsHandler(options) {
     pendingTimers: /* @__PURE__ */ new Map(),
     ledgerOffset: 0,
     ledgerRemainder: "",
-    humanLockSnapshot: createEmptyHumanLockSnapshot()
+    humanLockSnapshot: createEmptyHumanLockSnapshot(),
+    nextEventId: 1,
+    ringBuffer: new RingBuffer(RING_BUFFER_CAPACITY)
   };
   return async function handleEvents(req, res) {
     if (state.clients.size >= CONNECTION_LIMIT) {
@@ -161,6 +196,19 @@ function createEventsHandler(options) {
     res.setHeader("X-Accel-Buffering", "no");
     res.flushHeaders?.();
     res.write(": connected\n\n");
+    const lastEventId = readLastEventId(req);
+    if (lastEventId !== void 0) {
+      const missed = state.ringBuffer.replayFrom(lastEventId);
+      for (const entry of missed) {
+        if (!res.writableEnded) {
+          res.write(`id: ${entry.id}
+event: ${entry.type}
+data: ${entry.data}
+
+`);
+        }
+      }
+    }
     state.clients.add(res);
     const heartbeat = setInterval(() => {
       if (!res.writableEnded) {
@@ -368,11 +416,14 @@ function parseLedgerAppendedEvent(line) {
 }
 function broadcastEvent(state, event) {
   const payload = fabricEventSchema.parse(event);
-  const frame = `id: ${randomUUID()}
+  const eventId = state.nextEventId++;
+  const data = JSON.stringify(payload);
+  const frame = `id: ${eventId}
 event: ${payload.type}
-data: ${JSON.stringify(payload)}
+data: ${data}
 
 `;
+  state.ringBuffer.push({ id: eventId, type: payload.type, data });
   const disconnectedClients = [];
   for (const client of state.clients) {
     try {
@@ -454,6 +505,21 @@ function areSetsEqual(left, right) {
   }
   return true;
 }
+function readLastEventId(req) {
+  const header = req.headers["last-event-id"];
+  const headerValue = Array.isArray(header) ? header[0] : header;
+  const rawUrl = req.url ?? "";
+  const queryStart = rawUrl.indexOf("?");
+  const queryString = queryStart >= 0 ? rawUrl.slice(queryStart + 1) : "";
+  const params = new URLSearchParams(queryString);
+  const queryValue = params.get("lastEventId") ?? void 0;
+  const raw = headerValue ?? queryValue;
+  if (raw === void 0 || raw.length === 0) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
 function normalizePath(value) {
   return value.replaceAll("\\", "/");
 }
@@ -730,7 +796,7 @@ function createApproveLedgerEntry(input) {
 function registerHumanLockApi(app, projectRoot) {
   app.get("/api/human-lock", async (_req, res) => {
     try {
-      readAgentsMeta(projectRoot);
+      await readAgentsMeta(projectRoot);
       res.json(await readHumanLock(projectRoot));
     } catch (error) {
       sendUnknownError(res, error);
@@ -746,7 +812,7 @@ function registerHumanLockApi(app, projectRoot) {
       return;
     }
     try {
-      readAgentsMeta(projectRoot);
+      await readAgentsMeta(projectRoot);
       const entry = await readHumanLockEntry(projectRoot, validation.data.file);
       if (entry === null) {
         sendError(
@@ -769,7 +835,7 @@ function registerHumanLockApi(app, projectRoot) {
       return;
     }
     try {
-      readAgentsMeta(projectRoot);
+      await readAgentsMeta(projectRoot);
       res.json(await approveHumanLock(projectRoot, validation.data));
     } catch (error) {
       sendUnknownError(res, error);
@@ -822,7 +888,7 @@ function registerIntentApi(app, projectRoot) {
       return;
     }
     try {
-      readAgentsMeta(projectRoot);
+      await readAgentsMeta(projectRoot);
       const result = await annotateIntent(projectRoot, validation.data);
       res.status(result.created ? 201 : 200).json(result);
     } catch (error) {
@@ -844,7 +910,7 @@ function registerLedgerApi(app, projectRoot) {
       return;
     }
     try {
-      readAgentsMeta(projectRoot);
+      await readAgentsMeta(projectRoot);
       res.json(await readLedger(projectRoot, validation.data));
     } catch (error) {
       sendUnknownError(res, error);
@@ -856,7 +922,7 @@ function registerLedgerApi(app, projectRoot) {
 function registerRulesApi(app, projectRoot) {
   app.get("/api/rules", async (_req, res) => {
     try {
-      res.json(readAgentsMeta(projectRoot));
+      res.json(await readAgentsMeta(projectRoot));
     } catch (error) {
       sendUnknownError(res, error);
     }
@@ -1062,13 +1128,14 @@ function hashToken(token) {
 // src/http.ts
 var DEFAULT_HOST = "127.0.0.1";
 var LEDGER_FILE = ".intent-ledger.jsonl";
+var NOTIFY_DEBOUNCE_MS = 200;
 var JsonlEventStore = class {
   constructor(ledgerPath) {
     this.ledgerPath = ledgerPath;
   }
   ledgerPath;
   async storeEvent(streamId, message) {
-    const eventId = randomUUID2();
+    const eventId = randomUUID();
     const entry = {
       kind: "mcp-event",
       eventId,
@@ -1121,11 +1188,41 @@ function createFabricHttpApp(options) {
   const eventStore = new JsonlEventStore(ledgerPath);
   const sessions = /* @__PURE__ */ new Map();
   process.env.FABRIC_PROJECT_ROOT = projectRoot;
+  const cacheWatcher = chokidar2.watch(
+    [".fabric/agents.meta.json", "AGENTS.md"],
+    {
+      cwd: projectRoot,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 120,
+        pollInterval: 20
+      }
+    }
+  );
+  let agentsMdNotifyTimer;
+  let toolListNotifyTimer;
+  cacheWatcher.on("change", (relativePath) => {
+    const normalized = relativePath.replaceAll("\\", "/");
+    if (normalized === ".fabric/agents.meta.json") {
+      contextCache.invalidate("file_watch", projectRoot);
+      clearTimeout(toolListNotifyTimer);
+      toolListNotifyTimer = setTimeout(() => {
+        notifyAllSessions(sessions, "tools/list_changed");
+      }, NOTIFY_DEBOUNCE_MS);
+    } else if (normalized === "AGENTS.md") {
+      contextCache.invalidate("file_watch", projectRoot);
+      clearTimeout(agentsMdNotifyTimer);
+      agentsMdNotifyTimer = setTimeout(() => {
+        notifyAllSessions(sessions, "resource_updated", AGENTS_MD_RESOURCE_URI);
+      }, NOTIFY_DEBOUNCE_MS);
+    }
+  });
   app.disable("x-powered-by");
   if (authToken !== void 0) {
     const bearerAuth = createBearerAuthMiddleware(authToken);
     app.use("/api", bearerAuth);
     app.use("/events", bearerAuth);
+    app.use("/mcp", bearerAuth);
   }
   registerRulesApi(app, projectRoot);
   registerLedgerApi(app, projectRoot);
@@ -1156,11 +1253,25 @@ function createFabricHttpApp(options) {
   registerDashboardStatic(app, { dashboardDistPath, dev });
   return app;
 }
+function notifyAllSessions(sessions, kind, uri) {
+  for (const { server } of sessions.values()) {
+    try {
+      if (kind === "tools/list_changed") {
+        server.sendToolListChanged();
+      } else if (kind === "resources/list_changed") {
+        server.sendResourceListChanged();
+      } else if (kind === "resource_updated" && uri !== void 0) {
+        void server.server.sendResourceUpdated({ uri });
+      }
+    } catch {
+    }
+  }
+}
 async function createSession(eventStore, sessions) {
   const { createFabricServer } = await import("./index.js");
   const server = createFabricServer();
   const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: randomUUID2,
+    sessionIdGenerator: randomUUID,
     enableJsonResponse: true,
     eventStore,
     onsessioninitialized: async (sessionId) => {
@@ -1227,5 +1338,6 @@ function isNodeError2(error) {
   return error instanceof Error;
 }
 export {
-  createFabricHttpApp
+  createFabricHttpApp,
+  notifyAllSessions
 };

package/dist/index.d.ts

@@ -61,6 +61,12 @@ declare function runDoctorAuditReport(target: string, options?: {
     windowMs?: number;
 }): Promise<DoctorAuditReport>;
 
+/**
+ * Shared constants used across the server package.
+ */
+/** MCP resource URI for the project's AGENTS.md (L0 rules) file. */
+declare const AGENTS_MD_RESOURCE_URI = "fabric://agents-md";
+
 declare function createFabricServer(): McpServer;
 declare function startStdioServer(): Promise<void>;
 declare function startHttpServer(options: {
@@ -72,4 +78,4 @@ declare function startHttpServer(options: {
     dev?: boolean;
 }): Promise<Server>;
 
-export { type DoctorAuditReport, type DoctorReport, createFabricServer, runDoctorAuditReport, runDoctorReport, startHttpServer, startStdioServer };
+export { AGENTS_MD_RESOURCE_URI, type DoctorAuditReport, type DoctorReport, createFabricServer, runDoctorAuditReport, runDoctorReport, startHttpServer, startStdioServer };