@dotdrelle/wiki-manager 0.15.29 → 0.15.32

package/src/orchestrator/dispatcher.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { createDispatcher } from './dispatcher.js';
+import { createDispatcher, normalizeTaskError } from './dispatcher.js';
 
 test('dispatcher returns a retryable logical failure when agent_execute reports workspace_busy', async () => {
   const session = {
@@ -159,3 +159,26 @@ test('dispatcher keeps a null error when a terminal status reports none', async
   assert.equal(result.ok, true);
   assert.equal(result.error, null);
 });
+
+test('normalizeTaskError keeps the agent reason as the message, never the fallback', () => {
+  // Regression: the fallback describes only WHERE the failure was seen
+  // ("agent_execute rejected task"). Letting it win discarded the one
+  // actionable sentence — and left Donna to invent a cause.
+  const error = normalizeTaskError("Error: source 'acpi' not found", {
+    fallbackCode: 'execution_rejected',
+    fallbackMessage: 'agent_execute rejected task',
+  });
+
+  assert.equal(error.code, "Error: source 'acpi' not found");
+  assert.equal(error.message, "Error: source 'acpi' not found");
+});
+
+test('normalizeTaskError falls back only when the agent reports no reason at all', () => {
+  const error = normalizeTaskError('', {
+    fallbackCode: 'execution_rejected',
+    fallbackMessage: 'agent_execute rejected task',
+  });
+
+  assert.equal(error.code, 'execution_rejected');
+  assert.equal(error.message, 'agent_execute rejected task');
+});

package/src/runtime/auth.test.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import { resolveRuntimeAuthToken } from './auth.js';
-import { assertRuntimeNode, runtimeNodeExecutable, shutdownOwnedRuntime } from './lifecycle.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 });
@@ -27,67 +27,3 @@ test('runtime lifecycle uses a Node executable with node:sqlite support', async
   assert.ok(runtimeNode.executable);
   assert.ok(Number(runtimeNode.version.split('.')[0]) >= 22);
 });
-
-test('shutdownOwnedRuntime reports progress and stops an idle owned runtime', async () => {
-  const originalFetch = globalThis.fetch;
-  const calls = [];
-  const logs = [];
-  globalThis.fetch = async (url, options = {}) => {
-    calls.push({ url: String(url), method: options.method ?? 'GET' });
-    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
-      status: calls.length === 1 ? 200 : 202,
-      headers: { 'content-type': 'application/json' },
-    });
-  };
-  try {
-    const result = await shutdownOwnedRuntime(
-      { url: 'http://127.0.0.1:7788', started: true, token: null },
-      { log: (message) => logs.push(message), timeoutMs: 100 },
-    );
-    assert.equal(result.action, 'shutdown');
-    assert.deepEqual(calls.map((call) => call.method), ['GET', 'POST']);
-    assert.match(logs.join('\n'), /runtime arrêté/);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test('shutdownOwnedRuntime also stops an idle reused runtime', async () => {
-  const originalFetch = globalThis.fetch;
-  const calls = [];
-  globalThis.fetch = async (_url, options = {}) => {
-    calls.push(options.method ?? 'GET');
-    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
-      status: calls.length === 1 ? 200 : 202,
-      headers: { 'content-type': 'application/json' },
-    });
-  };
-  try {
-    const result = await shutdownOwnedRuntime(
-      { url: 'http://127.0.0.1:7788', started: false, token: null },
-      { timeoutMs: 100 },
-    );
-    assert.equal(result.action, 'shutdown');
-    assert.deepEqual(calls, ['GET', 'POST']);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test('shutdownOwnedRuntime bounds an unresponsive shutdown', async () => {
-  const originalFetch = globalThis.fetch;
-  const logs = [];
-  globalThis.fetch = async (_url, { signal } = {}) => new Promise((_resolve, reject) => {
-    signal?.addEventListener('abort', () => reject(new DOMException('aborted', 'AbortError')), { once: true });
-  });
-  try {
-    const result = await shutdownOwnedRuntime(
-      { url: 'http://127.0.0.1:7788', started: true, token: null },
-      { log: (message) => logs.push(message), timeoutMs: 5 },
-    );
-    assert.equal(result.action, 'timeout');
-    assert.match(logs.join('\n'), /délai de fermeture/);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});

package/src/runtime/donna-contract.test.js

@@ -146,7 +146,8 @@ test('CME setup and source configuration stay outside export orchestration', asy
   const calledTools = [];
   globalThis.fetch = async (_url, options = {}) => {
     const body = JSON.parse(String(options.body ?? '{}'));
-    calledTools.push(body.params?.name);
+    // Record tool calls only — the MCP session handshake is not a tool call.
+    if (body.method === 'tools/call') calledTools.push(body.params?.name);
     return {
       ok: true,
       status: 200,

package/src/runtime/lifecycle.js

@@ -139,36 +139,3 @@ export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = run
     return null;
   }
 }
-
-// Close the runtime attached to the shell when it is idle, including a process
-// reused at startup. Restricting cleanup to `started: true` left ownerless
-// runtimes occupying port 7788 with another manager directory/token.
-// An active run still survives the shell.
-export async function shutdownOwnedRuntime(runtime, { log = (_message) => {}, timeoutMs = 3000 } = {}) {
-  if (!runtime?.url) return { action: 'kept', reason: 'unavailable' };
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), Math.max(1, Number(timeoutMs) || 3000));
-  try {
-    const health = await runtimeHealthOrNull(runtime.url, runtime.token, controller.signal);
-    if (!health) return { action: 'kept', reason: 'unreachable' };
-    const activeRuns = Array.isArray(health.activeRuns) ? health.activeRuns : [];
-    if (activeRuns.length > 0) {
-      const labels = activeRuns
-        .map((run) => [run.workspace, run.runId ? String(run.runId).slice(0, 8) : null].filter(Boolean).join('/'))
-        .join(', ');
-      log(`runtime laissé actif : run en cours (${labels}) — il survivra à ce shell ; relance wiki-manager pour le retrouver.`);
-      return { action: 'kept', reason: 'run_active', activeRuns };
-    }
-    await postRuntimeShutdown({ url: runtime.url, token: runtime.token, signal: controller.signal });
-    log('runtime arrêté (aucun run en cours).');
-    return { action: 'shutdown' };
-  } catch (err) {
-    if (controller.signal.aborted) {
-      log('délai de fermeture du runtime dépassé — le shell termine sans attendre davantage.');
-      return { action: 'timeout', reason: 'shutdown_timeout' };
-    }
-    return { action: 'error', reason: err instanceof Error ? err.message : String(err) };
-  } finally {
-    clearTimeout(timeout);
-  }
-}

package/src/runtime/runner.test.js

@@ -401,7 +401,16 @@ test('replanRuntimeRun requires runtime approval for mutating replanned work', a
 test('runRuntimeAgenticWorkflow replans after terminal activity error', async () => {
   const originalFetch = globalThis.fetch;
   let pollAttempts = 0;
-  globalThis.fetch = async () => {
+  globalThis.fetch = async (_url, init) => {
+    // Count polls, not the one-off MCP session handshake.
+    if (JSON.parse(init.body).method === 'initialize') {
+      return {
+        ok: true,
+        status: 200,
+        headers: { get: () => null },
+        text: async () => '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":"2025-06-18"}}',
+      };
+    }
     pollAttempts += 1;
     return {
       ok: true,

package/src/runtime/supervisor.test.js

@@ -93,7 +93,17 @@ test('pollActivitiesOnce does not repeat an unchanged retry state when retryAt m
 test('pollActivitiesOnce retries transient MCP poll failures', async () => {
   const originalFetch = globalThis.fetch;
   let attempts = 0;
-  globalThis.fetch = async () => {
+  globalThis.fetch = async (_url, init) => {
+    // The session handshake is not the thing under test: answer it, and make
+    // the first *poll* the transient failure.
+    if (JSON.parse(init.body).method === 'initialize') {
+      return {
+        ok: true,
+        status: 200,
+        headers: { get: () => null },
+        text: async () => '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":"2025-06-18"}}',
+      };
+    }
     attempts += 1;
     if (attempts === 1) {
       return {

package/src/shell/tui.tsx

@@ -150,30 +150,22 @@ function App(props: {
   const [preflightBusy, setPreflightBusy] = createSignal(false);
   let ctrlCTimer: ReturnType<typeof setTimeout> | null = null;
   let exiting = false;
-  // Single exit path: the owned-runtime shutdown MUST happen here, on the
-  // user's actual exit gesture. render() resolves at MOUNT, so code placed
-  // after `await runOpenTuiShell(...)` runs while the shell is still on
-  // screen — 0.12.9 shipped that and killed the runtime mid-session.
+  // The runtime is shared infrastructure: `llm-wiki serve` can still be using
+  // it after this shell closes. Exiting the UI only destroys the renderer;
+  // explicit lifecycle commands own runtime shutdown.
   const exitShell = () => {
     if (exiting) return;
     exiting = true;
     setExitStatus('Fermeture enclenchée…');
-    // Register the complete shutdown before destroying the renderer: onDestroy
-    // resolves runOpenTuiShell, which must still await this cleanup task.
     const task = Promise.resolve().then(async () => {
       renderer.destroy();
-      console.log('[wiki-manager] fermeture enclenchée — nettoyage en cours…');
-      const messages: string[] = [];
-      try {
-        if (props.runtime?.url) {
-          const { shutdownOwnedRuntime } = await import('../runtime/lifecycle.js');
-          await shutdownOwnedRuntime(props.runtime, { log: (message: string) => { messages.push(message); } });
-        }
-      } catch {
-        // Best effort: never block the exit on runtime cleanup.
-      }
-      for (const message of messages) console.log(`[wiki-manager] ${message}`);
-      console.log('[wiki-manager] fermeture terminée — shell clos proprement.');
+      console.log('[wiki-manager] shell closed; shared runtime left running.');
+      // MCP clients, image-refresh probes, and reconnect timers may still own
+      // event-loop handles. They belong to this shell process, not to the
+      // detached shared runtime. Once the renderer is gone there is no useful
+      // foreground work left, so terminate explicitly instead of leaving the
+      // terminal pending indefinitely.
+      process.exit(0);
     });
     if (props.exitRef) props.exitRef.current = task;
   };

package/wiki-workspace

@@ -84,6 +84,7 @@ Usage:
   wiki-workspace [--cacert <path>] <command> ...
   wiki-workspace config <workspace> [path]
   wiki-workspace up <workspace>
+  wiki-workspace refresh
   wiki-workspace wiki <workspace> <command> [args...]
   wiki-workspace list
 
@@ -91,6 +92,7 @@ Commands:
   config <workspace> [path]         Create workspace folder, auto-select ports, run wiki init
   up <workspace> [--open]           Start workspace stack: wiki + production
   list                              List configured workspaces
+  refresh                           Stop runtime/stacks and remove their Compose images
 
   agents up [--pull]                Start all external agents (cme, documents)
   agents down                       Stop all external agents
@@ -260,6 +262,31 @@ agents_compose() {
   local compose_env_args=()
   [[ -f "$MANAGER_ENV_FILE" ]] && compose_env_args+=(--env-file "$MANAGER_ENV_FILE")
 
+  # Local-iteration build only: the packaged connectors service carries a
+  # `build:` block pointing at the sibling agent-connectors repo, whose OAuth
+  # credentials live in a gitignored .env.build.local. Compose resolves the
+  # value-less build args from *this* process environment, not from
+  # --env-file, so the variables must be exported here or the image ships with
+  # empty WIKILLM_GOOGLE_OAUTH_* and every Google connector stays unusable.
+  local connectors_build_env="$ROOT_DIR/../agent-external/agent-connectors/.env.build.local"
+  if [[ -f "$connectors_build_env" ]]; then
+    local build_key build_value
+    while IFS='=' read -r build_key build_value; do
+      case "$build_key" in
+        WIKILLM_GOOGLE_OAUTH_CLIENT_ID|WIKILLM_GOOGLE_OAUTH_CLIENT_SECRET) ;;
+        *) continue ;;
+      esac
+      [[ -n "${!build_key:-}" ]] || export "$build_key=$build_value"
+    done < <(grep -v '^[[:space:]]*#' "$connectors_build_env" || true)
+  fi
+
+  require_connectors_build_credentials() {
+    local build_key
+    for build_key in WIKILLM_GOOGLE_OAUTH_CLIENT_ID WIKILLM_GOOGLE_OAUTH_CLIENT_SECRET; do
+      [[ -n "${!build_key:-}" ]] || die "cannot build connectors: $build_key is missing from $connectors_build_env"
+    done
+  }
+
   _agents_dc() {
     local cacert_args=()
     local profile_args=()
@@ -288,6 +315,9 @@ agents_compose() {
       [[ $# -eq 0 ]] || die "agents up accepts only --pull"
       ensure_agent_tokens
       ensure_endpoints_file
+      if connectors_enabled && [[ -f "$ROOT_DIR/../agent-external/agent-connectors/Dockerfile" ]]; then
+        require_connectors_build_credentials
+      fi
       # The .env may have just been created above — recompute the env-file
       # flag so freshly generated tokens reach the containers on first run.
       compose_env_args=()
@@ -314,6 +344,10 @@ agents_compose() {
       [[ $# -eq 0 ]] || die "agents down does not take arguments"
       _agents_dc down
       ;;
+    purge)
+      [[ $# -eq 0 ]] || die "agents purge does not take arguments"
+      _agents_dc down --rmi all --remove-orphans
+      ;;
     logs)
       local log_args=()
       read_lines_into_array log_args logs_args "$@"
@@ -687,6 +721,19 @@ runtime_command() {
       ;;
     down|stop)
       [[ $# -eq 0 ]] || die "runtime down does not take arguments"
+      token="$(ensure_manager_runtime_token)"
+      if runtime_health_check; then
+        RUNTIME_URL="$(runtime_health_url)/shutdown" RUNTIME_TOKEN="$token" "$node_bin" --input-type=module -e \
+          "const h=process.env.RUNTIME_TOKEN?{Authorization:'Bearer '+process.env.RUNTIME_TOKEN}:{}; const r=await fetch(process.env.RUNTIME_URL,{method:'POST',headers:h}); process.exit(r.ok?0:1);"
+        local wait_count=0
+        while runtime_health_check && (( wait_count < 40 )); do
+          sleep 0.1
+          (( wait_count++ )) || true
+        done
+        rm -f "$pid_file"
+        printf 'agent-runtime stopped\n'
+        return
+      fi
       if ! runtime_pid_running; then
         printf 'agent-runtime is not running from %s\n' "$pid_file"
         rm -f "$pid_file"
@@ -731,6 +778,23 @@ runtime_command() {
   esac
 }
 
+refresh_project() {
+  printf 'Stopping shared runtime...\n'
+  runtime_command down
+
+  local entry workspace
+  for entry in "$WORKSPACES_DIR"/*; do
+    [[ -f "$entry/.env" ]] || continue
+    workspace="$(basename "$entry")"
+    printf 'Removing workspace stack and images: %s\n' "$workspace"
+    compose_for_workspace "$workspace" down --rmi all --remove-orphans
+  done
+
+  printf 'Removing external-agent stack and images...\n'
+  agents_compose purge
+  printf 'Refresh complete. Persistent workspace and agent data were preserved.\n'
+}
+
 ensure_runtime_up() {
   if [[ "${WIKI_MANAGER_RUNTIME_AUTOSTART:-1}" == "0" ]]; then
     return
@@ -1214,6 +1278,11 @@ main() {
     exit 0
   fi
 
+  if [[ $# -eq 1 && "$1" == "refresh" ]]; then
+    refresh_project
+    exit 0
+  fi
+
   # config <workspace> [path]
   if [[ $# -ge 2 && "$1" == "config" ]]; then
     local cfg_workspace="$2"