@fenglimg/fabric-shared 2.2.0-rc.3 → 2.2.0-rc.8

package/dist/node/atomic-write.js

@@ -1,124 +1,9 @@
-// src/node/atomic-write.ts
-import { appendFile, mkdir, open, readFile, rename, stat, unlink, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { randomUUID } from "crypto";
-function makeTmpSuffix() {
-  const rand = Math.floor(Math.random() * 65535).toString(16).padStart(4, "0");
-  return `.${process.pid}.${Date.now()}.${rand}.tmp`;
-}
-async function atomicWriteText(path, content, opts) {
-  const tmpPath = path + makeTmpSuffix();
-  try {
-    if (opts?.fsync) {
-      const fd = await open(tmpPath, "w");
-      try {
-        await fd.writeFile(content, "utf8");
-        await fd.datasync();
-      } finally {
-        await fd.close();
-      }
-    } else {
-      await writeFile(tmpPath, content, "utf8");
-    }
-    await rename(tmpPath, path);
-  } catch (err) {
-    try {
-      await unlink(tmpPath);
-    } catch {
-    }
-    throw err;
-  }
-}
-async function atomicWriteJson(path, value, opts) {
-  const indent = opts?.indent ?? 2;
-  const content = JSON.stringify(value, null, indent) + "\n";
-  await atomicWriteText(path, content, { fsync: opts?.fsync });
-}
-function isErrnoException(err) {
-  return err instanceof Error && typeof err.code === "string";
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function withFileLock(lockPath, fn, opts = {}) {
-  const staleMs = opts.staleMs ?? 1e4;
-  const retryDelayMs = opts.retryDelayMs ?? 20;
-  const maxWaitMs = opts.maxWaitMs ?? 1e4;
-  await mkdir(dirname(lockPath), { recursive: true });
-  const token = `${process.pid}.${randomUUID()}`;
-  const start = Date.now();
-  for (; ; ) {
-    let handle;
-    try {
-      handle = await open(lockPath, "wx");
-    } catch (err) {
-      if (!isErrnoException(err) || err.code !== "EEXIST") throw err;
-      try {
-        const st = await stat(lockPath);
-        if (Date.now() - st.mtimeMs > staleMs) {
-          const staleToken = await readFile(lockPath, "utf8").catch(() => null);
-          if (staleToken !== null) {
-            await unlinkIfToken(lockPath, staleToken);
-          }
-          continue;
-        }
-      } catch {
-        continue;
-      }
-      if (Date.now() - start > maxWaitMs) {
-        throw new Error(`withFileLock: timed out acquiring ${lockPath} after ${maxWaitMs}ms`);
-      }
-      await sleep(retryDelayMs);
-      continue;
-    }
-    try {
-      await handle.writeFile(token, "utf8");
-      await handle.close();
-      return await fn();
-    } finally {
-      await unlinkIfToken(lockPath, token);
-    }
-  }
-}
-async function unlinkIfToken(lockPath, expected) {
-  try {
-    const current = await readFile(lockPath, "utf8");
-    if (current === expected) {
-      await unlink(lockPath).catch(() => void 0);
-    }
-  } catch {
-  }
-}
-function createLedgerWriteQueue() {
-  const chains = /* @__PURE__ */ new Map();
-  async function doAppend(path, line) {
-    const normalized = line.endsWith("\n") ? line : line + "\n";
-    await appendFile(path, normalized, "utf8");
-  }
-  function enqueue(path, work) {
-    const prev = chains.get(path) ?? Promise.resolve();
-    const result = prev.catch(() => void 0).then(() => work());
-    const chainSlot = result.then(
-      () => void 0,
-      () => void 0
-    );
-    chains.set(path, chainSlot);
-    chainSlot.finally(() => {
-      if (chains.get(path) === chainSlot) {
-        chains.delete(path);
-      }
-    });
-    return result;
-  }
-  return {
-    append(path, line) {
-      return enqueue(path, () => doAppend(path, line));
-    },
-    runExclusive(path, fn) {
-      return enqueue(path, fn);
-    }
-  };
-}
+import {
+  atomicWriteJson,
+  atomicWriteText,
+  createLedgerWriteQueue,
+  withFileLock
+} from "../chunk-C7WZPYZE.js";
 export {
   atomicWriteJson,
   atomicWriteText,

package/dist/node/mcp-payload-guard.js

@@ -1,6 +1,6 @@
 import {
   MCPError
-} from "../chunk-VW5QGPIN.js";
+} from "../chunk-O6GIHZF3.js";
 
 // src/node/mcp-payload-guard.ts
 var McpPayloadTooLargeError = class extends MCPError {

package/dist/node.d.ts

@@ -11,4 +11,13 @@ type FrameworkInfo = {
 type TechProfile = FrameworkInfo;
 declare function detectFramework(root: string): FrameworkInfo;
 
-export { type FrameworkInfo, type TechProfile, detectFramework };
+interface ServeLockState {
+    pid: number;
+    acquiredAt: number;
+    host?: string;
+}
+declare function serveLockPath(projectRoot: string): string;
+declare function isAlive(pid: number): boolean;
+declare function readServeLockState(projectRoot: string): ServeLockState | null;
+
+export { type FrameworkInfo, type ServeLockState, type TechProfile, detectFramework, isAlive, readServeLockState, serveLockPath };

package/dist/node.js

@@ -170,6 +170,37 @@ function collectProjectFileEvidence(root, relativePaths) {
 function compactStrings(values) {
   return [...new Set(values.filter((value) => value !== null && value !== void 0 && value.length > 0))];
 }
+
+// src/node/serve-lock.ts
+import fs from "fs";
+import path from "path";
+var SERVE_LOCK_FILENAME = ".serve.lock";
+function serveLockPath(projectRoot) {
+  return path.join(projectRoot, ".fabric", SERVE_LOCK_FILENAME);
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    const err = e;
+    if (err.code === "ESRCH") return false;
+    if (err.code === "EPERM") return true;
+    throw e;
+  }
+}
+function readServeLockState(projectRoot) {
+  const p = serveLockPath(projectRoot);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
 export {
-  detectFramework
+  detectFramework,
+  isAlive,
+  readServeLockState,
+  serveLockPath
 };