@dotdrelle/wiki-manager 0.6.47 → 0.8.2

package/src/core/queueStore.test.js

@@ -0,0 +1,32 @@
+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.match(item.id, /^q-[0-9a-f-]{36}$/);
+  assert.equal(queue.length, 1);
+  assert.equal(ensureJobQueue(session), queue);
+  assert.equal(changed, 1);
+});

package/src/core/wikiWorkspace.test.js

@@ -0,0 +1,24 @@
+import { readFile } from 'node:fs/promises';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+test('wiki-workspace autostarts host runtime before workspace services', async () => {
+  const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
+
+  assert.match(script, /ensure_runtime_up\(\) \{/);
+  assert.match(script, /WIKI_MANAGER_RUNTIME_AUTOSTART:-1/);
+  assert.match(script, /Starting host agent-runtime/);
+  assert.match(script, /start_workspace_services\(\) \{\n  ensure_runtime_up\n  compose_for_workspace "\$1" up -d serve mcp-http production-mcp/);
+  assert.match(script, /start_workspace_services "\$workspace"\n\n  local serve_port prod_port/);
+  assert.match(script, /start_workspace_services "\$workspace"\n      local serve_port production_port/);
+  assert.match(script, /ensure_runtime_up\n      printf 'Starting mcp-http/);
+});
+
+test('wiki-workspace checks runtime pid command before killing', async () => {
+  const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
+
+  assert.match(script, /runtime_pid_command\(\) \{/);
+  assert.match(script, /runtime_pid_matches\(\) \{/);
+  assert.match(script, /if ! runtime_pid_matches; then\n        printf 'refusing to stop pid/);
+  assert.match(script, /kill "\$\(cat "\$pid_file"\)"/);
+});

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/approvals.js

@@ -0,0 +1,113 @@
+import { randomUUID } from 'node:crypto';
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+
+const DEFAULT_APPROVAL_TIMEOUT_MS = 10 * 60 * 1000;
+
+export function createApprovalManager(session, {
+  defaultTimeoutMs = DEFAULT_APPROVAL_TIMEOUT_MS,
+} = {}) {
+  const pending = new Map();
+
+  async function requestApproval(request = {}) {
+    const scope = request.scope === 'tool' ? 'tool' : 'run';
+    const approvalId = request.approvalId ?? randomUUID();
+    const runId = request.runId ?? session._currentRunIdentity?.runId ?? null;
+    const timeoutMs = Number.isFinite(Number(request.timeoutMs))
+      ? Math.max(1, Number(request.timeoutMs))
+      : defaultTimeoutMs;
+    const eventType = scope === 'tool' ? 'tool_pending_approval' : 'run_pending_approval';
+    const approvedType = scope === 'tool' ? 'tool_approved' : 'run_approved';
+
+    dispatchAgentEvent(session, createAgentEvent(eventType, {
+      origin: 'runtime',
+      runId,
+      payload: {
+        approvalId,
+        runId,
+        itemId: request.itemId ?? null,
+        reason: request.reason ?? null,
+        tool: request.tool ?? null,
+        plan: request.plan ?? null,
+        timeoutMs,
+      },
+    }));
+
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(approvalId);
+        const err = new Error(`Approval timed out: ${approvalId}`);
+        err.name = 'ApprovalError';
+        reject(err);
+      }, timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timer);
+        request.signal?.removeEventListener('abort', onAbort);
+      };
+      const onAbort = () => {
+        pending.delete(approvalId);
+        cleanup();
+        const err = new Error(`Approval cancelled: ${approvalId}`);
+        err.name = 'AbortError';
+        reject(err);
+      };
+      pending.set(approvalId, {
+        approvalId,
+        scope,
+        runId,
+        itemId: request.itemId ?? null,
+        resolve: () => {
+          pending.delete(approvalId);
+          cleanup();
+          resolve();
+        },
+      });
+      if (request.signal?.aborted) {
+        onAbort();
+        return;
+      }
+      request.signal?.addEventListener('abort', onAbort, { once: true });
+    });
+
+    dispatchAgentEvent(session, createAgentEvent(approvedType, {
+      origin: 'runtime',
+      runId,
+      payload: {
+        approvalId,
+        runId,
+        itemId: request.itemId ?? null,
+      },
+    }));
+    return { approved: true, approvalId, runId, itemId: request.itemId ?? null };
+  }
+
+  function approve({ approvalId = null, runId = null, itemId = null } = {}) {
+    const entry = approvalId
+      ? pending.get(approvalId)
+      : [...pending.values()].find((item) =>
+          (runId && item.runId === runId) || (itemId && item.itemId === itemId),
+        );
+    if (!entry) return { approved: false, reason: 'approval not found' };
+    entry.resolve();
+    return {
+      approved: true,
+      approvalId: entry.approvalId,
+      runId: entry.runId,
+      itemId: entry.itemId,
+    };
+  }
+
+  function list() {
+    return [...pending.entries()].map(([approvalId, item]) => ({
+      approvalId,
+      scope: item.scope,
+      runId: item.runId,
+      itemId: item.itemId,
+    }));
+  }
+
+  return {
+    requestApproval,
+    approve,
+    list,
+  };
+}

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,29 @@
+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';
+import { assertRuntimeNode, runtimeNodeExecutable } from './lifecycle.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);
+});
+
+test('runtime lifecycle uses a Node executable with node:sqlite support', async () => {
+  const runtimeNode = await assertRuntimeNode(runtimeNodeExecutable());
+
+  assert.ok(runtimeNode.executable);
+  assert.ok(Number(runtimeNode.version.split('.')[0]) >= 22);
+});

package/src/runtime/client.js

@@ -0,0 +1,154 @@
+import { runtimeTokenFromEnv as runtimeToken } from './auth.js';
+
+function base(url) {
+  return url.replace(/\/$/, '');
+}
+
+function runtimeEndpoint(url, path, workspace = null) {
+  const endpoint = new URL(`${base(url)}${path}`);
+  if (workspace) endpoint.searchParams.set('workspace', workspace);
+  return endpoint.toString();
+}
+
+export function runtimeUrlFromEnv() {
+  return process.env.WIKI_MANAGER_RUNTIME_URL ?? 'http://127.0.0.1:7788';
+}
+
+export async function fetchRuntimeState({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+} = {}) {
+  const response = await fetch(runtimeEndpoint(url, '/state', workspace), {
+    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(),
+  workspace = null,
+} = {}) {
+  const response = await fetch(runtimeEndpoint(url, '/health', workspace), {
+    headers: runtimeHeaders(token),
+  });
+  if (!response.ok) return null;
+  return response.json();
+}
+
+export async function postRuntimeRun(input, {
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+  evaluate = undefined,
+  replans = undefined,
+} = {}) {
+  const response = await fetch(runtimeEndpoint(url, '/run', workspace), {
+    method: 'POST',
+    headers: {
+      ...runtimeHeaders(token),
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(Object.assign({ input, workspace }, evaluate !== undefined && { evaluate }, replans !== undefined && { replans })),
+  });
+  if (!response.ok) throw new Error(`Runtime run failed: HTTP ${response.status}`);
+  return response.json();
+}
+
+export async function postRuntimeCancel({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+} = {}) {
+  const response = await fetch(runtimeEndpoint(url, '/cancel', workspace), {
+    method: 'POST',
+    headers: runtimeHeaders(token),
+  });
+  if (!response.ok && response.status !== 501) throw new Error(`Runtime cancel failed: HTTP ${response.status}`);
+  return response.json();
+}
+
+export async function postRuntimeResume({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+} = {}) {
+  const response = await fetch(runtimeEndpoint(url, '/resume', workspace), {
+    method: 'POST',
+    headers: runtimeHeaders(token),
+  });
+  if (!response.ok) throw new Error(`Runtime resume failed: HTTP ${response.status}`);
+  return response.json();
+}
+
+export async function postRuntimeApprove({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+  runId = null,
+  itemId = null,
+  approvalId = null,
+} = {}) {
+  const endpoint = runtimeEndpoint(url, '/approve', workspace);
+  const parsed = new URL(endpoint);
+  if (runId) parsed.searchParams.set('runId', runId);
+  if (itemId) parsed.searchParams.set('itemId', itemId);
+  if (approvalId) parsed.searchParams.set('approvalId', approvalId);
+  const response = await fetch(parsed.toString(), {
+    method: 'POST',
+    headers: runtimeHeaders(token),
+  });
+  if (!response.ok) throw new Error(`Runtime approve 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,
+  workspace = null,
+} = {}) {
+  const response = await fetch(runtimeEndpoint(url, '/events/stream', workspace), {
+    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,84 @@
+import { execFile, 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 function runtimeNodeExecutable() {
+  return process.versions.bun
+    ? (process.env.WIKI_MANAGER_NODE_BIN ?? 'node')
+    : process.execPath;
+}
+
+export async function assertRuntimeNode(executable = runtimeNodeExecutable()) {
+  const version = await new Promise((resolveVersion, reject) => {
+    execFile(executable, ['-p', 'process.versions.node'], (err, stdout) => {
+      if (err) {
+        reject(new Error(`Runtime requires Node.js 22+; could not execute ${executable}. Set WIKI_MANAGER_NODE_BIN to a Node.js 22 binary.`));
+        return;
+      }
+      resolveVersion(String(stdout).trim());
+    });
+  });
+  const major = Number(String(version).split('.')[0]);
+  if (!Number.isInteger(major) || major < 22) {
+    throw new Error(`Runtime requires Node.js 22+ for node:sqlite; ${executable} is Node ${version}. Set WIKI_MANAGER_NODE_BIN to a Node.js 22 binary.`);
+  }
+  return { executable, version };
+}
+
+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 runtimeNode = await assertRuntimeNode();
+  const child = spawn(runtimeNode.executable, [
+    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, node: runtimeNode };
+    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, { workspace = session.workspace ?? null } = {}) {
+  session.jobQueue = store.listQueue({ workspace });
+  return createQueueStore(session, { persist: () => store.saveQueue(session.jobQueue, { workspace }) });
+}