@boxxy/server 0.1.3 → 0.1.5

package/dist/test-utils/create-test-server.d.ts

@@ -1,6 +1,8 @@
+import type { WatchReport } from '@boxxy/dispatch';
 import type { FakeForge } from '@boxxy/dispatch/test-utils/create-fake-forge';
 import type { TestDispatch } from '@boxxy/dispatch/test-utils/create-test-dispatch';
-import type { AttemptRow, CallerProof, Clock, PhaseName } from '@boxxy/model';
+import type { ClosableClaimStore } from '@boxxy/dispatch/test-utils/types';
+import type { AttemptRow, CallerProof, Clock, PepysReader, PhaseName } from '@boxxy/model';
 import type { FakeNotifier } from '@boxxy/model/test-utils/create-fake-notifier';
 import type { FakePepysReader } from '@boxxy/model/test-utils/create-fake-pepys-reader';
 import type { TickReport } from '../tick/run-tick.ts';
@@ -9,6 +11,8 @@ import type { FakeCallerProof } from './create-fake-caller-proof.ts';
 export interface TestServerOptions {
     readonly hasPepys?: boolean;
     readonly makeCallerProof?: (clock: Clock) => Promise<CallerProof>;
+    readonly pepys?: PepysReader;
+    readonly store?: ClosableClaimStore;
 }
 export interface TestServer {
     readonly dispatch: TestDispatch;
@@ -25,6 +29,7 @@ export interface TestServer {
     readonly owner: (request: Request) => Promise<Response>;
     readonly worker: (request: Request) => Promise<Response>;
     readonly tick: () => Promise<TickReport>;
+    readonly watch: () => Promise<WatchReport>;
     readonly seedStartedAttempt: (phase: PhaseName) => Promise<AttemptRow>;
 }
 export declare function createTestServer(options?: TestServerOptions): Promise<TestServer>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boxxy/server",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "The boxxy server: the API behind its three doors, and the runner loop",
   "homepage": "https://github.com/zgeoff/boxxy/tree/main/apps/server#readme",
   "bugs": "https://github.com/zgeoff/boxxy/issues",
@@ -32,19 +32,19 @@
     "typecheck": "tsrs --noEmit"
   },
   "dependencies": {
-    "@boxxy/caller-proof-imp": "0.1.3",
-    "@boxxy/closeout": "0.1.3",
-    "@boxxy/content-hash": "0.1.3",
-    "@boxxy/contract": "0.1.3",
-    "@boxxy/dispatch": "0.1.3",
-    "@boxxy/forge-github": "0.1.3",
-    "@boxxy/model": "0.1.3",
-    "@boxxy/notifier-atc": "0.1.3",
-    "@boxxy/pepys": "0.1.3",
-    "@boxxy/planning": "0.1.3",
-    "@boxxy/rules": "0.1.3",
-    "@boxxy/store-sqlite": "0.1.3",
-    "@boxxy/worker-atc": "0.1.3",
+    "@boxxy/caller-proof-imp": "0.1.5",
+    "@boxxy/closeout": "0.1.5",
+    "@boxxy/content-hash": "0.1.5",
+    "@boxxy/contract": "0.1.5",
+    "@boxxy/dispatch": "0.1.5",
+    "@boxxy/forge-github": "0.1.5",
+    "@boxxy/model": "0.1.5",
+    "@boxxy/notifier-atc": "0.1.5",
+    "@boxxy/pepys": "0.1.5",
+    "@boxxy/planning": "0.1.5",
+    "@boxxy/rules": "0.1.5",
+    "@boxxy/store-sqlite": "0.1.5",
+    "@boxxy/worker-atc": "0.1.5",
     "@modelcontextprotocol/server": "2.4.0",
     "@orpc/client": "2.0.0-beta.50",
     "@orpc/mcp": "2.0.0-beta.50",

package/src/config/read-trusted-issuers.ts

@@ -1,25 +1,36 @@
-import { readdir } from 'node:fs/promises';
+import { readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 
 export type IssuersAnswer =
   | { readonly kind: 'read'; readonly issuers: readonly unknown[] }
   | { readonly kind: 'invalid'; readonly message: string };
 
-// The trust documents, one per file of each folder, as parsed JSON in name order. The adapter
-// checks their shape; this reads them only.
+// The trust documents, one per regular file of each folder, as parsed JSON in name order. The
+// adapter checks their shape; this reads them only. Folders that hold no document refuse, so a
+// configured but empty mount never starts a server that refuses every session in silence.
 export async function readTrustedIssuers(folders: readonly string[]): Promise<IssuersAnswer> {
   const issuers: unknown[] = [];
 
   for (const folder of folders) {
-    const files = await readFileNames(folder);
+    const names = await readEntryNames(folder);
 
-    if (files === null) {
+    if (names === null) {
       return { kind: 'invalid', message: `no trusted issuers folder at ${folder}` };
     }
 
-    for (const name of files) {
+    for (const name of names) {
       const file = path.join(folder, name);
 
+      const entry = await readEntryKind(file);
+
+      if (entry === 'missing') {
+        return { kind: 'invalid', message: `the trust document at ${file} points nowhere` };
+      }
+
+      if (entry === 'other') {
+        continue;
+      }
+
       const text = await Bun.file(file).text();
 
       const json = parseJSON(text);
@@ -32,23 +43,38 @@ export async function readTrustedIssuers(folders: readonly string[]): Promise<Is
     }
   }
 
+  if (issuers.length === 0) {
+    return { kind: 'invalid', message: `no trust document in ${folders.join(', ')}` };
+  }
+
   return { kind: 'read', issuers };
 }
 
-// null: the folder does not exist
-async function readFileNames(folder: string): Promise<string[] | null> {
+// null: the folder does not exist. A Kubernetes volume keeps its real files under `..data` and
+// `..<timestamp>` and shows each key as a symlink beside them, so `..` names are skipped.
+async function readEntryNames(folder: string): Promise<string[] | null> {
   try {
-    const entries = await readdir(folder, { withFileTypes: true });
+    const names = await readdir(folder);
 
-    return entries
-      .filter((entry) => entry.isFile())
-      .map((entry) => entry.name)
+    return names
+      .filter((name) => !name.startsWith('..'))
       .toSorted((left, right) => left.localeCompare(right));
   } catch {
     return null;
   }
 }
 
+// `stat` follows a symlink to its target; a symlink that points nowhere is `missing`
+async function readEntryKind(file: string): Promise<'file' | 'other' | 'missing'> {
+  try {
+    const stats = await stat(file);
+
+    return stats.isFile() ? 'file' : 'other';
+  } catch {
+    return 'missing';
+  }
+}
+
 function parseJSON(text: string): unknown {
   try {
     const value: unknown = JSON.parse(text);

package/src/test-utils/create-test-server.ts

@@ -1,12 +1,16 @@
+import { watchPullRequests } from '@boxxy/dispatch';
+import type { WatchReport } from '@boxxy/dispatch';
 import type { FakeForge } from '@boxxy/dispatch/test-utils/create-fake-forge';
 import { createFakeForge } from '@boxxy/dispatch/test-utils/create-fake-forge';
 import type { TestDispatch } from '@boxxy/dispatch/test-utils/create-test-dispatch';
 import { createTestDispatch } from '@boxxy/dispatch/test-utils/create-test-dispatch';
+import type { ClosableClaimStore } from '@boxxy/dispatch/test-utils/types';
 import type {
   AttemptId,
   AttemptRow,
   CallerProof,
   Clock,
+  PepysReader,
   PhaseName,
   SessionReading,
 } from '@boxxy/model';
@@ -33,6 +37,12 @@ export interface TestServerOptions {
   // the server's real proof in place of the fake one, built on the test's clock; the fake that
   // `callerProof` returns then proves nothing
   readonly makeCallerProof?: (clock: Clock) => Promise<CallerProof>;
+
+  // the reader of a pepys under test in place of the fake one, which `pepys` then still returns
+  readonly pepys?: PepysReader;
+
+  // the memory store when left out
+  readonly store?: ClosableClaimStore;
 }
 
 export interface TestServer {
@@ -57,6 +67,9 @@ export interface TestServer {
   // one runner tick at the clock's time
   readonly tick: () => Promise<TickReport>;
 
+  // one pass of the pull request watch at the clock's time
+  readonly watch: () => Promise<WatchReport>;
+
   // an item at the phase, claimed and started by the fake worker; its row carries the caller
   // that its session reports
   readonly seedStartedAttempt: (phase: PhaseName) => Promise<AttemptRow>;
@@ -65,7 +78,9 @@ export interface TestServer {
 // The server's two listeners on the memory store, the fake worker, the fake clock, a fake pepys
 // reader, a fake notifier and a fake forge, with the example rules. No port is opened.
 export async function createTestServer(options: TestServerOptions = {}): Promise<TestServer> {
-  const dispatch = await createTestDispatch();
+  const dispatchOptions = options.store === undefined ? {} : { store: options.store };
+
+  const dispatch = await createTestDispatch(dispatchOptions);
 
   const callerProof = createFakeCallerProof();
   const pepys = createFakePepysReader();
@@ -95,7 +110,7 @@ export async function createTestServer(options: TestServerOptions = {}): Promise
         ? callerProof
         : await options.makeCallerProof(dispatch.clock),
     workerTokenDigest: buildTokenDigest(workerToken),
-    pepys: options.hasPepys === false ? null : pepys,
+    pepys: options.hasPepys === false ? null : (options.pepys ?? pepys),
     forge,
     outbox: createOffOutbox(dispatch.store, dispatch.clock),
     readings,
@@ -129,6 +144,15 @@ export async function createTestServer(options: TestServerOptions = {}): Promise
         readings,
         log,
       }),
+    watch: () =>
+      watchPullRequests({
+        store: dispatch.store,
+        forge,
+        rules: dispatch.rules(),
+        runner: dispatch.runner,
+        now: dispatch.clock.now(),
+        newId: dispatch.newId,
+      }),
     seedStartedAttempt: async (phase) => {
       await dispatch.seedItem({ phase });