@dotdrelle/wiki-manager 0.6.34 → 0.7.3

package/src/core/queueStore.js

@@ -0,0 +1,27 @@
+export function createQueueStore(session, { persist = () => {} } = {}) {
+  session.jobQueue ??= [];
+  return {
+    list() {
+      session.jobQueue ??= [];
+      return session.jobQueue;
+    },
+    replace(queue) {
+      session.jobQueue = Array.isArray(queue) ? queue : [];
+      persist();
+      return session.jobQueue;
+    },
+    changed() {
+      session.jobQueue ??= [];
+      persist();
+    },
+  };
+}
+
+export function createMemoryQueueStore(session) {
+  return createQueueStore(session, { persist: () => session._onQueueUpdate?.(session.jobQueue) });
+}
+
+export function queueStoreFor(session) {
+  session.queueStore ??= createMemoryQueueStore(session);
+  return session.queueStore;
+}

package/src/core/queueStore.test.js

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { enqueueProductionJob, ensureJobQueue } from './jobQueue.js';
+
+test('job queue uses an injected queue store', () => {
+  const queue = [];
+  let changed = 0;
+  const session = {
+    workspace: 'docs',
+    queueStore: {
+      list() {
+        return queue;
+      },
+      replace(next) {
+        queue.splice(0, queue.length, ...next);
+        changed += 1;
+        return queue;
+      },
+      changed() {
+        changed += 1;
+      },
+    },
+  };
+
+  const item = enqueueProductionJob(session, { type: 'build' }, 'workspace_busy');
+
+  assert.equal(item.workspace, 'docs');
+  assert.equal(queue.length, 1);
+  assert.equal(ensureJobQueue(session), queue);
+  assert.equal(changed, 1);
+});

package/src/core/startupCheck.js

@@ -92,7 +92,7 @@ function checkWikirc(workspace) {
       profileName: loaded.profile.name,
     };
     const gaps = [];
-    if (!summary.hasApiKey || !summary.model) gaps.push({ kind: 'llm', context });
+    if (!summary.provider || !summary.baseUrl || !summary.hasApiKey || !summary.model) gaps.push({ kind: 'llm', context });
     if (!summary.vectorEnabled) gaps.push({ kind: 'vector', context });
     return gaps;
   } catch {

package/src/core/startupCheck.test.js

@@ -0,0 +1,66 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { runChecks } from './startupCheck.js';
+
+async function withWorkspace(wikircLines, fn) {
+  const root = await mkdtemp(join(tmpdir(), 'wiki-manager-startup-check-'));
+  const registryRoot = join(root, 'registry');
+  const registryPath = join(registryRoot, 'demo');
+  const workspacePath = join(root, 'workspace');
+  mkdirSync(registryPath, { recursive: true });
+  mkdirSync(workspacePath, { recursive: true });
+  writeFileSync(join(registryPath, '.env'), [
+    'WORKSPACE_NAME=demo',
+    `WIKI_WORKSPACE_PATH=${workspacePath}`,
+    '',
+  ].join('\n'), 'utf8');
+  writeFileSync(join(workspacePath, '.wikirc.yaml'), [...wikircLines, ''].join('\n'), 'utf8');
+
+  const previousDir = process.env.WIKI_WORKSPACES_DIR;
+  process.env.WIKI_WORKSPACES_DIR = registryRoot;
+  try {
+    await fn({ workspacePath });
+  } finally {
+    if (previousDir === undefined) delete process.env.WIKI_WORKSPACES_DIR;
+    else process.env.WIKI_WORKSPACES_DIR = previousDir;
+  }
+}
+
+function hasGap(gaps, kind) {
+  return gaps.some((gap) => gap.kind === kind);
+}
+
+test('runChecks treats default LLM config without baseUrl as incomplete', async () => {
+  await withWorkspace([
+    'llm:',
+    '  provider: openai-compatible',
+    '  apiKey: key',
+    '  model: chat-model',
+    'retrieval:',
+    '  vector:',
+    '    enabled: true',
+  ], async () => {
+    const gaps = await runChecks();
+    assert.equal(hasGap(gaps, 'llm'), true);
+  });
+});
+
+test('runChecks treats default LLM config with provider, baseUrl, apiKey and model as complete', async () => {
+  await withWorkspace([
+    'llm:',
+    '  provider: openai-compatible',
+    '  baseUrl: http://localhost:8000/v1',
+    '  apiKey: key',
+    '  model: chat-model',
+    'retrieval:',
+    '  vector:',
+    '    enabled: true',
+  ], async () => {
+    const gaps = await runChecks();
+    assert.equal(hasGap(gaps, 'llm'), false);
+  });
+});

package/src/core/wikirc.js

@@ -29,8 +29,8 @@ export function resolveWikircProfile(workspacePath, profileName = 'default') {
   const normalized = profileName || 'default';
   const found = profiles.find((profile) => profile.name === normalized || profile.fileName === normalized);
   if (!found) {
-    const available = profiles.map((profile) => profile.name).join(', ') || 'aucun';
-    throw new Error(`profil wikirc introuvable: ${normalized} (disponibles: ${available})`);
+    const available = profiles.map((profile) => profile.name).join(', ') || 'none';
+    throw new Error(`wikirc profile not found: ${normalized} (available: ${available})`);
   }
   return found;
 }

package/src/core/workspaces.js

@@ -33,12 +33,19 @@ export function listWorkspaces() {
       if (!existsSync(envFile)) return [];
       const env = readEnvFile(envFile);
       const workspacePath = env.WIKI_WORKSPACE_PATH || registryPath;
+      let resolvedWorkspacePath;
+      try {
+        resolvedWorkspacePath = realpathSync.native?.(workspacePath) ?? realpathSync(workspacePath);
+      } catch {
+        // Host-absolute WIKI_WORKSPACE_PATH not accessible here (e.g. inside a container); use registry dir.
+        resolvedWorkspacePath = registryPath;
+      }
       return [
         {
           name: env.WORKSPACE_NAME || entry.name,
           registryPath,
           envFile,
-          workspacePath: realpathSync.native?.(workspacePath) ?? realpathSync(workspacePath),
+          workspacePath: resolvedWorkspacePath,
           env,
         },
       ];

package/src/runtime/auth.js

@@ -0,0 +1,35 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { defaultRuntimeStateDir } from '../core/env.js';
+
+export function runtimeTokenPath(stateDir = defaultRuntimeStateDir()) {
+  return join(resolve(stateDir), 'runtime.token');
+}
+
+export function runtimeTokenFromEnv() {
+  return process.env.WIKI_MANAGER_RUNTIME_TOKEN ?? process.env.RUNTIME_AUTH_TOKEN ?? null;
+}
+
+export function resolveRuntimeAuthToken({
+  host = '127.0.0.1',
+  stateDir = defaultRuntimeStateDir(),
+  explicitToken = runtimeTokenFromEnv(),
+} = {}) {
+  if (explicitToken) return { token: explicitToken, source: 'env', tokenPath: null };
+  if (!isExposedHost(host)) return { token: null, source: 'none', tokenPath: null };
+
+  const tokenPath = runtimeTokenPath(stateDir);
+  if (existsSync(tokenPath)) {
+    const token = readFileSync(tokenPath, 'utf8').trim();
+    if (token) return { token, source: 'file', tokenPath };
+  }
+  const token = randomBytes(32).toString('hex');
+  mkdirSync(resolve(stateDir), { recursive: true });
+  writeFileSync(tokenPath, `${token}\n`, { mode: 0o600 });
+  return { token, source: 'generated', tokenPath };
+}
+
+export function isExposedHost(host) {
+  return ['0.0.0.0', '::', '[::]'].includes(String(host ?? '').trim());
+}

package/src/runtime/auth.test.js

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { resolveRuntimeAuthToken } from './auth.js';
+
+test('resolveRuntimeAuthToken: loopback host does not require token', () => {
+  const result = resolveRuntimeAuthToken({ host: '127.0.0.1', explicitToken: null });
+  assert.equal(result.token, null);
+  assert.equal(result.source, 'none');
+});
+
+test('resolveRuntimeAuthToken: exposed host generates and reuses token', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-auth-'));
+  const first = resolveRuntimeAuthToken({ host: '0.0.0.0', stateDir, explicitToken: null });
+  const second = resolveRuntimeAuthToken({ host: '0.0.0.0', stateDir, explicitToken: null });
+  assert.equal(first.source, 'generated');
+  assert.equal(second.source, 'file');
+  assert.equal(second.token, first.token);
+});

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);
+  });
+}