@dotdrelle/wiki-manager 0.6.47 → 0.7.3

package/src/core/agentLoop.js

@@ -0,0 +1,164 @@
+import { buildAgentSystemPrompt, buildLimitedAgentResponse } from '../agent/graph.js';
+import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
+import { activitySnapshot, newNonTerminalActivities } from './activity.js';
+import { extractHeadlessPlan, formatCompletedActivities, formatPlanStatus } from './plan.js';
+
+export function abortError(message = 'Agent run cancelled.') {
+  const err = new Error(message);
+  err.name = 'AbortError';
+  return err;
+}
+
+export function throwIfAborted(signal, message) {
+  if (signal?.aborted) throw abortError(message);
+}
+
+export async function runAgentTurn(agent, session, input, {
+  messages = [],
+  signal = null,
+} = {}) {
+  let streamedContent = '';
+  session._onStream = (delta) => { streamedContent += delta; };
+  session._onStreamReset = () => { streamedContent = ''; };
+  let result;
+  try {
+    result = await agent.invoke({ input, session, messages });
+  } finally {
+    delete session._onStream;
+    delete session._onStreamReset;
+  }
+  if (result.streamedInline) {
+    return streamedContent.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+  }
+  if (result.response != null) return result.response;
+  if (result.readyToStream && session.llm?.stream) {
+    const { system, messages: streamMessages = [] } = result.streamContext ?? {};
+    let content = '';
+    for await (const delta of session.llm.stream({
+      system: system ?? buildAgentSystemPrompt({ input, session }),
+      messages: streamMessages,
+      signal,
+    })) {
+      content += delta;
+    }
+    return content.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+  }
+  return buildLimitedAgentResponse({ input, session });
+}
+
+export async function runAgenticLoop(agent, session, initialInput, {
+  maxTurns,
+  timeoutMs,
+  signal = null,
+  runId = null,
+  runTurn = runAgentTurn,
+  waitForActivities,
+  planOrigin = 'llm',
+  onTurnStart = null,
+  onTurnResponse = null,
+  onAssistantMessage = null,
+  onPlanExtracted = null,
+  onPlanAlreadySet = null,
+  onComplete = null,
+  onPendingSteps = null,
+  onActivitiesStarted = null,
+  onActivitiesCompleted = null,
+  onMaxTurns = null,
+  abortMessage = 'Agent run cancelled.',
+} = {}) {
+  if (!waitForActivities) throw new Error('runAgenticLoop requires waitForActivities.');
+  const conversationHistory = [];
+  let currentInput = initialInput;
+
+  for (let turn = 1; turn <= maxTurns; turn += 1) {
+    throwIfAborted(signal, abortMessage);
+    onTurnStart?.({ turn, maxTurns });
+
+    const snapshot = activitySnapshot(session);
+    const response = await runTurn(agent, session, currentInput, {
+      messages: conversationHistory,
+      signal,
+    });
+    onTurnResponse?.({ turn, response });
+    onAssistantMessage?.({ response, runId });
+
+    conversationHistory.push(
+      { role: 'user', content: currentInput },
+      { role: 'assistant', content: response },
+    );
+
+    if (turn === 1) {
+      if (session.headlessPlan === null) {
+        const extractedPlan = extractHeadlessPlan(response);
+        if (extractedPlan) {
+          dispatchAgentEvent(session, createAgentEvent('plan_set', {
+            origin: planOrigin,
+            runId,
+            payload: { steps: extractedPlan },
+          }));
+          onPlanExtracted?.({ steps: session.headlessPlan ?? extractedPlan, fallback: true });
+        }
+      } else {
+        onPlanAlreadySet?.({ steps: session.headlessPlan });
+      }
+    }
+
+    const newPending = newNonTerminalActivities(snapshot, session);
+    if (newPending.length === 0) {
+      const pendingSteps = (session.headlessPlan ?? []).filter((step) => step.status === 'pending');
+      if (pendingSteps.length === 0) {
+        onComplete?.();
+        return { ok: true };
+      }
+      onPendingSteps?.({ pendingSteps });
+      currentInput = pendingStepsPrompt(initialInput, session.headlessPlan);
+      continue;
+    }
+
+    onActivitiesStarted?.({ activities: newPending });
+    const waitResult = await waitForActivities(session, newPending, { timeoutMs, signal });
+    if (!waitResult.ok) {
+      return {
+        ok: false,
+        timedOut: Boolean(waitResult.timedOut),
+        completed: waitResult.completed ?? [],
+        waitResult,
+      };
+    }
+
+    const completed = waitResult.completed ?? [];
+    const summary = formatCompletedActivities(completed);
+    onActivitiesCompleted?.({ completed, summary });
+    currentInput = completedActivitiesPrompt(initialInput, session.headlessPlan, summary);
+  }
+
+  onMaxTurns?.({ maxTurns });
+  return { ok: false, maxTurns: true };
+}
+
+function pendingStepsPrompt(initialInput, plan) {
+  return [
+    'Original task:',
+    initialInput,
+    '',
+    `Plan status:\n${formatPlanStatus(plan)}`,
+    '',
+    'No new background activity was started in the previous turn.',
+    'Continue the original plan. Start the next pending step only.',
+    'If required information is missing and cannot be inferred, stop with a clear blocker.',
+  ].join('\n');
+}
+
+function completedActivitiesPrompt(initialInput, plan, summary) {
+  return [
+    'Original task:',
+    initialInput,
+    '',
+    plan ? `Plan status:\n${formatPlanStatus(plan)}\n` : null,
+    'Completed activities:',
+    summary,
+    '',
+    'Continue the original plan. Start the next required step only.',
+    'If all steps are complete, provide the final summary.',
+  ].filter(Boolean).join('\n');
+}

package/src/core/agentLoop.test.js

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
+import { runAgenticLoop } from './agentLoop.js';
+
+test('runAgenticLoop waits for new activities and continues with a completion summary', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+  };
+  const inputs = [];
+  const callbacks = [];
+  const agent = {
+    async invoke({ input, session: turnSession }) {
+      inputs.push(input);
+      if (inputs.length === 1) {
+        dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+          payload: {
+            activity: {
+              id: 'job-1',
+              source: 'production',
+              kind: 'job',
+              label: 'production job',
+              status: 'running',
+              terminal: false,
+            },
+          },
+        }));
+        return { response: 'Started production job.' };
+      }
+      return { response: 'All done.' };
+    },
+  };
+
+  const result = await runAgenticLoop(agent, session, 'Build workspace', {
+    maxTurns: 3,
+    timeoutMs: 1000,
+    waitForActivities: async (turnSession, startedActivities) => {
+      assert.equal(startedActivities.length, 1);
+      dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+        payload: {
+          activity: {
+            id: 'job-1',
+            source: 'production',
+            kind: 'job',
+            label: 'production job',
+            status: 'done',
+            terminal: true,
+          },
+        },
+      }));
+      if (turnSession.headlessPlan?.[0]) turnSession.headlessPlan[0].status = 'done';
+      return { ok: true, completed: Object.values(turnSession.activities) };
+    },
+    onActivitiesStarted: ({ activities }) => callbacks.push(`started:${activities.length}`),
+    onActivitiesCompleted: ({ summary }) => callbacks.push(summary),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(inputs.length, 2);
+  assert.match(inputs[1], /Completed activities:/);
+  assert.match(inputs[1], /production job-1: done/);
+  assert.deepEqual(callbacks, ['started:1', '- production job-1: done']);
+});
+
+test('runAgenticLoop extracts a fallback numbered plan from first response', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+  };
+  const result = await runAgenticLoop({
+    async invoke() {
+      return { response: '1. Collect sources\n2. Build page' };
+    },
+  }, session, 'Plan task', {
+    maxTurns: 1,
+    timeoutMs: 1000,
+    waitForActivities: async () => assert.fail('No activities should be waited for.'),
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.maxTurns, true);
+  assert.equal(session.headlessPlan.length, 2);
+  assert.equal(session.headlessPlan[0].description, 'Collect sources');
+});

package/src/core/cacert.js

@@ -40,8 +40,7 @@ function composeOverrideContent(cacertPath, services) {
     services: serviceEntries,
   };
   return [
-    '# Generated by wiki-manager. Safe to delete.',
-    '# Rewritten when --cacert is used with a Docker Compose command.',
+    '# Generated by wiki-manager. Edit freely; delete to regenerate.',
     YAML.stringify(doc).trimEnd(),
     '',
   ].join('\n');
@@ -61,6 +60,8 @@ export function ensureCacertComposeOverride(composeFilePath, fileName = 'cacert.
   const runtimeDir = managerRuntimeDir();
   mkdirSync(runtimeDir, { recursive: true });
   const overridePath = join(runtimeDir, fileName);
-  writeFileSync(overridePath, composeOverrideContent(cacertPath, services), 'utf8');
+  if (!existsSync(overridePath)) {
+    writeFileSync(overridePath, composeOverrideContent(cacertPath, services), 'utf8');
+  }
   return (_cacertOverrideCache = overridePath);
 }

package/src/core/compose.js

@@ -9,7 +9,7 @@ import { managerRoot } from './workspaces.js';
 
 const execFileAsync = promisify(execFile);
 
-export const COMPOSE_SERVICES = ['serve', 'mcp-http', 'production-mcp'];
+export const COMPOSE_SERVICES = ['serve', 'mcp-http', 'agent-runtime', 'production-mcp'];
 const SERVICE_DESCRIPTION_LABEL = 'wiki-manager.description';
 
 const DEFAULT_SERVICE_ALIASES = {
@@ -17,6 +17,7 @@ const DEFAULT_SERVICE_ALIASES = {
   ui: ['serve'],
   wiki: ['mcp-http'],
   mcp: ['mcp-http'],
+  runtime: ['agent-runtime'],
   production: ['production-mcp'],
 };
 

package/src/core/dockerCompose.test.js

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import YAML from 'yaml';
+
+test('agent-runtime compose command passes runtime args to the image entrypoint', async () => {
+  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const compose = YAML.parse(raw);
+  const service = compose.services['agent-runtime'];
+
+  assert.equal(service.image, 'dotdrelle/llm-wiki-manager:latest');
+  assert.equal(service.command, 'runtime --host 0.0.0.0 --port 7788 --state-dir /state');
+  assert.ok(!service.command.startsWith('wiki-manager '));
+});

package/src/core/documentIntake.test.js

@@ -16,16 +16,16 @@ test('document intake stores uploads without requiring documents MCP', async ()
   const source = path.join(root, 'rapport.pdf');
   await writeFile(source, 'fake pdf content');
   const session = {
-    workspace: 'juno',
+    workspace: 'my-project',
     mcp: {},
   };
 
   try {
     const { record, converted } = await storeAndMaybeConvertDocument(session, source);
     assert.equal(converted, false);
-    assert.equal(record.workspace, 'juno');
+    assert.equal(record.workspace, 'my-project');
     assert.equal(record.status, 'stored');
-    assert.equal(record.agentPath.startsWith('/documents/input/juno/'), true);
+    assert.equal(record.agentPath.startsWith('/documents/input/my-project/'), true);
     assert.equal(await readFile(record.storedPath, 'utf8'), 'fake pdf content');
 
     const uploads = await listDocumentUploads(session);
@@ -45,7 +45,7 @@ test('document intake accepts quoted absolute paths with spaces', async () => {
   const source = path.join(root, 'Screenshot 2026-06-21 at 10.03.36.png');
   await writeFile(source, 'fake png content');
   const session = {
-    workspace: 'juno',
+    workspace: 'my-project',
     mcp: {},
   };
 
@@ -66,7 +66,7 @@ test('document intake accepts double-quoted absolute paths with spaces', async (
   const source = path.join(root, 'scan avec espace.pdf');
   await writeFile(source, 'fake pdf content');
   const session = {
-    workspace: 'juno',
+    workspace: 'my-project',
     mcp: {},
   };
 
@@ -87,7 +87,7 @@ test('document intake replaces an existing upload with the same original filenam
   process.env.AGENTS_DATA_DIR = agentsDataDir;
   const source = path.join(root, 'rapport.pdf');
   const session = {
-    workspace: 'juno',
+    workspace: 'my-project',
     mcp: {},
   };
 
@@ -98,7 +98,7 @@ test('document intake replaces an existing upload with the same original filenam
     await mkdir(path.dirname(outputPath), { recursive: true });
     await writeFile(outputPath, 'old markdown');
 
-    const manifest = path.join(agentsDataDir, 'documents', 'uploads', 'juno.jsonl');
+    const manifest = path.join(agentsDataDir, 'documents', 'uploads', 'my-project.jsonl');
     const firstRecord = JSON.parse(await readFile(manifest, 'utf8'));
     await writeFile(manifest, `${JSON.stringify({ ...firstRecord, outputPath })}\n`, 'utf8');
 

package/src/core/env.js

@@ -15,6 +15,12 @@ export function managerRuntimeDir() {
   return join(managerStateDir(), '.wiki-manager');
 }
 
+export function defaultRuntimeStateDir() {
+  return process.env.WIKI_MANAGER_STATE_DIR
+    ? resolve(process.env.WIKI_MANAGER_STATE_DIR)
+    : managerRuntimeDir();
+}
+
 export function managerEnvFile() {
   return process.env.WIKI_MANAGER_ENV_FILE
     ? resolve(process.env.WIKI_MANAGER_ENV_FILE)

package/src/core/jobQueue.js

@@ -1,6 +1,7 @@
 import { extractActivity, parseJsonText, sessionActivities } from './activity.js';
 import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
 import { callMcpTool, formatMcpToolResult } from './mcp.js';
+import { queueStoreFor } from './queueStore.js';
 
 const TERMINAL = new Set(['done', 'failed', 'cancelled', 'canceled', 'complete', 'completed', 'success', 'error']);
 
@@ -8,6 +9,10 @@ function now() {
   return new Date().toISOString();
 }
 
+function notifyQueueUpdate(session) {
+  queueStoreFor(session).changed();
+}
+
 function shortId() {
   return `q-${Math.random().toString(16).slice(2, 6)}`;
 }
@@ -17,8 +22,7 @@ function terminalStatus(status) {
 }
 
 export function ensureJobQueue(session) {
-  session.jobQueue ??= [];
-  return session.jobQueue;
+  return queueStoreFor(session).list();
 }
 
 export function productionLockBusy(session) {
@@ -41,6 +45,7 @@ export function enqueueProductionJob(session, args = {}, reason = 'waiting') {
     createdAt: now(),
   };
   ensureJobQueue(session).push(item);
+  notifyQueueUpdate(session);
   return item;
 }
 
@@ -85,10 +90,11 @@ export function formatQueue(session) {
 export function clearFinishedQueueItems(session) {
   const queue = ensureJobQueue(session);
   const before = queue.length;
-  session.jobQueue = queue.filter((item) =>
+  const next = queue.filter((item) =>
     item.workspace !== session.workspace || !terminalStatus(item.status),
   );
-  return before - session.jobQueue.length;
+  queueStoreFor(session).replace(next);
+  return before - next.length;
 }
 
 function findQueueItem(session, id) {
@@ -102,6 +108,7 @@ export async function cancelQueueItem(session, id) {
     const label = item.status === 'starting' ? 'starting' : 'queued';
     item.status = 'cancelled';
     item.finishedAt = now();
+    notifyQueueUpdate(session);
     return { ok: true, message: `Cancelled ${label} job ${id}.` };
   }
   if (item.status === 'running') {
@@ -109,6 +116,7 @@ export async function cancelQueueItem(session, id) {
       await callMcpTool(session.mcp, 'production', 'production_cancel_job', { jobId: item.jobId });
       item.status = 'cancelled';
       item.finishedAt = now();
+      notifyQueueUpdate(session);
       return { ok: true, message: `Cancellation requested for ${id} (${item.jobId}).` };
     }
     return { ok: false, message: `No cancel tool available for ${id}.` };
@@ -140,6 +148,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
 
   item.status = 'starting';
   item.startedAt = now();
+  notifyQueueUpdate(session);
   hooks.refresh?.();
   hooks.addLog?.(`queue: starting ${item.id} ${queueSummary(item.args)}`);
 
@@ -154,6 +163,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
     if (payload?.ok === false && payload?.error === 'workspace_busy') {
       item.status = 'waiting';
       item.reason = 'workspace_busy';
+      notifyQueueUpdate(session);
       hooks.addLog?.(`queue: ${item.id} still waiting, production lock busy`);
       hooks.refresh?.();
       return item;
@@ -164,6 +174,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
       item.jobId = activity.id;
       item.activityKey = activity.key;
       item.finishedAt = activity.terminal ? now() : undefined;
+      notifyQueueUpdate(session);
       dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
         origin: 'queue',
         payload: { activity },
@@ -171,6 +182,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
     } else {
       item.status = 'done';
       item.finishedAt = now();
+      notifyQueueUpdate(session);
     }
     hooks.addLog?.(`queue: ${item.id} ${item.status}${item.jobId ? ` job=${item.jobId}` : ''}`);
     hooks.refresh?.();
@@ -179,6 +191,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
     item.status = 'failed';
     item.error = err instanceof Error ? err.message : String(err);
     item.finishedAt = now();
+    notifyQueueUpdate(session);
     hooks.addLog?.(`queue: ${item.id} failed · ${item.error}`);
     hooks.refresh?.();
     return item;
@@ -193,5 +206,6 @@ export function syncQueueWithActivity(session, activity) {
   item.activityKey = activity.key;
   item.finishedAt = activity.terminal ? now() : item.finishedAt;
   item.error = activity.error ?? item.error;
+  notifyQueueUpdate(session);
   return item;
 }

package/src/core/mcp.js

@@ -211,7 +211,7 @@ async function mcpRequest(endpoint, method, params, signal, options = {}) {
           params: {
             protocolVersion: '2025-06-18',
             capabilities: {},
-            clientInfo: { name: 'wiki-manager', version: '0.6.47' },
+            clientInfo: { name: 'wiki-manager', version: '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/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);
+});