docdex 0.2.21 → 0.2.23

package/lib/postinstall_setup.js

@@ -3,6 +3,7 @@
 
 const fs = require("node:fs");
 const net = require("node:net");
+const http = require("node:http");
 const os = require("node:os");
 const path = require("node:path");
 const readline = require("node:readline");
@@ -12,8 +13,11 @@ const { spawn, spawnSync } = require("node:child_process");
 const { detectPlatformKey, UnsupportedPlatformError } = require("./platform");
 
 const DEFAULT_HOST = "127.0.0.1";
-const DEFAULT_PORT_PRIMARY = 3000;
-const DEFAULT_PORT_FALLBACK = 3210;
+const DEFAULT_DAEMON_PORT = 28491;
+const DAEMON_HEALTH_TIMEOUT_MS = 8000;
+const DAEMON_HEALTH_REQUEST_TIMEOUT_MS = 1000;
+const DAEMON_HEALTH_POLL_INTERVAL_MS = 200;
+const DAEMON_HEALTH_PATH = "/healthz";
 const STARTUP_FAILURE_MARKER = "startup_registration_failed.json";
 const DEFAULT_OLLAMA_MODEL = "nomic-embed-text";
 const DEFAULT_OLLAMA_CHAT_MODEL = "phi3.5:3.8b";
@@ -39,6 +43,17 @@ function setupPendingPath() {
   return path.join(stateDir(), SETUP_PENDING_MARKER);
 }
 
+function daemonLockPaths() {
+  const root = path.join(os.homedir(), ".docdex");
+  const paths = [];
+  if (process.env.DOCDEX_DAEMON_LOCK_PATH) {
+    paths.push(process.env.DOCDEX_DAEMON_LOCK_PATH);
+  }
+  paths.push(path.join(root, "locks", "daemon.lock"));
+  paths.push(path.join(root, "daemon.lock"));
+  return Array.from(new Set(paths.filter(Boolean)));
+}
+
 function configUrlForPort(port) {
   return `http://localhost:${port}/sse`;
 }
@@ -59,22 +74,51 @@ function isPortAvailable(port, host) {
   });
 }
 
-async function pickAvailablePort(host, preferred) {
-  for (const port of preferred) {
-    if (await isPortAvailable(port, host)) return port;
-  }
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.unref();
-    server.once("error", reject);
-    server.once("listening", () => {
-      const addr = server.address();
-      server.close(() => resolve(addr.port));
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function checkDaemonHealth({ host, port, timeoutMs = DAEMON_HEALTH_REQUEST_TIMEOUT_MS }) {
+  return new Promise((resolve) => {
+    const req = http.request(
+      {
+        host,
+        port,
+        path: DAEMON_HEALTH_PATH,
+        method: "GET",
+        timeout: timeoutMs
+      },
+      (res) => {
+        let body = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          resolve(res.statusCode === 200 && body.trim() === "ok");
+        });
+      }
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
     });
-    server.listen(0, host);
+    req.on("error", () => resolve(false));
+    req.end();
   });
 }
 
+async function waitForDaemonHealthy({ host, port, timeoutMs = DAEMON_HEALTH_TIMEOUT_MS }) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await checkDaemonHealth({ host, port })) {
+      return true;
+    }
+    await sleep(DAEMON_HEALTH_POLL_INTERVAL_MS);
+  }
+  return false;
+}
+
 function parseServerBind(contents) {
   let inServer = false;
   const lines = contents.split(/\r?\n/);
@@ -91,6 +135,125 @@ function parseServerBind(contents) {
   return null;
 }
 
+function stopDaemonService({ logger } = {}) {
+  if (process.platform === "darwin") {
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    const domain = uid != null ? `gui/${uid}` : null;
+    const plistPath = path.join(os.homedir(), "Library", "LaunchAgents", "com.docdex.daemon.plist");
+    const bootoutByLabel = domain
+      ? spawnSync("launchctl", ["bootout", domain, "com.docdex.daemon"])
+      : spawnSync("launchctl", ["bootout", "com.docdex.daemon"]);
+    const bootoutByPath = domain
+      ? spawnSync("launchctl", ["bootout", domain, plistPath])
+      : spawnSync("launchctl", ["bootout", plistPath]);
+    const fallback = spawnSync("launchctl", ["unload", "-w", plistPath]);
+    spawnSync("launchctl", ["remove", "com.docdex.daemon"]);
+    if (bootoutByLabel.status === 0 || bootoutByPath.status === 0 || fallback.status === 0) {
+      return true;
+    }
+    logger?.warn?.(
+      `[docdex] launchctl stop failed: ${bootoutByLabel.stderr || bootoutByPath.stderr || fallback.stderr || "unknown error"}`
+    );
+    return false;
+  }
+  if (process.platform === "linux") {
+    const stop = spawnSync("systemctl", ["--user", "stop", "docdexd.service"]);
+    if (stop.status === 0) return true;
+    logger?.warn?.(`[docdex] systemd stop failed: ${stop.stderr || "unknown error"}`);
+    return false;
+  }
+  if (process.platform === "win32") {
+    const stop = spawnSync("schtasks", ["/End", "/TN", "Docdex Daemon"]);
+    if (stop.status === 0) return true;
+    logger?.warn?.(`[docdex] schtasks stop failed: ${stop.stderr || "unknown error"}`);
+    return false;
+  }
+  return false;
+}
+
+function startDaemonService({ logger } = {}) {
+  if (process.platform === "darwin") {
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    const domain = uid != null ? `gui/${uid}` : null;
+    const kickstart = domain
+      ? spawnSync("launchctl", ["kickstart", "-k", `${domain}/com.docdex.daemon`])
+      : spawnSync("launchctl", ["kickstart", "-k", "com.docdex.daemon"]);
+    if (kickstart.status === 0) return true;
+    const start = spawnSync("launchctl", ["start", "com.docdex.daemon"]);
+    if (start.status === 0) return true;
+    logger?.warn?.(`[docdex] launchctl start failed: ${kickstart.stderr || start.stderr || "unknown error"}`);
+    return false;
+  }
+  if (process.platform === "linux") {
+    const start = spawnSync("systemctl", ["--user", "restart", "docdexd.service"]);
+    if (start.status === 0) return true;
+    logger?.warn?.(`[docdex] systemd start failed: ${start.stderr || "unknown error"}`);
+    return false;
+  }
+  if (process.platform === "win32") {
+    const run = spawnSync("schtasks", ["/Run", "/TN", "Docdex Daemon"]);
+    if (run.status === 0) return true;
+    logger?.warn?.(`[docdex] schtasks run failed: ${run.stderr || "unknown error"}`);
+    return false;
+  }
+  return false;
+}
+
+function stopDaemonByName({ logger } = {}) {
+  if (process.platform === "win32") {
+    const result = spawnSync("taskkill", ["/IM", "docdexd.exe", "/T", "/F"]);
+    if (result?.error?.code === "ENOENT") return false;
+    return true;
+  }
+  const result = spawnSync("pkill", ["-TERM", "-x", "docdexd"]);
+  if (result?.error?.code === "ENOENT") {
+    spawnSync("killall", ["-TERM", "docdexd"]);
+    return false;
+  }
+  spawnSync("pkill", ["-TERM", "-f", "docdexd"]);
+  return true;
+}
+
+function clearDaemonLocks() {
+  let removed = false;
+  for (const lockPath of daemonLockPaths()) {
+    if (!lockPath || !fs.existsSync(lockPath)) continue;
+    try {
+      const resolved = path.resolve(lockPath);
+      const home = path.resolve(os.homedir());
+      if (!resolved.startsWith(home + path.sep)) continue;
+      fs.unlinkSync(lockPath);
+      removed = true;
+    } catch {
+      continue;
+    }
+  }
+  return removed;
+}
+
+function stopDaemonFromLock({ logger } = {}) {
+  let stopped = false;
+  for (const lockPath of daemonLockPaths()) {
+    if (!lockPath || !fs.existsSync(lockPath)) continue;
+    try {
+      const raw = fs.readFileSync(lockPath, "utf8");
+      if (!raw.trim()) continue;
+      const payload = JSON.parse(raw);
+      const pid = Number(payload?.pid);
+      if (!Number.isFinite(pid) || pid <= 0) continue;
+      try {
+        process.kill(pid, "SIGTERM");
+        stopped = true;
+      } catch (err) {
+        logger?.warn?.(`[docdex] failed to stop daemon pid ${pid}: ${err?.message || err}`);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return stopped;
+}
+
 function upsertServerConfig(contents, httpBindAddr) {
   const lines = contents.split(/\r?\n/);
   const output = [];
@@ -826,6 +989,41 @@ function resolveBinaryPath({ binaryPath } = {}) {
   return null;
 }
 
+function isPathWithin(parent, candidate) {
+  const base = path.resolve(parent);
+  const target = path.resolve(candidate);
+  if (base === target) return true;
+  return target.startsWith(base + path.sep);
+}
+
+function isMacProtectedPath(candidate) {
+  if (process.platform !== "darwin") return false;
+  const home = os.homedir();
+  return ["Desktop", "Documents", "Downloads"].some((dir) => isPathWithin(path.join(home, dir), candidate));
+}
+
+function ensureStartupBinary(binaryPath, { logger } = {}) {
+  if (!binaryPath) return null;
+  if (!isMacProtectedPath(binaryPath) && !isTempPath(binaryPath)) return binaryPath;
+  const binDir = path.join(os.homedir(), ".docdex", "bin");
+  const target = path.join(binDir, path.basename(binaryPath));
+  if (fs.existsSync(target)) return target;
+  try {
+    fs.mkdirSync(binDir, { recursive: true });
+    fs.copyFileSync(binaryPath, target);
+    fs.chmodSync(target, 0o755);
+    return target;
+  } catch (err) {
+    logger?.warn?.(`[docdex] failed to stage daemon binary for startup: ${err?.message || err}`);
+    return binaryPath;
+  }
+}
+
+function resolveStartupBinaryPaths({ binaryPath, logger } = {}) {
+  const resolvedBinary = ensureStartupBinary(binaryPath, { logger });
+  return { binaryPath: resolvedBinary };
+}
+
 function applyAgentInstructions({ logger } = {}) {
   const instructions = buildDocdexInstructionBlock(loadAgentInstructions());
   if (!normalizeInstructionText(instructions)) return { ok: false, reason: "missing_instructions" };
@@ -886,14 +1084,6 @@ function applyAgentInstructions({ logger } = {}) {
   return { ok: true, updated };
 }
 
-function resolveMcpBinaryPath(binaryPath) {
-  if (!binaryPath) return null;
-  const dir = path.dirname(binaryPath);
-  const name = process.platform === "win32" ? "docdex-mcp-server.exe" : "docdex-mcp-server";
-  const candidate = path.join(dir, name);
-  return fs.existsSync(candidate) ? candidate : null;
-}
-
 function ensureDaemonRoot() {
   const root = daemonRootPath();
   fs.mkdirSync(root, { recursive: true });
@@ -1464,30 +1654,36 @@ async function maybePromptOllamaModel({
   return { status: "skipped", reason: "invalid_selection" };
 }
 
-function resolvePlaywrightFetcherPath() {
-  const candidate = path.join(__dirname, "playwright_fetch.js");
-  return fs.existsSync(candidate) ? candidate : null;
+function envBool(value) {
+  if (!value) return false;
+  const normalized = String(value).trim().toLowerCase();
+  return ["1", "true", "t", "yes", "y", "on"].includes(normalized);
+}
+
+function isTempPath(value, osModule = os) {
+  if (!value) return false;
+  const tmpdir = osModule.tmpdir();
+  if (!tmpdir) return false;
+  const resolvedValue = path.resolve(value);
+  const resolvedTmp = path.resolve(tmpdir);
+  return resolvedValue === resolvedTmp || resolvedValue.startsWith(resolvedTmp + path.sep);
 }
 
-function buildDaemonEnvPairs({ mcpBinaryPath } = {}) {
-  const pairs = [["DOCDEX_BROWSER_AUTO_INSTALL", "0"]];
-  if (mcpBinaryPath) pairs.push(["DOCDEX_MCP_SERVER_BIN", mcpBinaryPath]);
-  const fetcher = resolvePlaywrightFetcherPath();
-  if (fetcher) pairs.push(["DOCDEX_PLAYWRIGHT_FETCHER", fetcher]);
-  return pairs;
+function buildDaemonEnvPairs() {
+  return [["DOCDEX_BROWSER_AUTO_INSTALL", "0"]];
 }
 
-function buildDaemonEnv({ mcpBinaryPath } = {}) {
-  return Object.fromEntries(buildDaemonEnvPairs({ mcpBinaryPath }));
+function buildDaemonEnv() {
+  return Object.fromEntries(buildDaemonEnvPairs());
 }
 
-function registerStartup({ binaryPath, mcpBinaryPath, port, repoRoot, logger }) {
+function registerStartup({ binaryPath, port, repoRoot, logger }) {
   if (!binaryPath) return { ok: false, reason: "missing_binary" };
-  const envPairs = buildDaemonEnvPairs({ mcpBinaryPath });
+  stopDaemonService({ logger });
+  const envPairs = buildDaemonEnvPairs();
+  const workingDir = repoRoot ? path.resolve(repoRoot) : null;
   const args = [
     "daemon",
-    "--repo",
-    repoRoot,
     "--host",
     DEFAULT_HOST,
     "--port",
@@ -1520,6 +1716,9 @@ function registerStartup({ binaryPath, mcpBinaryPath, port, repoRoot, logger })
       `  <array>\n` +
       programArgs.map((arg) => `    <string>${arg}</string>\n`).join("") +
       `  </array>\n` +
+      (workingDir
+        ? `  <key>WorkingDirectory</key>\n` + `  <string>${workingDir}</string>\n`
+        : "") +
       `  <key>RunAtLoad</key>\n` +
       `  <true/>\n` +
       `  <key>KeepAlive</key>\n` +
@@ -1555,6 +1754,7 @@ function registerStartup({ binaryPath, mcpBinaryPath, port, repoRoot, logger })
       "",
       "[Service]",
       `ExecStart=${binaryPath} ${args.join(" ")}`,
+      workingDir ? `WorkingDirectory=${workingDir}` : "",
       ...envLines,
       "Restart=always",
       "RestartSec=2",
@@ -1575,8 +1775,9 @@ function registerStartup({ binaryPath, mcpBinaryPath, port, repoRoot, logger })
     const taskName = "Docdex Daemon";
     const joinedArgs = args.map((arg) => `"${arg}"`).join(" ");
     const envParts = envPairs.map(([key, value]) => `set "${key}=${value}"`);
+    const cdCommand = workingDir ? `cd /d "${workingDir}"` : null;
     const taskArgs =
-      `"cmd.exe" /c "${envParts.join(" && ")} && \"${binaryPath}\" ${joinedArgs}"`;
+      `"cmd.exe" /c "${envParts.join(" && ")}${cdCommand ? ` && ${cdCommand}` : ""} && \"${binaryPath}\" ${joinedArgs}"`;
     const create = spawnSync("schtasks", [
       "/Create",
       "/F",
@@ -1600,34 +1801,28 @@ function registerStartup({ binaryPath, mcpBinaryPath, port, repoRoot, logger })
   return { ok: false, reason: "unsupported_platform" };
 }
 
-function startDaemonNow({ binaryPath, mcpBinaryPath, port, repoRoot }) {
-  if (!binaryPath) return false;
-  const extraEnv = buildDaemonEnv({ mcpBinaryPath });
-  const child = spawn(
+async function startDaemonWithHealthCheck({ binaryPath, port, host, logger }) {
+  const startup = registerStartup({
     binaryPath,
-    [
-      "daemon",
-      "--repo",
-      repoRoot,
-      "--host",
-      DEFAULT_HOST,
-      "--port",
-      String(port),
-      "--log",
-      "warn",
-      "--secure-mode=false"
-    ],
-    {
-      stdio: "ignore",
-      detached: true,
-      env: {
-        ...process.env,
-        ...extraEnv
-      }
-    }
-  );
-  child.unref();
-  return true;
+    port,
+    repoRoot: daemonRootPath(),
+    logger
+  });
+  if (!startup.ok) {
+    logger?.warn?.(`[docdex] daemon service registration failed (${startup.reason || "unknown"}).`);
+    return { ok: false, reason: "startup_failed" };
+  }
+  startDaemonService({ logger });
+  const healthy = await waitForDaemonHealthy({ host, port });
+  if (healthy) {
+    return { ok: true, reason: "healthy" };
+  }
+  logger?.warn?.(`[docdex] daemon failed health check on ${host}:${port}`);
+  stopDaemonService({ logger });
+  stopDaemonFromLock({ logger });
+  stopDaemonByName({ logger });
+  clearDaemonLocks();
+  return { ok: false, reason: "health_failed" };
 }
 
 function recordStartupFailure(details) {
@@ -1758,16 +1953,34 @@ async function runPostInstallSetup({ binaryPath, logger } = {}) {
   if (fs.existsSync(configPath)) {
     existingConfig = fs.readFileSync(configPath, "utf8");
   }
-  const configuredBind = existingConfig ? parseServerBind(existingConfig) : null;
-  let port;
-  if (process.env.DOCDEX_DAEMON_PORT) {
-    port = Number(process.env.DOCDEX_DAEMON_PORT);
-  } else if (configuredBind) {
-    const match = configuredBind.match(/:(\d+)$/);
-    port = match ? Number(match[1]) : null;
+  const port = DEFAULT_DAEMON_PORT;
+  const available = await isPortAvailable(port, DEFAULT_HOST);
+  if (!available) {
+    log.error?.(
+      `[docdex] ${DEFAULT_HOST}:${port} is already in use; docdex requires a fixed port. Stop the process using this port and re-run the install.`
+    );
+    throw new Error(`docdex requires ${DEFAULT_HOST}:${port}, but the port is already in use`);
   }
-  if (!port || Number.isNaN(port)) {
-    port = await pickAvailablePort(DEFAULT_HOST, [DEFAULT_PORT_PRIMARY, DEFAULT_PORT_FALLBACK]);
+
+  const daemonRoot = ensureDaemonRoot();
+  const resolvedBinary = resolveBinaryPath({ binaryPath });
+  const startupBinaries = resolveStartupBinaryPaths({
+    binaryPath: resolvedBinary,
+    logger: log
+  });
+  stopDaemonService({ logger: log });
+  stopDaemonFromLock({ logger: log });
+  stopDaemonByName({ logger: log });
+  clearDaemonLocks();
+  const result = await startDaemonWithHealthCheck({
+    binaryPath: startupBinaries.binaryPath,
+    port,
+    host: DEFAULT_HOST,
+    logger: log
+  });
+  if (!result.ok) {
+    log.warn?.(`[docdex] daemon failed to start on ${DEFAULT_HOST}:${port}.`);
+    throw new Error("docdex daemon failed to start");
   }
 
   const httpBindAddr = `${DEFAULT_HOST}:${port}`;
@@ -1800,29 +2013,8 @@ async function runPostInstallSetup({ binaryPath, logger } = {}) {
   }
   upsertCodexConfig(paths.codex, codexUrl);
   applyAgentInstructions({ logger: log });
-
-  const daemonRoot = ensureDaemonRoot();
-  const resolvedBinary = resolveBinaryPath({ binaryPath });
-  const resolvedMcpBinary = resolveMcpBinaryPath(resolvedBinary);
-  const startup = registerStartup({
-    binaryPath: resolvedBinary,
-    mcpBinaryPath: resolvedMcpBinary,
-    port,
-    repoRoot: daemonRoot,
-    logger: log
-  });
-  if (!startup.ok) {
-    if (!startupFailureReported()) {
-      log.warn?.("[docdex] startup registration failed; run the daemon manually:");
-      log.warn?.(`[docdex]   ${resolvedBinary || "docdexd"} daemon --repo ${daemonRoot} --host ${DEFAULT_HOST} --port ${port}`);
-      recordStartupFailure({ reason: startup.reason, port, repoRoot: daemonRoot });
-    }
-  } else {
-    clearStartupFailure();
-  }
-
-  startDaemonNow({ binaryPath: resolvedBinary, mcpBinaryPath: resolvedMcpBinary, port, repoRoot: daemonRoot });
-  const setupLaunch = launchSetupWizard({ binaryPath: resolvedBinary, logger: log });
+  clearStartupFailure();
+  const setupLaunch = launchSetupWizard({ binaryPath: startupBinaries.binaryPath, logger: log });
   if (!setupLaunch.ok && setupLaunch.reason !== "skipped") {
     log.warn?.("[docdex] setup wizard did not launch. Run `docdex setup`.");
     recordSetupPending({ reason: setupLaunch.reason, port, repoRoot: daemonRoot });
@@ -1837,7 +2029,6 @@ module.exports = {
   upsertMcpServerJson,
   upsertZedConfig,
   upsertCodexConfig,
-  pickAvailablePort,
   configUrlForPort,
   configStreamableUrlForPort,
   parseEnvBool,