@remnic/core 1.1.31 → 9.3.515

package/src/access-cli.ts

@@ -5,9 +5,11 @@ import type { PluginConfig } from "./types.js";
 import { Orchestrator } from "./orchestrator.js";
 import { EngramAccessService } from "./access-service.js";
 import { readEnvVar, resolveHomeDir } from "./runtime/env.js";
-import { resolveRemnicPluginEntry } from "./plugin-id.js";
+import { resolvePluginEntry } from "./plugin-entry-resolver.js";
 import { expandTildePath } from "./utils/path.js";
 
+const OPENCLAW_REMNIC_PLUGIN_IDS = ["openclaw-remnic", "openclaw-engram"] as const;
+
 type CommandName = "browse" | "store";
 
 type ParsedArgs = {
@@ -29,7 +31,7 @@ type Runtime = {
 export type AccessCliOptions = {
   /**
    * The calling plugin's own id (e.g. `"openclaw-engram"` when invoked by the
-   * shim binary).  Forwarded to {@link resolveRemnicPluginEntry} so shim CLI
+   * shim binary).  Forwarded to the plugin-entry resolver so shim CLI
    * users target their own `plugins.entries["openclaw-engram"]` block instead
    * of accidentally resolving to the canonical `"openclaw-remnic"` entry when
    * `plugins.slots.memory` is unset (#403).
@@ -37,6 +39,44 @@ export type AccessCliOptions = {
   preferredId?: string;
 };
 
+function getOpenClawPluginEntries(raw: Record<string, unknown>): Record<string, unknown> | undefined {
+  const plugins =
+    raw["plugins"] && typeof raw["plugins"] === "object" && !Array.isArray(raw["plugins"])
+      ? (raw["plugins"] as Record<string, unknown>)
+      : undefined;
+  const entries =
+    plugins && plugins["entries"] && typeof plugins["entries"] === "object" && !Array.isArray(plugins["entries"])
+      ? (plugins["entries"] as Record<string, unknown>)
+      : undefined;
+  return entries;
+}
+
+function getOpenClawMemorySlotId(raw: Record<string, unknown>): string | undefined {
+  const plugins =
+    raw["plugins"] && typeof raw["plugins"] === "object" && !Array.isArray(raw["plugins"])
+      ? (raw["plugins"] as Record<string, unknown>)
+      : undefined;
+  const slots =
+    plugins && plugins["slots"] && typeof plugins["slots"] === "object" && !Array.isArray(plugins["slots"])
+      ? (plugins["slots"] as Record<string, unknown>)
+      : undefined;
+  const slotId = slots?.["memory"];
+  return typeof slotId === "string" ? slotId : undefined;
+}
+
+function resolveOpenClawRemnicPluginEntry(raw: unknown, preferredId?: string): Record<string, unknown> | undefined {
+  return resolvePluginEntry(raw, {
+    candidateIds: OPENCLAW_REMNIC_PLUGIN_IDS,
+    preferredId,
+    getEntries: getOpenClawPluginEntries,
+    getSlotId: getOpenClawMemorySlotId,
+  });
+}
+
+function hasAllowedOpenClawRemnicPluginId(value: string): boolean {
+  return (OPENCLAW_REMNIC_PLUGIN_IDS as readonly string[]).includes(value);
+}
+
 type UsageErrorKind =
   | "unsupported-command"
   | "unexpected-positional"
@@ -307,12 +347,26 @@ function loadPluginConfig(preferredId?: string): Record<string, unknown> {
     expandOptionalPath(readEnvVar("OPENCLAW_ENGRAM_CONFIG_PATH")) ||
     path.join(resolveHomeDir(), ".openclaw", "openclaw.json");
   const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
-  // Delegate slot → preferredId → PLUGIN_ID → LEGACY_PLUGIN_ID resolution to
-  // the shared helper so all config loaders stay in sync (#403).  Shim CLI
+  const slotId =
+    raw && typeof raw === "object" && !Array.isArray(raw)
+      ? getOpenClawMemorySlotId(raw as Record<string, unknown>)
+      : undefined;
+  if (typeof slotId === "string" && !hasAllowedOpenClawRemnicPluginId(slotId)) {
+    throw new Error(
+      `OpenClaw memory slot points to non-Remnic plugin "${slotId}"; refusing to use default Remnic access config.`,
+    );
+  }
+  // Delegate slot → preferredId → canonical → legacy resolution to the
+  // generic helper so all config loaders stay in sync (#403).  Shim CLI
   // callers pass `preferredId: "openclaw-engram"` so legacy shim installs
   // target their own config block instead of falling through to the canonical
   // "openclaw-remnic" entry.
-  const entry = resolveRemnicPluginEntry(raw, preferredId);
+  const entry = resolveOpenClawRemnicPluginEntry(raw, preferredId);
+  if (!entry) {
+    throw new Error(
+      "OpenClaw config does not contain an allowed Remnic plugin entry; refusing to use default Remnic access config.",
+    );
+  }
   return (entry?.["config"] as Record<string, unknown> | undefined) ?? {};
 }
 

package/src/access-http.test.ts

@@ -9,6 +9,7 @@ import { EngramAccessHttpServer } from "./access-http.js";
 import { EngramAccessInputError, type EngramAccessService } from "./access-service.js";
 import { parseConfig } from "./config.js";
 import { readPair, writePair } from "./contradiction/contradiction-review.js";
+import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { OFFLINE_SYNC_MAX_MTIME_MS } from "./offline-sync.js";
 import type { StorageManager } from "./storage.js";
 
@@ -30,6 +31,155 @@ test("HTTP server rejects invalid constructor ports", () => {
   }
 });
 
+test("parseConfig validates agentAccessHttp.port bounds and CLI strings", () => {
+  for (const [input, expected] of [
+    [0, 0],
+    [4318, 4318],
+    [65535, 65535],
+    ["5555", 5555],
+  ] as const) {
+    const parsed = parseConfig({ agentAccessHttp: { port: input } });
+    assert.equal(parsed.agentAccessHttp.port, expected);
+  }
+
+  for (const port of [
+    -1,
+    3.7,
+    65536,
+    Number.NaN,
+    Number.POSITIVE_INFINITY,
+    "not-a-port",
+  ]) {
+    assert.throws(
+      () => parseConfig({ agentAccessHttp: { port } }),
+      /agentAccessHttp\.port must be an integer from 0 to 65535/,
+      `port ${String(port)} should be rejected`,
+    );
+  }
+});
+
+test("HTTP memory browse rejects malformed pagination and sort query values", async () => {
+  const calls: unknown[] = [];
+  const service = {
+    memoryBrowse: async (request: unknown) => {
+      calls.push(request);
+      return { total: 0, memories: [] };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    for (const query of ["limit=10abc", "offset=1.5", "limit=0", "sort=udpated_desc"]) {
+      const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/memories?${query}`, {
+        headers: { authorization: "Bearer test-token" },
+      });
+      assert.equal(response.status, 400, `${query} should be rejected`);
+    }
+    assert.equal(calls.length, 0, "invalid queries must fail before calling memoryBrowse");
+
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/memories?limit=10&offset=1&sort=updated_desc`,
+      { headers: { authorization: "Bearer test-token" } },
+    );
+    assert.equal(response.status, 200);
+    assert.deepEqual(calls, [
+      {
+        query: undefined,
+        status: undefined,
+        category: undefined,
+        namespace: undefined,
+        authenticatedPrincipal: undefined,
+        sort: "updated_desc",
+        limit: 10,
+        offset: 1,
+      },
+    ]);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP admin console assets are public but API routes require bearer authentication", async () => {
+  const service = {} as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+  });
+
+  const status = await server.start();
+  try {
+    const shell = await fetch(`http://127.0.0.1:${status.port}/remnic/ui/`);
+    assert.equal(shell.status, 200);
+    assert.match(await shell.text(), /Remnic Admin Console/);
+
+    const app = await fetch(`http://127.0.0.1:${status.port}/remnic/ui/app.js`);
+    assert.equal(app.status, 200);
+    assert.match(app.headers.get("content-type") ?? "", /javascript/);
+
+    const api = await fetch(`http://127.0.0.1:${status.port}/engram/v1/health`);
+    const body = await api.json() as { code?: string };
+    assert.equal(api.status, 401);
+    assert.equal(body.code, "unauthorized");
+    assert.equal(api.headers.get("www-authenticate"), "Bearer");
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP coding-context endpoint accepts projectTag shorthand", async () => {
+  const calls: unknown[] = [];
+  const service = {
+    setCodingContext: (request: unknown) => {
+      calls.push(request);
+    },
+  } as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/coding-context`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "s1",
+        projectTag: "Blend/Supply",
+      }),
+    });
+
+    const projectId = projectTagProjectId("Blend/Supply");
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), { ok: true });
+    assert.deepEqual(calls, [
+      {
+        sessionKey: "s1",
+        codingContext: {
+          projectId,
+          branch: null,
+          rootPath: projectId,
+          defaultBranch: null,
+        },
+      },
+    ]);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP contradiction scan uses writable namespace resolver", async () => {
   const resolverCalls: Array<{ namespace: string | undefined; principal: string | undefined }> = [];
   const storage = {

package/src/access-http.ts

@@ -25,6 +25,7 @@ import {
   type GraphEvent,
 } from "./graph-events.js";
 import { expandTildePath } from "./utils/path.js";
+import { projectTagProjectId } from "./coding/coding-namespace.js";
 
 export interface EngramAccessHttpServerOptions {
   service: EngramAccessService;
@@ -137,6 +138,36 @@ function summarizeHttpRequest(req: IncomingMessage): string {
   }
 }
 
+function parseStrictIntegerQuery(
+  raw: string | null,
+  field: string,
+  defaultValue: number,
+  minValue: number,
+): number {
+  if (raw === null) return defaultValue;
+  if (!/^(?:0|[1-9]\d*)$/.test(raw)) {
+    throw new HttpError(400, `${field} must be an integer`, `invalid_${field}`);
+  }
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < minValue) {
+    throw new HttpError(400, `${field} must be an integer >= ${minValue}`, `invalid_${field}`);
+  }
+  return value;
+}
+
+function parseMemorySort(raw: string | null): "updated_desc" | "updated_asc" | "created_desc" | "created_asc" | undefined {
+  if (raw === null) return undefined;
+  if (
+    raw === "updated_desc" ||
+    raw === "updated_asc" ||
+    raw === "created_desc" ||
+    raw === "created_asc"
+  ) {
+    return raw;
+  }
+  throw new HttpError(400, "sort must be one of updated_desc|updated_asc|created_desc|created_asc", "invalid_sort");
+}
+
 /**
  * Decode a `:peerId` URL path segment, converting malformed percent-encoded
  * input (e.g., `%E0%A4%A`) into a 400 client error rather than letting
@@ -150,6 +181,21 @@ function decodePeerIdSegment(raw: string): string {
   }
 }
 
+function codingContextFromProjectTag(projectTag: string): {
+  projectId: string;
+  branch: string | null;
+  rootPath: string;
+  defaultBranch: string | null;
+} {
+  const projectId = projectTagProjectId(projectTag);
+  return {
+    projectId,
+    branch: null,
+    rootPath: projectId,
+    defaultBranch: null,
+  };
+}
+
 export class EngramAccessHttpServer {
   private readonly service: EngramAccessService;
   private readonly host: string;
@@ -322,14 +368,15 @@ export class EngramAccessHttpServer {
   }
 
   /** Cache for per-request identity resolution (avoids double adapter resolution) */
-  private identityCache = new WeakMap<IncomingMessage, { principal?: string; namespace?: string }>();
+  private identityCache = new WeakMap<IncomingMessage, { principal?: string; namespace?: string; sessionKey?: string }>();
 
-  /** Resolve principal and namespace from request headers and adapter identity */
-  private resolveRequestIdentity(req: IncomingMessage): { principal?: string; namespace?: string } {
+  /** Resolve principal, namespace, and session key from request headers and adapter identity */
+  private resolveRequestIdentity(req: IncomingMessage): { principal?: string; namespace?: string; sessionKey?: string } {
     const cached = this.identityCache.get(req);
     if (cached) return cached;
     let principal: string | undefined;
     let namespace: string | undefined;
+    let sessionKey: string | undefined;
 
     // Explicit header override takes priority for principal
     if (this.trustPrincipalHeader) {
@@ -343,20 +390,22 @@ export class EngramAccessHttpServer {
       }
     }
 
-    // Try adapter-based identity resolution for both principal and namespace
+    if (!principal) {
+      principal = this.authenticatedPrincipal;
+    }
+
+    // Try adapter-based identity resolution for namespace and, only when no
+    // server principal is configured, an adapter-owned default principal.
     const adapterIdentity = this.resolveAdapterIdentity(req);
     if (adapterIdentity) {
       if (!principal) {
         principal = adapterIdentity.principal;
       }
       namespace = adapterIdentity.namespace;
+      sessionKey = adapterIdentity.sessionKey;
     }
 
-    if (!principal) {
-      principal = this.authenticatedPrincipal;
-    }
-
-    const result = { principal, namespace };
+    const result = { principal, namespace, sessionKey };
     this.identityCache.set(req, result);
     return result;
   }
@@ -562,9 +611,17 @@ export class EngramAccessHttpServer {
     // doctor` (PR 8) surfaces the attached context.
     if (req.method === "POST" && pathname === "/engram/v1/coding-context") {
       const body = await this.readValidatedBody(req, "setCodingContext");
+      const codingContext =
+        body.codingContext !== undefined
+          ? body.codingContext
+          : typeof body.projectTag === "string"
+            ? codingContextFromProjectTag(body.projectTag)
+            : (() => {
+                throw new EngramAccessInputError("codingContext or projectTag is required");
+              })();
       this.service.setCodingContext({
         sessionKey: body.sessionKey,
-        codingContext: body.codingContext,
+        codingContext,
       });
       this.respondJson(res, 200, { ok: true });
       return;
@@ -602,6 +659,7 @@ export class EngramAccessHttpServer {
         namespace: this.resolveNamespace(req, body.namespace),
         principal: this.resolveRequestPrincipal(req),
         mode: body.mode,
+        passphrase: body.passphrase,
       });
       this.recordWriteRateLimitHit();
       this.respondJson(res, 200, result);
@@ -966,6 +1024,7 @@ export class EngramAccessHttpServer {
       const response = await this.service.lcmSearch({
         query: body.query,
         sessionKey: body.sessionKey,
+        sessionPrefix: body.sessionPrefix,
         namespace: this.resolveNamespace(req, body.namespace),
         authenticatedPrincipal: this.resolveRequestPrincipal(req),
         limit: body.limit,
@@ -1072,15 +1131,9 @@ export class EngramAccessHttpServer {
     }
 
     if (req.method === "GET" && pathname === "/engram/v1/memories") {
-      const limitRaw = parseInt(parsed.searchParams.get("limit") ?? "50", 10);
-      const offsetRaw = parseInt(parsed.searchParams.get("offset") ?? "0", 10);
-      const sortParam = parsed.searchParams.get("sort") ?? undefined;
-      const sort = sortParam === "updated_desc"
-        || sortParam === "updated_asc"
-        || sortParam === "created_desc"
-        || sortParam === "created_asc"
-        ? sortParam
-        : undefined;
+      const limit = parseStrictIntegerQuery(parsed.searchParams.get("limit"), "limit", 50, 1);
+      const offset = parseStrictIntegerQuery(parsed.searchParams.get("offset"), "offset", 0, 0);
+      const sort = parseMemorySort(parsed.searchParams.get("sort"));
       const response = await this.service.memoryBrowse({
         query: parsed.searchParams.get("q") ?? undefined,
         status: parsed.searchParams.get("status") ?? undefined,
@@ -1088,8 +1141,8 @@ export class EngramAccessHttpServer {
         namespace: parsed.searchParams.get("namespace") ?? undefined,
         authenticatedPrincipal: this.resolveRequestPrincipal(req),
         sort,
-        limit: Number.isFinite(limitRaw) ? limitRaw : 50,
-        offset: Number.isFinite(offsetRaw) ? offsetRaw : 0,
+        limit,
+        offset,
       });
       this.respondJson(res, 200, response);
       return;
@@ -1108,21 +1161,20 @@ export class EngramAccessHttpServer {
     if (req.method === "GET" && timelineMatch) {
       const memoryId = decodeURIComponent(timelineMatch[1] ?? "");
       const namespace = parsed.searchParams.get("namespace") ?? undefined;
-      const limitRaw = parseInt(parsed.searchParams.get("limit") ?? "200", 10);
-      const limit = Number.isFinite(limitRaw) ? limitRaw : 200;
+      const limit = parseStrictIntegerQuery(parsed.searchParams.get("limit"), "limit", 200, 1);
       const response = await this.service.memoryTimeline(memoryId, namespace, limit, this.resolveRequestPrincipal(req));
       this.respondJson(res, response.found ? 200 : 404, response);
       return;
     }
 
     if (req.method === "GET" && pathname === "/engram/v1/entities") {
-      const limitRaw = parseInt(parsed.searchParams.get("limit") ?? "50", 10);
-      const offsetRaw = parseInt(parsed.searchParams.get("offset") ?? "0", 10);
+      const limit = parseStrictIntegerQuery(parsed.searchParams.get("limit"), "limit", 50, 1);
+      const offset = parseStrictIntegerQuery(parsed.searchParams.get("offset"), "offset", 0, 0);
       const response = await this.service.entityList({
         namespace: parsed.searchParams.get("namespace") ?? undefined,
         query: parsed.searchParams.get("q") ?? undefined,
-        limit: Number.isFinite(limitRaw) ? limitRaw : 50,
-        offset: Number.isFinite(offsetRaw) ? offsetRaw : 0,
+        limit,
+        offset,
       });
       this.respondJson(res, 200, response);
       return;
@@ -1190,16 +1242,16 @@ export class EngramAccessHttpServer {
     }
 
     if (req.method === "GET" && pathname === "/engram/v1/trust-zones/records") {
-      const limitRaw = parseInt(parsed.searchParams.get("limit") ?? "25", 10);
-      const offsetRaw = parseInt(parsed.searchParams.get("offset") ?? "0", 10);
+      const limit = parseStrictIntegerQuery(parsed.searchParams.get("limit"), "limit", 25, 1);
+      const offset = parseStrictIntegerQuery(parsed.searchParams.get("offset"), "offset", 0, 0);
       const response = await this.service.trustZoneBrowse({
         query: parsed.searchParams.get("q") ?? undefined,
         zone: parseTrustZoneFilter(parsed.searchParams.get("zone")),
         kind: parseTrustZoneKindFilter(parsed.searchParams.get("kind")),
         sourceClass: parseTrustZoneSourceClassFilter(parsed.searchParams.get("sourceClass")),
         namespace: parsed.searchParams.get("namespace") ?? undefined,
-        limit: Number.isFinite(limitRaw) ? limitRaw : 25,
-        offset: Number.isFinite(offsetRaw) ? offsetRaw : 0,
+        limit,
+        offset,
       }, this.resolveRequestPrincipal(req));
       this.respondJson(res, 200, response);
       return;
@@ -1345,7 +1397,7 @@ export class EngramAccessHttpServer {
         return;
       }
       const namespace = parsed.searchParams.get("namespace") ?? undefined;
-      const limitRaw = parseInt(parsed.searchParams.get("limit") ?? "50", 10);
+      const limit = parseStrictIntegerQuery(parsed.searchParams.get("limit"), "limit", 50, 1);
       const {
         isDefaultReviewNamespace,
         listPairs,
@@ -1360,7 +1412,7 @@ export class EngramAccessHttpServer {
         filter: rawFilter as "all" | "unresolved" | "contradicts" | "independent" | "duplicates" | "needs-user",
         namespace: reviewNamespace,
         includeUnscopedForNamespace,
-        limit: Number.isFinite(limitRaw) ? limitRaw : 50,
+        limit,
       });
       this.respondJson(res, 200, result);
       return;
@@ -1902,8 +1954,11 @@ export class EngramAccessHttpServer {
       return typeof raw === "string" ? raw.trim() : undefined;
     })();
     const mcpCorrelationId = correlationIdStore.getStore() ?? randomUUID();
+    const requestIdentity = this.resolveRequestIdentity(req);
     const response = await this.mcpServer.handleRequest(request, {
-      principalOverride: this.resolveRequestPrincipal(req),
+      principalOverride: requestIdentity.principal,
+      namespaceOverride: requestIdentity.namespace,
+      sessionKeyOverride: requestIdentity.sessionKey,
       sessionId,
       correlationId: mcpCorrelationId,
     });