kojee-mcp 0.5.19 → 0.7.0

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
+};

package/dist/chunk-WBXU27BF.js

@@ -0,0 +1,35 @@
+import {
+  readSessionDiscoveryByKey
+} from "./chunk-67F67AQ6.js";
+import {
+  deriveDiscoveryKey,
+  findClaudeAncestorPid
+} from "./chunk-XJEBJIQE.js";
+import {
+  resolveSharedSessionId
+} from "./chunk-KNEJTD6G.js";
+
+// src/hooks/discovery.ts
+async function resolveHookDiscovery(stdinSessionId, deps = {}) {
+  const read = deps.readDiscovery ?? readSessionDiscoveryByKey;
+  const findPid = deps.findAncestorPid ?? findClaudeAncestorPid;
+  const projectDir = deps.projectDir !== void 0 ? deps.projectDir : process.env["CLAUDE_PROJECT_DIR"];
+  const sessionId = resolveSharedSessionId({ env: {}, stdinSessionId });
+  if (sessionId) {
+    const sidKey = deriveDiscoveryKey(projectDir, null, sessionId);
+    const sidHit = read(sidKey);
+    if (sidHit) return { discovery: sidHit, key: sidKey };
+    const ccPid2 = await findPid();
+    const legacyKey2 = deriveDiscoveryKey(projectDir, ccPid2, null);
+    const legacyHit = read(legacyKey2);
+    if (legacyHit) return { discovery: legacyHit, key: legacyKey2 };
+    return { discovery: null, key: sidKey };
+  }
+  const ccPid = await findPid();
+  const legacyKey = deriveDiscoveryKey(projectDir, ccPid, null);
+  return { discovery: read(legacyKey), key: legacyKey };
+}
+
+export {
+  resolveHookDiscovery
+};

package/dist/chunk-WIU5WGDF.js

@@ -0,0 +1,10 @@
+// src/hooks/codex-pending-path.ts
+import os from "os";
+import path from "path";
+function codexPendingMarkerPath() {
+  return path.join(os.homedir(), ".kojee", "codex-pending");
+}
+
+export {
+  codexPendingMarkerPath
+};

package/dist/chunk-XJEBJIQE.js

@@ -0,0 +1,52 @@
+// src/runtime/ancestry.ts
+import psList from "ps-list";
+import { createHash } from "crypto";
+var CLAUDE_PROCESS_RE = /\bclaude\b/i;
+function rowLooksLikeClaude(row) {
+  return CLAUDE_PROCESS_RE.test(`${row.name} ${row.cmd ?? ""}`);
+}
+async function findClaudeAncestorPid(startPid = process.ppid) {
+  let processes;
+  try {
+    processes = await psList();
+  } catch {
+    return null;
+  }
+  const byPid = /* @__PURE__ */ new Map();
+  for (const p of processes) byPid.set(p.pid, p);
+  let pid = startPid;
+  for (let depth = 0; depth < 20 && pid !== void 0 && pid > 1; depth++) {
+    const row = byPid.get(pid);
+    if (!row) return null;
+    if (rowLooksLikeClaude(row)) return pid;
+    if (row.ppid === void 0 || row.ppid === pid) return null;
+    pid = row.ppid;
+  }
+  return null;
+}
+async function pidLooksLikeClaude(pid) {
+  let processes;
+  try {
+    processes = await psList();
+  } catch {
+    return null;
+  }
+  const row = processes.find((p) => p.pid === pid);
+  if (!row) return null;
+  return rowLooksLikeClaude(row);
+}
+function deriveDiscoveryKey(projectDir, ccPid, sessionId) {
+  const hasProjectDir = typeof projectDir === "string" && projectDir.length > 0;
+  const prefix = createHash("sha256").update(hasProjectDir ? projectDir : "<no-project>").digest("hex").slice(0, 12);
+  const sid = typeof sessionId === "string" ? sessionId.trim() : "";
+  if (sid) return `${prefix}-s-${sid}`;
+  if (!hasProjectDir && ccPid === null) return `orphan-${process.pid}`;
+  if (ccPid === null) return `${prefix}-orphan`;
+  return `${prefix}-${ccPid}`;
+}
+
+export {
+  findClaudeAncestorPid,
+  pidLooksLikeClaude,
+  deriveDiscoveryKey
+};

package/dist/chunk-Z5LPNJQ6.js

@@ -0,0 +1,20 @@
+// src/tandem/session-id.ts
+import crypto from "crypto";
+import { ulid } from "ulidx";
+var MCP_SESSION_ID = ulid();
+function deriveStableSessionId(token, instanceKey) {
+  return crypto.createHash("sha256").update(`${token}:${instanceKey}`).digest("hex").slice(0, 32);
+}
+var _stableSessionId = null;
+function setStableSessionId(id) {
+  _stableSessionId = id;
+}
+function getSessionId() {
+  return _stableSessionId ?? MCP_SESSION_ID;
+}
+
+export {
+  deriveStableSessionId,
+  setStableSessionId,
+  getSessionId
+};