@animalabs/connectome-host 0.7.3 → 0.8.0

package/test/headless-panel-request.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Integration test for the 'panel-request' IPC verb against a REAL headless
+ * child (full framework, no inference): the same runPanelOp dispatcher the
+ * WebUI host uses locally must answer over the socket, so every operator
+ * panel (mcpl / settings / pins / health / context debug) works for fleet
+ * children exactly as it does for the host.
+ *
+ * Also verifies panel-response bypasses subscription filtering — a narrowed
+ * event stream must never eat a request/response pair.
+ */
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { spawn, type ChildProcess } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { connect as netConnect, type Socket } from 'node:net';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const TEST_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(TEST_DIR, '..');
+const INDEX_PATH = join(REPO_ROOT, 'src', 'index.ts');
+
+const MINIMAL_RECIPE = {
+  name: 'Panel Test',
+  agent: {
+    name: 'commander',
+    systemPrompt: 'never asked to infer in this test',
+  },
+  modules: {
+    subagents: false,
+    lessons: false,
+    retrieval: false,
+    wake: false,
+    workspace: false,
+  },
+};
+
+function lineReader(socket: Socket): { events: Array<Record<string, unknown>>; stop: () => void } {
+  const events: Array<Record<string, unknown>> = [];
+  let buf = '';
+  const handler = (chunk: Buffer): void => {
+    buf += chunk.toString('utf-8');
+    let i: number;
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, i).trim();
+      buf = buf.slice(i + 1);
+      if (!line) continue;
+      try { events.push(JSON.parse(line) as Record<string, unknown>); } catch { /* ignore malformed */ }
+    }
+  };
+  socket.on('data', handler);
+  return { events, stop: (): void => { socket.off('data', handler); } };
+}
+
+async function waitFor(check: () => boolean, timeoutMs: number, label: string): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (check()) return;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  throw new Error(`waitFor timed out after ${timeoutMs}ms: ${label}`);
+}
+
+async function connectSocket(path: string, timeoutMs = 3_000): Promise<Socket> {
+  return new Promise((resolveConn, rejectConn) => {
+    const s = netConnect(path);
+    const timer = setTimeout(() => {
+      s.destroy();
+      rejectConn(new Error(`socket connect timeout: ${path}`));
+    }, timeoutMs);
+    s.once('connect', () => { clearTimeout(timer); resolveConn(s); });
+    s.once('error', (err) => { clearTimeout(timer); rejectConn(err); });
+  });
+}
+
+describe('headless daemon — panel-request / panel-response', () => {
+  let tmpDir: string;
+  let socketPath: string;
+  let child: ChildProcess;
+  let sock: Socket;
+  let reader: { events: Array<Record<string, unknown>>; stop: () => void };
+  let corrSeq = 0;
+
+  /** Send one panel-request and await its panel-response. */
+  async function panel(op: string, params?: Record<string, unknown>): Promise<Record<string, unknown>> {
+    const corrId = `panel-test-${++corrSeq}`;
+    sock.write(JSON.stringify({ type: 'panel-request', op, ...(params ? { params } : {}), corrId }) + '\n');
+    await waitFor(
+      () => reader.events.some((e) => e.type === 'panel-response' && e.corrId === corrId),
+      10_000,
+      `panel-response for op=${op}`,
+    );
+    return reader.events.find((e) => e.type === 'panel-response' && e.corrId === corrId)!;
+  }
+
+  beforeAll(async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'fkm-panelreq-'));
+    const recipePath = join(tmpDir, 'recipe.json');
+    socketPath = join(tmpDir, 'ipc.sock');
+    writeFileSync(recipePath, JSON.stringify(MINIMAL_RECIPE), 'utf-8');
+
+    child = spawn(
+      'bun',
+      [INDEX_PATH, recipePath, '--headless'],
+      {
+        cwd: tmpDir,
+        env: {
+          ...process.env,
+          ANTHROPIC_API_KEY: 'sk-test-panel',
+          DATA_DIR: tmpDir,
+        },
+        stdio: ['ignore', 'ignore', 'ignore'],
+      },
+    );
+
+    await waitFor(() => existsSync(socketPath), 15_000, 'socket file appears');
+    sock = await connectSocket(socketPath);
+    reader = lineReader(sock);
+    await waitFor(
+      () => reader.events.some((e) => e.type === 'lifecycle' && (e as { phase?: string }).phase === 'ready'),
+      5_000,
+      'lifecycle:ready',
+    );
+  });
+
+  afterAll(async () => {
+    try { sock.write(JSON.stringify({ type: 'shutdown' }) + '\n'); } catch { /* noop */ }
+    await new Promise((r) => setTimeout(r, 500));
+    try { reader.stop(); sock.destroy(); } catch { /* noop */ }
+    try { if (child.exitCode === null) child.kill('SIGKILL'); } catch { /* noop */ }
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* noop */ }
+  });
+
+  test('op=health returns the healthz assembly', async () => {
+    const res = await panel('health');
+    expect(res.ok).toBe(true);
+    expect(res.op).toBe('health');
+    const data = res.data as Record<string, unknown>;
+    // Same shape /healthz serves: framework snapshot + the panel-data extras.
+    expect(data.agents ?? data.runtimeSettings ?? data.contextComposition).toBeDefined();
+  });
+
+  test('op=settings returns the primary agent runtime settings', async () => {
+    const res = await panel('settings');
+    expect(res.ok).toBe(true);
+    const data = res.data as { agent: string; settings: Record<string, unknown>; hotKeys: string[] };
+    expect(data.agent).toBe('commander');
+    expect(typeof data.settings).toBe('object');
+    expect(Array.isArray(data.hotKeys)).toBe(true);
+  });
+
+  test('op=mcpl returns registry + live server view', async () => {
+    const res = await panel('mcpl');
+    expect(res.ok).toBe(true);
+    const data = res.data as { configPath: string; servers: unknown[]; live: unknown[] };
+    expect(typeof data.configPath).toBe('string');
+    expect(Array.isArray(data.servers)).toBe(true);
+    expect(Array.isArray(data.live)).toBe(true);
+    expect(data.live.length).toBe(0); // minimal recipe opts into no MCPLs
+  });
+
+  test('op=pins returns a snapshot with candidates when asked', async () => {
+    const res = await panel('pins', { withCandidates: true });
+    expect(res.ok).toBe(true);
+    const data = res.data as { agent: string; pins: unknown[]; pinsSupported: boolean; candidates?: unknown[] };
+    expect(data.agent).toBe('commander');
+    expect(Array.isArray(data.pins)).toBe(true);
+    expect(typeof data.pinsSupported).toBe('boolean');
+    expect(Array.isArray(data.candidates)).toBe(true);
+  });
+
+  test('op=context-coverage names the agent and its branch', async () => {
+    const res = await panel('context-coverage');
+    expect(res.ok).toBe(true);
+    const data = res.data as { agent: string; branch: string; totals: Record<string, number> };
+    expect(data.agent).toBe('commander');
+    expect(typeof data.branch).toBe('string');
+    expect(typeof data.totals.chunks).toBe('number');
+  });
+
+  test('unknown agent comes back ok:false with 404', async () => {
+    const res = await panel('context-coverage', { agent: 'nonexistent' });
+    expect(res.ok).toBe(false);
+    expect(res.status).toBe(404);
+    expect(res.error).toContain('nonexistent');
+  });
+
+  test('unknown op comes back ok:false with 400', async () => {
+    const res = await panel('no-such-op');
+    expect(res.ok).toBe(false);
+    expect(res.status).toBe(400);
+    expect(res.error).toContain('unknown panel op');
+  });
+
+  test('panel-response bypasses subscription filter', async () => {
+    sock.write(JSON.stringify({ type: 'subscribe', events: ['command-output'] }) + '\n');
+    await new Promise((r) => setTimeout(r, 100));
+    const res = await panel('health');
+    expect(res.ok).toBe(true);
+  });
+});

package/test/identity-and-surfaces.test.ts

@@ -16,6 +16,7 @@ import { IdentityModule } from '../src/modules/identity-module.ts';
 import { McplAdminModule } from '../src/modules/mcpl-admin-module.ts';
 import { ObserversModule } from '../src/modules/observers-module.ts';
 
+const REQUEST_BODY_MAX_FOR_TEST = 256 * 1024;
 const call = (name: string, input: unknown) => ({ id: 't1', name, input });
 
 function fakeHome(routes: Record<string, (body: any) => { status: number; json: unknown }>): typeof fetch {
@@ -34,7 +35,7 @@ describe('identity module', () => {
     const dir = mkdtempSync(join(tmpdir(), 'ident-'));
     const mod = new IdentityModule({ keyPath: join(dir, 'identity-key.pem'), home: 'id.test' });
     expect(mod.getTools()).toEqual([]);
-    expect(mod.getUtilities().map((u) => u.name)).toEqual(['status', 'accept_invite']);
+    expect(mod.getUtilities().map((u) => u.name)).toEqual(['status', 'request', 'accept_invite']);
     // Framing check: no crypto/credential vocabulary in agent-visible text.
     const visible = JSON.stringify(mod.getUtilities()).toLowerCase();
     for (const scary of ['token', 'key', 'sign', 'proof', 'ed25519', 'mint', 'bearer']) {
@@ -86,6 +87,216 @@ describe('identity module', () => {
     expect(again.error).toContain('Already registered');
   });
 
+
+  it('request: allowlisted service, host-attached access, no credential in result', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'ident-'));
+    let authSeen = '';
+    const mod = new IdentityModule({
+      keyPath: join(dir, 'k.pem'),
+      home: 'id.test',
+      services: { orrery: 'https://orrery.test' },
+      fetchImpl: (async (url: any, init?: any) => {
+        const u = String(url);
+        if (u.includes('/enroll')) return new Response(JSON.stringify({ sub: 'agent:a@guest', token: 't0' }), { status: 200 });
+        if (u.includes('/token')) return new Response(JSON.stringify({ token: 'aid1.fresh.secret' }), { status: 200 });
+        if (u === 'https://orrery.test/api/ops') {
+          authSeen = String(init?.headers?.authorization ?? '');
+          return new Response(JSON.stringify({ ops: [1, 2] }), { status: 200 });
+        }
+        return new Response('{}', { status: 404 });
+      }) as typeof fetch,
+    });
+    // not registered yet -> neutral failure
+    const early = await mod.handleToolCall(call('request', { service: 'orrery', path: '/api/ops' }));
+    expect(early.success).toBe(false);
+
+    await mod.handleToolCall(call('accept_invite', { invite: 'i', name: 'A' }));
+    const res = await mod.handleToolCall(call('request', { service: 'orrery', path: '/api/ops' }));
+    expect(res.success).toBe(true);
+    expect((res.data as any).status).toBe(200);
+    expect((res.data as any).body).toEqual({ ops: [1, 2] });
+    expect(authSeen).toBe('Bearer aid1.fresh.secret');
+    // the credential must never appear in the agent-visible result
+    expect(JSON.stringify(res.data)).not.toContain('aid1.');
+
+    const unknown = await mod.handleToolCall(call('request', { service: 'nope', path: '/x' }));
+    expect(unknown.error).toContain('Available: orrery');
+    const badPath = await mod.handleToolCall(call('request', { service: 'orrery', path: 'api/ops' }));
+    expect(badPath.success).toBe(false);
+  });
+
+  it('request: services come from the home node directory, and a newly-listed one works without a restart', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'ident-'));
+    // The archipelago's service list lives at the home node, not in this host.
+    // It changes underneath us mid-run: `music` is added after the module has
+    // already fetched and cached a directory without it.
+    let directory: Record<string, string> = { orrery: 'https://orrery.test' };
+    let directoryFetches = 0;
+    const mod = new IdentityModule({
+      keyPath: join(dir, 'k.pem'),
+      home: 'id.test',
+      fetchImpl: (async (url: any, init?: any) => {
+        const u = String(url);
+        if (u.includes('/enroll')) return new Response(JSON.stringify({ sub: 'agent:a@id.test', token: 't0' }), { status: 200 });
+        if (u.includes('/token')) return new Response(JSON.stringify({ token: 'aid1.fresh.secret' }), { status: 200 });
+        if (u === 'https://id.test/services') {
+          directoryFetches++;
+          return new Response(JSON.stringify({ home: 'id.test', services: directory }), { status: 200 });
+        }
+        if (u === 'https://music.test/api/me') return new Response(JSON.stringify({ me: 'mythos' }), { status: 200 });
+        return new Response('{}', { status: 404 });
+      }) as typeof fetch,
+    });
+    await mod.handleToolCall(call('accept_invite', { invite: 'i', name: 'A' }));
+
+    // nothing compiled in, nothing in the recipe: the directory supplied it
+    const listed = await mod.handleToolCall(call('request', { service: 'orrery', path: '/x' }));
+    expect(listed.success).toBe(true); // resolved and called; upstream 404 is reported, not a resolution failure
+    expect((listed.data as any).status).toBe(404);
+
+    // music does not exist yet -> refused, and the refusal cost a re-check
+    const before = await mod.handleToolCall(call('request', { service: 'music', path: '/api/me' }));
+    expect(before.success).toBe(false);
+    expect(before.error).toContain('Unknown service "music"');
+
+    // operator adds it at the home node; no restart, no recipe edit here
+    directory = { orrery: 'https://orrery.test', music: 'https://music.test' };
+    const fetchesBefore = directoryFetches;
+
+    const after = await mod.handleToolCall(call('request', { service: 'music', path: '/api/me' }));
+    expect(after.success).toBe(true);
+    expect((after.data as any).body).toEqual({ me: 'mythos' });
+    // it re-asked rather than serving a stale "unknown" from cache
+    expect(directoryFetches).toBeGreaterThan(fetchesBefore);
+  });
+
+  it('request: a home node that cannot be reached degrades to the built-in map, never to an outage', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'ident-'));
+    const mod = new IdentityModule({
+      keyPath: join(dir, 'k.pem'),
+      home: 'id.test',
+      fetchImpl: (async (url: any) => {
+        const u = String(url);
+        if (u.includes('/enroll')) return new Response(JSON.stringify({ sub: 'agent:a@id.test', token: 't0' }), { status: 200 });
+        if (u.includes('/token')) return new Response(JSON.stringify({ token: 'aid1.fresh.secret' }), { status: 200 });
+        if (u === 'https://id.test/services') return new Response('nope', { status: 503 });
+        if (u === 'https://eidoverse.animalabs.ai/api/ping') return new Response(JSON.stringify({ ok: true }), { status: 200 });
+        return new Response('{}', { status: 404 });
+      }) as typeof fetch,
+    });
+    await mod.handleToolCall(call('accept_invite', { invite: 'i', name: 'A' }));
+    const res = await mod.handleToolCall(call('request', { service: 'eidoverse', path: '/api/ping' }));
+    expect(res.success).toBe(true);
+    expect((res.data as any).body).toEqual({ ok: true });
+  });
+
+  it('request: fromFile uploads a workspace file byte-exactly, without the bytes touching context', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'ident-'));
+    // A file far larger than the JSON body cap — the case that made this exist.
+    const audio = Buffer.alloc(REQUEST_BODY_MAX_FOR_TEST + 4096, 0);
+    audio.write('ID3', 0);
+    audio[audio.length - 1] = 0x7f;
+    let sentBody: Buffer | null = null;
+    let sentType = '';
+    const workspace = {
+      readBinary: async (path: string) =>
+        path === 'files/music/track.mp3' ? { data: audio } : { error: `File not found: ${path}` },
+      writeBinary: async () => ({ success: true }),
+    };
+    const mod = new IdentityModule({
+      keyPath: join(dir, 'k.pem'),
+      home: 'id.test',
+      services: { music: 'https://music.test' },
+      fetchImpl: (async (url: any, init?: any) => {
+        const u = String(url);
+        if (u.includes('/enroll')) return new Response(JSON.stringify({ sub: 'agent:a@id.test', token: 't0' }), { status: 200 });
+        if (u.includes('/token')) return new Response(JSON.stringify({ token: 'aid1.fresh.secret' }), { status: 200 });
+        if (u.includes('/services')) return new Response(JSON.stringify({ services: {} }), { status: 200 });
+        if (u === 'https://music.test/api/upload/1/audio') {
+          sentBody = Buffer.from(init?.body as Uint8Array);
+          sentType = String(init?.headers?.['content-type'] ?? '');
+          return new Response(JSON.stringify({ ok: true }), { status: 200 });
+        }
+        return new Response('{}', { status: 404 });
+      }) as typeof fetch,
+    });
+    (mod as any).ctx = { getModule: (n: string) => (n === 'workspace' ? workspace : null) };
+    await mod.handleToolCall(call('accept_invite', { invite: 'i', name: 'A' }));
+
+    const res = await mod.handleToolCall(
+      call('request', { service: 'music', path: '/api/upload/1/audio', method: 'PUT', fromFile: 'files/music/track.mp3' }),
+    );
+    expect(res.success).toBe(true);
+    // byte-exact, and typed from the extension rather than guessed by the model
+    expect(sentBody!.equals(audio)).toBe(true);
+    expect(sentType).toBe('audio/mpeg');
+    // a receipt, but never the payload itself, in the agent-visible result
+    expect((res.data as any).sent).toEqual({
+      path: 'files/music/track.mp3',
+      size: audio.byteLength,
+      contentType: 'audio/mpeg',
+    });
+    expect(JSON.stringify(res.data).length).toBeLessThan(1000);
+
+    // guard rails
+    const both = await mod.handleToolCall(
+      call('request', { service: 'music', path: '/x', method: 'PUT', body: { a: 1 }, fromFile: 'files/music/track.mp3' }),
+    );
+    expect(both.error).toContain('not both');
+    const onGet = await mod.handleToolCall(call('request', { service: 'music', path: '/x', fromFile: 'files/music/track.mp3' }));
+    expect(onGet.error).toContain('POST or PUT');
+    const missing = await mod.handleToolCall(
+      call('request', { service: 'music', path: '/x', method: 'PUT', fromFile: 'files/nope.mp3' }),
+    );
+    expect(missing.error).toContain('could not read');
+  });
+
+  it('request: binary responses are described safely or saved byte-exactly to workspace', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'ident-'));
+    const png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0xff, 0x00, 0x7f]);
+    let saved: { path: string; data: Buffer; mime: string } | null = null;
+    const mod = new IdentityModule({
+      keyPath: join(dir, 'k.pem'),
+      home: 'id.test',
+      services: { orrery: 'https://orrery.test' },
+      fetchImpl: (async (url: any) => {
+        const u = String(url);
+        if (u.includes('/enroll')) return new Response(JSON.stringify({ sub: 'agent:a@guest' }), { status: 200 });
+        if (u.includes('/token')) return new Response(JSON.stringify({ token: 'aid1.fresh.secret' }), { status: 200 });
+        if (u === 'https://orrery.test/api/assets/img/file') {
+          return new Response(png, { status: 200, headers: { 'content-type': 'image/png' } });
+        }
+        return new Response('{}', { status: 404, headers: { 'content-type': 'application/json' } });
+      }) as typeof fetch,
+    });
+    await mod.handleToolCall(call('accept_invite', { invite: 'i', name: 'A' }));
+
+    const described = await mod.handleToolCall(call('request', { service: 'orrery', path: '/api/assets/img/file' }));
+    expect(described.success).toBe(true);
+    expect((described.data as any).body).toBe(null);
+    expect((described.data as any).binary).toMatchObject({ size: png.length, contentType: 'image/png' });
+    expect(JSON.stringify(described.data)).not.toContain('�PNG');
+
+    await mod.start({
+      getModule: (name: string) => name === 'workspace' ? {
+        writeBinary: async (path: string, data: Buffer, mime: string) => {
+          saved = { path, data: Buffer.from(data), mime };
+          return { success: true, data: { path, size: data.length, mimeType: mime } };
+        },
+      } : null,
+    } as any);
+    const written = await mod.handleToolCall(call('request', {
+      service: 'orrery', path: '/api/assets/img/file', saveAs: 'files/artifacts/candidate.png',
+    }));
+    expect(written.success).toBe(true);
+    expect((written.data as any).saved).toMatchObject({
+      path: 'files/artifacts/candidate.png', size: png.length, contentType: 'image/png',
+    });
+    expect(saved?.path).toBe('files/artifacts/candidate.png');
+    expect(saved?.mime).toBe('image/png');
+    expect(saved?.data.equals(png)).toBe(true);
+  });
+
   it('host-facing accessFor: requires registration, then exchanges per call', async () => {
     const dir = mkdtempSync(join(tmpdir(), 'ident-'));
     let mints = 0;