@dotdrelle/wiki-manager 0.7.3 → 0.9.3

package/src/runtime/server.js

@@ -1,4 +1,6 @@
 import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { runtimeTokenFromEnv } from './auth.js';
 
 export function startRuntimeServer({
@@ -6,18 +8,24 @@ export function startRuntimeServer({
   port = 7788,
   token = runtimeTokenFromEnv(),
   store,
-  session,
+  session = null,
+  getContext,
   run,
   cancel,
+  resume,
+  approve,
+  configProfiles,
+  useConfigProfile,
 } = {}) {
   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 +38,157 @@ 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 === '/control') {
+        const workspace = workspaceFromUrl(url);
+        const context = await resolveContext({ workspace });
+        sendJson(response, 200, controlStatus(context, store));
+        return;
+      }
+      if (request.method === 'POST' && url.pathname === '/control') {
+        const { body, context } = await resolveBodyContext(request, url);
+        const action = String(body.action ?? 'status').trim().toLowerCase();
+        if (action === 'status') {
+          sendJson(response, 200, controlStatus(context, store));
+          return;
+        }
+        if (action === 'explain') {
+          const status = controlStatus(context, store);
+          sendJson(response, 200, { ...status, explanation: explainControlState(status) });
+          return;
+        }
+        if (action === 'enqueue') {
+          const input = String(body.input ?? body.prompt ?? body.request ?? '').trim();
+          if (!input) {
+            sendJson(response, 400, { error: 'Missing input.' });
+            return;
+          }
+          const item = enqueueControlRequest(context, input);
+          void startNextControlRequest(context);
+          sendJson(response, 202, {
+            accepted: true,
+            item,
+            ...controlStatus(context, store),
+          });
+          return;
+        }
+        sendJson(response, 400, { error: 'Unsupported control action.' });
+        return;
+      }
+      if (request.method === 'GET' && url.pathname === '/config/profiles') {
+        if (typeof configProfiles !== 'function') {
+          sendJson(response, 501, { error: 'Config profiles are not supported.' });
+          return;
+        }
+        const workspace = workspaceFromUrl(url);
+        const context = await resolveContext({ workspace });
+        const result = await configProfiles(context);
+        sendJson(response, 200, result);
+        return;
+      }
+      if (request.method === 'POST' && url.pathname === '/config/use') {
+        if (typeof useConfigProfile !== 'function') {
+          sendJson(response, 501, { error: 'Config profile switching is not supported.' });
+          return;
+        }
+        const { body, context } = await resolveBodyContext(request, url);
+        if (context.running) {
+          sendJson(response, 409, { error: 'Cannot switch config while a runtime run is active.' });
+          return;
+        }
+        const profile = String(body.profile ?? '').trim();
+        if (!profile) {
+          sendJson(response, 400, { error: 'Missing profile.' });
+          return;
+        }
+        const result = await useConfigProfile(context, profile);
+        sendJson(response, 200, result);
         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, context } = await resolveBodyContext(request, url);
+        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 })
-            .catch((err) => {
-              session._onRuntimeError?.(err);
-            })
-            .finally(() => {
-              running = false;
-              currentAbortController = null;
-            });
-          sendJson(response, 202, { accepted: true });
+          const accepted = startRuntimeRun(context, body);
+          sendJson(response, 202, accepted);
         } 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;
       }
 
@@ -111,14 +207,137 @@ export function startRuntimeServer({
         host,
         port: typeof address === 'object' && address ? address.port : port,
         publish,
+        drainControl: (context) => startNextControlRequest(context),
         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);
+  }
+
+  // Shared by POST handlers that take a JSON body carrying an optional
+  // `workspace` field: read the body, resolve the target workspace (body
+  // wins over the `?workspace=` query param), then resolve its context.
+  async function resolveBodyContext(request, url) {
+    const body = await readJson(request);
+    const workspace = workspaceFromBody(body) ?? workspaceFromUrl(url);
+    const context = await resolveContext({ workspace });
+    return { body, workspace, context };
+  }
+
+  function startRuntimeRun(context, body, { controlItemId = null } = {}) {
+    const runId = randomUUID();
+    const runWorkspace = context.workspace ?? body.workspace ?? null;
+    context.running = true;
+    context.currentAbortController = new AbortController();
+    const runBody = { ...body, workspace: runWorkspace, runId };
+    if (controlItemId) {
+      dispatchAgentEvent(context.session, createAgentEvent('control_started', {
+        origin: 'runtime',
+        runId,
+        workspace: runWorkspace,
+        payload: { id: controlItemId, runId },
+      }));
+    }
+    const runPromise = run(context, runBody, { signal: context.currentAbortController.signal, runId });
+    runPromise
+      .catch((err) => {
+        context.session?._onRuntimeError?.(err);
+      })
+      .finally(() => {
+        context.running = false;
+        context.currentAbortController = null;
+        void startNextControlRequest(context);
+      });
+    return { accepted: true, runId, workspace: runWorkspace };
+  }
+
+  function startNextControlRequest(context) {
+    if (!context?.session || context.running) return false;
+    const item = controlQueueFor(context.session).find((entry) => entry.status === 'queued');
+    if (!item) return false;
+    startRuntimeRun(context, {
+      input: item.input,
+      workspace: item.workspace ?? context.workspace ?? null,
+    }, { controlItemId: item.id });
+    return true;
+  }
+}
+
+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 controlStatus(context, store) {
+  const workspace = context?.workspace ?? context?.session?.workspace ?? null;
+  const state = store.getState(context?.session ?? null, { workspace });
+  return {
+    ok: true,
+    workspace,
+    status: context?.running ? 'running' : state.status ?? 'idle',
+    running: Boolean(context?.running),
+    plan: Array.isArray(state.plan) ? state.plan : [],
+    queue: Array.isArray(state.queue) ? state.queue : [],
+    controlQueue: controlQueueFor(context?.session),
+    approvals: Array.isArray(state.approvals) ? state.approvals : [],
+    summary: state.summary ?? null,
+  };
+}
+
+function explainControlState(status) {
+  if (status.running) {
+    const runningStep = status.plan.find((step) => step.status === 'running');
+    return runningStep
+      ? `Runtime run is active. Current step: ${runningStep.description ?? runningStep.label ?? runningStep.step}.`
+      : 'Runtime run is active. No current plan step is available yet.';
+  }
+  const pendingApproval = status.approvals.find((approval) => approval.status === 'pending_approval');
+  if (pendingApproval) {
+    return `Runtime is waiting for approval: ${pendingApproval.reason ?? pendingApproval.id}.`;
+  }
+  const queued = status.controlQueue.filter((item) => item.status === 'queued');
+  if (queued.length > 0) {
+    return `${queued.length} control request${queued.length === 1 ? '' : 's'} queued. They are not applied to the active plan automatically.`;
+  }
+  if (status.plan.some((step) => step.status === 'pending')) {
+    return 'Runtime is idle with pending plan steps visible from the last run.';
+  }
+  return 'Runtime is idle.';
+}
+
+function controlQueueFor(session) {
+  return Array.isArray(session?.controlQueue) ? session.controlQueue : [];
+}
+
+function enqueueControlRequest(context, input) {
+  const now = new Date().toISOString();
+  const item = {
+    id: `control-${randomUUID()}`,
+    workspace: context?.workspace ?? context?.session?.workspace ?? null,
+    type: 'run_request',
+    input,
+    status: 'queued',
+    createdAt: now,
+    updatedAt: now,
+  };
+  dispatchAgentEvent(context.session, createAgentEvent('control_enqueued', {
+    origin: 'runtime',
+    workspace: item.workspace,
+    payload: item,
+  }));
+  return item;
 }
 
 function isAuthorized(request, token) {