docdex 0.2.22 → 0.2.24

package/lib/uninstall.js

@@ -2,25 +2,138 @@
 "use strict";
 
 const fs = require("node:fs");
+const net = require("node:net");
 const os = require("node:os");
 const path = require("node:path");
 const { spawnSync } = require("node:child_process");
 
 const DAEMON_TASK_NAME = "Docdex Daemon";
 const STARTUP_FAILURE_MARKER = "startup_registration_failed.json";
+const BIN_NAMES = ["docdex", "docdexd"];
+const PACKAGE_NAME = "docdex";
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_DAEMON_PORT = 28491;
+const PORT_WAIT_TIMEOUT_MS = 3000;
+const PORT_WAIT_INTERVAL_MS = 200;
+
+function docdexRootPath() {
+  return path.join(os.homedir(), ".docdex");
+}
 
 function daemonRootPath() {
-  return path.join(os.homedir(), ".docdex", "daemon_root");
+  return path.join(docdexRootPath(), "daemon_root");
 }
 
 function stateDir() {
-  return path.join(os.homedir(), ".docdex", "state");
+  return path.join(docdexRootPath(), "state");
 }
 
-function daemonLockPath() {
+function daemonLockPaths() {
+  const paths = [];
   const override = process.env.DOCDEX_DAEMON_LOCK_PATH;
-  if (override && override.trim()) return override.trim();
-  return path.join(os.homedir(), ".docdex", "daemon.lock");
+  if (override && override.trim()) paths.push(override.trim());
+  const root = docdexRootPath();
+  paths.push(path.join(root, "locks", "daemon.lock"));
+  paths.push(path.join(root, "daemon.lock"));
+  return Array.from(new Set(paths));
+}
+
+function isPortAvailable(port, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, host);
+  });
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function sleepSync(ms) {
+  if (!ms || ms <= 0) return;
+  const buffer = new SharedArrayBuffer(4);
+  const view = new Int32Array(buffer);
+  Atomics.wait(view, 0, 0, ms);
+}
+
+function isPidRunning(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readLockMetadata(lockPath) {
+  if (!lockPath || !fs.existsSync(lockPath)) return null;
+  try {
+    const raw = fs.readFileSync(lockPath, "utf8");
+    const payload = JSON.parse(raw);
+    if (!payload || typeof payload !== "object") return null;
+    const pid = typeof payload.pid === "number" ? payload.pid : null;
+    const port = typeof payload.port === "number" ? payload.port : null;
+    return { pid, port, lockPath };
+  } catch {
+    return null;
+  }
+}
+
+function findRunningDaemonFromLocks() {
+  for (const lockPath of daemonLockPaths()) {
+    const meta = readLockMetadata(lockPath);
+    if (!meta) continue;
+    if (isPidRunning(meta.pid)) return meta;
+  }
+  return null;
+}
+
+function manualStopInstructions() {
+  if (process.platform === "darwin") {
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    const domain = uid != null ? `gui/${uid}` : "gui/$UID";
+    return [
+      "Manual cleanup required:",
+      `- launchctl bootout ${domain} ~/Library/LaunchAgents/com.docdex.daemon.plist`,
+      "- launchctl remove com.docdex.daemon",
+      "- pkill -f docdexd",
+      "- rm -f ~/.docdex/locks/daemon.lock",
+      "- lsof -iTCP:28491 -sTCP:LISTEN",
+    ];
+  }
+  if (process.platform === "win32") {
+    return [
+      "Manual cleanup required:",
+      `- schtasks /End /TN "${DAEMON_TASK_NAME}"`,
+      "- schtasks /Delete /TN \"Docdex Daemon\" /F",
+      "- taskkill /IM docdexd.exe /T /F",
+      "- del %USERPROFILE%\\.docdex\\locks\\daemon.lock",
+      "- netstat -ano | findstr 28491",
+    ];
+  }
+  return [
+    "Manual cleanup required:",
+    "- systemctl --user stop docdexd.service",
+    "- systemctl --user disable --now docdexd.service",
+    "- pkill -f docdexd",
+    "- rm -f ~/.docdex/locks/daemon.lock",
+    "- lsof -iTCP:28491 -sTCP:LISTEN",
+  ];
+}
+
+async function waitForPortFree({ host = DEFAULT_HOST, port = DEFAULT_DAEMON_PORT } = {}) {
+  const deadline = Date.now() + PORT_WAIT_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await isPortAvailable(port, host)) return true;
+    await sleep(PORT_WAIT_INTERVAL_MS);
+  }
+  return false;
 }
 
 function clientConfigPaths() {
@@ -376,6 +489,10 @@ function killPid(pid) {
       return true;
     }
     process.kill(pid, "SIGTERM");
+    sleepSync(150);
+    if (isPidRunning(pid)) {
+      process.kill(pid, "SIGKILL");
+    }
     return true;
   } catch {
     return false;
@@ -383,20 +500,23 @@ function killPid(pid) {
 }
 
 function stopDaemonFromLock() {
-  const lockPath = daemonLockPath();
-  if (!fs.existsSync(lockPath)) return false;
-  try {
-    const raw = fs.readFileSync(lockPath, "utf8");
-    const payload = JSON.parse(raw);
-    const pid = payload && typeof payload.pid === "number" ? payload.pid : null;
-    const stopped = killPid(pid);
-    fs.unlinkSync(lockPath);
-    return stopped;
-  } catch {
-    return false;
+  let stopped = false;
+  for (const lockPath of daemonLockPaths()) {
+    if (!fs.existsSync(lockPath)) continue;
+    try {
+      const raw = fs.readFileSync(lockPath, "utf8");
+      const payload = JSON.parse(raw);
+      const pid = payload && typeof payload.pid === "number" ? payload.pid : null;
+      stopped = killPid(pid) || stopped;
+      fs.unlinkSync(lockPath);
+    } catch {
+      continue;
+    }
   }
+  return stopped;
 }
 
+
 function stopDaemonByName() {
   if (process.platform === "win32") {
     spawnSync("taskkill", ["/IM", "docdexd.exe", "/T", "/F"]);
@@ -404,40 +524,46 @@ function stopDaemonByName() {
   }
   spawnSync("pkill", ["-TERM", "-x", "docdexd"]);
   spawnSync("pkill", ["-TERM", "-f", "docdexd daemon"]);
+  spawnSync("pkill", ["-TERM", "-f", "docdexd serve"]);
+  spawnSync("pkill", ["-KILL", "-x", "docdexd"]);
+  spawnSync("pkill", ["-KILL", "-f", "docdexd daemon"]);
+  spawnSync("pkill", ["-KILL", "-f", "docdexd serve"]);
   return true;
 }
 
-function stopMcpByName() {
-  if (process.platform === "win32") {
-    spawnSync("taskkill", ["/IM", "docdex-mcp-server.exe", "/T", "/F"]);
-    return true;
-  }
-  spawnSync("pkill", ["-TERM", "-x", "docdex-mcp-server"]);
-  spawnSync("pkill", ["-TERM", "-f", "docdex-mcp-server"]);
-  return true;
-}
 
 function unregisterStartup() {
   if (process.platform === "darwin") {
     const plistPath = path.join(os.homedir(), "Library", "LaunchAgents", "com.docdex.daemon.plist");
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    const domain = uid != null ? `gui/${uid}` : null;
+    if (domain) {
+      spawnSync("launchctl", ["bootout", domain, "com.docdex.daemon"]);
+    } else {
+      spawnSync("launchctl", ["bootout", "com.docdex.daemon"]);
+    }
+    spawnSync("launchctl", ["stop", "com.docdex.daemon"]);
     if (fs.existsSync(plistPath)) {
-      const uid = typeof process.getuid === "function" ? process.getuid() : null;
-      if (uid != null) {
-        spawnSync("launchctl", ["bootout", `gui/${uid}`, plistPath]);
+      if (domain) {
+        spawnSync("launchctl", ["bootout", domain, plistPath]);
+      } else {
+        spawnSync("launchctl", ["bootout", plistPath]);
       }
       spawnSync("launchctl", ["unload", "-w", plistPath]);
-      spawnSync("launchctl", ["remove", "com.docdex.daemon"]);
       try {
         fs.unlinkSync(plistPath);
       } catch {}
     }
+    spawnSync("launchctl", ["remove", "com.docdex.daemon"]);
     return true;
   }
 
   if (process.platform === "linux") {
     const systemdDir = path.join(os.homedir(), ".config", "systemd", "user");
     const unitPath = path.join(systemdDir, "docdexd.service");
+    spawnSync("systemctl", ["--user", "stop", "docdexd.service"]);
     spawnSync("systemctl", ["--user", "disable", "--now", "docdexd.service"]);
+    spawnSync("systemctl", ["--user", "reset-failed", "docdexd.service"]);
     if (fs.existsSync(unitPath)) {
       try {
         fs.unlinkSync(unitPath);
@@ -490,16 +616,119 @@ function removeClientConfigs() {
   }
 }
 
-async function main() {
-  const stopped = stopDaemonFromLock();
-  if (!stopped) {
-    stopDaemonByName();
+function removeDocdexRoot() {
+  const root = docdexRootPath();
+  if (!fs.existsSync(root)) return false;
+  const resolvedRoot = path.resolve(root);
+  const resolvedHome = path.resolve(os.homedir());
+  const expectedRoot = path.join(resolvedHome, ".docdex");
+  if (resolvedRoot !== expectedRoot) return false;
+  try {
+    fs.rmSync(resolvedRoot, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
   }
-  stopMcpByName();
+}
+
+function removePath(target) {
+  if (!target || !fs.existsSync(target)) return false;
+  try {
+    fs.rmSync(target, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removeBinsInDir(dirPath) {
+  if (!dirPath || !fs.existsSync(dirPath)) return false;
+  let removed = false;
+  for (const name of BIN_NAMES) {
+    removed = removePath(path.join(dirPath, name)) || removed;
+  }
+  return removed;
+}
+
+function removeNodeModuleAt(dirPath) {
+  if (!dirPath) return false;
+  return removePath(path.join(dirPath, PACKAGE_NAME));
+}
+
+function removePrefixInstalls(prefix) {
+  if (!prefix) return;
+  removeBinsInDir(path.join(prefix, "bin"));
+  removeBinsInDir(prefix);
+  removeNodeModuleAt(path.join(prefix, "lib", "node_modules"));
+  removeNodeModuleAt(path.join(prefix, "node_modules"));
+}
+
+function removeHomebrewInstalls() {
+  const prefixes = new Set();
+  if (process.env.HOMEBREW_PREFIX) prefixes.add(process.env.HOMEBREW_PREFIX);
+  prefixes.add("/opt/homebrew");
+  prefixes.add("/usr/local");
+  for (const prefix of prefixes) {
+    removeBinsInDir(path.join(prefix, "bin"));
+  }
+}
+
+function removeNvmInstalls() {
+  const home = os.homedir();
+  const roots = new Set();
+  if (process.env.NVM_DIR) roots.add(process.env.NVM_DIR);
+  if (process.env.NVM_HOME) roots.add(process.env.NVM_HOME);
+  roots.add(path.join(home, ".nvm"));
+  if (process.env.NVM_BIN) {
+    removeBinsInDir(process.env.NVM_BIN);
+  }
+  for (const root of roots) {
+    if (!root || !fs.existsSync(root)) continue;
+    const versionsRoot = path.join(root, "versions", "node");
+    if (!fs.existsSync(versionsRoot)) continue;
+    const entries = fs.readdirSync(versionsRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const versionDir = path.join(versionsRoot, entry.name);
+      removeBinsInDir(path.join(versionDir, "bin"));
+      removeNodeModuleAt(path.join(versionDir, "lib", "node_modules"));
+      removeNodeModuleAt(path.join(versionDir, "node_modules"));
+    }
+  }
+}
+
+function removeCargoInstalls() {
+  const home = os.homedir();
+  removeBinsInDir(path.join(home, ".cargo", "bin"));
+}
+
+function purgeExternalInstalls() {
+  const prefix = process.env.npm_config_prefix || process.env.PREFIX;
+  if (prefix) removePrefixInstalls(prefix);
+  removeHomebrewInstalls();
+  removeNvmInstalls();
+  removeCargoInstalls();
+}
+
+async function main() {
   unregisterStartup();
+  stopDaemonFromLock();
+  stopDaemonByName();
+  const freed = await waitForPortFree();
+  const running = findRunningDaemonFromLocks();
+  if (!freed || running) {
+    console.warn(
+      `[docdex] ${DEFAULT_HOST}:${DEFAULT_DAEMON_PORT} is still in use or a daemon PID is alive; stop the process manually before reinstalling.`
+    );
+    for (const line of manualStopInstructions()) {
+      console.warn(`[docdex] ${line}`);
+    }
+  }
   removeClientConfigs();
   clearStartupFailure();
   removeDaemonRootNotice();
+  removeDocdexRoot();
+  purgeExternalInstalls();
 }
 
 if (require.main === module) {

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "docdex",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "mcpName": "io.github.bekirdag/docdex",
   "description": "Local-first documentation and code indexer with HTTP/MCP search, AST, and agent memory.",
   "bin": {
     "docdex": "bin/docdex.js",
-    "docdexd": "bin/docdex.js",
-    "docdex-mcp-server": "bin/docdex-mcp-server.js"
+    "docdexd": "bin/docdex.js"
   },
   "files": [
     "bin",
@@ -62,7 +61,6 @@
     "access": "public"
   },
   "dependencies": {
-    "playwright": "^1.49.0",
     "tar": "^6.2.1"
   }
 }

package/bin/docdex-mcp-server.js

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const fs = require("node:fs");
-const path = require("node:path");
-const { spawn } = require("node:child_process");
-
-const {
-  detectPlatformKey,
-  targetTripleForPlatformKey,
-  assetPatternForPlatformKey,
-  UnsupportedPlatformError
-} = require("../lib/platform");
-
-function run() {
-  let platformKey;
-  try {
-    platformKey = detectPlatformKey();
-  } catch (err) {
-    if (err instanceof UnsupportedPlatformError) {
-      const detected = `${err.details?.platform ?? process.platform}/${err.details?.arch ?? process.arch}`;
-      const libc = err.details?.libc ? `/${err.details.libc}` : "";
-      console.error(`[docdex] unsupported platform (${detected}${libc})`);
-      console.error(`[docdex] error code: ${err.code}`);
-      console.error("[docdex] No download/run was attempted for this platform.");
-      if (Array.isArray(err.details?.supportedPlatformKeys) && err.details.supportedPlatformKeys.length) {
-        console.error(`[docdex] Supported platforms: ${err.details.supportedPlatformKeys.join(", ")}`);
-      }
-      if (typeof err.details?.candidatePlatformKey === "string") {
-        console.error(`[docdex] Asset naming pattern: ${assetPatternForPlatformKey(err.details.candidatePlatformKey)}`);
-      }
-      console.error("[docdex] Next steps: use a supported platform or build from source (Rust).");
-      process.exit(err.exitCode || 3);
-      return;
-    }
-    console.error(`[docdex] failed to detect platform: ${err?.message || String(err)}`);
-    process.exit(1);
-    return;
-  }
-
-  const basePath = path.join(__dirname, "..", "dist", platformKey);
-  const binaryPath = path.join(
-    basePath,
-    process.platform === "win32" ? "docdex-mcp-server.exe" : "docdex-mcp-server"
-  );
-
-  if (!fs.existsSync(binaryPath)) {
-    console.error(
-      `[docdex] Missing MCP server binary for ${platformKey}. Try reinstalling or set DOCDEX_MCP_SERVER_BIN.`
-    );
-    try {
-      console.error(`[docdex] Expected target triple: ${targetTripleForPlatformKey(platformKey)}`);
-      console.error(`[docdex] Asset naming pattern: ${assetPatternForPlatformKey(platformKey)}`);
-    } catch {}
-    process.exit(1);
-  }
-
-  const child = spawn(binaryPath, process.argv.slice(2), { stdio: "inherit" });
-  child.on("exit", (code) => process.exit(code ?? 1));
-  child.on("error", (err) => {
-    console.error(`[docdex] failed to launch MCP server: ${err.message}`);
-    process.exit(1);
-  });
-}
-
-run();

package/lib/playwright_fetch.js

@@ -1,174 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const { chromium, firefox, webkit } = require("playwright");
-
-const DEFAULT_TIMEOUT_MS = 15000;
-const DEFAULT_BROWSER = "chromium";
-const VIEWPORT = { width: 1920, height: 1080 };
-const CHROMIUM_ARGS = [
-  "--disable-blink-features=AutomationControlled",
-  "--disable-dev-shm-usage",
-  "--disable-gpu",
-  "--no-sandbox",
-  "--no-first-run",
-  "--no-default-browser-check"
-];
-
-function normalizeBrowser(value) {
-  const trimmed = String(value || "").trim().toLowerCase();
-  if (trimmed === "chrome" || trimmed === "chromium" || trimmed === "chromium-browser") {
-    return "chromium";
-  }
-  if (trimmed === "firefox") return "firefox";
-  if (trimmed === "webkit") return "webkit";
-  return DEFAULT_BROWSER;
-}
-
-function resolveBrowserType(name) {
-  switch (name) {
-    case "chromium":
-      return chromium;
-    case "firefox":
-      return firefox;
-    case "webkit":
-      return webkit;
-    default:
-      return chromium;
-  }
-}
-
-function parseArgs(argv) {
-  const parsed = {
-    url: "",
-    browser: DEFAULT_BROWSER,
-    timeoutMs: DEFAULT_TIMEOUT_MS,
-    userAgent: "",
-    headless: true,
-    userDataDir: ""
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const value = argv[i];
-    if (value === "--url" && argv[i + 1]) {
-      parsed.url = argv[i + 1];
-      i += 1;
-      continue;
-    }
-    if (value === "--browser" && argv[i + 1]) {
-      parsed.browser = argv[i + 1];
-      i += 1;
-      continue;
-    }
-    if (value === "--timeout-ms" && argv[i + 1]) {
-      parsed.timeoutMs = Number(argv[i + 1]);
-      i += 1;
-      continue;
-    }
-    if (value === "--user-agent" && argv[i + 1]) {
-      parsed.userAgent = argv[i + 1];
-      i += 1;
-      continue;
-    }
-    if (value === "--user-data-dir" && argv[i + 1]) {
-      parsed.userDataDir = argv[i + 1];
-      i += 1;
-      continue;
-    }
-    if (value === "--headless") {
-      parsed.headless = true;
-      continue;
-    }
-    if (value === "--headed") {
-      parsed.headless = false;
-      continue;
-    }
-  }
-  parsed.browser = normalizeBrowser(parsed.browser);
-  if (!parsed.url) {
-    throw new Error("missing --url");
-  }
-  if (!Number.isFinite(parsed.timeoutMs) || parsed.timeoutMs <= 0) {
-    parsed.timeoutMs = DEFAULT_TIMEOUT_MS;
-  }
-  return parsed;
-}
-
-async function fetchWithPlaywright(options) {
-  const browserName = normalizeBrowser(options.browser);
-  const browserType = resolveBrowserType(browserName);
-  const launchOptions = {
-    headless: options.headless
-  };
-  if (browserName === "chromium") {
-    launchOptions.args = CHROMIUM_ARGS;
-  }
-
-  let browser;
-  let context;
-  try {
-    if (options.userDataDir) {
-      context = await browserType.launchPersistentContext(options.userDataDir, {
-        ...launchOptions,
-        viewport: VIEWPORT,
-        userAgent: options.userAgent || undefined
-      });
-    } else {
-      browser = await browserType.launch(launchOptions);
-      context = await browser.newContext({
-        viewport: VIEWPORT,
-        userAgent: options.userAgent || undefined
-      });
-    }
-
-    await context.addInitScript(() => {
-      Object.defineProperty(navigator, "webdriver", { get: () => undefined });
-    });
-
-    const page = await context.newPage();
-    page.setDefaultTimeout(options.timeoutMs);
-    const response = await page.goto(options.url, {
-      waitUntil: "domcontentloaded",
-      timeout: options.timeoutMs
-    });
-    const html = await page.content();
-    const status = response ? response.status() : null;
-    const finalUrl = page.url();
-    await page.close();
-
-    if (!html || !String(html).trim()) {
-      throw new Error("empty HTML response");
-    }
-
-    return { html: String(html), status, final_url: finalUrl };
-  } finally {
-    if (context) {
-      await context.close();
-    }
-    if (browser) {
-      await browser.close();
-    }
-  }
-}
-
-async function main() {
-  try {
-    const options = parseArgs(process.argv.slice(2));
-    const result = await fetchWithPlaywright(options);
-    process.stdout.write(JSON.stringify(result) + "\n");
-  } catch (err) {
-    const message = err?.message || String(err);
-    console.error(`[docdex] playwright fetch failed: ${message}`);
-    process.exit(1);
-  }
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = {
-  fetchWithPlaywright,
-  normalizeBrowser,
-  parseArgs,
-  resolveBrowserType
-};