docdex 0.2.81 → 0.2.85

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 0.2.85
+- Add a packaged disabled-by-default encrypted user-memory sync preview with config/status/dry-run support, bundle generation, and server-store register, push, feed, apply, and ack endpoints.
+- Scope packaged hosted user-memory sync requests through external API-key introspection, including user-memory sync scope checks and a canonical hashed principal so multiple API keys for one user merge into one feed.
+- Add packaged AES-256-GCM payload envelopes, local decrypt/AAD/hash verification, profile-memory down-sync apply with embedding rebuild and last-write-wins import, and applied/skipped ledger tracking.
+- Document packaged production plan, progress, and threat model boundaries; non-profile lanes currently sync as encrypted inventory/policy events until safe importers are implemented.
+- Harden packaged release validation by widening daemon health waits under full-suite load and serializing MCP local-completion daemon tests that contend for local SQLite state.
+- Upgrade the packaged tar extraction dependency to `tar` 7.5.19 so production npm audit is clean before publish.
+- Bump packaged release metadata to 0.2.85.
+
+## 0.2.84
+- Distinguish packaged daemon startup-in-progress locks from healthy already-running daemons so `docdexd daemon` tells clients to wait for `/healthz` and `/v1/mcp` readiness instead of advertising an unavailable MCP endpoint.
+- Harden packaged npm postinstall daemon readiness checks by requiring both `/healthz` and the streamable MCP `/v1/mcp` route before treating a started or reused daemon as ready.
+- Make packaged daemon singleton and mcoda registry tests deterministic by using a bounded full health response read, disabling cloud refresh for registry-only assertions, and allowing slower daemon binds in local/CI environments with `DOCDEX_DAEMON_AUTO_START_TIMEOUT_SECS`.
+- Pin packaged GitHub Actions npm upgrades to npm 11.18.0 so trusted publishing remains compatible with the workflow's Node 20 runtime.
+- Bump packaged release metadata to 0.2.84.
+
 ## 0.2.81
 - Harden packaged repo memory storage by enabling SQLite WAL mode and a 5-second busy timeout so concurrent Docdex agents can tolerate transient `database is locked` contention during memory saves.
 - Add packaged regression coverage for repo memory connection settings.

package/assets/agents.md

@@ -1,4 +1,4 @@
----- START OF DOCDEX INFO V0.2.81 ----
+---- START OF DOCDEX INFO V0.2.85 ----
 Docdex URL: http://127.0.0.1:28491
 Use this base URL for Docdex HTTP endpoints.
 Health check endpoint: `GET /healthz` (not `/v1/health`).

package/lib/postinstall_setup.js

@@ -25,6 +25,7 @@ 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 DAEMON_MCP_READY_PATH = "/v1/mcp";
 const DAEMON_INFO_PATH = "/ai-help";
 const DAEMON_PORT_RELEASE_TIMEOUT_MS = 5000;
 const STARTUP_FAILURE_MARKER = "startup_registration_failed.json";
@@ -128,6 +129,52 @@ function checkDaemonHealth({ host, port, timeoutMs = DAEMON_HEALTH_REQUEST_TIMEO
   });
 }
 
+function checkDaemonMcpReady({ host, port, timeoutMs = DAEMON_HEALTH_REQUEST_TIMEOUT_MS }) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    const payload = JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "ping",
+      params: {}
+    });
+    const req = http.request(
+      {
+        host,
+        port,
+        path: DAEMON_MCP_READY_PATH,
+        method: "POST",
+        timeout: timeoutMs,
+        headers: {
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(payload)
+        }
+      },
+      (res) => {
+        let body = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          if (body.length < 4096) body += chunk;
+        });
+        res.on("end", () => {
+          finish(res.statusCode === 200 && body.includes("\"jsonrpc\""));
+        });
+      }
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      finish(false);
+    });
+    req.on("error", () => finish(false));
+    req.end(payload);
+  });
+}
+
 async function waitForDaemonHealthy({ host, port, timeoutMs = DAEMON_HEALTH_TIMEOUT_MS }) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -139,6 +186,33 @@ async function waitForDaemonHealthy({ host, port, timeoutMs = DAEMON_HEALTH_TIME
   return false;
 }
 
+async function waitForDaemonReady({
+  host,
+  port,
+  timeoutMs = DAEMON_HEALTH_TIMEOUT_MS,
+  deps
+}) {
+  const helpers = {
+    checkDaemonHealth,
+    checkDaemonMcpReady,
+    sleep
+  };
+  if (deps && typeof deps === "object") {
+    Object.assign(helpers, deps);
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (
+      await helpers.checkDaemonHealth({ host, port }) &&
+      await helpers.checkDaemonMcpReady({ host, port })
+    ) {
+      return true;
+    }
+    await helpers.sleep(DAEMON_HEALTH_POLL_INTERVAL_MS);
+  }
+  return false;
+}
+
 async function waitForPortAvailable({
   host,
   port,
@@ -265,11 +339,16 @@ async function resolveDaemonPortState({ host, port, logger, deps } = {}) {
   const lockRunning = lockMeta ? helpers.isPidRunning(lockMeta.pid) : false;
   const healthy = await helpers.checkDaemonHealth({ host, port });
   const identity = lockRunning ? true : await helpers.checkDocdexIdentity({ host, port });
+  const starting = Boolean(lockRunning && !healthy);
   const reuseExisting = Boolean(lockRunning || healthy || identity);
   if (reuseExisting) {
-    log.warn?.(`[docdex] ${host}:${port} already in use by a running docdex daemon; reusing it.`);
+    if (starting) {
+      log.warn?.(`[docdex] ${host}:${port} has a running docdex daemon process that is still starting; waiting for readiness.`);
+    } else {
+      log.warn?.(`[docdex] ${host}:${port} already in use by a running docdex daemon; reusing it.`);
+    }
   }
-  return { available: false, reuseExisting, stopped: false };
+  return { available: false, reuseExisting, starting, stopped: false };
 }
 
 function parseServerBind(contents) {
@@ -2690,11 +2769,12 @@ async function startDaemonWithHealthCheck({
   logger,
   distBaseDir,
   startNow = true,
+  waitForReady = startNow,
   deps
 }) {
   const helpers = {
     registerStartup,
-    waitForDaemonHealthy,
+    waitForDaemonReady,
     stopDaemonService,
     stopDaemonFromLock,
     stopDaemonByName,
@@ -2716,21 +2796,29 @@ async function startDaemonWithHealthCheck({
     return { ok: false, reason: "startup_failed" };
   }
   if (!startNow) {
+    if (waitForReady) {
+      const ready = await helpers.waitForDaemonReady({ host, port });
+      if (ready) {
+        return { ok: true, reason: "ready" };
+      }
+      logger?.warn?.(`[docdex] daemon failed readiness check on ${host}:${port}`);
+      return { ok: false, reason: "readiness_failed" };
+    }
     return { ok: true, reason: "registered" };
   }
   // `registerStartup(..., startNow: true)` already starts the service on all
   // supported platforms. Starting it again here can interrupt the first boot
   // and leave the daemon stuck behind its own lock file.
-  const healthy = await helpers.waitForDaemonHealthy({ host, port });
-  if (healthy) {
-    return { ok: true, reason: "healthy" };
+  const ready = await helpers.waitForDaemonReady({ host, port });
+  if (ready) {
+    return { ok: true, reason: "ready" };
   }
-  logger?.warn?.(`[docdex] daemon failed health check on ${host}:${port}`);
+  logger?.warn?.(`[docdex] daemon failed readiness check on ${host}:${port}`);
   helpers.stopDaemonService({ logger });
   helpers.stopDaemonFromLock({ logger });
   helpers.stopDaemonByName({ logger });
   helpers.clearDaemonLocks();
-  return { ok: false, reason: "health_failed" };
+  return { ok: false, reason: "readiness_failed" };
 }
 
 function recordStartupFailure(details) {
@@ -2997,7 +3085,8 @@ async function runPostInstallSetup({ binaryPath, logger, env, skipDaemon, distBa
       host: DEFAULT_HOST,
       logger: log,
       distBaseDir: resolvedDistBaseDir,
-      startNow: !reuseExisting && allowStartNow
+      startNow: !reuseExisting && allowStartNow,
+      waitForReady: reuseExisting || (!reuseExisting && allowStartNow)
     });
     if (!result.ok) {
       log.warn?.(`[docdex] daemon failed to start on ${DEFAULT_HOST}:${port}.`);
@@ -3096,6 +3185,8 @@ module.exports = {
   buildDaemonEnv,
   buildLaunchAgentPlist,
   startDaemonWithHealthCheck,
+  checkDaemonMcpReady,
+  waitForDaemonReady,
   resolveDaemonPortState,
   normalizeVersion
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docdex",
-  "version": "0.2.81",
+  "version": "0.2.85",
   "mcpName": "io.github.bekirdag/docdex",
   "description": "Local-first documentation and code indexer with HTTP/MCP search, AST, and agent memory.",
   "bin": {
@@ -62,6 +62,6 @@
     "access": "public"
   },
   "dependencies": {
-    "tar": "^6.2.1"
+    "tar": "^7.5.19"
   }
 }