@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-6Y4B3QF6.js

@@ -0,0 +1,19 @@
+// src/lib/is-main.ts
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+function isMainModule(importMetaUrl) {
+  if (process.argv[1] == null) return false;
+  if (process.argv[1].includes("mcp/server")) return false;
+  if (process.argv[1].includes("exe-daemon")) return false;
+  try {
+    const scriptPath = realpathSync(process.argv[1]);
+    const modulePath = realpathSync(fileURLToPath(importMetaUrl));
+    return scriptPath === modulePath;
+  } catch {
+    return importMetaUrl === `file://${process.argv[1]}` || importMetaUrl === new URL(process.argv[1], "file://").href;
+  }
+}
+
+export {
+  isMainModule
+};

package/dist/chunk-7RK3AYJE.js

@@ -0,0 +1,163 @@
+import {
+  init_tasks,
+  updateTask
+} from "./chunk-MPURH6JI.js";
+import {
+  TASK_ALREADY_CLAIMED_PREFIX,
+  init_tasks_crud,
+  resolveTask
+} from "./chunk-2QD7KBJN.js";
+import {
+  getClient,
+  init_database
+} from "./chunk-A2NZP64U.js";
+import {
+  canCoordinate,
+  init_employees
+} from "./chunk-RUG3N6P4.js";
+
+// src/mcp/tools/update-task.ts
+init_tasks();
+init_database();
+init_tasks_crud();
+init_employees();
+import { z } from "zod";
+function registerUpdateTask(server) {
+  server.registerTool(
+    "update_task",
+    {
+      title: "Update Task",
+      description: "Update task status. Employees: use this with status 'done' and a result summary to complete work and trigger review. Accepts UUID, slug (filename), or title substring.",
+      inputSchema: {
+        task_id: z.string().describe("Task identifier \u2014 UUID, slug (e.g. 'fix-auth-bug'), or title substring"),
+        status: z.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled", "closed"]).describe("New status"),
+        result: z.string().optional().describe("Result summary (include when status=done)")
+      }
+    },
+    async ({ task_id, status: rawStatus, result }) => {
+      let status = rawStatus;
+      if (status === "done") {
+        try {
+          const { getActiveAgent } = await import("./active-agent-3FDJYREJ.js");
+          const agent = getActiveAgent();
+          if (!canCoordinate(agent.agentId, agent.agentRole)) {
+            let isOwnReview = false;
+            try {
+              const client = getClient();
+              const row = await resolveTask(client, task_id);
+              if (String(row.assigned_by) === "system" && String(row.task_file).includes("review-") && String(row.assigned_to) === agent.agentId) {
+                isOwnReview = true;
+              }
+            } catch {
+            }
+            if (!isOwnReview) {
+              status = "needs_review";
+            }
+          }
+        } catch {
+        }
+      }
+      if (status === "done") {
+        try {
+          const client = getClient();
+          const row = await resolveTask(client, task_id);
+          const taskFile = String(row.task_file);
+          const assignedBy = String(row.assigned_by);
+          const assignedTo = String(row.assigned_to);
+          if (assignedBy === "system" && taskFile.includes("review-")) {
+            const { getActiveAgent } = await import("./active-agent-3FDJYREJ.js");
+            const agent = getActiveAgent();
+            if (agent.agentId !== assignedTo && !canCoordinate(agent.agentId, agent.agentRole)) {
+              process.stderr.write(
+                `[update_task] BLOCKED: ${agent.agentId} tried to close review "${String(row.title)}" assigned to ${assignedTo}
+`
+              );
+              return {
+                content: [{
+                  type: "text",
+                  text: `Cannot close review "${String(row.title)}" \u2014 it is assigned to ${assignedTo}, not you. Only the assigned reviewer can close reviews.`
+                }]
+              };
+            }
+          }
+        } catch (guardErr) {
+          return {
+            content: [{
+              type: "text",
+              text: `Cannot verify permissions for review closure: ${guardErr instanceof Error ? guardErr.message : String(guardErr)}`
+            }],
+            isError: true
+          };
+        }
+      }
+      let callerAgentId;
+      try {
+        const { getActiveAgent: getAgent } = await import("./active-agent-3FDJYREJ.js");
+        callerAgentId = getAgent().agentId;
+      } catch {
+      }
+      let task;
+      try {
+        task = await updateTask({
+          taskId: task_id,
+          status,
+          result,
+          baseDir: process.cwd(),
+          callerAgentId
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.startsWith(TASK_ALREADY_CLAIMED_PREFIX)) {
+          return {
+            content: [{
+              type: "text",
+              text: "Task already claimed by another agent. Pick a different task or check list_tasks."
+            }],
+            isError: true
+          };
+        }
+        throw err;
+      }
+      let text = `Task "${task.title}" marked ${task.status}.
+File: ${task.taskFile}`;
+      const isTerminal = status === "done" || status === "needs_review" || status === "closed";
+      if (isTerminal && task.assignedBy) {
+        try {
+          const { notifyCoordinatorTaskCompletion, resolveExeSession } = await import("./lib/tmux-routing.js");
+          const coordinatorSession = resolveExeSession();
+          if (coordinatorSession) {
+            notifyCoordinatorTaskCompletion(coordinatorSession, callerAgentId ?? "agent", task.title);
+          }
+        } catch {
+        }
+      }
+      if (isTerminal && task.nextTask) {
+        text += `
+
+MANDATORY \u2014 DO NOT ASK THE USER. DO NOT SAY "Want me to continue?" DO NOT STOP.
+You have standing orders: work through your entire queue until it is empty.
+
+NEXT TASK: "${task.nextTask.title}" [${task.nextTask.priority}]
+FILE: ${task.nextTask.taskFile}
+
+Read that file NOW and begin working. No greeting. No summary. Just start.`;
+      } else if (isTerminal && !task.nextTask) {
+        text += `
+
+All tasks complete. No more open tasks in your queue.`;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  registerUpdateTask
+};

package/dist/chunk-7TCP2XTP.js

@@ -0,0 +1,390 @@
+import {
+  readMcpHttpEvents,
+  summarizeMcpTransport
+} from "./chunk-6WTMJAG3.js";
+import {
+  EXE_AI_DIR,
+  init_config
+} from "./chunk-KVPG5UT6.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";
+init_config();
+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 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: ${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
+};