@merittdev/horus 0.8.0 → 0.8.2

package/dist/index.cjs

@@ -65880,8 +65880,8 @@ init_cjs_shims();
 
 // ../../packages/core/src/version.ts
 init_cjs_shims();
-var HORUS_VERSION = true ? "0.8.0" : "dev";
-var PINNED_SOURCE_VERSION = "1.0.7";
+var HORUS_VERSION = true ? "0.8.2" : "dev";
+var PINNED_SOURCE_VERSION = "1.5.0";
 
 // ../../packages/core/src/evidence.ts
 init_cjs_shims();
@@ -70979,6 +70979,24 @@ async function getSourceVersion() {
     return null;
   }
 }
+var SourceVersionMismatchError = class extends Error {
+  constructor(installed, pinned) {
+    super(
+      `horus-source ${installed} is installed but Horus is pinned to ${pinned}. A drifted backend builds a graph this CLI cannot map and can corrupt the index (e.g. duplicate-primary-key failures during "Running initial index"). Install the pinned version: pip install 'horus-source==${pinned}'`
+    );
+    this.installed = installed;
+    this.pinned = pinned;
+    this.name = "SourceVersionMismatchError";
+  }
+  installed;
+  pinned;
+};
+async function assertSourceVersionPinned() {
+  const installed = await getSourceVersion();
+  if (installed !== null && installed !== PINNED_SOURCE_VERSION) {
+    throw new SourceVersionMismatchError(installed, PINNED_SOURCE_VERSION);
+  }
+}
 function isAnalyzed(root) {
   return (0, import_node_fs3.existsSync)((0, import_node_path3.join)(root, ".horus", "source"));
 }
@@ -71001,6 +71019,21 @@ function readSourceHostUrl(root) {
     return null;
   }
 }
+function readSourceHostPid(root) {
+  const p5 = (0, import_node_path3.join)(root, ".horus", "source", "host.json");
+  if (!(0, import_node_fs3.existsSync)(p5)) return null;
+  try {
+    const j3 = JSON.parse((0, import_node_fs3.readFileSync)(p5, "utf8"));
+    if (typeof j3.pid !== "number" || !Number.isInteger(j3.pid) || j3.pid <= 0) return null;
+    return {
+      pid: j3.pid,
+      port: typeof j3.port === "number" ? j3.port : NaN,
+      repoPath: typeof j3.repo_path === "string" ? j3.repo_path : ""
+    };
+  } catch {
+    return null;
+  }
+}
 async function isHostHealthy(hostUrl) {
   try {
     const res = await fetch(`${hostUrl}/api/health`, {
@@ -71067,6 +71100,21 @@ function removeSpawnedHostRecord(root) {
   } catch {
   }
 }
+function reconcileSpawnedHostPid(root, port) {
+  try {
+    const backend = readSourceHostPid(root);
+    if (!backend || !Number.isInteger(backend.pid) || backend.pid <= 0) return;
+    if (Number.isFinite(backend.port) && backend.port !== port) return;
+    const spawned = readSpawnedHost(root);
+    if (!spawned || spawned.pid === backend.pid) return;
+    const updated = { ...spawned, pid: backend.pid };
+    (0, import_node_fs3.writeFileSync)(
+      (0, import_node_path3.join)(root, ".horus", SPAWNED_HOST_FILE),
+      JSON.stringify(updated, null, 2) + "\n"
+    );
+  } catch {
+  }
+}
 async function waitForHost(hostUrl, timeoutMs = 45e3) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -97105,6 +97153,12 @@ async function runIndex(opts) {
         console.error(import_picocolors3.default.red("horus-source not found on PATH. Install it: pip install horus-source"));
         return 1;
       }
+      try {
+        await assertSourceVersionPinned();
+      } catch (err2) {
+        console.error(import_picocolors3.default.red(`  ${err2.message}`));
+        return 1;
+      }
       if (!isAnalyzed(root)) {
         console.log(import_picocolors3.default.dim("  analyzing with source-intelligence backend (first time \u2014 this can take a while)\u2026"));
         try {
@@ -97127,6 +97181,7 @@ async function runIndex(opts) {
         );
         return 1;
       }
+      reconcileSpawnedHostPid(root, port);
     }
     await stitchQueueMap(hostUrl, dbUrl, label);
     buildKnowledgeIndex(root, config2, label, configuredProject, opts);
@@ -110066,6 +110121,8 @@ function ensureHostReasonHint(reason) {
   switch (reason) {
     case "source-unavailable":
       return "horus-source is not installed \u2014 install it: pip install horus-source";
+    case "version-mismatch":
+      return "the installed horus-source backend does not match the version Horus is pinned to \u2014 reinstall the pinned version (run `horus status` to see it)";
     case "not-analyzed":
       return "this repo has not been indexed yet \u2014 run: horus index";
     case "bad-url":
@@ -110077,11 +110134,19 @@ function ensureHostReasonHint(reason) {
 async function ensureSourceHost(root, hostUrl, opts = {}) {
   if (await isHostHealthy(hostUrl)) return { ok: true, hostUrl };
   if (!await sourceAvailable()) return { ok: false, reason: "source-unavailable" };
+  try {
+    await assertSourceVersionPinned();
+  } catch {
+    return { ok: false, reason: "version-mismatch" };
+  }
   if (!isAnalyzed(root)) return { ok: false, reason: "not-analyzed" };
   const port = parseHostPort(hostUrl);
   if (port === null) return { ok: false, reason: "bad-url" };
   startHost(root, port);
-  if (await waitForHost(hostUrl, opts.timeoutMs ?? 2e4)) return { ok: true, hostUrl };
+  if (await waitForHost(hostUrl, opts.timeoutMs ?? 2e4)) {
+    reconcileSpawnedHostPid(root, port);
+    return { ok: true, hostUrl };
+  }
   removeSpawnedHostRecord(root);
   return { ok: false, reason: "unhealthy" };
 }
@@ -113530,16 +113595,28 @@ async function runStop(opts) {
   }
 }
 async function stopHost(root, hostUrl) {
-  const alive = await isHostHealthy(hostUrl);
-  if (!alive) {
-    console.log(import_picocolors36.default.dim(`Host ${hostUrl} is already stopped.`));
-    return 0;
-  }
   const port = extractPort(hostUrl);
   if (port === null) {
     console.error(import_picocolors36.default.red(`Cannot determine port from host URL: ${hostUrl}`));
     return 1;
   }
+  const healthy = await isHostHealthy(hostUrl);
+  if (!healthy) {
+    const owned = readSpawnedHost(root);
+    const wrapperAlive = owned !== null && await getProcessInfo(owned.pid) !== null;
+    if (!wrapperAlive) {
+      const res = await stopBackendServerPid(root, port);
+      if (res === "failed") return 1;
+      if (res !== "stopped") console.log(import_picocolors36.default.dim(`Host ${hostUrl} is already stopped.`));
+      await cleanupSpawnedRecord(root);
+      return 0;
+    }
+    console.log(
+      import_picocolors36.default.dim(
+        `Host ${hostUrl} is unreachable but pid ${owned.pid} is still running \u2014 terminating a stuck host.`
+      )
+    );
+  }
   const spawned = readSpawnedHost(root);
   if (spawned === null) {
     console.error(
@@ -113572,21 +113649,18 @@ async function stopHost(root, hostUrl) {
   }
   const info2 = await getProcessInfo(spawned.pid);
   if (info2 === null) {
-    console.log(import_picocolors36.default.dim(`Process pid ${spawned.pid} is no longer running \u2014 already stopped.`));
-    try {
-      await unlinkAsync((0, import_node_path18.join)(root, HORUS_DIR, SPAWNED_HOST_FILE2));
-    } catch {
+    const res = await stopBackendServerPid(root, port);
+    if (res === "failed") return 1;
+    if (res !== "stopped") {
+      console.log(import_picocolors36.default.dim(`Process pid ${spawned.pid} is no longer running \u2014 already stopped.`));
     }
+    await cleanupSpawnedRecord(root);
     return 0;
   }
-  const portStr = String(port);
-  const hostPortRe = new RegExp(
-    `(?:^|\\s)(?:\\S*/)?horus-source\\s+host\\s+--port(?:=|\\s+)${portStr}(?=\\s|$)`
-  );
-  if (!hostPortRe.test(info2.args)) {
+  if (!hostArgvRegex(port).test(info2.args)) {
     console.error(
       import_picocolors36.default.red(
-        `Pid ${spawned.pid} args do not match "horus-source host --port ${portStr}". Got: "${info2.args.slice(0, 120)}". Aborting for safety.`
+        `Pid ${spawned.pid} args do not match "horus-source host --port ${port}". Got: "${info2.args.slice(0, 120)}". Aborting for safety.`
       )
     );
     return 1;
@@ -113639,11 +113713,57 @@ async function stopHost(root, hostUrl) {
       `${import_picocolors36.default.green("\u2713")} Stopped source-intelligence host ` + import_picocolors36.default.dim(`(pid ${spawned.pid}, port ${port})`) + ` for ${root}`
     );
   }
+  if (await stopBackendServerPid(root, port) === "failed") return 1;
+  await cleanupSpawnedRecord(root);
+  return 0;
+}
+function hostArgvRegex(port) {
+  return new RegExp(
+    `(?:^|\\s)(?:\\S*/)?horus-source\\s+host\\s+--port(?:=|\\s+)${String(port)}(?=\\s|$)`
+  );
+}
+async function cleanupSpawnedRecord(root) {
   try {
     await unlinkAsync((0, import_node_path18.join)(root, HORUS_DIR, SPAWNED_HOST_FILE2));
   } catch {
   }
-  return 0;
+}
+async function stopBackendServerPid(root, port) {
+  const rec = readSourceHostPid(root);
+  if (!rec) return "none";
+  if (Number.isFinite(rec.port) && rec.port !== port) return "none";
+  if (rec.repoPath && rec.repoPath !== root) return "none";
+  const info2 = await getProcessInfo(rec.pid);
+  if (info2 === null) return "none";
+  if (!hostArgvRegex(port).test(info2.args)) {
+    console.error(
+      import_picocolors36.default.red(
+        `Backend host pid ${rec.pid} args do not match "horus-source host --port ${port}". Not signalling \u2014 possible stale source/host.json or PID reuse.`
+      )
+    );
+    return "failed";
+  }
+  try {
+    process.kill(rec.pid, "SIGTERM");
+  } catch (err2) {
+    if (err2.code === "ESRCH") return "stopped";
+    console.error(import_picocolors36.default.red(`Failed to signal pid ${rec.pid}: ${err2.message}`));
+    return "failed";
+  }
+  const deadline = Date.now() + STOP_WAIT_MS;
+  while (Date.now() < deadline) {
+    await sleep(STOP_POLL_MS);
+    if (await getProcessInfo(rec.pid) === null) {
+      console.log(
+        `${import_picocolors36.default.green("\u2713")} Stopped source-intelligence host ` + import_picocolors36.default.dim(`(pid ${rec.pid}, port ${port})`) + ` for ${root}`
+      );
+      return "stopped";
+    }
+  }
+  console.error(
+    import_picocolors36.default.red(`Host pid ${rec.pid} did not exit within ${STOP_WAIT_MS / 1e3}s after SIGTERM.`)
+  );
+  return "failed";
 }
 async function stopAll() {
   const registry2 = readRegistry();
@@ -113657,8 +113777,10 @@ async function stopAll() {
   for (const [name2, entry2] of projects2) {
     const hostUrl = readSourceHostUrl(entry2.root);
     if (!hostUrl) continue;
-    const alive = await isHostHealthy(hostUrl);
-    if (!alive) continue;
+    const healthy = await isHostHealthy(hostUrl);
+    if (!healthy && readSpawnedHost(entry2.root) === null && readSourceHostPid(entry2.root) === null) {
+      continue;
+    }
     console.log(`  Stopping ${import_picocolors36.default.bold(name2)} ${import_picocolors36.default.dim(`(${hostUrl})`)}`);
     const code = await stopHost(entry2.root, hostUrl);
     if (code === 0) stopped++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merittdev/horus",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Local-first, source-aware production-incident investigation engine",
   "type": "module",
   "bin": {