kojee-mcp 0.6.0 → 0.7.1

package/dist/{chunk-DURRQDYI.js → chunk-TNZITJAB.js}

@@ -1,9 +1,10 @@
 import {
+  readSessionDiscoveryByKey,
   sessionDiscoveryDir
-} from "./chunk-DO42NPNR.js";
+} from "./chunk-67F67AQ6.js";
 import {
   secureFile
-} from "./chunk-BLEGIR35.js";
+} from "./chunk-U5HHHRXA.js";
 
 // src/delivery/lib/event-log.ts
 import fs from "fs";
@@ -21,23 +22,35 @@ function statusLogPath(eventLogPath) {
   const m = base.match(/^kojee-events-(.+)\.log$/);
   return path.join(dir, m ? `kojee-status-${m[1]}.log` : `${base}.status`);
 }
-function livePathOwnedBySibling(candidatePath) {
+function livePathOwnedByForeignProxy(candidatePath, selfKey) {
   try {
-    const { livePaths } = listActiveSessionIds();
-    return livePaths.has(path.resolve(candidatePath));
+    const resolved = path.resolve(candidatePath);
+    const { liveOwners } = scanDiscovery(false);
+    for (const owner of liveOwners) {
+      if (owner.eventLogPath !== resolved) continue;
+      if (selfKey && owner.discoveryKey === selfKey) continue;
+      return true;
+    }
+    return false;
   } catch {
     return false;
   }
 }
+function resolveEventLogPath(opts) {
+  const dir = opts.dir ?? DEFAULT_DIR;
+  const base = path.join(dir, `kojee-events-${opts.key}.log`);
+  if (livePathOwnedByForeignProxy(base, opts.selfKey)) {
+    const suffix = opts.selfKey ?? String(process.pid);
+    return path.join(dir, `kojee-events-${opts.key}-${suffix}.log`);
+  }
+  return base;
+}
 function startEventLog(opts) {
   const dir = opts.dir ?? DEFAULT_DIR;
   const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
   const statusMaxBytes = opts.statusMaxBytes ?? DEFAULT_STATUS_MAX_BYTES;
   fs.mkdirSync(dir, { recursive: true });
-  let filePath = path.join(dir, `kojee-events-${opts.key}.log`);
-  if (livePathOwnedBySibling(filePath)) {
-    filePath = path.join(dir, `kojee-events-${opts.key}-${process.pid}.log`);
-  }
+  const filePath = resolveEventLogPath(opts);
   const statusPath = statusLogPath(filePath);
   fs.writeFileSync(filePath, "", { mode: 384 });
   secureFile(filePath);
@@ -114,6 +127,13 @@ function startEventLog(opts) {
       });
     },
     cleanup() {
+      if (opts.selfKey) {
+        const disc = readSessionDiscoveryByKey(opts.selfKey);
+        const owner = disc?.proxyPid ?? disc?.pid;
+        if (disc && typeof owner === "number" && owner !== process.pid && isProcessAlive(owner) && disc.eventLogPath && path.resolve(disc.eventLogPath) === path.resolve(filePath)) {
+          return;
+        }
+      }
       try {
         fs.unlinkSync(filePath);
       } catch {
@@ -175,19 +195,21 @@ function isProcessAlive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (err) {
-    if (err.code === "EPERM") return true;
+    const code = err.code;
+    if (code === "EPERM" || code === "EACCES") return true;
     return false;
   }
 }
-function listActiveSessionIds() {
+function scanDiscovery(reap) {
   const dir = sessionDiscoveryDir();
   const active = /* @__PURE__ */ new Set();
   const livePaths = /* @__PURE__ */ new Set();
+  const liveOwners = [];
   let entries;
   try {
     entries = fs.readdirSync(dir);
   } catch {
-    return { active, livePaths };
+    return { active, livePaths, liveOwners };
   }
   const dead = [];
   for (const name of entries) {
@@ -200,13 +222,20 @@ function listActiveSessionIds() {
       const livenessPid = data.proxyPid ?? data.pid;
       if (typeof livenessPid === "number" && isProcessAlive(livenessPid)) {
         active.add(sessionId);
-        if (data.eventLogPath) livePaths.add(path.resolve(data.eventLogPath));
+        if (data.eventLogPath) {
+          livePaths.add(path.resolve(data.eventLogPath));
+          liveOwners.push({
+            discoveryKey: data.discoveryKey ?? sessionId,
+            eventLogPath: path.resolve(data.eventLogPath)
+          });
+        }
       } else {
         dead.push({ filePath, eventLogPath: data.eventLogPath });
       }
     } catch {
     }
   }
+  if (!reap) return { active, livePaths, liveOwners };
   for (const { filePath, eventLogPath } of dead) {
     try {
       fs.unlinkSync(filePath);
@@ -216,14 +245,14 @@ function listActiveSessionIds() {
       reapEventLogSiblings(eventLogPath);
     }
   }
-  return { active, livePaths };
+  return { active, livePaths, liveOwners };
 }
 function sweepStaleEventLogs(dir = DEFAULT_DIR, minAgeMs = DEFAULT_MIN_AGE_MS) {
   try {
     fs.unlinkSync(path.join(dir, "kojee-events-no-session.log"));
   } catch {
   }
-  const { active, livePaths } = listActiveSessionIds();
+  const { active, livePaths } = scanDiscovery(true);
   let entries;
   try {
     entries = fs.readdirSync(dir);
@@ -266,6 +295,7 @@ function sweepStaleEventLogs(dir = DEFAULT_DIR, minAgeMs = DEFAULT_MIN_AGE_MS) {
 export {
   STATUS_LINE_PREFIX,
   statusLogPath,
+  resolveEventLogPath,
   startEventLog,
   monitorHeartbeatPath,
   nudgeSentinelPath,

package/dist/chunk-U5HHHRXA.js

@@ -0,0 +1,103 @@
+// src/fs-retry.ts
+import fs from "fs";
+var RETRYABLE = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function withFileOpRetry(op, opts = {}) {
+  const tries = opts.tries ?? 5;
+  const backoffMs = opts.backoffMs ?? 15;
+  let lastErr;
+  for (let i = 0; i < tries; i++) {
+    try {
+      return op();
+    } catch (err) {
+      const code = err.code;
+      if (!code || !RETRYABLE.has(code)) throw err;
+      lastErr = err;
+      if (i < tries - 1) sleepSync(backoffMs);
+    }
+  }
+  throw lastErr;
+}
+function renameSyncRetry(from, to, opts) {
+  withFileOpRetry(() => fs.renameSync(from, to), opts);
+}
+function unlinkSyncRetry(p, opts) {
+  try {
+    withFileOpRetry(() => fs.unlinkSync(p), opts);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+
+// src/secure-file.ts
+import fs2 from "fs";
+import os from "os";
+import { execFileSync } from "child_process";
+function isWindows() {
+  return process.platform === "win32";
+}
+function secureFile(filePath) {
+  if (isWindows()) {
+    restrictAclToCurrentUser(filePath, "(F)");
+  } else {
+    try {
+      fs2.chmodSync(filePath, 384);
+    } catch {
+    }
+  }
+}
+function secureDir(dirPath) {
+  if (isWindows()) {
+    restrictAclToCurrentUser(dirPath, "(OI)(CI)(F)");
+  } else {
+    try {
+      fs2.chmodSync(dirPath, 448);
+    } catch {
+    }
+  }
+}
+function currentUserSid() {
+  try {
+    const out = execFileSync("whoami", ["/user", "/fo", "csv", "/nh"], { encoding: "utf8" });
+    const m = out.match(/S-1-[0-9-]+/);
+    return m ? m[0] : null;
+  } catch {
+    return null;
+  }
+}
+function restrictAclToCurrentUser(target, permission) {
+  try {
+    const sid = currentUserSid();
+    const grantee = sid ? `*${sid}` : os.userInfo().username;
+    execFileSync("icacls", [target, "/grant:r", `${grantee}:${permission}`], { stdio: "ignore" });
+    execFileSync("icacls", [target, "/inheritance:r"], { stdio: "ignore" });
+    if (permission.includes("(F)")) {
+      try {
+        fs2.accessSync(target, fs2.constants.R_OK);
+      } catch {
+        try {
+          execFileSync("icacls", [target, "/grant:r", `${grantee}:${permission}`], { stdio: "ignore" });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function createSecureFileSync(filePath) {
+  unlinkSyncRetry(filePath);
+  const fd = fs2.openSync(filePath, "wx", 384);
+  fs2.closeSync(fd);
+  secureFile(filePath);
+}
+
+export {
+  renameSyncRetry,
+  unlinkSyncRetry,
+  secureFile,
+  secureDir,
+  createSecureFileSync
+};