docdex 0.2.22 → 0.2.24

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 = [];
@@ -400,7 +563,7 @@ function upsertClaudeInstructions(pathname, instructions) {
   return true;
 }
 
-function upsertContinueInstructions(pathname, instructions) {
+function upsertContinueJsonInstructions(pathname, instructions) {
   const { value } = readJson(pathname);
   if (typeof value !== "object" || value == null || Array.isArray(value)) return false;
   const merged = mergeInstructionText(value.systemMessage, instructions);
@@ -410,6 +573,198 @@ function upsertContinueInstructions(pathname, instructions) {
   return true;
 }
 
+function countLeadingWhitespace(line) {
+  const match = line.match(/^\s*/);
+  return match ? match[0].length : 0;
+}
+
+function isYamlTopLevelKey(line, baseIndent) {
+  const indent = countLeadingWhitespace(line);
+  if (indent > baseIndent) return false;
+  const trimmed = line.trimStart();
+  if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-")) return false;
+  return trimmed.includes(":");
+}
+
+function hasYamlContent(lines) {
+  return lines.some((line) => {
+    const trimmed = line.trim();
+    return trimmed && !trimmed.startsWith("#");
+  });
+}
+
+function splitInlineYamlList(value) {
+  const trimmed = String(value || "").trim();
+  if (trimmed === "[]") return [];
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return null;
+  const inner = trimmed.slice(1, -1);
+  const items = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+  for (const ch of inner) {
+    if (escaped) {
+      current += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\\\") {
+      escaped = true;
+      current += ch;
+      continue;
+    }
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+      continue;
+    }
+    if (ch === "," && !inSingle && !inDouble) {
+      const next = current.trim();
+      if (next) items.push(next);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  const next = current.trim();
+  if (next) items.push(next);
+  return items;
+}
+
+function inlineRulesToItems(value, itemIndent) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) return [];
+  const prefix = " ".repeat(itemIndent);
+  const split = splitInlineYamlList(trimmed);
+  if (split) {
+    return split.map((item) => [`${prefix}- ${item}`]).filter((item) => item[0].trim() !== `${prefix}-`);
+  }
+  return [[`${prefix}- ${trimmed}`]];
+}
+
+function buildYamlRuleBlock(itemIndent, instructions) {
+  const prefix = " ".repeat(itemIndent);
+  const contentPrefix = " ".repeat(itemIndent + 2);
+  const lines = [`${prefix}- |`];
+  for (const line of String(instructions).split(/\r?\n/)) {
+    lines.push(`${contentPrefix}${line}`);
+  }
+  return lines;
+}
+
+function rewriteContinueYamlRules(source, instructions, addDocdex) {
+  const lines = String(source || "").split(/\r?\n/);
+  const ruleLineRe = /^(\s*)rules\s*:(.*)$/;
+  let rulesIndex = -1;
+  let rulesIndent = 0;
+  let rulesInline = "";
+  for (let i = 0; i < lines.length; i += 1) {
+    const match = lines[i].match(ruleLineRe);
+    if (!match) continue;
+    rulesIndex = i;
+    rulesIndent = match[1]?.length || 0;
+    rulesInline = (match[2] || "").trim();
+    if (rulesInline.includes("#")) {
+      rulesInline = rulesInline.split("#")[0].trim();
+    }
+    if (rulesInline.startsWith("#")) rulesInline = "";
+    break;
+  }
+
+  if (rulesIndex === -1) {
+    if (!addDocdex) return null;
+    const trimmed = String(source || "").trimEnd();
+    const docdexBlock = buildYamlRuleBlock(2, instructions);
+    const prefix = trimmed ? `${trimmed}\n\n` : "";
+    return `${prefix}rules:\n${docdexBlock.join("\n")}`;
+  }
+
+  let endIndex = lines.length;
+  for (let i = rulesIndex + 1; i < lines.length; i += 1) {
+    if (isYamlTopLevelKey(lines[i], rulesIndent)) {
+      endIndex = i;
+      break;
+    }
+  }
+  const blockLines = lines.slice(rulesIndex + 1, endIndex);
+  const preLines = [];
+  const items = [];
+  let currentItem = [];
+  let itemIndent = null;
+  let startedItems = false;
+
+  for (const line of blockLines) {
+    const trimmed = line.trimStart();
+    const indent = countLeadingWhitespace(line);
+    const isItem = trimmed.startsWith("-") && indent > rulesIndent;
+    if (isItem) {
+      if (itemIndent == null) itemIndent = indent;
+      if (indent === itemIndent) {
+        if (startedItems && currentItem.length) {
+          items.push(currentItem);
+          currentItem = [];
+        }
+        startedItems = true;
+      }
+      currentItem.push(line);
+      continue;
+    }
+    if (startedItems) {
+      currentItem.push(line);
+    } else {
+      preLines.push(line);
+    }
+  }
+  if (currentItem.length) items.push(currentItem);
+
+  const inferredIndent = itemIndent == null ? rulesIndent + 2 : itemIndent;
+  if (!items.length && rulesInline) {
+    items.push(...inlineRulesToItems(rulesInline, inferredIndent));
+    rulesInline = "";
+  }
+
+  const keptItems = items.filter((item) => {
+    const text = item.join("\n");
+    return !(text.includes(DOCDEX_INFO_START_PREFIX) && text.includes(DOCDEX_INFO_END));
+  });
+
+  if (addDocdex) {
+    keptItems.push(buildYamlRuleBlock(inferredIndent, instructions));
+  }
+
+  const removeRulesBlock =
+    !addDocdex && !keptItems.length && !hasYamlContent(preLines) && !rulesInline;
+
+  const output = [];
+  output.push(...lines.slice(0, rulesIndex));
+  if (!removeRulesBlock) {
+    output.push(`${" ".repeat(rulesIndent)}rules:`);
+    output.push(...preLines);
+    for (const item of keptItems) {
+      output.push(...item);
+    }
+  }
+  output.push(...lines.slice(endIndex));
+  const next = output.join("\n");
+  return next === source ? null : next;
+}
+
+function upsertContinueYamlRules(pathname, instructions) {
+  if (!fs.existsSync(pathname)) return false;
+  const normalized = normalizeInstructionText(instructions);
+  if (!normalized) return false;
+  const current = fs.readFileSync(pathname, "utf8");
+  const updated = rewriteContinueYamlRules(current, normalized, true);
+  if (!updated) return false;
+  return writeTextFile(pathname, updated);
+}
+
 function upsertZedInstructions(pathname, instructions) {
   const { value } = readJson(pathname);
   if (typeof value !== "object" || value == null || Array.isArray(value)) return false;
@@ -423,12 +778,56 @@ function upsertZedInstructions(pathname, instructions) {
   return true;
 }
 
-function upsertVsCodeInstructions(pathname, instructionsPath) {
+function upsertVsCodeInstructionKey(value, key, instructions) {
+  const existing = typeof value[key] === "string" ? value[key] : "";
+  const merged = mergeInstructionText(existing, instructions);
+  if (!merged || merged === existing) return false;
+  value[key] = merged;
+  return true;
+}
+
+function upsertVsCodeInstructionLocations(value, instructionsDir) {
+  const key = "chat.instructionsFilesLocations";
+  const location = String(instructionsDir);
+  if (value[key] && typeof value[key] === "object" && !Array.isArray(value[key])) {
+    if (value[key][location] === true) return false;
+    value[key][location] = true;
+    return true;
+  }
+  if (Array.isArray(value[key])) {
+    if (value[key].some((entry) => entry === location)) return false;
+    value[key].push(location);
+    return true;
+  }
+  if (typeof value[key] === "string") {
+    if (value[key] === location) return false;
+    value[key] = [value[key], location];
+    return true;
+  }
+  value[key] = { [location]: true };
+  return true;
+}
+
+function upsertVsCodeInstructions(pathname, instructions, instructionsDir) {
   const { value } = readJson(pathname);
   if (typeof value !== "object" || value == null || Array.isArray(value)) return false;
-  const key = "copilot.chat.codeGeneration.instructions";
-  if (value[key] === instructionsPath) return false;
-  value[key] = instructionsPath;
+  const normalized = normalizeInstructionText(instructions);
+  if (!normalized) return false;
+  let updated = false;
+  if (upsertVsCodeInstructionKey(value, "github.copilot.chat.codeGeneration.instructions", instructions)) {
+    updated = true;
+  }
+  if (upsertVsCodeInstructionKey(value, "copilot.chat.codeGeneration.instructions", instructions)) {
+    updated = true;
+  }
+  if (value["github.copilot.chat.codeGeneration.useInstructionFiles"] !== true) {
+    value["github.copilot.chat.codeGeneration.useInstructionFiles"] = true;
+    updated = true;
+  }
+  if (upsertVsCodeInstructionLocations(value, instructionsDir)) {
+    updated = true;
+  }
+  if (!updated) return false;
   writeJson(pathname, value);
   return true;
 }
@@ -758,6 +1157,12 @@ function clientInstructionPaths() {
   const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
   const userProfile = process.env.USERPROFILE || home;
   const vscodeGlobalInstructions = path.join(home, ".vscode", "global_instructions.md");
+  const vscodeInstructionsDir = path.join(home, ".vscode", "instructions");
+  const vscodeInstructionsFile = path.join(vscodeInstructionsDir, "docdex.md");
+  const continueRoot = path.join(userProfile, ".continue");
+  const continueJson = path.join(continueRoot, "config.json");
+  const continueYaml = path.join(continueRoot, "config.yaml");
+  const continueYml = path.join(continueRoot, "config.yml");
   const windsurfGlobalRules = path.join(userProfile, ".codeium", "windsurf", "memories", "global_rules.md");
   const rooRules = path.join(home, ".roo", "rules", "docdex.md");
   const pearaiAgent = path.join(home, ".config", "pearai", "agent.md");
@@ -769,10 +1174,14 @@ function clientInstructionPaths() {
     case "win32":
       return {
         claude: path.join(appData, "Claude", "claude_desktop_config.json"),
-        continue: path.join(userProfile, ".continue", "config.json"),
+        continue: continueJson,
+        continueYaml,
+        continueYml,
         zed: path.join(appData, "Zed", "settings.json"),
         vscodeSettings: path.join(appData, "Code", "User", "settings.json"),
         vscodeGlobalInstructions,
+        vscodeInstructionsDir,
+        vscodeInstructionsFile,
         windsurfGlobalRules,
         rooRules,
         pearaiAgent,
@@ -784,10 +1193,14 @@ function clientInstructionPaths() {
     case "darwin":
       return {
         claude: path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
-        continue: path.join(home, ".continue", "config.json"),
+        continue: continueJson,
+        continueYaml,
+        continueYml,
         zed: path.join(home, ".config", "zed", "settings.json"),
         vscodeSettings: path.join(home, "Library", "Application Support", "Code", "User", "settings.json"),
         vscodeGlobalInstructions,
+        vscodeInstructionsDir,
+        vscodeInstructionsFile,
         windsurfGlobalRules,
         rooRules,
         pearaiAgent,
@@ -799,10 +1212,14 @@ function clientInstructionPaths() {
     default:
       return {
         claude: path.join(home, ".config", "Claude", "claude_desktop_config.json"),
-        continue: path.join(home, ".continue", "config.json"),
+        continue: continueJson,
+        continueYaml,
+        continueYml,
         zed: path.join(home, ".config", "zed", "settings.json"),
         vscodeSettings: path.join(home, ".config", "Code", "User", "settings.json"),
         vscodeGlobalInstructions,
+        vscodeInstructionsDir,
+        vscodeInstructionsFile,
         windsurfGlobalRules,
         rooRules,
         pearaiAgent,
@@ -826,6 +1243,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" };
@@ -847,8 +1299,15 @@ function applyAgentInstructions({ logger } = {}) {
       upsertPromptFile(paths.vscodeGlobalInstructions, instructions, { prepend: true })
     );
   }
-  if (paths.vscodeSettings && paths.vscodeGlobalInstructions) {
-    safeApply("vscode-settings", () => upsertVsCodeInstructions(paths.vscodeSettings, paths.vscodeGlobalInstructions));
+  if (paths.vscodeInstructionsFile) {
+    safeApply("vscode-instructions-file", () =>
+      upsertPromptFile(paths.vscodeInstructionsFile, instructions, { prepend: true })
+    );
+  }
+  if (paths.vscodeSettings && paths.vscodeInstructionsDir) {
+    safeApply("vscode-settings", () =>
+      upsertVsCodeInstructions(paths.vscodeSettings, instructions, paths.vscodeInstructionsDir)
+    );
   }
   if (paths.windsurfGlobalRules) {
     safeApply("windsurf", () => upsertPromptFile(paths.windsurfGlobalRules, instructions, { prepend: true }));
@@ -862,18 +1321,25 @@ function applyAgentInstructions({ logger } = {}) {
   if (paths.claude) {
     safeApply("claude", () => upsertClaudeInstructions(paths.claude, instructions));
   }
-  if (paths.continue) {
-    safeApply("continue", () => upsertContinueInstructions(paths.continue, instructions));
+  const continueYamlExists =
+    (paths.continueYaml && fs.existsSync(paths.continueYaml)) ||
+    (paths.continueYml && fs.existsSync(paths.continueYml));
+  if (continueYamlExists) {
+    if (paths.continueYaml && fs.existsSync(paths.continueYaml)) {
+      safeApply("continue-yaml", () => upsertContinueYamlRules(paths.continueYaml, instructions));
+    }
+    if (paths.continueYml && fs.existsSync(paths.continueYml)) {
+      safeApply("continue-yml", () => upsertContinueYamlRules(paths.continueYml, instructions));
+    }
+    if (paths.continue && fs.existsSync(paths.continue)) {
+      safeApply("continue-json", () => upsertContinueJsonInstructions(paths.continue, instructions));
+    }
+  } else if (paths.continue) {
+    safeApply("continue-json", () => upsertContinueJsonInstructions(paths.continue, instructions));
   }
   if (paths.zed) {
     safeApply("zed", () => upsertZedInstructions(paths.zed, instructions));
   }
-  if (paths.aiderConfig) {
-    safeApply("aider", () => upsertYamlInstruction(paths.aiderConfig, "system-prompt", instructions));
-  }
-  if (paths.gooseConfig) {
-    safeApply("goose", () => upsertYamlInstruction(paths.gooseConfig, "instructions", instructions));
-  }
   if (paths.openInterpreterConfig) {
     safeApply("open-interpreter", () =>
       upsertYamlInstruction(paths.openInterpreterConfig, "system_message", instructions)
@@ -886,14 +1352,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 +1922,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 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 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 buildDaemonEnv({ mcpBinaryPath } = {}) {
-  return Object.fromEntries(buildDaemonEnvPairs({ mcpBinaryPath }));
+function buildDaemonEnvPairs() {
+  return [["DOCDEX_BROWSER_AUTO_INSTALL", "0"]];
 }
 
-function registerStartup({ binaryPath, mcpBinaryPath, port, repoRoot, logger }) {
+function buildDaemonEnv() {
+  return Object.fromEntries(buildDaemonEnvPairs());
+}
+
+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 +1984,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 +2022,7 @@ function registerStartup({ binaryPath, mcpBinaryPath, port, repoRoot, logger })
       "",
       "[Service]",
       `ExecStart=${binaryPath} ${args.join(" ")}`,
+      workingDir ? `WorkingDirectory=${workingDir}` : "",
       ...envLines,
       "Restart=always",
       "RestartSec=2",
@@ -1575,8 +2043,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 +2069,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 +2221,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 +2281,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 +2297,6 @@ module.exports = {
   upsertMcpServerJson,
   upsertZedConfig,
   upsertCodexConfig,
-  pickAvailablePort,
   configUrlForPort,
   configStreamableUrlForPort,
   parseEnvBool,