@askexenow/exe-os 0.9.68 → 0.9.69

package/dist/bin/cc-doctor.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/bin/exe-healthcheck.ts
-import { existsSync, readFileSync, readdirSync } from "fs";
-import path from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync } from "fs";
+import path3 from "path";
 import { execSync } from "child_process";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/is-main.ts
 import { realpathSync } from "fs";
@@ -21,31 +21,239 @@ function isMainModule(importMetaUrl) {
   }
 }
 
+// src/lib/config.ts
+import { readFile, writeFile } from "fs/promises";
+import { readFileSync, existsSync as existsSync2, renameSync } from "fs";
+import path from "path";
+import os from "os";
+
+// src/lib/secure-files.ts
+import { chmodSync, existsSync, mkdirSync } from "fs";
+import { chmod, mkdir } from "fs/promises";
+
+// src/lib/config.ts
+function resolveDataDir() {
+  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
+  if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
+  const newDir = path.join(os.homedir(), ".exe-os");
+  const legacyDir = path.join(os.homedir(), ".exe-mem");
+  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
+    try {
+      renameSync(legacyDir, newDir);
+      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
+`);
+    } catch {
+      return legacyDir;
+    }
+  }
+  return newDir;
+}
+var EXE_AI_DIR = resolveDataDir();
+var DB_PATH = path.join(EXE_AI_DIR, "memories.db");
+var MODELS_DIR = path.join(EXE_AI_DIR, "models");
+var CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
+var LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
+var CURRENT_CONFIG_VERSION = 1;
+var DEFAULT_CONFIG = {
+  config_version: CURRENT_CONFIG_VERSION,
+  dbPath: DB_PATH,
+  modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
+  embeddingDim: 1024,
+  batchSize: 20,
+  flushIntervalMs: 1e4,
+  autoIngestion: true,
+  autoRetrieval: true,
+  searchMode: "hybrid",
+  hookSearchMode: "hybrid",
+  fileGrepEnabled: true,
+  splashEffect: true,
+  consolidationEnabled: true,
+  consolidationIntervalMs: 6 * 60 * 60 * 1e3,
+  consolidationModel: "claude-haiku-4-5-20251001",
+  consolidationMaxCallsPerRun: 20,
+  selfQueryRouter: true,
+  selfQueryModel: "claude-haiku-4-5-20251001",
+  rerankerEnabled: true,
+  scalingRoadmap: {
+    rerankerAutoTrigger: {
+      enabled: true,
+      broadQueryMinCardinality: 5e4,
+      fetchTopK: 200,
+      returnTopK: 20
+    }
+  },
+  graphRagEnabled: true,
+  wikiEnabled: false,
+  wikiUrl: "",
+  wikiApiKey: "",
+  wikiSyncIntervalMs: 30 * 60 * 1e3,
+  wikiWorkspaceMapping: {},
+  wikiAutoUpdate: true,
+  wikiAutoUpdateThreshold: 0.5,
+  wikiAutoUpdateCreateNew: true,
+  skillLearning: true,
+  skillThreshold: 3,
+  skillModel: "claude-haiku-4-5-20251001",
+  exeHeartbeat: {
+    enabled: true,
+    intervalSeconds: 60,
+    staleInProgressThresholdHours: 2
+  },
+  sessionLifecycle: {
+    idleKillEnabled: true,
+    idleKillTicksRequired: 3,
+    idleKillIntercomAckWindowMs: 1e4,
+    maxAutoInstances: 10
+  },
+  autoUpdate: {
+    checkOnBoot: true,
+    autoInstall: false,
+    checkIntervalMs: 24 * 60 * 60 * 1e3
+  },
+  orchestration: {
+    phase: "phase_1_coo",
+    phaseSetBy: "default"
+  }
+};
+
+// src/lib/mcp-transport-health.ts
+import { appendFileSync, closeSync, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, readSync, statSync, writeFileSync } from "fs";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var MCP_HTTP_EVENTS_PATH = path2.join(EXE_AI_DIR, "mcp-http-events.jsonl");
+var MCP_MONITOR_DIR = path2.join(EXE_AI_DIR, "monitor");
+var MCP_TRANSPORT_SUMMARY_PATH = path2.join(MCP_MONITOR_DIR, "mcp-transport-summary.json");
+var DEFAULT_EVENT_READ_BYTES = 256 * 1024;
+var DEFAULT_EVENT_MAX_BYTES = 1024 * 1024;
+var EVENT_READ_BYTES = parsePositiveInt(process.env.EXE_MCP_HTTP_EVENT_READ_BYTES, DEFAULT_EVENT_READ_BYTES);
+var EVENT_MAX_BYTES = parsePositiveInt(process.env.EXE_MCP_HTTP_EVENT_MAX_BYTES, DEFAULT_EVENT_MAX_BYTES);
+function parsePositiveInt(value, fallback) {
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function readTailText(filePath, maxBytes) {
+  const stats = statSync(filePath);
+  if (stats.size <= maxBytes) return readFileSync2(filePath, "utf8");
+  const fd = openSync(filePath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(maxBytes);
+    readSync(fd, buffer, 0, maxBytes, stats.size - maxBytes);
+    const text = buffer.toString("utf8");
+    const firstNewline = text.indexOf("\n");
+    return firstNewline >= 0 ? text.slice(firstNewline + 1) : text;
+  } finally {
+    closeSync(fd);
+  }
+}
+function readPackageVersion() {
+  let dir = path2.dirname(fileURLToPath2(import.meta.url));
+  const { root } = path2.parse(dir);
+  while (dir !== root) {
+    const pkgPath = path2.join(dir, "package.json");
+    if (existsSync3(pkgPath)) {
+      try {
+        const parsed = JSON.parse(readFileSync2(pkgPath, "utf8"));
+        return parsed.version ?? "unknown";
+      } catch {
+        return "unknown";
+      }
+    }
+    dir = path2.dirname(dir);
+  }
+  return "unknown";
+}
+function parseMcpHttpEventLines(raw, limit = 200) {
+  const lines = raw.trim().split("\n").filter(Boolean).slice(-limit);
+  const events = [];
+  for (const line of lines) {
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return events;
+}
+function readMcpHttpEvents(limit = 200) {
+  if (!existsSync3(MCP_HTTP_EVENTS_PATH)) return [];
+  const raw = readTailText(MCP_HTTP_EVENTS_PATH, EVENT_READ_BYTES);
+  return parseMcpHttpEventLines(raw, limit);
+}
+function summarizeMcpTransport(events = readMcpHttpEvents()) {
+  const lastServerStartIndex = events.map((event) => event.message).lastIndexOf("server_started");
+  const scopedEvents = lastServerStartIndex >= 0 ? events.slice(lastServerStartIndex) : events;
+  const activeSessionEvent = [...scopedEvents].reverse().find((event) => typeof event.activeSessions === "number");
+  const successfulToolCalls = scopedEvents.filter((event) => event.message === "tool_call_ok");
+  const lastSuccessfulToolCall = successfulToolCalls.at(-1) ?? null;
+  const summary = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: readPackageVersion(),
+    scope: "local",
+    privacy: "metadata_only",
+    eventLogPath: MCP_HTTP_EVENTS_PATH,
+    activeSessions: activeSessionEvent?.activeSessions ?? null,
+    sessionsCreated: scopedEvents.filter((event) => event.message === "session_initialized").length,
+    sessionsClosed: scopedEvents.filter((event) => event.message === "session_closed").length,
+    missingSessionErrors: scopedEvents.filter((event) => event.message?.includes("missing MCP session")).length,
+    staleSessionErrors: scopedEvents.filter((event) => event.message?.includes("stale or unknown")).length,
+    transportErrors: scopedEvents.filter((event) => event.level === "warn" || event.level === "error").length,
+    lastSuccessfulHandshake: scopedEvents.filter((event) => event.message === "session_initialized").at(-1)?.timestamp ?? null,
+    lastSuccessfulToolCall: lastSuccessfulToolCall?.timestamp ?? null,
+    lastSuccessfulToolCallByRuntime: {},
+    lastSuccessfulToolCallByAgent: {},
+    lastSuccessfulToolCallByFamily: {},
+    activeSessionsByRuntime: {},
+    recentWarnings: scopedEvents.filter((event) => event.level === "warn" || event.level === "error").slice(-10),
+    remediation: [
+      "If MCP tools fail with missing/stale session, reconnect the MCP client (/mcp or restart the runtime).",
+      "Do not access the database directly; MCP is the only data interface.",
+      "Check get_daemon_health or exe-healthcheck for daemon/MCP endpoint status before retrying work."
+    ]
+  };
+  const createdBySession = /* @__PURE__ */ new Map();
+  for (const event of scopedEvents) {
+    if (event.message === "session_initialized" && event.sessionId) createdBySession.set(event.sessionId, event);
+    if ((event.message === "session_closed" || event.message === "session_expired") && event.sessionId) {
+      createdBySession.delete(event.sessionId);
+    }
+  }
+  for (const event of createdBySession.values()) {
+    const runtime = event.runtime ?? "Unknown";
+    summary.activeSessionsByRuntime[runtime] = (summary.activeSessionsByRuntime[runtime] ?? 0) + 1;
+  }
+  for (const event of successfulToolCalls) {
+    if (event.runtime) summary.lastSuccessfulToolCallByRuntime[event.runtime] = event.timestamp ?? "";
+    if (event.agentId) summary.lastSuccessfulToolCallByAgent[event.agentId] = event.timestamp ?? "";
+    if (event.toolFamily) summary.lastSuccessfulToolCallByFamily[event.toolFamily] = event.timestamp ?? "";
+  }
+  return summary;
+}
+
 // src/bin/exe-healthcheck.ts
 function findPackageRoot() {
-  let dir = path.dirname(fileURLToPath2(import.meta.url));
-  const { root } = path.parse(dir);
+  let dir = path3.dirname(fileURLToPath3(import.meta.url));
+  const { root } = path3.parse(dir);
   while (dir !== root) {
-    if (existsSync(path.join(dir, "package.json"))) return dir;
-    dir = path.dirname(dir);
+    if (existsSync4(path3.join(dir, "package.json"))) return dir;
+    dir = path3.dirname(dir);
   }
   throw new Error("Cannot find package root");
 }
 function checkBuildIntegrity(pkgRoot) {
   const results = [];
-  const tsupConfig = path.join(pkgRoot, "tsup.config.ts");
-  if (!existsSync(tsupConfig)) {
+  const tsupConfig = path3.join(pkgRoot, "tsup.config.ts");
+  if (!existsSync4(tsupConfig)) {
     return [{ name: "build/tsup-config", pass: false, detail: "tsup.config.ts not found" }];
   }
-  const configContent = readFileSync(tsupConfig, "utf-8");
+  const configContent = readFileSync3(tsupConfig, "utf-8");
   const entryMatches = configContent.matchAll(/"([^"]+)":\s*"src\//g);
   const missing = [];
   let total = 0;
   for (const match of entryMatches) {
     const outputKey = match[1];
-    const expectedPath = path.join(pkgRoot, "dist", `${outputKey}.js`);
+    const expectedPath = path3.join(pkgRoot, "dist", `${outputKey}.js`);
     total++;
-    if (!existsSync(expectedPath)) {
+    if (!existsSync4(expectedPath)) {
       missing.push(`dist/${outputKey}.js`);
     }
   }
@@ -67,8 +275,8 @@ function checkBuildIntegrity(pkgRoot) {
 }
 function checkEmbedPipeline(pkgRoot) {
   const results = [];
-  const daemonPath = path.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync(daemonPath)) {
+  const daemonPath = path3.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync4(daemonPath)) {
     results.push({
       name: "exed/daemon-exists",
       pass: false,
@@ -79,17 +287,17 @@ function checkEmbedPipeline(pkgRoot) {
   results.push({ name: "exed/daemon-exists", pass: true, detail: "dist/lib/exe-daemon.js exists" });
   const entryDirs = ["dist/hooks", "dist/bin", "dist/mcp"];
   for (const dir of entryDirs) {
-    const fullDir = path.join(pkgRoot, dir);
-    if (!existsSync(fullDir)) continue;
+    const fullDir = path3.join(pkgRoot, dir);
+    if (!existsSync4(fullDir)) continue;
     let walkDir = fullDir;
-    const { root } = path.parse(walkDir);
+    const { root } = path3.parse(walkDir);
     let foundRoot = null;
     while (walkDir !== root) {
-      if (existsSync(path.join(walkDir, "package.json"))) {
+      if (existsSync4(path3.join(walkDir, "package.json"))) {
         foundRoot = walkDir;
         break;
       }
-      walkDir = path.dirname(walkDir);
+      walkDir = path3.dirname(walkDir);
     }
     if (!foundRoot) {
       results.push({
@@ -99,8 +307,8 @@ function checkEmbedPipeline(pkgRoot) {
       });
       continue;
     }
-    const resolvedDaemon = path.join(foundRoot, "dist", "lib", "exe-daemon.js");
-    const reachable = existsSync(resolvedDaemon);
+    const resolvedDaemon = path3.join(foundRoot, "dist", "lib", "exe-daemon.js");
+    const reachable = existsSync4(resolvedDaemon);
     results.push({
       name: `exed/reachable-from-${dir}`,
       pass: reachable,
@@ -111,8 +319,8 @@ function checkEmbedPipeline(pkgRoot) {
 }
 function checkTaskSystem(pkgRoot) {
   const results = [];
-  const scannerPath = path.join(pkgRoot, "dist", "bin", "scan-tasks.js");
-  if (!existsSync(scannerPath)) {
+  const scannerPath = path3.join(pkgRoot, "dist", "bin", "scan-tasks.js");
+  if (!existsSync4(scannerPath)) {
     results.push({ name: "tasks/scanner", pass: false, detail: "scan-tasks.js not found" });
     return results;
   }
@@ -134,8 +342,8 @@ function checkTaskSystem(pkgRoot) {
 }
 function checkWorkerSpawning(pkgRoot) {
   const results = [];
-  const workerPath = path.join(pkgRoot, "dist", "hooks", "ingest-worker.js");
-  if (!existsSync(workerPath)) {
+  const workerPath = path3.join(pkgRoot, "dist", "hooks", "ingest-worker.js");
+  if (!existsSync4(workerPath)) {
     results.push({ name: "workers/ingest-worker", pass: false, detail: "ingest-worker.js not found" });
     return results;
   }
@@ -149,14 +357,14 @@ function checkWorkerSpawning(pkgRoot) {
       detail: `Parse error: ${err instanceof Error ? err.message.slice(0, 200) : String(err)}`
     });
   }
-  const hooksDir = path.join(pkgRoot, "dist", "hooks");
-  if (existsSync(hooksDir)) {
+  const hooksDir = path3.join(pkgRoot, "dist", "hooks");
+  if (existsSync4(hooksDir)) {
     const hookFiles = readdirSync(hooksDir).filter((f) => f.endsWith(".js") && !f.endsWith(".js.map"));
     let hooksPassed = 0;
     const hooksFailed = [];
     for (const hook of hookFiles) {
       try {
-        execSync(`node --check "${path.join(hooksDir, hook)}" 2>&1`, { timeout: 1e4, encoding: "utf-8" });
+        execSync(`node --check "${path3.join(hooksDir, hook)}" 2>&1`, { timeout: 1e4, encoding: "utf-8" });
         hooksPassed++;
       } catch {
         hooksFailed.push(hook);
@@ -178,6 +386,60 @@ function checkWorkerSpawning(pkgRoot) {
   }
   return results;
 }
+function checkMcpTransport() {
+  const results = [];
+  const pidPath = path3.join(EXE_AI_DIR, "exed.pid");
+  const tokenPath = path3.join(EXE_AI_DIR, "exed.token");
+  let daemonAlive = false;
+  if (existsSync4(pidPath)) {
+    try {
+      const pid = parseInt(readFileSync3(pidPath, "utf8").trim(), 10);
+      process.kill(pid, 0);
+      daemonAlive = true;
+      results.push({ name: "mcp/daemon-process", pass: true, detail: `exed process alive (pid ${pid})` });
+    } catch {
+      results.push({ name: "mcp/daemon-process", pass: false, detail: "exed.pid exists but process is not alive; restart exe-os/exed" });
+    }
+  } else {
+    results.push({ name: "mcp/daemon-process", pass: false, detail: "No exed.pid found; daemon is not running" });
+  }
+  if (daemonAlive && existsSync4(tokenPath)) {
+    try {
+      const token = readFileSync3(tokenPath, "utf8").trim();
+      const response = execSync(
+        `curl -sS -i -m 2 -H "Authorization: Bearer ${token}" -H 'Accept: application/json, text/event-stream' http://127.0.0.1:48739/mcp`,
+        { encoding: "utf8", timeout: 3e3 }
+      );
+      const jsonRpcError = response.includes("Content-Type: application/json") && response.includes("missing MCP session");
+      results.push({
+        name: "mcp/http-endpoint",
+        pass: jsonRpcError,
+        detail: jsonRpcError ? "MCP HTTP endpoint reachable; missing-session probe returns JSON-RPC (expected)" : "MCP HTTP endpoint reachable but did not return expected JSON-RPC missing-session response"
+      });
+    } catch (err) {
+      results.push({
+        name: "mcp/http-endpoint",
+        pass: false,
+        detail: `MCP HTTP endpoint not reachable: ${err instanceof Error ? err.message.slice(0, 180) : String(err)}`
+      });
+    }
+  } else if (daemonAlive) {
+    results.push({ name: "mcp/http-endpoint", pass: false, detail: "Daemon is alive but exed.token is missing; cannot probe MCP HTTP" });
+  }
+  const events = readMcpHttpEvents(200);
+  const summary = summarizeMcpTransport(events);
+  results.push({
+    name: "mcp/local-event-log",
+    pass: true,
+    detail: `${events.length} recent event(s); activeSessions=${summary.activeSessions ?? "unknown"}; lastHandshake=${summary.lastSuccessfulHandshake ?? "none"}; lastTool=${summary.lastSuccessfulToolCall ?? "none"}`
+  });
+  results.push({
+    name: "mcp/monitor-summary",
+    pass: true,
+    detail: `Privacy-safe local monitor summary: ${path3.join(EXE_AI_DIR, "monitor", "mcp-transport-summary.json")}`
+  });
+  return results;
+}
 function checkClaudeCodeInstall() {
   const results = [];
   const execPath = process.env.CLAUDE_CODE_EXECPATH ?? "";
@@ -232,14 +494,14 @@ function checkClaudeCodeInstall() {
       detail: "Failed to check claude binary path"
     });
   }
-  const versionsDir = path.join(
+  const versionsDir = path3.join(
     process.env.HOME ?? process.env.USERPROFILE ?? "",
     ".local",
     "share",
     "claude",
     "versions"
   );
-  if (existsSync(versionsDir)) {
+  if (existsSync4(versionsDir)) {
     try {
       const entries = readdirSync(versionsDir);
       if (entries.length > 0) {
@@ -315,6 +577,7 @@ function runHealthCheck() {
     ...checkEmbedPipeline(pkgRoot),
     ...checkTaskSystem(pkgRoot),
     ...checkWorkerSpawning(pkgRoot),
+    ...checkMcpTransport(),
     ...checkClaudeCodeInstall()
   ];
   const passed = results.filter((r) => r.pass).length;