@askexenow/exe-os 0.9.287 → 0.9.289

package/dist/chunk-6MFM4N37.js

@@ -0,0 +1,574 @@
+import {
+  ensureDaemonToken,
+  readDaemonToken
+} from "./chunk-32K5NWMR.js";
+import {
+  computeDaemonHeapCapMb
+} from "./chunk-3XX3CDKF.js";
+import {
+  requestRestart
+} from "./chunk-7L2EV3XX.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-5P3HOBZX.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 _lastAliveSocketWarningAt = 0;
+var _missingSocketRecoveryAttemptedAt = 0;
+var _connectFailedAt = 0;
+var CONNECT_FAILFAST_COOLDOWN_MS = 1e4;
+var HEALTH_CHECK_INTERVAL = 100;
+var MAX_RETRIES_BEFORE_RESTART = 3;
+var RETRY_DELAYS_MS = [1e3, 3e3, 5e3];
+var ALIVE_SOCKET_WARNING_INTERVAL_MS = 6e4;
+var MISSING_SOCKET_RECOVERY_INTERVAL_MS = 6e4;
+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 readDaemonPid() {
+  if (!existsSync(PID_PATH)) return null;
+  try {
+    const pid = parseInt(readFileSync(PID_PATH, "utf8").trim(), 10);
+    return pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function warnAliveSocketUnresponsive(message) {
+  const now = Date.now();
+  if (now - _lastAliveSocketWarningAt < ALIVE_SOCKET_WARNING_INTERVAL_MS) return;
+  _lastAliveSocketWarningAt = now;
+  process.stderr.write(`${message}
+`);
+}
+function shouldRecoverMissingSocket() {
+  if (existsSync(SOCKET_PATH)) return false;
+  if (!isDaemonPidAlive()) return false;
+  const now = Date.now();
+  if (now - _missingSocketRecoveryAttemptedAt < MISSING_SOCKET_RECOVERY_INTERVAL_MS) return false;
+  _missingSocketRecoveryAttemptedAt = now;
+  return true;
+}
+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 = computeDaemonHeapCapMb(totalGB);
+  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()) {
+    _connectFailedAt = 0;
+    return true;
+  }
+  if (_connectFailedAt > 0 && Date.now() - _connectFailedAt < CONNECT_FAILFAST_COOLDOWN_MS) {
+    return false;
+  }
+  if (shouldRecoverMissingSocket()) {
+    const pid = readDaemonPid();
+    process.stderr.write(
+      `[exed-client] Daemon socket missing while PID ${pid ?? "unknown"} is alive \u2014 requesting supervised recovery
+`
+    );
+    killAndRespawnDaemon("daemon socket missing while PID alive", { forceMissingSocket: true });
+  }
+  if (isDaemonPidAlive()) {
+    warnAliveSocketUnresponsive("[exed-client] Daemon PID alive but socket unresponsive \u2014 waiting for recovery (not spawning duplicate)");
+  } 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()) {
+      _connectFailedAt = 0;
+      return true;
+    }
+    delay = Math.min(delay * 2, 3e3);
+  }
+  _connectFailedAt = Date.now();
+  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 canClientRequestDaemonRestart() {
+  return process.env.EXE_DAEMON_CLIENT_CAN_RESTART === "1";
+}
+function killAndRespawnDaemon(reason, opts) {
+  if (!opts?.forceMissingSocket && !canClientRequestDaemonRestart()) {
+    process.stderr.write(
+      `[exed-client] Restart suppressed (${reason ?? "consecutive failures"}) \u2014 client-side daemon restarts are disabled; degrading gracefully.
+`
+    );
+    if (_socket) {
+      _socket.destroy();
+      _socket = null;
+    }
+    _connected = false;
+    _buffer = "";
+    return false;
+  }
+  const result = requestRestart(reason ?? "consecutive failures", opts);
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  if (!result.ok) {
+    return false;
+  }
+  if (!isDaemonPidAlive()) {
+    spawnDaemon();
+  } else {
+    process.stderr.write("[exed-client] Daemon PID alive after kill \u2014 launchd will restart when it exits\n");
+  }
+  return true;
+}
+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 handling daemon failure
+`);
+  const restartRequested = killAndRespawnDaemon(`${label}: ${_consecutiveFailures} consecutive failures`, { isEmbedRelated: isEmbed });
+  if (!restartRequested) {
+    return result;
+  }
+  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 handling daemon failure
+`);
+      const restartRequested = killAndRespawnDaemon(`Embed health check failed at request ${_requestCount}`, { isEmbedRelated: true });
+      if (!restartRequested) return null;
+      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 isDaemonAutoReconnecting() {
+  return _autoReconnecting;
+}
+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,
+  isDaemonAutoReconnecting,
+  sendIngestRequest
+};