@askexenow/exe-os 0.9.280 → 0.9.282

package/dist/chunk-F6L33PAQ.js

@@ -0,0 +1,231 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-MYEABW5Z.js";
+import {
+  atomicWriteJsonSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/session-registry.ts
+import { readFileSync, mkdirSync, existsSync, openSync, closeSync, writeSync, unlinkSync, constants } from "fs";
+import { execFileSync } from "child_process";
+import path from "path";
+import os from "os";
+var REGISTRY_PATH = path.join(os.homedir(), ".exe-os", "session-registry.json");
+var REGISTRY_LOCK_PATH = `${REGISTRY_PATH}.lock`;
+var REGISTRY_CACHE_TTL_MS = 100;
+var registryCache = null;
+function acquireRegistryLock() {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const data = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
+  const deadline = Date.now() + 250;
+  while (Date.now() < deadline) {
+    try {
+      const fd = openSync(REGISTRY_LOCK_PATH, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
+      writeSync(fd, data);
+      closeSync(fd);
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") return false;
+      try {
+        const lock = JSON.parse(readFileSync(REGISTRY_LOCK_PATH, "utf8"));
+        if (Date.now() - Number(lock.timestamp ?? 0) > 3e4) unlinkSync(REGISTRY_LOCK_PATH);
+      } catch {
+        try {
+          unlinkSync(REGISTRY_LOCK_PATH);
+        } catch {
+        }
+      }
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+  }
+  return false;
+}
+function releaseRegistryLock() {
+  try {
+    unlinkSync(REGISTRY_LOCK_PATH);
+  } catch {
+  }
+}
+function readSessionsUncached() {
+  try {
+    const raw = readFileSync(REGISTRY_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function writeSessions(sessions) {
+  atomicWriteJsonSync(REGISTRY_PATH, sessions);
+  registryCache = { at: Date.now(), sessions };
+}
+function registerSession(entry) {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const _locked = acquireRegistryLock();
+  try {
+    const sessions = readSessionsUncached();
+    const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
+    if (idx >= 0) {
+      sessions[idx] = entry;
+    } else {
+      sessions.push(entry);
+    }
+    writeSessions(sessions);
+  } finally {
+    if (_locked) releaseRegistryLock();
+  }
+  recordOrchestrationEventBestEffort({
+    eventType: "registry.registered",
+    source: "session-registry.registerSession",
+    agentId: entry.agentId,
+    sessionScope: entry.parentExe,
+    tmuxSession: entry.windowName,
+    payload: { hasProjectDir: Boolean(entry.projectDir) }
+  });
+}
+function refreshSessionProject(windowName, projectDir) {
+  if (!acquireRegistryLock()) return;
+  try {
+    const sessions = readSessionsUncached();
+    const entry = sessions.find((s) => s.windowName === windowName);
+    if (!entry || entry.projectDir === projectDir) return;
+    entry.projectDir = projectDir;
+    writeSessions(sessions);
+  } catch {
+  } finally {
+    releaseRegistryLock();
+  }
+}
+function listSessions() {
+  const now = Date.now();
+  if (registryCache && now - registryCache.at < REGISTRY_CACHE_TTL_MS) {
+    return registryCache.sessions;
+  }
+  const sessions = readSessionsUncached();
+  registryCache = { at: now, sessions };
+  return sessions;
+}
+function pruneStaleSessions() {
+  if (!acquireRegistryLock()) return 0;
+  const sessions = readSessionsUncached();
+  if (sessions.length === 0) {
+    releaseRegistryLock();
+    return 0;
+  }
+  let liveSessions = [];
+  try {
+    liveSessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim().split("\n").filter(Boolean);
+  } catch {
+    releaseRegistryLock();
+    return 0;
+  }
+  const liveSet = new Set(liveSessions);
+  const alive = sessions.filter((s) => liveSet.has(s.windowName));
+  const staleSessions = sessions.filter((s) => !liveSet.has(s.windowName));
+  if (staleSessions.length > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_tmux",
+      source: "session-registry.pruneStaleSessions",
+      severity: "warn",
+      attempt: staleSessions.length,
+      payload: {
+        count: staleSessions.length,
+        examples: staleSessions.slice(0, 5).map((s) => s.windowName)
+      }
+    });
+  }
+  const pruned = sessions.length - alive.length;
+  if (pruned > 0) {
+    writeSessions(alive);
+  }
+  releaseRegistryLock();
+  return pruned;
+}
+function checkSessionRegistryConsistency(liveSessionsOverride) {
+  const sessions = listSessions();
+  const result = { missingTmux: 0, missingRegistry: 0 };
+  let liveSessions = liveSessionsOverride;
+  if (!liveSessions) {
+    try {
+      liveSessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim().split("\n").filter(Boolean);
+    } catch {
+      return result;
+    }
+  }
+  const liveSet = new Set(liveSessions);
+  const registeredSet = new Set(sessions.map((s) => s.windowName));
+  const missingTmuxExamples = [];
+  const missingRegistryExamples = [];
+  for (const entry of sessions) {
+    if (liveSet.has(entry.windowName)) continue;
+    result.missingTmux++;
+    if (missingTmuxExamples.length < 5) missingTmuxExamples.push(entry.windowName);
+  }
+  for (const live of liveSessions) {
+    if (registeredSet.has(live)) continue;
+    if (!looksLikeExeOsSession(live)) continue;
+    result.missingRegistry++;
+    if (missingRegistryExamples.length < 5) missingRegistryExamples.push(live);
+  }
+  if (result.missingTmux > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_tmux",
+      source: "session-registry.checkSessionRegistryConsistency",
+      severity: "warn",
+      attempt: result.missingTmux,
+      payload: {
+        count: result.missingTmux,
+        examples: missingTmuxExamples
+      }
+    });
+  }
+  if (result.missingRegistry > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_entry",
+      source: "session-registry.checkSessionRegistryConsistency",
+      severity: "warn",
+      attempt: result.missingRegistry,
+      payload: {
+        count: result.missingRegistry,
+        examples: missingRegistryExamples
+      }
+    });
+  }
+  return result;
+}
+function looksLikeExeOsSession(sessionName) {
+  const coordName = getCoordinatorNameCached();
+  const escaped = coordName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const coordPattern = new RegExp(`^${escaped}\\d*$`);
+  const employeePattern = new RegExp(`-${escaped}\\d*$`);
+  return coordPattern.test(sessionName) || employeePattern.test(sessionName);
+}
+function getCoordinatorNameCached() {
+  try {
+    const rosterPath = path.join(os.homedir(), ".exe-os", "exe-employees.json");
+    if (existsSync(rosterPath)) {
+      const roster = JSON.parse(readFileSync(rosterPath, "utf8"));
+      const coo = roster.find((e) => (e.role ?? "").toUpperCase() === "COO");
+      if (coo?.name) return coo.name;
+    }
+  } catch {
+  }
+  return "exe";
+}
+
+export {
+  registerSession,
+  refreshSessionProject,
+  listSessions,
+  pruneStaleSessions,
+  checkSessionRegistryConsistency
+};

package/dist/chunk-FC2SCTVE.js

@@ -0,0 +1,38 @@
+import {
+  listReminders
+} from "./chunk-6TRSVY7L.js";
+
+// src/mcp/tools/list-reminders.ts
+import { z } from "zod";
+function registerListReminders(server) {
+  server.registerTool(
+    "list_reminders",
+    {
+      title: "List Reminders",
+      description: "List active reminders. Pass include_completed=true to see all.",
+      inputSchema: {
+        include_completed: z.boolean().optional().default(false).describe("Include completed reminders")
+      }
+    },
+    async ({ include_completed }) => {
+      const reminders = await listReminders(include_completed);
+      if (reminders.length === 0) {
+        return {
+          content: [{ type: "text", text: "No active reminders." }]
+        };
+      }
+      const lines = reminders.map((r) => {
+        const due = r.dueDate ? ` (due: ${r.dueDate})` : "";
+        const done = r.completedAt ? " [DONE]" : "";
+        return `\u2022 ${r.text}${due}${done}  [id: ${r.id.slice(0, 8)}]`;
+      });
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+export {
+  registerListReminders
+};