@dotdrelle/wiki-manager 0.9.3 → 0.11.0

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;
@@ -426,6 +568,203 @@ test('runtime server control enqueue emits events but does not patch an active p
   }
 });
 
+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',

package/src/runtime/store.js

@@ -4,6 +4,7 @@ import { DatabaseSync } from 'node:sqlite';
 import { applyAgentProjectionToSession, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
 import { defaultRuntimeStateDir } from '../core/env.js';
 import { projectQueue } from '../core/jobQueue.js';
+import { projectWorkflow } from '../core/workflow.js';
 
 export { defaultRuntimeStateDir };
 
@@ -35,6 +36,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
       type TEXT NOT NULL,
       run_id TEXT,
       turn_id TEXT,
+      task_id TEXT,
       workspace TEXT,
       origin TEXT,
       payload TEXT NOT NULL
@@ -69,6 +71,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   `);
   ensureColumn(db, 'events', 'sequence', 'INTEGER');
   ensureColumn(db, 'events', 'workspace', 'TEXT');
+  ensureColumn(db, 'events', 'task_id', 'TEXT');
   ensureColumn(db, 'runs', 'workspace', 'TEXT');
   backfillEventSequence(db);
   db.exec('CREATE INDEX IF NOT EXISTS idx_events_workspace ON events(workspace)');
@@ -78,17 +81,17 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   let lastEventSequence = null;
 
   const insertEvent = db.prepare(`
-    INSERT OR IGNORE INTO events (sequence, id, ts, type, run_id, turn_id, workspace, origin, payload)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT OR IGNORE INTO events (sequence, id, ts, type, run_id, turn_id, task_id, workspace, origin, payload)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
   const nextEventSequenceStatement = db.prepare('SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence FROM events');
   const listEventsStatement = db.prepare(`
-    SELECT sequence, id, ts, type, run_id, turn_id, workspace, origin, payload
+    SELECT sequence, id, ts, type, run_id, turn_id, task_id, workspace, origin, payload
     FROM events
     ORDER BY sequence ASC
   `);
   const listEventsByWorkspaceStatement = db.prepare(`
-    SELECT sequence, id, ts, type, run_id, turn_id, workspace, origin, payload
+    SELECT sequence, id, ts, type, run_id, turn_id, task_id, workspace, origin, payload
     FROM events
     WHERE workspace = ?
     ORDER BY sequence ASC
@@ -195,6 +198,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
       event.type,
       event.runId ?? null,
       event.turnId ?? null,
+      event.taskId ?? event.payload?.taskId ?? null,
       ws,
       event.origin ?? null,
       JSON.stringify(event.payload ?? {}),
@@ -240,6 +244,12 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     return rows.map(rowToEvent);
   }
 
+  function listAuditTrail({ workspace = null, runId = null } = {}) {
+    return listEvents({ workspace })
+      .filter((event) => !runId || event.runId === runId || event.payload?.runId === runId)
+      .map(eventToAuditEntry);
+  }
+
   function listRuns({ workspace = null } = {}) {
     const rows = workspace
       ? listRunsByWorkspaceStatement.all(workspace)
@@ -362,15 +372,22 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     const events = session?.agentProjection ? null : listEvents({ workspace });
     const projection = session?.agentProjection ?? reduceAgentEvents(events);
     const rawQueue = session?.queueStore?.list() ?? listQueue({ workspace });
-    return {
+    const queue = projectQueue(projection.plan, rawQueue, { workspace });
+    const controlQueue = Array.isArray(projection.controlQueue)
+      ? projection.controlQueue.filter((item) => !workspace || item.workspace === workspace || !item.workspace).map((item) => ({ ...item }))
+      : [];
+    const baseState = {
       ...projection,
-      runs: listRuns({ workspace }),
-      queue: projectQueue(projection.plan, rawQueue, { workspace }),
-      controlQueue: Array.isArray(projection.controlQueue)
-        ? projection.controlQueue.filter((item) => !workspace || item.workspace === workspace || !item.workspace).map((item) => ({ ...item }))
-        : [],
+      queue,
+      controlQueue,
       eventsCursor: session?.agentEvents?.at(-1)?.sequence ?? events?.at(-1)?.sequence ?? lastEventSequence,
     };
+    const runs = listRuns({ workspace });
+    return {
+      ...baseState,
+      runs,
+      workflow: projectWorkflow({ ...baseState, runs, workspace }, events ?? session?.agentEvents ?? []),
+    };
   }
 
   function hydrateSession(session, { workspace = null } = {}) {
@@ -391,6 +408,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     persistEvent,
     persistRun,
     listEvents,
+    listAuditTrail,
     listRuns,
     listRecoverableRuns,
     listRecoverableWorkspaces,
@@ -414,11 +432,42 @@ function rowToEvent(row) {
     origin: row.origin ?? 'system',
     runId: row.run_id ?? null,
     turnId: row.turn_id ?? null,
+    taskId: row.task_id ?? null,
     workspace: row.workspace ?? null,
     payload: row.payload ? JSON.parse(row.payload) : {},
   };
 }
 
+function eventToAuditEntry(event) {
+  const payload = event.payload ?? {};
+  const activity = payload.activity ?? {};
+  return {
+    sequence: event.sequence ?? null,
+    ts: event.ts,
+    type: event.type,
+    runId: event.runId ?? payload.runId ?? null,
+    turnId: event.turnId ?? payload.turnId ?? null,
+    taskId: event.taskId ?? payload.taskId ?? activity.taskId ?? null,
+    activityId: payload.activityId ?? activity.id ?? activity.key ?? null,
+    toolCallId: payload.toolCallId ?? payload.callId ?? null,
+    workspace: event.workspace ?? payload.workspace ?? null,
+    caller: event.origin ?? payload.caller ?? 'system',
+    status: payload.status ?? activity.status ?? null,
+    tool: payload.tool ?? payload.name ?? activity.tool ?? null,
+    summary: auditSummary(event),
+  };
+}
+
+function auditSummary(event) {
+  const payload = event.payload ?? {};
+  if (typeof payload.message === 'string') return payload.message;
+  if (typeof payload.summary === 'string') return payload.summary;
+  if (typeof payload.input === 'string') return payload.input;
+  if (typeof payload.content === 'string') return payload.content.slice(0, 240);
+  if (payload.activity?.label) return payload.activity.label;
+  return event.type;
+}
+
 function ensureColumn(db, table, column, definition) {
   const existing = db.prepare(`PRAGMA table_info(${table})`).all();
   if (existing.some((row) => row.name === column)) return;

package/src/runtime/store.test.js

@@ -59,6 +59,7 @@ test('runtime store persists run identity fields on events', () => {
     origin: 'agent',
     runId: 'run-2',
     turnId: 'run-2:turn-1',
+    taskId: 'task-1',
     workspace: 'docs',
     payload: { content: 'done' },
   }));
@@ -66,10 +67,51 @@ test('runtime store persists run identity fields on events', () => {
   const [event] = store.listEvents();
   assert.equal(event.runId, 'run-2');
   assert.equal(event.turnId, 'run-2:turn-1');
+  assert.equal(event.taskId, 'task-1');
   assert.equal(event.workspace, 'docs');
   store.close();
 });
 
+test('runtime store exposes a correlated audit trail', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('tool_call_started', {
+    origin: 'agent',
+    runId: 'run-audit',
+    turnId: 'run-audit:turn-1',
+    taskId: 'task-a',
+    workspace: 'docs',
+    payload: { callId: 'call-1', name: 'production_start_job' },
+  }));
+  store.persistEvent(createAgentEvent('activity_upserted', {
+    origin: 'tool',
+    runId: 'run-audit',
+    turnId: 'run-audit:turn-1',
+    taskId: 'task-a',
+    workspace: 'docs',
+    payload: {
+      activity: {
+        id: 'job-1',
+        source: 'production',
+        kind: 'job',
+        label: 'Production job',
+        status: 'running',
+        progress: {},
+        poll: null,
+        outputRefs: [],
+      },
+    },
+  }));
+
+  const audit = store.listAuditTrail({ workspace: 'docs', runId: 'run-audit' });
+  assert.equal(audit.length, 2);
+  assert.equal(audit[0].toolCallId, 'call-1');
+  assert.equal(audit[0].taskId, 'task-a');
+  assert.equal(audit[1].activityId, 'job-1');
+  assert.equal(audit[1].workspace, 'docs');
+  store.close();
+});
+
 test('runtime store replays evaluator verdict into state', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
@@ -404,11 +446,15 @@ test('runtime state exposes queue as blocked jobs and pending plan steps', () =>
     { id: 'q-done', workspace: 'docs', status: 'done', args: { type: 'done' } },
   ], { workspace: 'docs' });
 
-  const queue = store.getState(session, { workspace: 'docs' }).queue;
+  const state = store.getState(session, { workspace: 'docs' });
+  const queue = state.queue;
   assert.deepEqual(queue.map((item) => item.id), ['q-wait', 'plan-2', 'plan-3']);
   assert.equal(queue[0].queueType, 'blocked_job');
   assert.equal(queue[1].queueType, 'pending_step');
   assert.equal(queue[1].args.type, 'Build');
+  assert.ok(state.workflow.nodes.some((node) => node.id === 'task:2'));
+  assert.ok(state.workflow.nodes.some((node) => node.id === 'queue:q-wait'));
+  assert.ok(state.workflow.waitingReasons.includes('queue:q-wait'));
   store.close();
 });
 

package/src/shell/RightPane.tsx

@@ -1,5 +1,6 @@
 /** @jsxImportSource @opentui/solid */
 import { createMemo, Index, Show } from 'solid-js';
+import { fit } from './textFit';
 
 type PlanStep = { step: number; description: string; status: string };
 type QueueItem = {
@@ -45,13 +46,6 @@ function wrapLine(value: string, width: number) {
   return lines;
 }
 
-function fit(value: string, width: number) {
-  const max = Math.max(1, width);
-  if (value.length <= max) return value;
-  if (max <= 1) return '…';
-  return value.slice(0, max - 1) + '…';
-}
-
 function logLineParts(line: string): LogLineParts {
   const match = line.match(/^((?:\d{1,2}:\d{2}(?::\d{2})?(?:\s?[AP]M)?|\d{4}-\d{2}-\d{2}[T ][0-9:.]+Z?))\s+(.+)$/i);
   if (!match) return { time: null, message: line };