@dotdrelle/wiki-manager 0.12.8 → 0.12.9

package/README.md

@@ -48,6 +48,7 @@ Use a local installation when the manager should be pinned in a project's
 
 ```bash
 npm install @dotdrelle/wiki-manager
+npm approve-scripts bun  # only when npm reports that Bun's postinstall is pending
 npx wiki-manager
 npx wiki-workspace --help
 ```
@@ -55,7 +56,9 @@ npx wiki-workspace --help
 `npm install` does not add `wiki-manager` or `wiki-workspace` to the shell's
 global `PATH`. Run local executables with `npx` (or `npm exec wiki-manager` and
 `npm exec wiki-workspace`). Bun is installed automatically as a package runtime;
-you do not need to add `~/.bun/bin` to `PATH`.
+you do not need to add `~/.bun/bin` to `PATH`. Recent npm versions may require
+the explicit `npm approve-scripts bun` security approval shown above before the
+first launch.
 
 ### Global installation
 
@@ -69,7 +72,12 @@ wiki-workspace --help
 ```
 
 The global installation also installs the required Bun runtime. A separately
-installed Bun remains supported, but is not required.
+installed Bun remains supported, but is not required. If npm blocks Bun's
+installation script, reinstall with:
+
+```bash
+npm install --global --allow-scripts=bun @dotdrelle/wiki-manager
+```
 
 In both modes, launch the commands from the directory that should hold the
 manager state (`workspaces/`, `.env`, and `mcp.endpoints.json`).

package/bin/wiki-manager

@@ -71,6 +71,13 @@ if [[ -z "$BUN_BIN" ]]; then
     'Reinstall @dotdrelle/wiki-manager or install Bun from https://bun.sh/docs/installation.' >&2
   exit 127
 fi
+if ! "$BUN_BIN" --version >/dev/null 2>&1; then
+  printf '%s\n' \
+    'The bundled Bun runtime is installed but not initialized.' \
+    'Local install:  npm approve-scripts bun' \
+    'Global install: npm install -g --allow-scripts=bun @dotdrelle/wiki-manager' >&2
+  exit 126
+fi
 
 if [[ ${#ARGS[@]} -eq 0 ]]; then
   exec "$BUN_BIN" "$BIN_DIR/wiki-manager.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.12.8",
+  "version": "0.12.9",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/cli/wiki-manager.js

@@ -677,6 +677,9 @@ async function runRuntime(argv, agent) {
     port,
     store,
     getContext: getWorkspaceContext,
+    listActiveRuns: () => [...contexts.values()]
+      .filter((context) => context?.running)
+      .map((context) => ({ workspace: context.workspace ?? null, runId: context.currentRunId ?? null })),
     run: executeRun,
     cancel: (context) => emitRuntimeLog(context.session, 'runtime: cancel requested'),
     resume: ({ workspace }) => recoverRuntime({ workspace, manual: true }),
@@ -801,12 +804,18 @@ export async function runCli(argv) {
     let runtime = null;
     try {
       const { ensureRuntime } = await import('../runtime/lifecycle.js');
-      runtime = await ensureRuntime();
+      // If the manager files were just scaffolded, a pre-existing runtime
+      // predates them: restart it so its sessions load the new endpoints.
+      runtime = await ensureRuntime({ forceRestart: scaffolded.length > 0 });
     } catch (err) {
       runtime = unavailableRuntime(err);
       console.error(`Runtime unavailable: ${runtime.error}`);
     }
     await runOpenTuiShell({ agent, packageJson, runtime });
+    if (runtime?.url) {
+      const { shutdownOwnedRuntime } = await import('../runtime/lifecycle.js');
+      await shutdownOwnedRuntime(runtime, { log: (message) => console.log(`[wiki-manager] ${message}`) });
+    }
     return;
   }
 
@@ -821,4 +830,8 @@ export async function runCli(argv) {
     }
   }
   await runShell({ agent, packageJson, runtime });
+  if (runtime?.url) {
+    const { shutdownOwnedRuntime } = await import('../runtime/lifecycle.js');
+    await shutdownOwnedRuntime(runtime, { log: (message) => console.log(`[wiki-manager] ${message}`) });
+  }
 }

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.12.8",
-  "commit": "eefd59f"
+  "version": "0.12.9",
+  "commit": "286bec2"
 }

package/src/core/env.js

@@ -38,8 +38,8 @@ const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..')
 // mcp.endpoints.json nor .env, so the external agents (cme, mailer,
 // documents) silently never connect — /status shows no agents and Donna has
 // no CME tools to configure anything with. Copy the packaged examples so a
-// fresh directory works out of the box with the default agent ports; the
-// user only has to fill in tokens/keys.
+// fresh directory works out of the box with the default agent ports. Optional
+// credentials can be added later for the external services the user enables.
 export function ensureManagerScaffold({ log = () => {} } = {}) {
   const created = [];
   const endpointsFile = managerMcpEndpointsFile();
@@ -55,7 +55,7 @@ export function ensureManagerScaffold({ log = () => {} } = {}) {
     created.push('.env');
   }
   if (created.length > 0) {
-    log(`scaffold: created ${created.join(' and ')} in ${managerStateDir()} from packaged example(s) — fill in tokens/keys (WIKI_WORKSPACES_DIR, *_MCP_AUTH_TOKEN…) before starting agents.`);
+    log(`configuration initialized successfully in ${managerStateDir()} — created ${created.join(' and ')} from packaged defaults. Optional credentials can be added later for external services.`);
   }
   return created;
 }

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.12.8';
+const WIKI_MANAGER_VERSION = '0.12.9';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/wikiSetup.js

@@ -3,6 +3,7 @@ import { readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
 import { patchWikircProfile } from './wikirc.js';
+import { managerEnvFile, managerMcpEndpointsFile } from './env.js';
 import { createWorkspace, findWorkspace, isValidWorkspaceName, listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
 
 const execFileAsync = promisify(execFile);
@@ -39,6 +40,13 @@ export async function startAgents(options = {}) {
       env: {
         ...process.env,
         WIKI_WORKSPACES_DIR: workspacesDir(),
+        // cwd is the npm package root (the script and compose files live
+        // there), so the manager files MUST be pinned explicitly: without
+        // these, wiki-workspace resolved .env and mcp.endpoints.json against
+        // $PWD and generated agent tokens into the PACKAGE directory — the
+        // user's .env stayed empty on a fresh install.
+        WIKI_MANAGER_ENV_FILE: managerEnvFile(),
+        WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
       },
       timeout: options.timeout ?? 180_000,
       maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,

package/src/runtime/lifecycle.js

@@ -39,6 +39,7 @@ export async function ensureRuntime({
   stateDir = process.env.WIKI_MANAGER_STATE_DIR ?? defaultRuntimeStateDir(),
   url = process.env.WIKI_MANAGER_RUNTIME_URL ?? `http://127.0.0.1:${port}`,
   timeoutMs = 5000,
+  forceRestart = false,
 } = {}) {
   const auth = resolveRuntimeAuthToken({ host, stateDir });
   if (auth.token) process.env.WIKI_MANAGER_RUNTIME_TOKEN = auth.token;
@@ -46,7 +47,11 @@ export async function ensureRuntime({
   if (existing) {
     const expectedCacertPath = activeCacertPath();
     const actualCacertPath = existing.cacertPath ? resolve(existing.cacertPath) : null;
-    if (actualCacertPath === expectedCacertPath) {
+    // forceRestart: the caller knows the manager configuration just changed
+    // (e.g. mcp.endpoints.json scaffolded on first run) — a runtime started
+    // BEFORE that only knows the old endpoints and would keep answering
+    // without the agents until manually restarted.
+    if (!forceRestart && actualCacertPath === expectedCacertPath) {
       return { url, started: false, health: existing, token: auth.token, tokenPath: auth.tokenPath };
     }
     await postRuntimeShutdown({ url, token: auth.token });
@@ -99,3 +104,28 @@ export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = run
     return null;
   }
 }
+
+// Contract with the user: the shell OWNS the runtime it started — leaving it
+// alive after exit produced zombie runtimes running yesterday's code and
+// yesterday's endpoints. Nuance preserved: if a run is active anywhere, the
+// runtime is left alive so the run survives the shell (that promise stays).
+export async function shutdownOwnedRuntime(runtime, { log = () => {} } = {}) {
+  if (!runtime?.url || !runtime?.started) return { action: 'kept', reason: 'not_owned' };
+  try {
+    const health = await runtimeHealthOrNull(runtime.url, runtime.token);
+    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 });
+    log('runtime arrêté (démarré par ce shell, aucun run en cours).');
+    return { action: 'shutdown' };
+  } catch (err) {
+    return { action: 'error', reason: err instanceof Error ? err.message : String(err) };
+  }
+}

package/src/runtime/server.js

@@ -20,6 +20,7 @@ export function startRuntimeServer({
   approve,
   configProfiles,
   useConfigProfile,
+  listActiveRuns = null,
   exitOnShutdown = process.env.WIKI_MANAGER_RUNTIME_CHILD === '1',
 } = {}) {
   const clients = new Set();
@@ -52,10 +53,14 @@ export function startRuntimeServer({
       if (request.method === 'GET' && url.pathname === '/health') {
         const workspace = workspaceFromUrl(url);
         const context = workspace ? await resolveContext({ workspace }) : null;
+        // activeRuns spans ALL workspace contexts: the shell uses it at exit
+        // to decide whether shutting down its own runtime would kill work.
+        const activeRuns = typeof listActiveRuns === 'function' ? listActiveRuns() : [];
         sendJson(response, 200, {
           ok: true,
           status: context?.running ? 'running' : 'idle',
           workspace: context?.workspace ?? workspace ?? null,
+          activeRuns,
           dbPath: store.dbPath,
           cacertPath: activeCacertPath(),
           nodeExtraCaCerts: process.env.NODE_EXTRA_CA_CERTS ?? null,

package/src/runtime/server.test.js

@@ -1396,3 +1396,31 @@ test('runtime server answers control messages posted to /run during an active ru
     await handle.close();
   }
 });
+
+test('runtime health reports active runs across workspaces', async (t) => {
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: { dbPath: ':memory:', getState: () => ({ status: 'idle' }), listEvents: () => [] },
+      session: {},
+      // The shell reads this at exit: shutting down its own runtime must not
+      // kill a run that is supposed to survive the shell.
+      listActiveRuns: () => [{ workspace: 'juno', runId: 'run-1234abcd' }],
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const health = await (await fetch(`http://127.0.0.1:${handle.port}/health`)).json();
+    assert.deepEqual(health.activeRuns, [{ workspace: 'juno', runId: 'run-1234abcd' }]);
+  } finally {
+    await handle.close();
+  }
+});