@dotdrelle/wiki-manager 0.7.3 → 0.8.2

package/src/runtime/runner.test.js

@@ -0,0 +1,270 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { finishRuntimeRun, runRuntimeAgenticWorkflow } from './runner.js';
+
+test('finishRuntimeRun emits evaluation before run_done', async () => {
+  const events = [];
+  const session = {
+    activities: {},
+    headlessPlan: [
+      { step: 1, description: 'Analyze', status: 'done' },
+      { step: 2, description: 'Execute', status: 'done' },
+    ],
+    agentProjection: {
+      conversation: [{ role: 'assistant', content: 'Done.' }],
+    },
+    llm: {
+      async completeWithTools({ system, tools, messages }) {
+        assert.match(system, /strict evaluator/);
+        assert.deepEqual(tools, []);
+        assert.match(messages[0].content, /Original task:/);
+        return { content: '{"ok":true,"reason":"Task complete.","suggestedAction":null}' };
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+
+  const result = await finishRuntimeRun(session, 'Build workspace', { runId: 'run-1' });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(events.map((event) => event.type), ['runtime_log', 'run_evaluated', 'run_done']);
+  assert.equal(session.agentProjection.evaluation.ok, true);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('finishRuntimeRun turns negative evaluation into run_error', async () => {
+  const events = [];
+  const session = {
+    activities: {},
+    headlessPlan: [{ step: 1, description: 'Export', status: 'done' }],
+    agentProjection: {
+      conversation: [{ role: 'assistant', content: 'Done.' }],
+    },
+    llm: {
+      async completeWithTools() {
+        return { content: '{"ok":false,"reason":"Export file missing.","suggestedAction":"Run export again."}' };
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+
+  const result = await finishRuntimeRun(session, 'Export deliverable', { runId: 'run-2' });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.evaluationRejected, true);
+  assert.deepEqual(events.map((event) => event.type), ['runtime_log', 'run_evaluated', 'run_error']);
+  assert.equal(session.agentProjection.evaluation.ok, false);
+  assert.equal(session.agentProjection.status, 'error');
+  assert.match(session.agentProjection.logs.at(-1), /Export file missing/);
+});
+
+test('finishRuntimeRun falls back open when evaluator response is invalid', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+    agentProjection: { conversation: [] },
+    llm: {
+      async completeWithTools() {
+        return { content: 'not json' };
+      },
+    },
+  };
+
+  const result = await finishRuntimeRun(session, 'Do work', { runId: 'run-3' });
+
+  assert.equal(result.ok, true);
+  assert.equal(session.agentProjection.evaluation.ok, true);
+  assert.match(session.agentProjection.evaluation.reason, /Evaluator unavailable/);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('finishRuntimeRun can skip evaluation', async () => {
+  let called = false;
+  const session = {
+    activities: {},
+    headlessPlan: null,
+    agentProjection: { conversation: [] },
+    llm: {
+      async completeWithTools() {
+        called = true;
+        return { content: '{"ok":true,"reason":"ok"}' };
+      },
+    },
+  };
+
+  const result = await finishRuntimeRun(session, 'Do work', { runId: 'run-4', evaluate: false });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.evaluation, null);
+  assert.equal(called, false);
+  assert.equal(session.agentProjection.evaluation, null);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('runRuntimeAgenticWorkflow replans after negative evaluation', async () => {
+  const events = [];
+  const llmCalls = [];
+  const session = {
+    activities: {},
+    headlessPlan: null,
+    llm: {
+      async completeWithTools({ system }) {
+        llmCalls.push(system);
+        if (/strict evaluator/.test(system) && llmCalls.length === 1) {
+          return { content: '{"ok":false,"reason":"Export missing.","suggestedAction":"Run export."}' };
+        }
+        if (/replanner/.test(system)) {
+          return { content: '{"steps":["Run export"]}' };
+        }
+        return { content: '{"ok":true,"reason":"Export complete.","suggestedAction":null}' };
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  let turns = 0;
+  const agent = {
+    async invoke({ session: turnSession }) {
+      turns += 1;
+      if (turnSession.headlessPlan?.[0]?.status === 'pending') {
+        dispatchAgentEvent(turnSession, createAgentEvent('plan_step_updated', {
+          origin: 'tool',
+          payload: { step: 1, status: 'done' },
+        }));
+      }
+      return { response: turns === 1 ? 'Initial done.' : 'Export done.' };
+    },
+  };
+
+  const result = await runRuntimeAgenticWorkflow(agent, session, 'Export deliverable', {
+    runId: 'run-replan-eval',
+    timeoutMs: 1000,
+    maxTurns: 2,
+    maxReplans: 1,
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(turns, 2);
+  assert.ok(events.some((event) => event.type === 'run_replanned'));
+  assert.deepEqual(session.agentProjection.replans[0].plan, ['Run export']);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('runRuntimeAgenticWorkflow replans after terminal activity error', async () => {
+  const originalFetch = globalThis.fetch;
+  let pollAttempts = 0;
+  globalThis.fetch = async () => {
+    pollAttempts += 1;
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({
+        result: {
+          content: [{ type: 'text', text: JSON.stringify({
+            _activity: {
+              id: 'job-failed',
+              source: 'production',
+              label: 'Production build',
+              status: 'error',
+              terminal: true,
+              error: 'build failed',
+            },
+          }) }],
+        },
+      }),
+    };
+  };
+  const session = {
+    mcp: {
+      production: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3000/mcp/',
+        retry: { maxAttempts: 1, backoffMs: 0 },
+      },
+    },
+    activities: {},
+    headlessPlan: null,
+    llm: {
+      async completeWithTools({ system }) {
+        if (/replanner/.test(system)) return { content: '{"steps":["Retry build"]}' };
+        return { content: '{"ok":true,"reason":"Build complete.","suggestedAction":null}' };
+      },
+    },
+  };
+  let turns = 0;
+  const agent = {
+    async invoke({ session: turnSession }) {
+      turns += 1;
+      if (turns === 1) {
+        dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+          payload: {
+            activity: {
+              id: 'job-failed',
+              source: 'production',
+              label: 'Production build',
+              status: 'running',
+              terminal: false,
+              poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-failed' }, intervalMs: 0 },
+            },
+          },
+        }));
+        return { response: 'Started build.' };
+      }
+      if (turnSession.headlessPlan?.[0]?.status === 'pending') {
+        dispatchAgentEvent(turnSession, createAgentEvent('plan_step_updated', {
+          origin: 'tool',
+          payload: { step: 1, status: 'done' },
+        }));
+      }
+      return { response: 'Retry done.' };
+    },
+  };
+
+  try {
+    const result = await runRuntimeAgenticWorkflow(agent, session, 'Build workspace', {
+      runId: 'run-replan-activity',
+      timeoutMs: 1000,
+      maxTurns: 3,
+      maxReplans: 1,
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(pollAttempts, 1);
+    assert.equal(turns, 2);
+    assert.equal(session.agentProjection.replans[0].reason, 'Production build ended with error: build failed');
+    assert.deepEqual(session.agentProjection.replans[0].plan, ['Retry build']);
+    assert.equal(session.agentProjection.status, 'done');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('runRuntimeAgenticWorkflow stops after replan budget is exhausted', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+    llm: {
+      async completeWithTools() {
+        return { content: '{"ok":false,"reason":"Still missing.","suggestedAction":"Try again."}' };
+      },
+    },
+  };
+  const agent = {
+    async invoke() {
+      return { response: 'Done.' };
+    },
+  };
+
+  const result = await runRuntimeAgenticWorkflow(agent, session, 'Do task', {
+    runId: 'run-replan-limit',
+    timeoutMs: 1000,
+    maxTurns: 1,
+    maxReplans: 0,
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.evaluationRejected, true);
+  assert.equal(session.agentProjection.status, 'error');
+  assert.equal(session.agentProjection.replans.length, 0);
+});

package/src/runtime/server.js

@@ -1,4 +1,5 @@
 import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
 import { runtimeTokenFromEnv } from './auth.js';
 
 export function startRuntimeServer({
@@ -6,18 +7,22 @@ export function startRuntimeServer({
   port = 7788,
   token = runtimeTokenFromEnv(),
   store,
-  session,
+  session = null,
+  getContext,
   run,
   cancel,
+  resume,
+  approve,
 } = {}) {
   const clients = new Set();
-  let running = false;
-  let currentAbortController = null;
+  const defaultContext = { workspace: null, session, running: false, currentAbortController: null };
+  const resolvedGetContext = getContext ?? (() => defaultContext);
 
   function publish(event) {
     const payload = `event: agent_event\ndata: ${JSON.stringify(event)}\n\n`;
-    for (const response of clients) {
-      response.write(payload);
+    for (const client of clients) {
+      if (client.workspace && event.workspace !== client.workspace) continue;
+      client.response.write(payload);
     }
   }
 
@@ -30,69 +35,106 @@ export function startRuntimeServer({
 
       const url = new URL(request.url ?? '/', `http://${request.headers.host ?? 'localhost'}`);
       if (request.method === 'GET' && url.pathname === '/health') {
-        sendJson(response, 200, { ok: true, status: running ? 'running' : 'idle', dbPath: store.dbPath });
+        const workspace = workspaceFromUrl(url);
+        const context = workspace ? await resolveContext({ workspace }) : null;
+        sendJson(response, 200, {
+          ok: true,
+          status: context?.running ? 'running' : 'idle',
+          workspace: context?.workspace ?? workspace ?? null,
+          dbPath: store.dbPath,
+        });
         return;
       }
       if (request.method === 'GET' && url.pathname === '/state') {
-        sendJson(response, 200, store.getState(session));
+        const workspace = workspaceFromUrl(url);
+        const context = workspace ? await resolveContext({ workspace }) : null;
+        sendJson(response, 200, store.getState(context?.session ?? session, { workspace }));
         return;
       }
       if (request.method === 'GET' && url.pathname === '/events') {
-        sendJson(response, 200, { events: store.listEvents() });
+        const workspace = workspaceFromUrl(url);
+        sendJson(response, 200, { events: store.listEvents({ workspace }) });
         return;
       }
       if (request.method === 'GET' && url.pathname === '/events/stream') {
+        const workspace = workspaceFromUrl(url);
+        const context = workspace ? await resolveContext({ workspace }) : null;
         response.writeHead(200, {
           'Content-Type': 'text/event-stream',
           'Cache-Control': 'no-cache',
           Connection: 'keep-alive',
           'X-Accel-Buffering': 'no',
         });
-        response.write(`event: state\ndata: ${JSON.stringify(store.getState(session))}\n\n`);
-        clients.add(response);
-        request.on('close', () => clients.delete(response));
+        response.write(`event: state\ndata: ${JSON.stringify(store.getState(context?.session ?? session, { workspace }))}\n\n`);
+        const client = { response, workspace };
+        clients.add(client);
+        request.on('close', () => clients.delete(client));
         return;
       }
       if (request.method === 'POST' && url.pathname === '/run') {
-        if (running) {
+        const body = await readJson(request);
+        const workspace = workspaceFromBody(body) ?? workspaceFromUrl(url);
+        const context = await resolveContext({ workspace });
+        if (context.running) {
           sendJson(response, 409, { error: 'A runtime run is already active.' });
           return;
         }
-        running = true;
-        currentAbortController = new AbortController();
         try {
-          const body = await readJson(request);
           const input = String(body.input ?? body.prompt ?? '').trim();
           if (!input) {
-            running = false;
-            currentAbortController = null;
             sendJson(response, 400, { error: 'Missing input.' });
             return;
           }
-          run(body, { signal: currentAbortController.signal })
+          const runId = randomUUID();
+          const runWorkspace = context.workspace ?? workspace ?? null;
+          context.running = true;
+          context.currentAbortController = new AbortController();
+          const runBody = { ...body, workspace: runWorkspace, runId };
+          const runPromise = run(context, runBody, { signal: context.currentAbortController.signal, runId });
+          runPromise
             .catch((err) => {
-              session._onRuntimeError?.(err);
+              context.session?._onRuntimeError?.(err);
             })
             .finally(() => {
-              running = false;
-              currentAbortController = null;
+              context.running = false;
+              context.currentAbortController = null;
             });
-          sendJson(response, 202, { accepted: true });
+          sendJson(response, 202, { accepted: true, runId, workspace: runWorkspace });
         } catch (err) {
-          running = false;
-          currentAbortController = null;
+          context.running = false;
+          context.currentAbortController = null;
           throw err;
         }
         return;
       }
       if (request.method === 'POST' && url.pathname === '/cancel') {
-        if (!running || !currentAbortController) {
+        const workspace = workspaceFromUrl(url);
+        const context = await resolveContext({ workspace });
+        if (!context.running || !context.currentAbortController) {
           sendJson(response, 200, { cancelled: false, reason: 'no active run' });
           return;
         }
-        currentAbortController.abort();
-        await cancel?.();
-        sendJson(response, 202, { cancelled: true });
+        context.currentAbortController.abort();
+        await cancel?.(context);
+        sendJson(response, 202, { cancelled: true, workspace: context.workspace ?? workspace ?? null });
+        return;
+      }
+      if (request.method === 'POST' && url.pathname === '/resume') {
+        const workspace = workspaceFromUrl(url);
+        const result = await resume?.({ workspace });
+        sendJson(response, 202, result ?? { resumed: false, workspace: workspace ?? null });
+        return;
+      }
+      if (request.method === 'POST' && url.pathname === '/approve') {
+        const body = await readJson(request);
+        const workspace = workspaceFromBody(body) ?? workspaceFromUrl(url);
+        const result = await approve?.({
+          workspace,
+          runId: url.searchParams.get('runId') ?? body.runId ?? null,
+          itemId: url.searchParams.get('itemId') ?? body.itemId ?? null,
+          approvalId: url.searchParams.get('approvalId') ?? body.approvalId ?? null,
+        });
+        sendJson(response, result?.approved ? 202 : 404, result ?? { approved: false });
         return;
       }
 
@@ -112,13 +154,27 @@ export function startRuntimeServer({
         port: typeof address === 'object' && address ? address.port : port,
         publish,
         close: () => new Promise((closeResolve, closeReject) => {
-          for (const response of clients) response.end();
+          for (const client of clients) client.response.end();
           clients.clear();
           server.close((err) => (err ? closeReject(err) : closeResolve()));
         }),
       });
     });
   });
+
+  async function resolveContext({ workspace = null } = {}) {
+    return resolvedGetContext(workspace);
+  }
+}
+
+function workspaceFromUrl(url) {
+  const workspace = url.searchParams.get('workspace');
+  return workspace ? workspace.trim() || null : null;
+}
+
+function workspaceFromBody(body) {
+  const workspace = body?.workspace;
+  return workspace == null ? null : String(workspace).trim() || null;
 }
 
 function isAuthorized(request, token) {