@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-L24HYX62.js

@@ -0,0 +1,498 @@
+import {
+  ensureDaemonToken,
+  readDaemonToken
+} from "./chunk-YADYM2DE.js";
+import {
+  requestRestart
+} from "./chunk-PWMMIGVQ.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-TNTFEWU5.js";
+
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import os from "os";
+import { spawn, execSync } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync, unlinkSync, readFileSync, openSync, closeSync, statSync, writeSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path.join(EXE_AI_DIR, "exed.sock");
+var PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path.join(EXE_AI_DIR, "exed.pid");
+var SPAWN_LOCK_PATH = path.join(EXE_AI_DIR, "exed-spawn.lock");
+var SPAWN_LOCK_STALE_MS = 3e4;
+var CONNECT_TIMEOUT_MS = 15e3;
+var REQUEST_TIMEOUT_MS = 3e4;
+var DAEMON_TOKEN_ENV = "EXE_DAEMON_TOKEN";
+var _socket = null;
+var _connected = false;
+var _autoReconnecting = false;
+var _buffer = "";
+var _requestCount = 0;
+var _consecutiveFailures = 0;
+var HEALTH_CHECK_INTERVAL = 100;
+var MAX_RETRIES_BEFORE_RESTART = 3;
+var RETRY_DELAYS_MS = [1e3, 3e3, 5e3];
+var _pending = /* @__PURE__ */ new Map();
+var MAX_BUFFER = 1e7;
+function handleData(chunk) {
+  _buffer += chunk.toString();
+  if (_buffer.length > MAX_BUFFER) {
+    _buffer = "";
+    return;
+  }
+  let newlineIdx;
+  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
+    const line = _buffer.slice(0, newlineIdx).trim();
+    _buffer = _buffer.slice(newlineIdx + 1);
+    if (!line) continue;
+    try {
+      const response = JSON.parse(line);
+      const id = response.id;
+      if (!id) continue;
+      const entry = _pending.get(id);
+      if (entry) {
+        clearTimeout(entry.timer);
+        _pending.delete(id);
+        entry.resolve(response);
+      }
+    } catch {
+    }
+  }
+}
+var _zombieCache = null;
+function isZombie(pid) {
+  if (_zombieCache && _zombieCache.pid === pid && Date.now() - _zombieCache.ts < 2e3) {
+    return _zombieCache.result;
+  }
+  try {
+    const state = execSync(`ps -p ${pid} -o state=`, { encoding: "utf8", timeout: 2e3 }).trim();
+    const result = state.startsWith("Z");
+    _zombieCache = { pid, result, ts: Date.now() };
+    return result;
+  } catch {
+    _zombieCache = { pid, result: false, ts: Date.now() };
+    return false;
+  }
+}
+function cleanupStaleFiles() {
+  if (existsSync(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          if (!isZombie(pid)) {
+            return;
+          }
+          process.stderr.write(`[exed-client] PID ${pid} is a zombie \u2014 cleaning up stale files
+`);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function isDaemonPidAlive() {
+  if (!existsSync(PID_PATH)) return false;
+  try {
+    const pid = parseInt(readFileSync(PID_PATH, "utf8").trim(), 10);
+    if (!(pid > 0)) return false;
+    process.kill(pid, 0);
+    return !isZombie(pid);
+  } catch {
+    return false;
+  }
+}
+function findPackageRoot() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  const { root } = path.parse(dir);
+  while (dir !== root) {
+    if (existsSync(path.join(dir, "package.json"))) return dir;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+function spawnDaemon() {
+  try {
+    const result = execSync("launchctl list com.askexe.exed 2>/dev/null", { encoding: "utf8", timeout: 3e3 });
+    if (result.includes("com.askexe.exed")) {
+      process.stderr.write("[exed-client] Daemon not responding \u2014 launchd will restart it. Waiting...\n");
+      return;
+    }
+  } catch {
+  }
+  process.stderr.write("[exed-client] No launchd supervisor \u2014 spawning daemon directly (dev mode)\n");
+  const totalGB = os.totalmem() / (1024 * 1024 * 1024);
+  if (totalGB <= 8) {
+    process.stderr.write(`[exed-client] SKIP: ${totalGB.toFixed(0)}GB system \u2014 daemon disabled.
+`);
+    return;
+  }
+  const pkgRoot = findPackageRoot();
+  if (!pkgRoot) {
+    process.stderr.write("[exed-client] WARN: cannot find package root\n");
+    return;
+  }
+  const daemonPath = path.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync(daemonPath)) {
+    process.stderr.write(`[exed-client] WARN: daemon not found at ${daemonPath}
+`);
+    return;
+  }
+  const daemonToken = ensureDaemonToken(process.env[DAEMON_TOKEN_ENV] ?? null);
+  const logPath = path.join(path.dirname(SOCKET_PATH), "exed.log");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const heapCapMB = totalGB <= 16 ? 2048 : Math.min(Math.round(totalGB * 0.25 * 1024), 6144);
+  const child = spawn(process.execPath, [`--max-old-space-size=${heapCapMB}`, "--expose-gc", daemonPath], {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd],
+    env: {
+      ...process.env,
+      TMUX: void 0,
+      TMUX_PANE: void 0,
+      EXE_DAEMON_SOCK: SOCKET_PATH,
+      EXE_DAEMON_PID: PID_PATH,
+      [DAEMON_TOKEN_ENV]: daemonToken
+    }
+  });
+  child.unref();
+  if (typeof stderrFd === "number") try {
+    closeSync(stderrFd);
+  } catch {
+  }
+}
+function acquireSpawnLock() {
+  try {
+    const fd = openSync(SPAWN_LOCK_PATH, "wx");
+    writeSync(fd, String(process.pid));
+    closeSync(fd);
+    return true;
+  } catch {
+    try {
+      const lockContent = readFileSync(SPAWN_LOCK_PATH, "utf8").trim();
+      const lockPid = parseInt(lockContent, 10);
+      const stat = statSync(SPAWN_LOCK_PATH);
+      const isStale = Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS;
+      let holderDead = false;
+      if (lockPid > 0) {
+        try {
+          process.kill(lockPid, 0);
+        } catch {
+          holderDead = true;
+        }
+      }
+      if (isStale || holderDead) {
+        try {
+          unlinkSync(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          writeSync(fd, String(process.pid));
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync(SPAWN_LOCK_PATH);
+  } catch {
+  }
+}
+function connectToSocket() {
+  return new Promise((resolve) => {
+    if (_socket && _connected) {
+      resolve(true);
+      return;
+    }
+    const socket = net.createConnection({ path: SOCKET_PATH });
+    const connectTimeout = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, 2e3);
+    socket.on("connect", () => {
+      clearTimeout(connectTimeout);
+      _socket = socket;
+      _connected = true;
+      _buffer = "";
+      socket.on("data", handleData);
+      socket.on("close", () => {
+        _connected = false;
+        _socket = null;
+        for (const [id, entry] of _pending) {
+          clearTimeout(entry.timer);
+          _pending.delete(id);
+          entry.resolve({ error: "Connection closed" });
+        }
+        if (!_autoReconnecting) {
+          _autoReconnecting = true;
+          const maxRetries = 20;
+          let attempt = 0;
+          const daemonDead = !isDaemonPidAlive();
+          if (daemonDead) {
+            process.stderr.write("[daemon-client] Daemon PID dead \u2014 fast-path respawn (skipping jitter)\n");
+            try {
+              cleanupStaleFiles();
+              if (acquireSpawnLock()) {
+                try {
+                  spawnDaemon();
+                } finally {
+                  releaseSpawnLock();
+                }
+              }
+            } catch {
+            }
+          }
+          const jitter = daemonDead ? () => 500 + Math.random() * 500 : () => 2e3 + Math.random() * 2e3;
+          const initialDelay = daemonDead ? 200 : Math.random() * 2e3;
+          setTimeout(() => {
+            const retryTimer = setInterval(async () => {
+              attempt++;
+              if (attempt > maxRetries) {
+                clearInterval(retryTimer);
+                _autoReconnecting = false;
+                process.stderr.write(`[daemon-client] Auto-reconnect failed after ${maxRetries} attempts
+`);
+                return;
+              }
+              const ok = await connectToSocket();
+              if (ok) {
+                clearInterval(retryTimer);
+                _autoReconnecting = false;
+                if (attempt > 1) process.stderr.write(`[daemon-client] Auto-reconnected to daemon (attempt ${attempt})
+`);
+              }
+            }, jitter());
+          }, initialDelay);
+        }
+      });
+      socket.on("error", () => {
+        _connected = false;
+        _socket = null;
+      });
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(connectTimeout);
+      resolve(false);
+    });
+  });
+}
+async function connectEmbedDaemon() {
+  if (process.env.EXE_DISABLE_DAEMON_AUTOSTART === "1" || process.env.VITEST) {
+    return connectToSocket();
+  }
+  if (_socket && _connected) return true;
+  if (await connectToSocket()) return true;
+  if (isDaemonPidAlive()) {
+    process.stderr.write("[exed-client] Daemon PID alive but socket unresponsive \u2014 waiting for recovery (not spawning duplicate)\n");
+  } else if (acquireSpawnLock()) {
+    try {
+      cleanupStaleFiles();
+      spawnDaemon();
+    } finally {
+      releaseSpawnLock();
+    }
+  }
+  const start = Date.now();
+  let delay = 100;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay));
+    if (await connectToSocket()) return true;
+    delay = Math.min(delay * 2, 3e3);
+  }
+  return false;
+}
+function sendRequest(texts, priority) {
+  return sendDaemonRequest({ texts, priority });
+}
+function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise(async (resolve) => {
+    if ((!_socket || !_connected) && _autoReconnecting) {
+      const waitStart = Date.now();
+      while (!_connected && Date.now() - waitStart < 15e3) {
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+    }
+    if (!_socket || !_connected) {
+      resolve({ error: "Not connected" });
+      return;
+    }
+    const id = randomUUID();
+    const token = process.env[DAEMON_TOKEN_ENV] ?? readDaemonToken();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve({ error: "Request timeout" });
+    }, timeoutMs);
+    _pending.set(id, { resolve, timer });
+    try {
+      _socket.write(JSON.stringify({ id, token, ...payload }) + "\n");
+    } catch {
+      clearTimeout(timer);
+      _pending.delete(id);
+      resolve({ error: "Write failed" });
+    }
+  });
+}
+async function pingDaemon() {
+  if (!_socket || !_connected) return null;
+  const response = await sendDaemonRequest({ type: "health" }, 5e3);
+  if (response.health) {
+    return response.health;
+  }
+  return null;
+}
+function killAndRespawnDaemon(reason, opts) {
+  const result = requestRestart(reason ?? "consecutive failures", opts);
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  if (!result.ok) {
+    return;
+  }
+  if (!isDaemonPidAlive()) {
+    spawnDaemon();
+  } else {
+    process.stderr.write("[exed-client] Daemon PID alive after kill \u2014 launchd will restart when it exits\n");
+  }
+}
+async function retryThenRestart(doRequest, label) {
+  const result = await doRequest();
+  if (!result.error) {
+    _consecutiveFailures = 0;
+    return result;
+  }
+  if (result.error.includes("Model not loaded") || result.error.includes("embeddings unavailable")) {
+    return result;
+  }
+  _consecutiveFailures++;
+  for (let i = 0; i < MAX_RETRIES_BEFORE_RESTART; i++) {
+    const delayMs = RETRY_DELAYS_MS[i] ?? 5e3;
+    process.stderr.write(`[exed-client] ${label} failed (${result.error}), retry ${i + 1}/${MAX_RETRIES_BEFORE_RESTART} in ${delayMs}ms
+`);
+    await new Promise((r) => setTimeout(r, delayMs));
+    if (!_connected) {
+      if (!await connectToSocket()) continue;
+    }
+    const retry = await doRequest();
+    if (!retry.error) {
+      _consecutiveFailures = 0;
+      return retry;
+    }
+    _consecutiveFailures++;
+  }
+  const isEmbed = label.toLowerCase().includes("embed");
+  process.stderr.write(`[exed-client] ${label}: ${_consecutiveFailures} consecutive failures \u2014 requesting daemon restart
+`);
+  killAndRespawnDaemon(`${label}: ${_consecutiveFailures} consecutive failures`, { isEmbedRelated: isEmbed });
+  const start = Date.now();
+  let delay = 200;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay));
+    if (await connectToSocket()) break;
+    delay = Math.min(delay * 2, 3e3);
+  }
+  if (!_connected) return { error: "Daemon restart failed" };
+  const final = await doRequest();
+  if (!final.error) _consecutiveFailures = 0;
+  return final;
+}
+async function embedViaClient(text, priority = "high") {
+  const _oomPath = path.join(os.homedir(), ".exe-os", "embedding-oom-marker");
+  if (existsSync(_oomPath)) return null;
+  if (!_connected && !await connectEmbedDaemon()) return null;
+  _requestCount++;
+  if (_requestCount % HEALTH_CHECK_INTERVAL === 0) {
+    const health = await pingDaemon();
+    if (!health) {
+      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 requesting daemon restart
+`);
+      killAndRespawnDaemon(`Embed health check failed at request ${_requestCount}`, { isEmbedRelated: true });
+      const start = Date.now();
+      let d = 200;
+      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+        await new Promise((r) => setTimeout(r, d));
+        if (await connectToSocket()) break;
+        d = Math.min(d * 2, 3e3);
+      }
+      if (!_connected) return null;
+    }
+  }
+  const result = await retryThenRestart(
+    () => sendRequest([text], priority),
+    "Embed"
+  );
+  return !result.error && result.vectors?.[0] ? result.vectors[0] : null;
+}
+async function embedBatchViaClient(texts, priority = "high") {
+  const _oomPath2 = path.join(os.homedir(), ".exe-os", "embedding-oom-marker");
+  if (existsSync(_oomPath2)) return null;
+  if (!_connected && !await connectEmbedDaemon()) return null;
+  _requestCount++;
+  const result = await retryThenRestart(
+    () => sendRequest(texts, priority),
+    "Batch embed"
+  );
+  return !result.error && result.vectors ? result.vectors : null;
+}
+function disconnectClient() {
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  for (const [id, entry] of _pending) {
+    clearTimeout(entry.timer);
+    _pending.delete(id);
+    entry.resolve({ error: "Client disconnected" });
+  }
+}
+function isClientConnected() {
+  return _connected;
+}
+function sendIngestRequest(payload) {
+  if (!_socket || !_connected) return false;
+  try {
+    const id = randomUUID();
+    const token = process.env[DAEMON_TOKEN_ENV] ?? readDaemonToken();
+    _socket.write(JSON.stringify({ id, token, type: "ingest", ...payload }) + "\n");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  connectEmbedDaemon,
+  sendDaemonRequest,
+  pingDaemon,
+  embedViaClient,
+  embedBatchViaClient,
+  disconnectClient,
+  isClientConnected,
+  sendIngestRequest
+};

package/dist/chunk-L3TB7CC3.js

@@ -0,0 +1,170 @@
+// src/adapters/runtime-hook-manifest.ts
+var EXE_HOOK_FILES = {
+  postToolCombined: "post-tool-combined.js",
+  ingest: "ingest.js",
+  errorRecall: "error-recall.js",
+  ingestWorker: "ingest-worker.js"
+};
+var EXE_HOOKS = {
+  postToolCombined: "dist/hooks/post-tool-combined.js",
+  sessionStart: "dist/hooks/session-start.js",
+  promptSubmit: "dist/hooks/prompt-submit.js",
+  heartbeat: "dist/hooks/exe-heartbeat-hook.js",
+  stop: "dist/hooks/stop.js",
+  preToolUse: "dist/hooks/pre-tool-use.js",
+  subagentStop: "dist/hooks/subagent-stop.js",
+  preCompact: "dist/hooks/pre-compact.js",
+  postCompact: "dist/hooks/post-compact.js",
+  sessionEnd: "dist/hooks/session-end.js",
+  notification: "dist/hooks/notification.js",
+  instructionsLoaded: "dist/hooks/instructions-loaded.js"
+};
+var EXE_HOOK_MANIFEST = [
+  {
+    key: "postToolCombined",
+    event: "PostToolUse",
+    commandMarker: EXE_HOOKS.postToolCombined,
+    owner: "exe-os",
+    purpose: "Single PostToolUse entrypoint for ingestion, error recall, summaries, and bug detection.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "none"
+  },
+  {
+    key: "sessionStart",
+    event: "SessionStart",
+    commandMarker: EXE_HOOKS.sessionStart,
+    owner: "exe-os",
+    purpose: "Loads agent identity, procedures, and boot context.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "none"
+  },
+  {
+    key: "promptSubmit",
+    event: "UserPromptSubmit",
+    commandMarker: EXE_HOOKS.promptSubmit,
+    owner: "exe-os",
+    purpose: "Injects current tasks, pending reviews, and local context before each prompt.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "none"
+  },
+  {
+    key: "heartbeat",
+    event: "UserPromptSubmit",
+    commandMarker: EXE_HOOKS.heartbeat,
+    owner: "exe-os",
+    purpose: "Lightweight heartbeat/status sidecar for Claude Code sessions.",
+    runtimes: ["claude"],
+    checkpointRole: "none"
+  },
+  {
+    key: "stop",
+    event: "Stop",
+    commandMarker: EXE_HOOKS.stop,
+    owner: "exe-os",
+    purpose: "Finalizes task state, capacity signals, and emergency checkpointing.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "capacity_checkpoint"
+  },
+  {
+    key: "preToolUse",
+    event: "PreToolUse",
+    commandMarker: EXE_HOOKS.preToolUse,
+    owner: "exe-os",
+    purpose: "Preflight guardrails before shell/tool execution.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "none"
+  },
+  {
+    key: "subagentStop",
+    event: "SubagentStop",
+    commandMarker: EXE_HOOKS.subagentStop,
+    owner: "exe-os",
+    purpose: "Captures subagent completion context.",
+    runtimes: ["claude"],
+    checkpointRole: "none"
+  },
+  {
+    key: "preCompact",
+    event: "PreCompact",
+    commandMarker: EXE_HOOKS.preCompact,
+    owner: "exe-os",
+    purpose: "Writes active-task snapshot and compaction recovery context.",
+    runtimes: ["claude"],
+    checkpointRole: "recovery_context"
+  },
+  {
+    key: "postCompact",
+    event: "PostCompact",
+    commandMarker: EXE_HOOKS.postCompact,
+    owner: "exe-os",
+    purpose: "Rehydrates recovery context after compaction.",
+    runtimes: ["claude"],
+    checkpointRole: "recovery_context"
+  },
+  {
+    key: "sessionEnd",
+    event: "SessionEnd",
+    commandMarker: EXE_HOOKS.sessionEnd,
+    owner: "exe-os",
+    purpose: "Stores session-end checkpoint and triages orphaned in-progress tasks.",
+    runtimes: ["claude"],
+    checkpointRole: "session_summary"
+  },
+  {
+    key: "notification",
+    event: "Notification",
+    commandMarker: EXE_HOOKS.notification,
+    owner: "exe-os",
+    purpose: "Captures runtime notifications and nudges.",
+    runtimes: ["claude"],
+    checkpointRole: "none"
+  },
+  {
+    key: "instructionsLoaded",
+    event: "InstructionsLoaded",
+    commandMarker: EXE_HOOKS.instructionsLoaded,
+    owner: "exe-os",
+    purpose: "Applies runtime instruction post-processing.",
+    runtimes: ["claude"],
+    checkpointRole: "none"
+  }
+];
+var LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS = [
+  "dist/hooks/ingest.js",
+  "dist/hooks/error-recall.js",
+  "dist/hooks/ingest-worker.js"
+];
+var LEGACY_HOME_DIR_HOOK_PATTERNS = [
+  ".exe-os/hooks/",
+  // Old hook storage path (pre-npm-package era)
+  "log-prefix.js",
+  // Removed hook from early versions
+  "approval-bridge.log"
+  // Removed log redirect from early versions
+];
+function isLegacyHomeDirHookCommand(command) {
+  return LEGACY_HOME_DIR_HOOK_PATTERNS.some((pattern) => command.includes(pattern));
+}
+function commandHasAnyMarker(command, markers) {
+  return markers.some((marker) => command.includes(marker));
+}
+function isLegacySplitPostToolCommand(command) {
+  return commandHasAnyMarker(command, LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS);
+}
+function manifestEntryForCommand(command) {
+  return EXE_HOOK_MANIFEST.find((entry) => command.includes(entry.commandMarker));
+}
+function textHasLegacySplitPostToolHook(text) {
+  return [EXE_HOOK_FILES.ingest, EXE_HOOK_FILES.errorRecall, EXE_HOOK_FILES.ingestWorker].some((file) => text.includes(file));
+}
+
+export {
+  EXE_HOOK_FILES,
+  EXE_HOOKS,
+  EXE_HOOK_MANIFEST,
+  LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS,
+  isLegacyHomeDirHookCommand,
+  isLegacySplitPostToolCommand,
+  manifestEntryForCommand,
+  textHasLegacySplitPostToolHook
+};