@remnic/core 1.1.30 → 9.3.515

package/src/access-http.test.ts

@@ -3,11 +3,13 @@ import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
+import { gzipSync } from "node:zlib";
 
 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";
 
@@ -29,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 = {
@@ -287,6 +438,176 @@ test("HTTP offline snapshot forwards namespace and transfer options", async () =
   }
 });
 
+test("HTTP offline snapshot accepts gzipped fast-base bodies", async () => {
+  const calls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+    includeTranscripts: boolean | undefined;
+    includeContent: boolean | undefined;
+    baseFiles: unknown;
+    baseCapturedAt: Date | undefined;
+  }> = [];
+  const service = {
+    offlineSyncSnapshot: async (options: {
+      namespace?: string;
+      principal?: string;
+      includeTranscripts?: boolean;
+      includeContent?: boolean;
+      baseFiles?: unknown;
+      baseCapturedAt?: Date;
+    }) => {
+      calls.push({
+        namespace: options.namespace,
+        principal: options.principal,
+        includeTranscripts: options.includeTranscripts,
+        includeContent: options.includeContent,
+        baseFiles: options.baseFiles,
+        baseCapturedAt: options.baseCapturedAt,
+      });
+      return {
+        namespace: options.namespace ?? "default",
+        format: "remnic.offline-sync.snapshot.v1",
+        schemaVersion: 1,
+        createdAt: new Date("2026-05-21T00:00:00Z").toISOString(),
+        sourceId: "remote:test",
+        includeTranscripts: options.includeTranscripts !== false,
+        files: [],
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    principal: "reader",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const body = gzipSync(JSON.stringify({
+      namespace: "team",
+      includeTranscripts: false,
+      includeContent: false,
+      baseCapturedAt: "2026-05-20T00:00:00.000Z",
+      baseFiles: [{
+        path: "facts/a.md",
+        sha256: "a".repeat(64),
+        bytes: 12,
+        mtimeMs: 1234,
+      }],
+    }));
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/snapshot`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+          "content-encoding": "gzip",
+        },
+        body,
+      },
+    );
+    const responseBody = await response.json() as { namespace?: string };
+
+    assert.equal(response.status, 200);
+    assert.equal(responseBody.namespace, "team");
+    assert.equal(calls.length, 1);
+    const call = calls[0];
+    assert.ok(call);
+    assert.deepEqual(call, {
+      namespace: "team",
+      principal: "reader",
+      includeTranscripts: false,
+      includeContent: false,
+      baseFiles: [{
+        path: "facts/a.md",
+        sha256: "a".repeat(64),
+        bytes: 12,
+        mtimeMs: 1234,
+      }],
+      baseCapturedAt: new Date("2026-05-20T00:00:00.000Z"),
+    });
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP offline snapshot stream emits metadata records as NDJSON", async () => {
+  const calls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+    includeTranscripts: boolean | undefined;
+    includeContent: boolean | undefined;
+  }> = [];
+  const service = {
+    offlineSyncSnapshotStream: async (options: {
+      namespace?: string;
+      principal?: string;
+      includeTranscripts?: boolean;
+      includeContent?: boolean;
+    }) => {
+      calls.push({
+        namespace: options.namespace,
+        principal: options.principal,
+        includeTranscripts: options.includeTranscripts,
+        includeContent: options.includeContent,
+      });
+      return {
+        namespace: options.namespace ?? "default",
+        format: "remnic.offline-sync.snapshot.v1",
+        schemaVersion: 1,
+        createdAt: new Date("2026-05-21T00:00:00Z").toISOString(),
+        sourceId: "remote:test",
+        includeTranscripts: options.includeTranscripts !== false,
+        files: (async function* () {
+          yield {
+            path: "facts/a.md",
+            sha256: "a".repeat(64),
+            bytes: 12,
+            mtimeMs: 1234,
+          };
+        })(),
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    principal: "reader",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/snapshot-stream?namespace=team&include_transcripts=false&content=false`,
+      { headers: { authorization: "Bearer test-token" } },
+    );
+    const lines = (await response.text())
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line) as Record<string, unknown>);
+
+    assert.equal(response.status, 200);
+    assert.equal(response.headers.get("content-type"), "application/x-ndjson; charset=utf-8");
+    assert.equal(lines[0]?.type, "snapshot");
+    assert.equal(lines[0]?.namespace, "team");
+    assert.equal(lines[1]?.type, "file");
+    assert.deepEqual((lines[1]?.file as { path?: string }).path, "facts/a.md");
+    assert.deepEqual(calls, [{
+      namespace: "team",
+      principal: "reader",
+      includeTranscripts: false,
+      includeContent: false,
+    }]);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP offline files forwards namespace and requested paths", async () => {
   const calls: Array<{
     namespace: string | undefined;