@dotdrelle/wiki-manager 0.6.47 → 0.8.2

package/src/runtime/server.js

@@ -0,0 +1,216 @@
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { runtimeTokenFromEnv } from './auth.js';
+
+export function startRuntimeServer({
+  host = '0.0.0.0',
+  port = 7788,
+  token = runtimeTokenFromEnv(),
+  store,
+  session = null,
+  getContext,
+  run,
+  cancel,
+  resume,
+  approve,
+} = {}) {
+  const clients = new Set();
+  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 client of clients) {
+      if (client.workspace && event.workspace !== client.workspace) continue;
+      client.response.write(payload);
+    }
+  }
+
+  const server = createServer(async (request, response) => {
+    try {
+      if (!isAuthorized(request, token)) {
+        sendJson(response, 401, { error: 'Unauthorized' });
+        return;
+      }
+
+      const url = new URL(request.url ?? '/', `http://${request.headers.host ?? 'localhost'}`);
+      if (request.method === 'GET' && url.pathname === '/health') {
+        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') {
+        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') {
+        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(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') {
+        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;
+        }
+        try {
+          const input = String(body.input ?? body.prompt ?? '').trim();
+          if (!input) {
+            sendJson(response, 400, { error: 'Missing input.' });
+            return;
+          }
+          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) => {
+              context.session?._onRuntimeError?.(err);
+            })
+            .finally(() => {
+              context.running = false;
+              context.currentAbortController = null;
+            });
+          sendJson(response, 202, { accepted: true, runId, workspace: runWorkspace });
+        } catch (err) {
+          context.running = false;
+          context.currentAbortController = null;
+          throw err;
+        }
+        return;
+      }
+      if (request.method === 'POST' && url.pathname === '/cancel') {
+        const workspace = workspaceFromUrl(url);
+        const context = await resolveContext({ workspace });
+        if (!context.running || !context.currentAbortController) {
+          sendJson(response, 200, { cancelled: false, reason: 'no active run' });
+          return;
+        }
+        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;
+      }
+
+      sendJson(response, 404, { error: 'Not found' });
+    } catch (err) {
+      sendJson(response, 500, { error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, host, () => {
+      server.off('error', reject);
+      const address = server.address();
+      resolve({
+        host,
+        port: typeof address === 'object' && address ? address.port : port,
+        publish,
+        close: () => new Promise((closeResolve, closeReject) => {
+          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) {
+  if (!token) return true;
+  const authorization = request.headers.authorization ?? '';
+  if (authorization === `Bearer ${token}`) return true;
+  return request.headers['x-runtime-token'] === token;
+}
+
+function sendJson(response, statusCode, value) {
+  response.writeHead(statusCode, { 'Content-Type': 'application/json' });
+  response.end(`${JSON.stringify(value)}\n`);
+}
+
+function readJson(request) {
+  return new Promise((resolve, reject) => {
+    let raw = '';
+    request.setEncoding('utf8');
+    request.on('data', (chunk) => {
+      raw += chunk;
+      if (raw.length > 1024 * 1024) {
+        reject(new Error('Request body too large.'));
+        request.destroy();
+      }
+    });
+    request.on('end', () => {
+      if (!raw.trim()) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    request.on('error', reject);
+  });
+}

package/src/runtime/server.test.js

@@ -0,0 +1,308 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { startRuntimeServer } from './server.js';
+
+test('runtime server accepts only one active run', async (t) => {
+  let releaseRun;
+  let runCount = 0;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      session: {},
+      run: async () => {
+        runCount += 1;
+        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 url = `http://127.0.0.1:${handle.port}/run`;
+    let acceptedRun = null;
+    const [first, second] = await Promise.all([
+      fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'first' }),
+      }),
+      fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'second' }),
+      }),
+    ]);
+
+    assert.deepEqual([first.status, second.status].sort(), [202, 409]);
+    const accepted = first.status === 202 ? first : second;
+    acceptedRun = await accepted.json();
+    assert.equal(acceptedRun.accepted, true);
+    assert.match(acceptedRun.runId, /^[0-9a-f-]{36}$/);
+    assert.equal(runCount, 1);
+  } finally {
+    releaseRun?.();
+    await handle.close();
+  }
+});
+
+test('runtime server returns the accepted run id and passes it to the runner', async (t) => {
+  let receivedBody = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      session: {},
+      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}/run`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'build', workspace: 'juno', evaluate: false, replans: 1 }),
+    });
+    assert.equal(response.status, 202);
+    const body = await response.json();
+    assert.equal(body.accepted, true);
+    assert.match(body.runId, /^[0-9a-f-]{36}$/);
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(receivedBody.runId, body.runId);
+    assert.equal(receivedBody.workspace, 'juno');
+    assert.equal(receivedBody.evaluate, false);
+    assert.equal(receivedBody.replans, 1);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server isolates active runs by workspace', async (t) => {
+  const releases = new Map();
+  const runWorkspaces = [];
+  const contexts = new Map();
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: (session) => ({ status: session?.running ? 'running' : 'idle' }),
+        listEvents: () => [],
+      },
+      getContext: async (workspace) => {
+        if (!contexts.has(workspace)) {
+          contexts.set(workspace, {
+            workspace,
+            session: { workspace },
+            running: false,
+            currentAbortController: null,
+          });
+        }
+        return contexts.get(workspace);
+      },
+      run: async (context) => {
+        runWorkspaces.push(context.workspace);
+        context.session.running = true;
+        await new Promise((resolve) => { releases.set(context.workspace, resolve); });
+        context.session.running = false;
+      },
+    });
+  } 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}/run`;
+    const [juno, docs] = await Promise.all([
+      fetch(`${url}?workspace=juno`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'first' }),
+      }),
+      fetch(`${url}?workspace=docs`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'second' }),
+      }),
+    ]);
+    assert.deepEqual([juno.status, docs.status], [202, 202]);
+
+    const conflict = await fetch(`${url}?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'third' }),
+    });
+    assert.equal(conflict.status, 409);
+    assert.deepEqual(runWorkspaces.sort(), ['docs', 'juno']);
+  } finally {
+    releases.get('juno')?.();
+    releases.get('docs')?.();
+    await handle.close();
+  }
+});
+
+test('runtime server filters state and events by workspace', async (t) => {
+  let stateWorkspace = null;
+  let eventWorkspace = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: (_session, options) => {
+          stateWorkspace = options.workspace;
+          return { status: 'idle', workspace: options.workspace };
+        },
+        listEvents: (options) => {
+          eventWorkspace = options.workspace;
+          return [{ id: 'e1', workspace: options.workspace }];
+        },
+      },
+      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 state = await fetch(`http://127.0.0.1:${handle.port}/state?workspace=juno`);
+    assert.equal(state.status, 200);
+    assert.equal((await state.json()).workspace, 'juno');
+    assert.equal(stateWorkspace, 'juno');
+
+    const events = await fetch(`http://127.0.0.1:${handle.port}/events?workspace=docs`);
+    assert.equal(events.status, 200);
+    assert.deepEqual(await events.json(), { events: [{ id: 'e1', workspace: 'docs' }] });
+    assert.equal(eventWorkspace, 'docs');
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server exposes manual resume endpoint', async (t) => {
+  let resumedWorkspace = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      run: async () => {},
+      resume: async ({ workspace }) => {
+        resumedWorkspace = workspace;
+        return { resumed: 1, interrupted: 0, workspaces: [{ workspace, resumed: 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}/resume?workspace=juno`, {
+      method: 'POST',
+    });
+    assert.equal(response.status, 202);
+    assert.equal(resumedWorkspace, 'juno');
+    assert.deepEqual(await response.json(), {
+      resumed: 1,
+      interrupted: 0,
+      workspaces: [{ workspace: 'juno', resumed: true }],
+    });
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server exposes approval endpoint', async (t) => {
+  let approved = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      run: async () => {},
+      approve: async (request) => {
+        approved = request;
+        return { approved: true, runId: request.runId, itemId: request.itemId };
+      },
+    });
+  } 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}/approve?workspace=juno&runId=run-1&itemId=item-1`, {
+      method: 'POST',
+    });
+    assert.equal(response.status, 202);
+    assert.deepEqual(approved, {
+      workspace: 'juno',
+      runId: 'run-1',
+      itemId: 'item-1',
+      approvalId: null,
+    });
+    assert.deepEqual(await response.json(), { approved: true, runId: 'run-1', itemId: 'item-1' });
+  } finally {
+    await handle.close();
+  }
+});