@dotdrelle/wiki-manager 0.8.2 → 0.10.4

package/src/runtime/server.test.js

@@ -1,7 +1,51 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { startRuntimeServer } from './server.js';
 
+test('runtime server checks bearer and x-runtime-token credentials', async (t) => {
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      token: 'runtime-secret',
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      session: {},
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const url = `http://127.0.0.1:${handle.port}/health`;
+
+    const missing = await fetch(url);
+    assert.equal(missing.status, 401);
+
+    const bearer = await fetch(url, {
+      headers: { authorization: 'Bearer runtime-secret' },
+    });
+    assert.equal(bearer.status, 200);
+
+    const legacy = await fetch(url, {
+      headers: { 'x-runtime-token': 'runtime-secret' },
+    });
+    assert.equal(legacy.status, 200);
+  } finally {
+    await handle.close();
+  }
+});
+
 test('runtime server accepts only one active run', async (t) => {
   let releaseRun;
   let runCount = 0;
@@ -102,6 +146,58 @@ test('runtime server returns the accepted run id and passes it to the runner', a
   }
 });
 
+test('runtime server state exposes active run identity while running', async (t) => {
+  let releaseRun;
+  const context = {
+    workspace: 'juno',
+    session: { workspace: 'juno' },
+    running: false,
+    currentAbortController: null,
+    currentRunId: null,
+  };
+  let acceptedRun;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle', plan: [] }),
+        listEvents: () => [],
+      },
+      getContext: async () => context,
+      run: async () => {
+        await new Promise((resolve) => { releaseRun = resolve; });
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const runResponse = await fetch(`http://127.0.0.1:${handle.port}/run?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'build' }),
+    });
+    acceptedRun = await runResponse.json();
+    const stateResponse = await fetch(`http://127.0.0.1:${handle.port}/state?workspace=juno`);
+    const state = await stateResponse.json();
+    assert.equal(state.status, 'running');
+    assert.equal(state.running, true);
+    assert.equal(state.runId, acceptedRun.runId);
+    assert.equal(state.workspace, 'juno');
+  } finally {
+    releaseRun?.();
+    await handle.close();
+  }
+});
+
 test('runtime server isolates active runs by workspace', async (t) => {
   const releases = new Map();
   const runWorkspaces = [];
@@ -222,6 +318,52 @@ test('runtime server filters state and events by workspace', async (t) => {
   }
 });
 
+test('runtime server exposes a correlated audit trail endpoint', async (t) => {
+  let auditArgs = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+        listAuditTrail: (options) => {
+          auditArgs = options;
+          return [{ sequence: 1, type: 'tool_call_started', runId: options.runId, taskId: 'task-a' }];
+        },
+      },
+      getContext: async (workspace) => ({
+        workspace,
+        session: { workspace },
+        running: false,
+        currentAbortController: null,
+      }),
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/audit?workspace=docs&runId=run-1`);
+    assert.equal(response.status, 200);
+    const body = await response.json();
+    assert.equal(body.ok, true);
+    assert.equal(body.workspace, 'docs');
+    assert.equal(body.runId, 'run-1');
+    assert.deepEqual(body.audit, [{ sequence: 1, type: 'tool_call_started', runId: 'run-1', taskId: 'task-a' }]);
+    assert.deepEqual(auditArgs, { workspace: 'docs', runId: 'run-1' });
+  } finally {
+    await handle.close();
+  }
+});
+
 test('runtime server exposes manual resume endpoint', async (t) => {
   let resumedWorkspace = null;
   let handle;
@@ -306,3 +448,522 @@ test('runtime server exposes approval endpoint', async (t) => {
     await handle.close();
   }
 });
+
+test('runtime server exposes control status and explanation', async (t) => {
+  const session = {
+    workspace: 'juno',
+    controlQueue: [{ id: 'control-1', workspace: 'juno', status: 'queued', input: 'later' }],
+  };
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({
+          status: 'idle',
+          plan: [{ step: 1, description: 'Check status', status: 'pending' }],
+          queue: [],
+          controlQueue: session.controlQueue,
+          approvals: [],
+          summary: null,
+        }),
+        listEvents: () => [],
+      },
+      getContext: async () => ({
+        workspace: 'juno',
+        session,
+        running: false,
+        currentAbortController: null,
+      }),
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const status = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`);
+    assert.equal(status.status, 200);
+    const statusBody = await status.json();
+    assert.equal(statusBody.status, 'idle');
+    assert.equal(statusBody.running, false);
+    assert.equal(statusBody.controlQueue[0].id, 'control-1');
+
+    const explain = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'explain' }),
+    });
+    assert.equal(explain.status, 200);
+    assert.match((await explain.json()).explanation, /control request/);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server control enqueue emits events but does not patch an active plan or start a run', async (t) => {
+  const session = {
+    workspace: 'juno',
+    controlQueue: [],
+  };
+  const events = [];
+  session._onAgentEvent = (event) => events.push(event);
+  let runCount = 0;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({
+          status: 'running',
+          plan: [{ step: 1, description: 'Active step', status: 'running' }],
+          queue: [],
+          controlQueue: session.controlQueue,
+          approvals: [],
+          summary: null,
+        }),
+        listEvents: () => [],
+      },
+      getContext: async () => ({
+        workspace: 'juno',
+        session,
+        running: true,
+        currentAbortController: new AbortController(),
+      }),
+      run: async () => { runCount += 1; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'enqueue', input: 'run this after current work' }),
+    });
+    assert.equal(response.status, 202);
+    const body = await response.json();
+    assert.equal(body.accepted, true);
+    assert.equal(body.item.status, 'queued');
+    assert.equal(body.controlQueue.length, 1);
+    assert.equal(body.plan[0].description, 'Active step');
+    assert.equal(session.controlQueue[0].input, 'run this after current work');
+    assert.equal(events.filter((event) => event.type === 'control_enqueued').length, 1);
+    assert.equal(runCount, 0);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server control message observes an active run without enqueueing', async (t) => {
+  const session = {
+    workspace: 'juno',
+    controlQueue: [],
+  };
+  let runCount = 0;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({
+          status: 'running',
+          plan: [{ step: 1, description: 'Build documents', status: 'running' }],
+          queue: [],
+          approvals: [],
+          summary: null,
+        }),
+        listEvents: () => [],
+      },
+      getContext: async () => ({
+        workspace: 'juno',
+        session,
+        running: true,
+        currentAbortController: new AbortController(),
+      }),
+      run: async () => { runCount += 1; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'message', input: 'Où en est le build ?' }),
+    });
+    assert.equal(response.status, 200);
+    const body = await response.json();
+    assert.equal(body.kind, 'observe');
+    assert.match(body.explanation, /Build documents/);
+    assert.equal(session.controlQueue.length, 0);
+    assert.equal(runCount, 0);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server control message records active plan mutation as a proposal', async (t) => {
+  const session = {
+    workspace: 'juno',
+    controlQueue: [],
+  };
+  dispatchAgentEvent(session, createAgentEvent('run_started', {
+    origin: 'runtime',
+    runId: 'run-mutate',
+    workspace: 'juno',
+  }));
+  dispatchAgentEvent(session, createAgentEvent('plan_set', {
+    origin: 'tool',
+    runId: 'run-mutate',
+    workspace: 'juno',
+    payload: {
+      steps: [{ step: 1, id: 'generate', description: 'Generate', status: 'running' }],
+    },
+  }));
+  let runCount = 0;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({
+          ...session.agentProjection,
+          status: session.agentProjection?.status ?? 'running',
+          queue: [],
+          runs: [{ id: 'run-mutate', workspace: 'juno', status: 'running' }],
+          runId: 'run-mutate',
+        }),
+        listEvents: () => [],
+      },
+      getContext: async () => ({
+        workspace: 'juno',
+        session,
+        running: true,
+        currentAbortController: new AbortController(),
+        currentRunId: 'run-mutate',
+      }),
+      run: async () => { runCount += 1; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'message', input: 'Ajoute un envoi après chaque génération' }),
+    });
+    assert.equal(response.status, 202);
+    const body = await response.json();
+    assert.equal(body.kind, 'mutate');
+    assert.equal(body.proposal.status, 'proposed');
+    assert.equal(body.proposal.input, 'Ajoute un envoi après chaque génération');
+    assert.equal(session.agentProjection.planPatches[0].status, 'proposed');
+    assert.ok(session.agentEvents.some((event) => event.type === 'control_message_received'));
+    assert.ok(session.agentEvents.some((event) => event.type === 'plan_patch_proposed'));
+    const approveResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'approve_patch', patchId: body.proposal.id }),
+    });
+    assert.equal(approveResponse.status, 202);
+    const approved = await approveResponse.json();
+    assert.equal(approved.kind, 'approve_patch');
+    // plan_set (revision 0->1) then the approved patch application (1->2).
+    assert.equal(session.agentProjection.planRevision, 2);
+    assert.deepEqual(session.agentProjection.plan.map((step) => step.id), ['generate', session.agentProjection.plan[1].id]);
+    assert.deepEqual(session.agentProjection.plan[1].dependsOn, ['generate']);
+    assert.ok(session.agentEvents.some((event) => event.type === 'plan_patch_approved'));
+    assert.ok(session.agentEvents.some((event) => event.type === 'plan_patch_applied'));
+    assert.equal(session.controlQueue.length, 0);
+    assert.equal(runCount, 0);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server control message reports ambiguity without starting a run', async (t) => {
+  const session = {
+    workspace: 'juno',
+    controlQueue: [],
+  };
+  let runCount = 0;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({
+          status: 'running',
+          plan: [{ step: 1, description: 'Generate', status: 'running' }],
+          queue: [],
+          approvals: [],
+          summary: null,
+        }),
+        listEvents: () => [],
+      },
+      getContext: async () => ({
+        workspace: 'juno',
+        session,
+        running: true,
+        currentAbortController: new AbortController(),
+      }),
+      run: async () => { runCount += 1; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'message', input: 'Lance aussi la publication' }),
+    });
+    assert.equal(response.status, 200);
+    const body = await response.json();
+    assert.equal(body.kind, 'ambiguous');
+    assert.equal(body.choices.length, 3);
+    assert.equal(session.controlQueue.length, 0);
+    assert.equal(runCount, 0);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server drains queued control requests when idle', async (t) => {
+  const session = {
+    workspace: 'juno',
+    controlQueue: [],
+  };
+  const events = [];
+  session._onAgentEvent = (event) => events.push(event);
+  let receivedBody = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({
+          status: 'idle',
+          plan: [],
+          queue: [],
+          controlQueue: session.controlQueue,
+          approvals: [],
+          summary: null,
+        }),
+        listEvents: () => [],
+      },
+      getContext: async () => ({
+        workspace: 'juno',
+        session,
+        running: false,
+        currentAbortController: null,
+      }),
+      run: async (_context, body) => {
+        receivedBody = body;
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'enqueue', input: 'run from control queue' }),
+    });
+    assert.equal(response.status, 202);
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(receivedBody.input, 'run from control queue');
+    assert.equal(receivedBody.workspace, 'juno');
+    assert.match(receivedBody.runId, /^[0-9a-f-]{36}$/);
+    assert.equal(session.controlQueue[0].status, 'running');
+    assert.equal(session.controlQueue[0].runId, receivedBody.runId);
+    assert.deepEqual(events.map((event) => event.type), ['control_enqueued', 'control_started']);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server handle drains a pre-existing hydrated control request', async (t) => {
+  const session = {
+    workspace: 'juno',
+    controlQueue: [{ id: 'control-existing', workspace: 'juno', status: 'queued', input: 'resume queued control' }],
+  };
+  const events = [];
+  session._onAgentEvent = (event) => events.push(event);
+  const context = {
+    workspace: 'juno',
+    session,
+    running: false,
+    currentAbortController: null,
+  };
+  let receivedBody = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      getContext: async () => context,
+      run: async (_context, body) => {
+        receivedBody = body;
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    assert.equal(handle.drainControl(context), true);
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(receivedBody.input, 'resume queued control');
+    assert.equal(session.controlQueue[0].status, 'running');
+    assert.equal(events[0].type, 'control_started');
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server exposes config profile list and switch endpoints', async (t) => {
+  const context = {
+    workspace: 'juno',
+    session: { workspace: 'juno', wikirc: { profile: 'default' } },
+    running: false,
+    currentAbortController: null,
+  };
+  let switchedProfile = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      getContext: async () => context,
+      run: async () => {},
+      configProfiles: async () => ({ profiles: ['default', 'vpn'], active: context.session.wikirc.profile }),
+      useConfigProfile: async (_context, profile) => {
+        switchedProfile = profile;
+        context.session.wikirc.profile = profile;
+        return { ok: true, active: profile, config: { llm: { model: 'model-vpn' } } };
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const profiles = await fetch(`http://127.0.0.1:${handle.port}/config/profiles?workspace=juno`);
+    assert.equal(profiles.status, 200);
+    assert.deepEqual(await profiles.json(), { profiles: ['default', 'vpn'], active: 'default' });
+
+    const use = await fetch(`http://127.0.0.1:${handle.port}/config/use?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ profile: 'vpn' }),
+    });
+    assert.equal(use.status, 200);
+    assert.equal(switchedProfile, 'vpn');
+    assert.deepEqual(await use.json(), { ok: true, active: 'vpn', config: { llm: { model: 'model-vpn' } } });
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server rejects config switching while a run is active', async (t) => {
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'running' }),
+        listEvents: () => [],
+      },
+      getContext: async () => ({
+        workspace: 'juno',
+        session: { workspace: 'juno' },
+        running: true,
+        currentAbortController: null,
+      }),
+      run: async () => {},
+      useConfigProfile: async () => ({ ok: true }),
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/config/use?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ profile: 'vpn' }),
+    });
+    assert.equal(response.status, 409);
+  } finally {
+    await handle.close();
+  }
+});