@remnic/core 9.3.651 → 9.3.653

package/src/access-mcp.test.ts

@@ -371,11 +371,80 @@ test("MCP capsule tools tolerate client-injected cwd/projectTag (#1434)", async
   }
 });
 
+test("MCP capsule list tolerates client-injected sessionKey (#1513)", async () => {
+  let received: Record<string, unknown> | undefined;
+  const service = {
+    ...makeMockService(),
+    capsuleList: async (args: Record<string, unknown>) => {
+      received = args;
+      return { capsules: [] };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramMcpServer(service);
+
+  const response = await server.handleRequest(
+    makeToolRequest("engram.capsule_list", {
+      namespace: "team",
+      sessionKey: "pi-injected-session",
+      cwd: "/x",
+      projectTag: "t",
+    }),
+  );
+
+  assert.deepEqual(received, {
+    namespace: "team",
+    principal: undefined,
+  });
+  assert.equal((response as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
+});
+
+test("MCP capsule list derives namespace principal from client-injected sessionKey (#1513)", async () => {
+  let received: Record<string, unknown> | undefined;
+  const service = {
+    ...makeMockService(),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-mcp-capsule-list-session-principal",
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      principalFromSessionKeyMode: "map",
+      principalFromSessionKeyRules: [{ match: "pi-session", principal: "pi-agent" }],
+      namespacePolicies: [
+        { name: "team", readPrincipals: ["pi-agent"], writePrincipals: [] },
+      ],
+    }),
+    capsuleList: async (args: Record<string, unknown>) => {
+      received = args;
+      return { capsules: [] };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramMcpServer(service);
+
+  const response = await server.handleRequest(
+    makeToolRequest("engram.capsule_list", {
+      namespace: "team",
+      sessionKey: "pi-session",
+    }),
+  );
+
+  assert.deepEqual(received, {
+    namespace: "team",
+    principal: "pi-agent",
+  });
+  assert.equal((response as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
+});
+
 test("MCP session override is injected only into tools that accept sessionKey", async () => {
   let capsuleListArgs: Record<string, unknown> | undefined;
   let observeArgs: Record<string, unknown> | undefined;
   const service = {
     ...makeMockService(),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-mcp-session-override-test",
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      principalFromSessionKeyMode: "map",
+      principalFromSessionKeyRules: [{ match: "adapter-session", principal: "adapter-agent" }],
+    }),
     capsuleList: async (args: Record<string, unknown>) => {
       capsuleListArgs = args;
       return { capsules: [] };
@@ -400,7 +469,7 @@ test("MCP session override is injected only into tools that accept sessionKey",
 
   assert.deepEqual(capsuleListArgs, {
     namespace: undefined,
-    principal: undefined,
+    principal: "adapter-agent",
   });
   assert.deepEqual(observeArgs, {
     sessionKey: "adapter-session",

package/src/access-mcp.ts

@@ -20,6 +20,7 @@ import { validateBriefingFormat } from "./briefing.js";
 import { buildCitationGuidance, type CitationMetadata } from "./citations.js";
 import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { expandTildePath } from "./utils/path.js";
+import { resolvePrincipal } from "./namespaces/principal.js";
 import {
   REMNIC_CHATGPT_MEMORY_INSPECTOR_MIME_TYPE,
   REMNIC_CHATGPT_MEMORY_INSPECTOR_TOOL,
@@ -155,7 +156,7 @@ const STRICT_MCP_SCHEMA_KEYS: Partial<Record<SchemaName, readonly string[]>> = {
     "projectTag",
   ],
   capsuleImport: ["archivePath", "namespace", "mode", "passphrase", "cwd", "projectTag"],
-  capsuleList: ["namespace", "cwd", "projectTag"],
+  capsuleList: ["namespace", "sessionKey", "cwd", "projectTag"],
 };
 
 // Shared JSON-schema fragments for the client-injected git/project context
@@ -852,6 +853,10 @@ export class EngramMcpServer {
           type: "object",
           properties: {
             namespace: { type: "string" },
+            sessionKey: {
+              type: "string",
+              description: "Optional session key used to derive namespace principal when no trusted transport principal is present.",
+            },
             ...MCP_GIT_CONTEXT_SCHEMA_PROPS_IGNORED,
           },
           additionalProperties: false,
@@ -2694,9 +2699,14 @@ export class EngramMcpServer {
       }
       case "engram.capsule_list": {
         const body: CapsuleListRequest = parseMcpRequest("capsuleList", args);
+        const requestPrincipal =
+          effectivePrincipal ??
+          (body.sessionKey && this.service.configRef
+            ? resolvePrincipal(body.sessionKey, this.service.configRef)
+            : undefined);
         return this.service.capsuleList({
           namespace: body.namespace,
-          principal: effectivePrincipal,
+          principal: requestPrincipal,
         });
       }
       case "engram.memory_governance_run":

package/src/access-schema.ts

@@ -410,6 +410,7 @@ export const capsuleImportRequestSchema = z
 export const capsuleListRequestSchema = z
   .object({
     namespace: namespaceSchema,
+    sessionKey: sessionKeySchema,
   });
 
 // ---------------------------------------------------------------------------

package/src/access-service-health.test.ts

@@ -0,0 +1,402 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { EngramAccessService } from "./access-service.js";
+import { parseConfig } from "./config.js";
+import { namespaceCollectionName } from "./namespaces/search.js";
+import type { Orchestrator } from "./orchestrator.js";
+import type { SearchBackend } from "./search/port.js";
+
+function makeQmd(overrides: Partial<SearchBackend> & Record<string, unknown>): SearchBackend {
+  return {
+    async probe() {
+      return false;
+    },
+    isAvailable() {
+      return false;
+    },
+    debugStatus() {
+      return "backend=noop";
+    },
+    async search() {
+      return [];
+    },
+    async searchGlobal() {
+      return [];
+    },
+    async bm25Search() {
+      return [];
+    },
+    async vectorSearch() {
+      return [];
+    },
+    async hybridSearch() {
+      return [];
+    },
+    async update() {},
+    async updateCollection() {},
+    async embed() {},
+    async embedCollection() {},
+    async ensureCollection() {
+      return "skipped";
+    },
+    ...overrides,
+  } as SearchBackend;
+}
+
+test("health reports active QMD version and collection state", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    const qmd = makeQmd({
+      probe: async () => true,
+      isAvailable: () => true,
+      debugStatus: () => "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+      checkCollection: async (collection, execution) => {
+        assert.equal(collection, "remnic-memory");
+        assert.ok(execution?.signal instanceof AbortSignal);
+        return "present";
+      },
+      getVersionStatus: () => ({
+        installedVersion: "qmd 2.5.3",
+        supportedVersion: "2.5.3",
+        supported: true,
+        newerThanSupported: false,
+        upgradeAvailable: false,
+        capabilities: { doctor: true },
+      }),
+      isDaemonMode: () => false,
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd,
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(health.qmdEnabled, true);
+    assert.deepEqual(health.qmd, {
+      enabled: true,
+      active: true,
+      degraded: false,
+      mode: "cli",
+      collection: "remnic-memory",
+      collectionState: "present",
+      installedVersion: "qmd 2.5.3",
+      supportedVersion: "2.5.3",
+      supported: true,
+      upgradeAvailable: false,
+      doctorAvailable: true,
+      debugStatus: "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+    });
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health marks QMD as degraded when configured search falls back to noop", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-degraded-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({}),
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(health.qmd.active, false);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.mode, "fallback");
+    assert.equal(health.qmd.collectionState, "unknown");
+    assert.equal(health.qmd.debugStatus, "backend=noop");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health marks QMD as degraded when the checked collection is missing", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-missing-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({
+        probe: async () => true,
+        isAvailable: () => true,
+        debugStatus: () => "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+        checkCollection: async () => "missing",
+        isDaemonMode: () => false,
+      }),
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(health.qmd.collectionState, "missing");
+    assert.equal(health.qmd.active, false);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.mode, "fallback");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health reports degraded diagnostics when read-only root QMD probe fails", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-stale-probe-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({
+        probe: async () => false,
+        isAvailable: () => true,
+        debugStatus: () => "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+        checkCollection: async () => "present",
+        isDaemonMode: () => false,
+      }),
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(health.qmd.active, true);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.mode, "cli");
+    assert.equal(health.qmd.collectionState, "unknown");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health uses read-only root QMD availability checks", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-readonly-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    let checkAvailabilityCalled = false;
+    let probeCalled = false;
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({
+        probe: async () => {
+          probeCalled = true;
+          return true;
+        },
+        checkAvailability: async (execution) => {
+          checkAvailabilityCalled = true;
+          assert.ok(execution?.signal instanceof AbortSignal);
+          return true;
+        },
+        isAvailable: () => true,
+        debugStatus: () => "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+        checkCollection: async () => "present",
+        isDaemonMode: () => false,
+      }),
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(checkAvailabilityCalled, true);
+    assert.equal(probeCalled, false);
+    assert.equal(health.qmd.active, true);
+    assert.equal(health.qmd.degraded, false);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health reports namespace-scoped QMD backend state", async () => {
+  const rootDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-ns-"));
+  try {
+    const teamDir = path.join(rootDir, "namespaces", "team");
+    const config = parseConfig({
+      memoryDir: rootDir,
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+      namespacePolicies: [{ name: "team", readPrincipals: [], writePrincipals: [] }],
+    });
+    const expectedCollection = namespaceCollectionName("remnic-memory", "team", {
+      defaultNamespace: "default",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({}),
+      async getStorage(namespace: string) {
+        return { dir: namespace === "team" ? teamDir : rootDir };
+      },
+      async searchHealthForNamespace(namespace: string, execution?: { signal?: AbortSignal }) {
+        assert.equal(namespace, "team");
+        assert.ok(execution?.signal instanceof AbortSignal);
+        return {
+          collection: expectedCollection,
+          available: true,
+          collectionState: "present",
+          debugStatus: "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+          installedVersion: "qmd 2.5.3",
+          supportedVersion: "2.5.3",
+          supported: true,
+          upgradeAvailable: false,
+          doctorAvailable: true,
+          daemonMode: false,
+        };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health("team");
+
+    assert.equal(health.memoryDir, teamDir);
+    assert.equal(health.qmd.active, true);
+    assert.equal(health.qmd.degraded, false);
+    assert.equal(health.qmd.collection, expectedCollection);
+    assert.equal(health.qmd.collectionState, "present");
+    assert.equal(health.qmd.installedVersion, "qmd 2.5.3");
+  } finally {
+    await rm(rootDir, { recursive: true, force: true });
+  }
+});
+
+test("health marks namespace QMD unknown collection state degraded", async () => {
+  const rootDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-ns-unknown-"));
+  try {
+    const teamDir = path.join(rootDir, "namespaces", "team");
+    const config = parseConfig({
+      memoryDir: rootDir,
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+      namespacePolicies: [{ name: "team", readPrincipals: [], writePrincipals: [] }],
+    });
+    const expectedCollection = namespaceCollectionName("remnic-memory", "team", {
+      defaultNamespace: "default",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({}),
+      async getStorage(namespace: string) {
+        return { dir: namespace === "team" ? teamDir : rootDir };
+      },
+      async searchHealthForNamespace(namespace: string, execution?: { signal?: AbortSignal }) {
+        assert.equal(namespace, "team");
+        assert.ok(execution?.signal instanceof AbortSignal);
+        return {
+          collection: expectedCollection,
+          available: true,
+          collectionState: "unknown",
+          debugStatus: "cli=true collection=unknown",
+          installedVersion: "qmd 2.5.3",
+          supportedVersion: "2.5.3",
+          supported: true,
+          upgradeAvailable: false,
+          doctorAvailable: true,
+          daemonMode: false,
+        };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health("team");
+
+    assert.equal(health.memoryDir, teamDir);
+    assert.equal(health.qmd.active, true);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.collection, expectedCollection);
+    assert.equal(health.qmd.collectionState, "unknown");
+    assert.equal(health.qmd.mode, "cli");
+  } finally {
+    await rm(rootDir, { recursive: true, force: true });
+  }
+});
+
+test("health keeps namespace QMD failures scoped to the namespace", async () => {
+  const rootDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-ns-fail-"));
+  try {
+    const teamDir = path.join(rootDir, "namespaces", "team");
+    const config = parseConfig({
+      memoryDir: rootDir,
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+      namespacePolicies: [{ name: "team", readPrincipals: [], writePrincipals: [] }],
+    });
+    const expectedCollection = namespaceCollectionName("remnic-memory", "team", {
+      defaultNamespace: "default",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({
+        probe: async () => true,
+        isAvailable: () => true,
+        debugStatus: () => "root-qmd-should-not-leak",
+        checkCollection: async () => "present",
+      }),
+      async getStorage(namespace: string) {
+        return { dir: namespace === "team" ? teamDir : rootDir };
+      },
+      async searchHealthForNamespace() {
+        throw new Error(`namespace probe timed out at ${teamDir}/qmd/index.sqlite`);
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health("team");
+
+    assert.equal(health.memoryDir, teamDir);
+    assert.equal(health.qmd.collection, expectedCollection);
+    assert.equal(health.qmd.active, false);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.collectionState, "unknown");
+    assert.equal(health.qmd.mode, "fallback");
+    assert.equal(health.qmd.debugStatus, "backend=namespace-unavailable error=Error");
+    assert.doesNotMatch(health.qmd.debugStatus, /root-qmd-should-not-leak/);
+    assert.doesNotMatch(health.qmd.debugStatus, /index\.sqlite/);
+    assert.doesNotMatch(health.qmd.debugStatus, /remnic-health-qmd-ns-fail/);
+  } finally {
+    await rm(rootDir, { recursive: true, force: true });
+  }
+});