@dotdrelle/wiki-manager 0.6.47 → 0.7.3

package/src/runtime/client.js

@@ -0,0 +1,108 @@
+import { runtimeTokenFromEnv as runtimeToken } from './auth.js';
+
+function base(url) {
+  return url.replace(/\/$/, '');
+}
+
+export function runtimeUrlFromEnv() {
+  return process.env.WIKI_MANAGER_RUNTIME_URL ?? 'http://127.0.0.1:7788';
+}
+
+export async function fetchRuntimeState({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+} = {}) {
+  const response = await fetch(`${base(url)}/state`, {
+    headers: runtimeHeaders(token),
+  });
+  if (!response.ok) throw new Error(`Runtime state failed: HTTP ${response.status}`);
+  return response.json();
+}
+
+export async function checkRuntimeHealth({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+} = {}) {
+  const response = await fetch(`${base(url)}/health`, {
+    headers: runtimeHeaders(token),
+  });
+  if (!response.ok) return null;
+  return response.json();
+}
+
+export async function postRuntimeRun(input, {
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+} = {}) {
+  const response = await fetch(`${base(url)}/run`, {
+    method: 'POST',
+    headers: {
+      ...runtimeHeaders(token),
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ input, workspace }),
+  });
+  if (!response.ok) throw new Error(`Runtime run failed: HTTP ${response.status}`);
+  return response.json();
+}
+
+export async function postRuntimeCancel({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+} = {}) {
+  const response = await fetch(`${base(url)}/cancel`, {
+    method: 'POST',
+    headers: runtimeHeaders(token),
+  });
+  if (!response.ok && response.status !== 501) throw new Error(`Runtime cancel failed: HTTP ${response.status}`);
+  return response.json();
+}
+
+function runtimeHeaders(token) {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+
+export async function* streamRuntimeEvents({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  signal = null,
+} = {}) {
+  const response = await fetch(`${base(url)}/events/stream`, {
+    headers: { ...runtimeHeaders(token), Accept: 'text/event-stream' },
+    signal,
+  });
+  if (!response.ok) throw new Error(`Runtime SSE connect failed: HTTP ${response.status}`);
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const blocks = buffer.split('\n\n');
+      buffer = blocks.pop() ?? '';
+      for (const block of blocks) {
+        let type = 'message';
+        let data = '';
+        for (const line of block.split('\n')) {
+          if (line.startsWith('event: ')) type = line.slice(7).trim();
+          else if (line.startsWith('data: ')) data = line.slice(6);
+        }
+        if (!data) continue;
+        try {
+          yield { type, data: JSON.parse(data) };
+        } catch {
+          // malformed frame — skip
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+export function runtimeFetchOptions(token = runtimeToken()) {
+  return { headers: runtimeHeaders(token) };
+}

package/src/runtime/lifecycle.js

@@ -0,0 +1,60 @@
+import { spawn } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { checkRuntimeHealth, runtimeUrlFromEnv } from './client.js';
+import { defaultRuntimeStateDir } from '../core/env.js';
+import { resolveRuntimeAuthToken, runtimeTokenFromEnv } from './auth.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const managerRoot = resolve(__dirname, '../..');
+const binPath = resolve(managerRoot, 'bin/wiki-manager.js');
+
+export async function ensureRuntime({
+  host = process.env.WIKI_MANAGER_RUNTIME_HOST ?? '0.0.0.0',
+  port = Number(process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788),
+  stateDir = process.env.WIKI_MANAGER_STATE_DIR ?? defaultRuntimeStateDir(),
+  url = process.env.WIKI_MANAGER_RUNTIME_URL ?? `http://127.0.0.1:${port}`,
+  timeoutMs = 5000,
+} = {}) {
+  const auth = resolveRuntimeAuthToken({ host, stateDir });
+  if (auth.token) process.env.WIKI_MANAGER_RUNTIME_TOKEN = auth.token;
+  const existing = await runtimeHealthOrNull(url, auth.token);
+  if (existing) return { url, started: false, health: existing, token: auth.token, tokenPath: auth.tokenPath };
+
+  const child = spawn(process.execPath, [
+    binPath,
+    'runtime',
+    '--host',
+    host,
+    '--port',
+    String(port),
+    '--state-dir',
+    stateDir,
+  ], {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      ...(auth.token ? { WIKI_MANAGER_RUNTIME_TOKEN: auth.token } : {}),
+      WIKI_MANAGER_RUNTIME_CHILD: '1',
+    },
+  });
+  child.unref();
+
+  const deadline = Date.now() + timeoutMs;
+  let health = null;
+  while (Date.now() < deadline) {
+    health = await runtimeHealthOrNull(url, auth.token);
+    if (health) return { url, started: true, health, pid: child.pid, token: auth.token, tokenPath: auth.tokenPath };
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 150));
+  }
+  throw new Error(`Runtime did not become healthy at ${url}`);
+}
+
+export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = runtimeTokenFromEnv()) {
+  try {
+    return await checkRuntimeHealth({ url, token });
+  } catch {
+    return null;
+  }
+}

package/src/runtime/queueStore.js

@@ -0,0 +1,6 @@
+import { createQueueStore } from '../core/queueStore.js';
+
+export function createSqliteQueueStore(store, session) {
+  session.jobQueue = store.listQueue();
+  return createQueueStore(session, { persist: () => store.saveQueue(session.jobQueue) });
+}

package/src/runtime/runner.js

@@ -0,0 +1,73 @@
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { sessionActivities, terminalFailures } from '../core/activity.js';
+import { runAgenticLoop, throwIfAborted } from '../core/agentLoop.js';
+import { emitRuntimeLog, pollActivitiesOnce } from './supervisor.js';
+
+async function waitForRuntimeActivities(session, startedActivities, { timeoutMs, signal, pollBusy }) {
+  const deadline = Date.now() + timeoutMs;
+  const trackedKeys = new Set(startedActivities.map((activity) => activity.key));
+  emitRuntimeLog(session, `activity-loop: tracking ${trackedKeys.size} activity(s)`);
+
+  let tracked = [];
+  while (Date.now() < deadline) {
+    throwIfAborted(signal, 'Runtime run cancelled.');
+    await pollActivitiesOnce(session, { pollBusy, signal });
+    tracked = sessionActivities(session).filter((activity) => trackedKeys.has(activity.key));
+    const active = tracked.filter((activity) => !activity.terminal);
+    if (active.length === 0) {
+      const failures = terminalFailures(tracked);
+      if (failures.length > 0) {
+        for (const failure of failures) {
+          emitRuntimeLog(session, `activity-loop: ${failure.label} -> ${failure.status}${failure.error ? ` (${failure.error})` : ''}`);
+        }
+        return { ok: false, completed: tracked };
+      }
+      emitRuntimeLog(session, 'activity-loop: tracked activities terminal');
+      return { ok: true, completed: tracked };
+    }
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 1000));
+  }
+
+  emitRuntimeLog(session, 'activity-loop: timeout');
+  return { ok: false, timedOut: true, completed: tracked };
+}
+
+export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy }) {
+  return runAgenticLoop(agent, session, initialInput, {
+    signal,
+    timeoutMs,
+    maxTurns,
+    runId,
+    abortMessage: 'Runtime run cancelled.',
+    waitForActivities: (turnSession, startedActivities, waitOptions) =>
+      waitForRuntimeActivities(turnSession, startedActivities, { ...waitOptions, pollBusy }),
+    onTurnStart: ({ turn, maxTurns: totalTurns }) => {
+      emitRuntimeLog(session, `agentic-loop: turn ${turn}/${totalTurns}`);
+    },
+    onAssistantMessage: ({ response }) => {
+      const lastMessage = session.agentProjection?.conversation?.at(-1);
+      if (lastMessage?.role !== 'assistant' || lastMessage.content !== response) {
+        dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+          origin: 'agent',
+          runId,
+          payload: { content: response },
+        }));
+      }
+    },
+    onPlanExtracted: ({ steps }) => {
+      emitRuntimeLog(session, `agentic-loop: plan extracted from text (${steps.length} steps)`);
+    },
+    onComplete: () => {
+      emitRuntimeLog(session, 'agentic-loop: no pending activity or plan step');
+    },
+    onPendingSteps: ({ pendingSteps }) => {
+      emitRuntimeLog(session, `agentic-loop: ${pendingSteps.length} pending step(s), continuing`);
+    },
+    onActivitiesStarted: ({ activities }) => {
+      emitRuntimeLog(session, `agentic-loop: ${activities.length} new activity(s), waiting`);
+    },
+    onMaxTurns: ({ maxTurns: totalTurns }) => {
+      emitRuntimeLog(session, `agentic-loop: max turns (${totalTurns}) reached`);
+    },
+  });
+}

package/src/runtime/server.js

@@ -0,0 +1,160 @@
+import { createServer } from 'node:http';
+import { runtimeTokenFromEnv } from './auth.js';
+
+export function startRuntimeServer({
+  host = '0.0.0.0',
+  port = 7788,
+  token = runtimeTokenFromEnv(),
+  store,
+  session,
+  run,
+  cancel,
+} = {}) {
+  const clients = new Set();
+  let running = false;
+  let currentAbortController = null;
+
+  function publish(event) {
+    const payload = `event: agent_event\ndata: ${JSON.stringify(event)}\n\n`;
+    for (const response of clients) {
+      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') {
+        sendJson(response, 200, { ok: true, status: running ? 'running' : 'idle', dbPath: store.dbPath });
+        return;
+      }
+      if (request.method === 'GET' && url.pathname === '/state') {
+        sendJson(response, 200, store.getState(session));
+        return;
+      }
+      if (request.method === 'GET' && url.pathname === '/events') {
+        sendJson(response, 200, { events: store.listEvents() });
+        return;
+      }
+      if (request.method === 'GET' && url.pathname === '/events/stream') {
+        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));
+        return;
+      }
+      if (request.method === 'POST' && url.pathname === '/run') {
+        if (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 });
+        } catch (err) {
+          running = false;
+          currentAbortController = null;
+          throw err;
+        }
+        return;
+      }
+      if (request.method === 'POST' && url.pathname === '/cancel') {
+        if (!running || !currentAbortController) {
+          sendJson(response, 200, { cancelled: false, reason: 'no active run' });
+          return;
+        }
+        currentAbortController.abort();
+        await cancel?.();
+        sendJson(response, 202, { cancelled: true });
+        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 response of clients) response.end();
+          clients.clear();
+          server.close((err) => (err ? closeReject(err) : closeResolve()));
+        }),
+      });
+    });
+  });
+}
+
+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,53 @@
+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`;
+    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]);
+    assert.equal(runCount, 1);
+  } finally {
+    releaseRun?.();
+    await handle.close();
+  }
+});