@askexenow/exe-os 0.9.265 → 0.9.266

package/dist/chunk-JEOFG274.js

@@ -0,0 +1,394 @@
+import {
+  readMcpHttpEvents,
+  summarizeMcpTransport
+} from "./chunk-LBRIPVY3.js";
+import {
+  mcpHttpPort
+} from "./chunk-RPLEZ74B.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-VXIMSRTO.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/exe-healthcheck.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+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);
+  }
+  throw new Error("Cannot find package root");
+}
+function checkBuildIntegrity(pkgRoot) {
+  const results = [];
+  const tsupConfig = path.join(pkgRoot, "tsup.config.ts");
+  if (!existsSync(tsupConfig)) {
+    return [{ name: "build/tsup-config", pass: false, detail: "tsup.config.ts not found" }];
+  }
+  const configContent = readFileSync(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`);
+    total++;
+    if (!existsSync(expectedPath)) {
+      missing.push(`dist/${outputKey}.js`);
+    }
+  }
+  if (missing.length > 0) {
+    results.push({
+      name: "build/entry-points",
+      pass: false,
+      detail: `${missing.length}/${total} entry points missing:
+    ${missing.join("\n    ")}`
+    });
+  } else {
+    results.push({
+      name: "build/entry-points",
+      pass: true,
+      detail: `${total} entry points verified`
+    });
+  }
+  return results;
+}
+function checkEmbedPipeline(pkgRoot) {
+  const results = [];
+  const daemonPath = path.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync(daemonPath)) {
+    results.push({
+      name: "exed/daemon-exists",
+      pass: false,
+      detail: `exe-daemon.js not found at ${daemonPath}`
+    });
+    return results;
+  }
+  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;
+    let walkDir = fullDir;
+    const { root } = path.parse(walkDir);
+    let foundRoot = null;
+    while (walkDir !== root) {
+      if (existsSync(path.join(walkDir, "package.json"))) {
+        foundRoot = walkDir;
+        break;
+      }
+      walkDir = path.dirname(walkDir);
+    }
+    if (!foundRoot) {
+      results.push({
+        name: `exed/reachable-from-${dir}`,
+        pass: false,
+        detail: `Cannot find package root from ${dir}`
+      });
+      continue;
+    }
+    const resolvedDaemon = path.join(foundRoot, "dist", "lib", "exe-daemon.js");
+    const reachable = existsSync(resolvedDaemon);
+    results.push({
+      name: `exed/reachable-from-${dir}`,
+      pass: reachable,
+      detail: reachable ? `Resolves to ${resolvedDaemon}` : `NOT FOUND: ${resolvedDaemon}`
+    });
+  }
+  return results;
+}
+function checkTaskSystem(pkgRoot) {
+  const results = [];
+  const scannerPath = path.join(pkgRoot, "dist", "bin", "scan-tasks.js");
+  if (!existsSync(scannerPath)) {
+    results.push({ name: "tasks/scanner", pass: false, detail: "scan-tasks.js not found" });
+    return results;
+  }
+  try {
+    execSync(`node "${scannerPath}" /tmp/nonexistent-healthcheck-test --format=json 2>/dev/null`, {
+      timeout: 1e4,
+      encoding: "utf-8"
+    });
+    results.push({ name: "tasks/scanner", pass: true, detail: "scan-tasks.js runs without import errors" });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("Cannot find module") || msg.includes("ERR_MODULE_NOT_FOUND") || msg.includes("SyntaxError")) {
+      results.push({ name: "tasks/scanner", pass: false, detail: `Import error: ${msg.slice(0, 200)}` });
+    } else {
+      results.push({ name: "tasks/scanner", pass: true, detail: "scan-tasks.js runs (no import errors)" });
+    }
+  }
+  return results;
+}
+function checkWorkerSpawning(pkgRoot) {
+  const results = [];
+  const workerPath = path.join(pkgRoot, "dist", "hooks", "ingest-worker.js");
+  if (!existsSync(workerPath)) {
+    results.push({ name: "workers/ingest-worker", pass: false, detail: "ingest-worker.js not found" });
+    return results;
+  }
+  try {
+    execSync(`node --check "${workerPath}" 2>&1`, { timeout: 1e4, encoding: "utf-8" });
+    results.push({ name: "workers/ingest-worker", pass: true, detail: "ingest-worker.js parses OK" });
+  } catch (err) {
+    results.push({
+      name: "workers/ingest-worker",
+      pass: false,
+      detail: `Parse error: ${err instanceof Error ? err.message.slice(0, 200) : String(err)}`
+    });
+  }
+  const hooksDir = path.join(pkgRoot, "dist", "hooks");
+  if (existsSync(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" });
+        hooksPassed++;
+      } catch {
+        hooksFailed.push(hook);
+      }
+    }
+    if (hooksFailed.length > 0) {
+      results.push({
+        name: "workers/hooks-parse",
+        pass: false,
+        detail: `${hooksFailed.length}/${hookFiles.length} hooks fail to parse: ${hooksFailed.join(", ")}`
+      });
+    } else {
+      results.push({
+        name: "workers/hooks-parse",
+        pass: true,
+        detail: `${hooksPassed} hook entry points parse OK`
+      });
+    }
+  }
+  return results;
+}
+function checkMcpTransport() {
+  const results = [];
+  const pidPath = path.join(EXE_AI_DIR, "exed.pid");
+  const tokenPath = path.join(EXE_AI_DIR, "exed.token");
+  let daemonAlive = false;
+  if (existsSync(pidPath)) {
+    try {
+      const pid = parseInt(readFileSync(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 && existsSync(tokenPath)) {
+    try {
+      const token = readFileSync(tokenPath, "utf8").trim();
+      const port = mcpHttpPort();
+      const response = execSync(
+        `curl -sS -i -m 1 -H "Authorization: Bearer ${token}" -H 'Accept: application/json, text/event-stream' http://127.0.0.1:${port}/mcp`,
+        { encoding: "utf8", timeout: 1500 }
+      );
+      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) {
+      const msg = err instanceof Error ? err.message.slice(0, 180) : String(err);
+      const timedOut = msg.includes("ETIMEDOUT") || msg.includes("timed out") || msg.includes("killed");
+      results.push({
+        name: "mcp/http-endpoint",
+        pass: false,
+        detail: timedOut ? "Daemon alive but MCP unresponsive (timed out after 1.5s)" : `MCP HTTP endpoint not reachable: ${msg}`
+      });
+    }
+  } 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: ${path.join(EXE_AI_DIR, "monitor", "mcp-transport-summary.json")}`
+  });
+  return results;
+}
+function checkClaudeCodeInstall() {
+  const results = [];
+  const execPath = process.env.CLAUDE_CODE_EXECPATH ?? "";
+  if (execPath.length > 0 && (execPath.includes("claude/versions/") || execPath.includes("claude.exe") || execPath.includes("claude-native"))) {
+    results.push({
+      name: "cc/execpath-clean",
+      pass: false,
+      detail: `CLAUDE_CODE_EXECPATH points to native binary: "${execPath}" \u2014 20K phantom billing risk. Unset it: unset CLAUDE_CODE_EXECPATH`
+    });
+  } else {
+    results.push({
+      name: "cc/execpath-clean",
+      pass: true,
+      detail: execPath ? `CLAUDE_CODE_EXECPATH=${execPath} (node runtime, OK)` : "CLAUDE_CODE_EXECPATH is unset"
+    });
+  }
+  try {
+    const claudePath = execSync("which claude 2>/dev/null || true", { encoding: "utf8", timeout: 5e3 }).trim();
+    if (!claudePath) {
+      results.push({
+        name: "cc/cli-binary",
+        pass: false,
+        detail: "claude not found in PATH"
+      });
+    } else {
+      let resolved = claudePath;
+      try {
+        resolved = execSync(`readlink -f "${claudePath}" 2>/dev/null || readlink "${claudePath}" 2>/dev/null || echo "${claudePath}"`, {
+          encoding: "utf8",
+          timeout: 5e3
+        }).trim();
+      } catch {
+      }
+      if (resolved.includes("bin/claude.exe") || resolved.includes("bin/claude-native")) {
+        results.push({
+          name: "cc/cli-binary",
+          pass: false,
+          detail: `claude resolves to native binary: ${resolved}. Should be cli.js. Run: npm install -g @anthropic-ai/claude-code@2.1.98`
+        });
+      } else {
+        results.push({
+          name: "cc/cli-binary",
+          pass: true,
+          detail: `claude resolves to: ${resolved}`
+        });
+      }
+    }
+  } catch {
+    results.push({
+      name: "cc/cli-binary",
+      pass: false,
+      detail: "Failed to check claude binary path"
+    });
+  }
+  const versionsDir = path.join(
+    process.env.HOME ?? process.env.USERPROFILE ?? "",
+    ".local",
+    "share",
+    "claude",
+    "versions"
+  );
+  if (existsSync(versionsDir)) {
+    try {
+      const entries = readdirSync(versionsDir);
+      if (entries.length > 0) {
+        results.push({
+          name: "cc/native-cache-clean",
+          pass: false,
+          detail: `${entries.length} cached native version(s) found in ${versionsDir}: ${entries.slice(0, 3).join(", ")}${entries.length > 3 ? "..." : ""}. Remove: rm -rf "${versionsDir}"`
+        });
+      } else {
+        results.push({
+          name: "cc/native-cache-clean",
+          pass: true,
+          detail: `${versionsDir} is empty`
+        });
+      }
+    } catch {
+      results.push({
+        name: "cc/native-cache-clean",
+        pass: true,
+        detail: `${versionsDir} not readable (OK)`
+      });
+    }
+  } else {
+    results.push({
+      name: "cc/native-cache-clean",
+      pass: true,
+      detail: `${versionsDir} does not exist`
+    });
+  }
+  const disableOld = process.env.DISABLE_AUTOUPDATER === "1";
+  const disableNew = process.env.CLAUDE_CODE_AUTOUPDATER_DISABLED === "1";
+  if (!disableOld && !disableNew) {
+    results.push({
+      name: "cc/autoupdater-disabled",
+      pass: false,
+      detail: "Neither DISABLE_AUTOUPDATER=1 nor CLAUDE_CODE_AUTOUPDATER_DISABLED=1 is set. Auto-updater may install infected native binary. Export both in your shell profile."
+    });
+  } else {
+    const which = [
+      disableOld ? "DISABLE_AUTOUPDATER=1" : null,
+      disableNew ? "CLAUDE_CODE_AUTOUPDATER_DISABLED=1" : null
+    ].filter(Boolean).join(" + ");
+    results.push({
+      name: "cc/autoupdater-disabled",
+      pass: true,
+      detail: `Auto-updater disabled via ${which}`
+    });
+  }
+  try {
+    const ccVersion = execSync("claude --version 2>/dev/null || echo unknown", {
+      encoding: "utf8",
+      timeout: 5e3
+    }).trim();
+    const versionMatch = ccVersion.match(/(\d+\.\d+\.\d+)/);
+    if (versionMatch) {
+      const ver = versionMatch[1];
+      const [, minor] = ver.split(".").map(Number);
+      const isRisky = minor !== void 0 && minor >= 1 && parseInt(ver.split(".")[2] ?? "0") >= 119;
+      results.push({
+        name: "cc/version",
+        pass: !isRisky,
+        detail: isRisky ? `CC version ${ver} \u2014 \u22652.1.119 ships native binary only. Pin: npm install -g @anthropic-ai/claude-code@2.1.98` : `CC version ${ver}`
+      });
+    }
+  } catch {
+  }
+  return results;
+}
+function runHealthCheck() {
+  const pkgRoot = findPackageRoot();
+  const results = [
+    ...checkBuildIntegrity(pkgRoot),
+    ...checkEmbedPipeline(pkgRoot),
+    ...checkTaskSystem(pkgRoot),
+    ...checkWorkerSpawning(pkgRoot),
+    ...checkMcpTransport(),
+    ...checkClaudeCodeInstall()
+  ];
+  const passed = results.filter((r) => r.pass).length;
+  const failed = results.filter((r) => !r.pass).length;
+  return { results, passed, failed };
+}
+if (isMainModule(import.meta.url) && (process.argv[1] ?? "").includes("exe-healthcheck")) {
+  const { results, passed, failed } = runHealthCheck();
+  console.log("\n  exe-os Health Check\n");
+  for (const r of results) {
+    const icon = r.pass ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    console.log(`  ${icon} ${r.name}`);
+    console.log(`    ${r.detail}`);
+  }
+  console.log(`
+  ${passed} passed, ${failed} failed
+`);
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+export {
+  checkClaudeCodeInstall,
+  runHealthCheck
+};

package/dist/chunk-JH7ISOIJ.js

@@ -0,0 +1,33 @@
+import {
+  completeReminder
+} from "./chunk-DEBLYXA2.js";
+
+// src/mcp/tools/complete-reminder.ts
+import { z } from "zod";
+function registerCompleteReminder(server) {
+  server.registerTool(
+    "complete_reminder",
+    {
+      title: "Complete Reminder",
+      description: "Mark a reminder as done. Accepts UUID or text substring.",
+      inputSchema: {
+        reminder_id: z.string().describe("Reminder UUID or text substring to match")
+      }
+    },
+    async ({ reminder_id }) => {
+      const reminder = await completeReminder(reminder_id);
+      if (!reminder) {
+        return {
+          content: [{ type: "text", text: `No active reminder matching "${reminder_id}".` }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Reminder completed: "${reminder.text}"` }]
+      };
+    }
+  );
+}
+
+export {
+  registerCompleteReminder
+};