@dotdrelle/wiki-manager 0.7.3 → 0.9.3

package/src/cli/wiki-manager.js

@@ -1,4 +1,3 @@
-import { randomUUID } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
@@ -6,9 +5,11 @@ import { fileURLToPath } from 'node:url';
 import { loadManagerEnv } from '../core/env.js';
 loadManagerEnv();
 import { createAgentGraph } from '../agent/graph.js';
-import { handleSlashCommand, printHelp, printVersion } from '../commands/slash.js';
+import { handleSlashCommand, printHelp, printVersion, refreshMcpRuntimeStatus } from '../commands/slash.js';
 import { runShell } from '../shell/repl.js';
 import { runChecks } from '../core/startupCheck.js';
+import { applySessionWikircProfile } from '../core/sessionConfig.js';
+import { listWikircProfiles } from '../core/wikirc.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
 import { extractActivity, parseJsonText, sessionActivities, terminalFailures } from '../core/activity.js';
 import { syncActivitiesToPlan, formatPlanStatus } from '../core/plan.js';
@@ -20,7 +21,7 @@ import { runAgentTurn, runAgenticLoop } from '../core/agentLoop.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageJsonPath = resolve(__dirname, '../../package.json');
 const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'clear', 'chat', 'agent'];
+const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'clear', 'chat', 'agent', 'approve'];
 
 function valueAfter(argv, flag) {
   const index = argv.indexOf(flag);
@@ -286,12 +287,13 @@ async function runRuntime(argv, agent) {
     ].join('\n'));
     return;
   }
-  const { defaultRuntimeStateDir, openRuntimeStore } = await import('../runtime/store.js');
+  const { defaultRuntimeStateDir, openRuntimeStore, RECOVERABLE_QUEUE_STATUSES } = await import('../runtime/store.js');
   const { startRuntimeServer } = await import('../runtime/server.js');
   const { emitRuntimeLog, startActivitySupervisor } = await import('../runtime/supervisor.js');
   const { resolveRuntimeAuthToken } = await import('../runtime/auth.js');
   const { createSqliteQueueStore } = await import('../runtime/queueStore.js');
-  const { runRuntimeAgenticLoop } = await import('../runtime/runner.js');
+  const { createApprovalManager } = await import('../runtime/approvals.js');
+  const { runRuntimeAgenticWorkflow } = await import('../runtime/runner.js');
 
   const host = valueAfter(argv, '--host') ?? process.env.WIKI_MANAGER_RUNTIME_HOST ?? '0.0.0.0';
   const port = Number(valueAfter(argv, '--port') ?? process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788);
@@ -302,45 +304,270 @@ async function runRuntime(argv, agent) {
     throw new Error(`Invalid runtime port: ${port}`);
   }
 
-  const session = createSession();
-  session.headless = true;
-  session.chatMode = false;
-  session.packageJson = packageJson;
-
   const store = openRuntimeStore({ stateDir });
-  store.hydrateSession(session);
-  session.queueStore = createSqliteQueueStore(store, session);
-
   let serverHandle = null;
-  session._onAgentEvent = (event) => {
-    store.persistEvent(event);
-    serverHandle?.publish(event);
-  };
-  session._onRuntimeError = (err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    dispatchAgentEvent(session, createAgentEvent('run_error', {
-      origin: 'runtime',
-      payload: { message },
-    }));
-  };
+  const contexts = new Map();
+
+  async function getWorkspaceContext(workspaceName = null) {
+    const requestedWorkspace = workspaceName ? String(workspaceName).trim() : null;
+    const key = requestedWorkspace ?? '__default__';
+    if (contexts.has(key)) return contexts.get(key);
+
+    const pending = (async () => {
+      const session = createSession();
+      session.headless = true;
+      session.chatMode = false;
+      session.packageJson = packageJson;
+
+      if (requestedWorkspace) {
+        const result = await handleSlashCommand(`/use ${requestedWorkspace}`, { packageJson, session });
+        if (!session.workspacePath) throw new Error(result.output || `Workspace not loaded: ${requestedWorkspace}`);
+      }
+      const workspace = session.workspace ?? requestedWorkspace ?? null;
+      store.hydrateSession(session, { workspace });
+      session.queueStore = createSqliteQueueStore(store, session, { workspace });
+
+      const context = {
+        workspace,
+        session,
+        supervisor: null,
+        running: false,
+        currentAbortController: null,
+        approvalManager: null,
+      };
+      session._onAgentEvent = (event) => {
+        store.persistEvent(event);
+        serverHandle?.publish(event);
+      };
+      session._onRuntimeError = (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        dispatchAgentEvent(session, createAgentEvent('run_error', {
+          origin: 'runtime',
+          payload: { message, workspace },
+        }));
+      };
+      context.approvalManager = createApprovalManager(session, {
+        defaultTimeoutMs: Number.isFinite(Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS))
+          ? Math.max(1, Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS))
+          : undefined,
+      });
+      session._requestApproval = (request) => context.approvalManager.requestApproval(request);
+      context.supervisor = startActivitySupervisor(session);
+      contexts.set(key, context);
+      if (workspace && workspace !== key) contexts.set(workspace, context);
+      return context;
+    })();
+    contexts.set(key, pending);
+    pending.catch(() => {
+      if (contexts.get(key) === pending) contexts.delete(key);
+    });
+    return pending;
+  }
+
+  function recoveryMcpGaps(context) {
+    const gaps = [];
+    const session = context.session;
+    for (const activity of sessionActivities(session)) {
+      if (activity.terminal || !activity.poll?.server) continue;
+      const endpoint = session.mcp?.[activity.poll.server];
+      if (endpoint?.status !== 'connected') gaps.push(activity.poll.server);
+    }
+    for (const item of session.queueStore?.list?.() ?? []) {
+      const status = String(item.status ?? '').toLowerCase();
+      if (!RECOVERABLE_QUEUE_STATUSES.includes(status)) continue;
+      const endpoint = session.mcp?.[item.server ?? 'production'];
+      if (endpoint?.status !== 'connected') gaps.push(item.server ?? 'production');
+    }
+    return [...new Set(gaps)];
+  }
+
+  function activeNonTerminalActivities(session) {
+    return sessionActivities(session).filter((activity) => !activity.terminal);
+  }
+
+  function activePollingActivities(session) {
+    return activeNonTerminalActivities(session).filter((activity) => activity.poll);
+  }
+
+  function buildRecoveryPrompt(run, session) {
+    const conversation = session.agentProjection?.conversation ?? [];
+    const recentConversation = conversation
+      .slice(-8)
+      .map((message) => `${message.role}: ${message.content}`)
+      .join('\n');
+    return [
+      'Resume an interrupted runtime run.',
+      '',
+      'Original task:',
+      run.input ?? '(unknown)',
+      '',
+      session.headlessPlan ? `Current plan:\n${formatPlanStatus(session.headlessPlan)}` : null,
+      recentConversation ? `Recent conversation:\n${recentConversation}` : null,
+      '',
+      'Continue from the current plan state. Start only the next pending step.',
+      'If the work is already complete, provide a concise final summary.',
+    ].filter(Boolean).join('\n');
+  }
+
+  function startRecoveredAgenticRun(context, run) {
+    if (context.running) return false;
+    const session = context.session;
+    const supervisor = context.supervisor;
+    const runId = run.id;
+    const input = buildRecoveryPrompt(run, session);
+    context.running = true;
+    context.currentAbortController = new AbortController();
+    session._currentRunIdentity = {
+      runId,
+      turnId: `${runId}:resume-0`,
+      workspace: context.workspace,
+    };
+    session._abortSignal = context.currentAbortController.signal;
+    supervisor?.setRunSignal(context.currentAbortController.signal);
+    session._onStep = (message) => emitRuntimeLog(session, message);
+    emitRuntimeLog(session, `runtime: resuming interrupted run ${runId}`);
+
+    runRuntimeAgenticWorkflow(agent, session, run.input ?? input, {
+      initialInput: input,
+      signal: context.currentAbortController.signal,
+      timeoutMs: 3600 * 1000,
+      maxTurns: 20,
+      runId,
+      pollBusy: supervisor?.pollBusy,
+    })
+      .catch((err) => {
+        if (err?.name === 'AbortError') {
+          dispatchAgentEvent(session, createAgentEvent('run_cancelled', {
+            origin: 'runtime',
+            runId,
+            payload: { runId, message: 'Recovered runtime run cancelled.' },
+          }));
+          return;
+        }
+        dispatchAgentEvent(session, createAgentEvent('run_error', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            runId,
+            message: err instanceof Error ? err.message : String(err),
+          },
+        }));
+      })
+      .finally(() => {
+        context.running = false;
+        context.currentAbortController = null;
+        supervisor?.setRunSignal(null);
+        delete session._abortSignal;
+        delete session._onStep;
+        delete session._currentRunIdentity;
+      });
 
-  let supervisor = null;
+    return true;
+  }
 
-  async function executeRun(body, { signal } = {}) {
+  async function recoverWorkspace(workspace, { manual = false } = {}) {
+    try {
+      const context = await getWorkspaceContext(workspace);
+      await refreshMcpRuntimeStatus(context.session);
+      const gaps = recoveryMcpGaps(context);
+      if (gaps.length > 0) {
+        const interrupted = store.interruptRuns({ workspace: context.workspace });
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: false,
+          interrupted,
+          reason: `MCP unavailable: ${gaps.join(', ')}`,
+        };
+      }
+      const recoverableRuns = store.listRecoverableRuns({ workspace: context.workspace });
+      const runningRun = recoverableRuns.find((run) => run.status === 'running');
+      const activeActivities = activeNonTerminalActivities(context.session);
+      const pollingActivities = activePollingActivities(context.session);
+      if (runningRun && activeActivities.length === 0) {
+        if (!runningRun.input) {
+          const interrupted = store.interruptRuns({ workspace: context.workspace });
+          return {
+            workspace: context.workspace ?? workspace ?? null,
+            resumed: false,
+            interrupted,
+            reason: 'Missing original run input.',
+          };
+        }
+        const started = startRecoveredAgenticRun(context, runningRun);
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: started,
+          interrupted: 0,
+          mode: 'agentic_loop',
+        };
+      }
+      if (runningRun && runningRun.input && pollingActivities.length > 0) {
+        context.session._onActivitiesTerminal = () => {
+          startRecoveredAgenticRun(context, runningRun);
+        };
+        emitRuntimeLog(context.session, `runtime: recovery watching ${pollingActivities.length} active activity(s)`);
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: true,
+          interrupted: 0,
+          mode: 'activity_poll_then_resume',
+        };
+      }
+      emitRuntimeLog(context.session, manual ? 'runtime: manual resume completed' : 'runtime: recovery completed');
+      const controlStarted = pollingActivities.length === 0
+        ? serverHandle?.drainControl?.(context) === true
+        : false;
+      return {
+        workspace: context.workspace ?? workspace ?? null,
+        resumed: true,
+        interrupted: 0,
+        mode: controlStarted ? 'control_queue' : pollingActivities.length > 0 ? 'activity_poll' : 'context',
+      };
+    } catch (err) {
+      const interrupted = store.interruptRuns({ workspace });
+      return {
+        workspace: workspace ?? null,
+        resumed: false,
+        interrupted,
+        reason: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
+
+  async function recoverRuntime({ workspace = null, manual = false } = {}) {
+    const workspaces = workspace ? [workspace] : store.listRecoverableWorkspaces();
+    const results = await Promise.all(workspaces.map((item) => recoverWorkspace(item, { manual })));
+    return {
+      resumed: results.filter((result) => result.resumed).length,
+      interrupted: results.reduce((sum, result) => sum + Number(result.interrupted ?? 0), 0),
+      workspaces: results,
+    };
+  }
+
+  async function executeRun(context, body, { signal } = {}) {
+    const session = context.session;
+    const supervisor = context.supervisor;
     const input = String(body.input ?? body.prompt ?? '').trim();
     const workspace = body.workspace ? String(body.workspace).trim() : null;
     const timeoutMs = (Number.isFinite(Number(body.timeout)) ? Math.max(1, Number(body.timeout)) : 3600) * 1000;
     const maxTurns = Number.isFinite(Number(body.maxTurns)) ? Math.max(1, Number(body.maxTurns)) : 20;
-    const runId = randomUUID();
+    const maxReplans = Number.isFinite(Number(body.replans)) ? Math.max(0, Math.floor(Number(body.replans))) : undefined;
+    const runId = String(body.runId);
     try {
       if (workspace && session.workspace !== workspace) {
         const result = await handleSlashCommand(`/use ${workspace}`, { packageJson, session });
         if (!session.workspacePath) throw new Error(result.output || `Workspace not loaded: ${workspace}`);
       }
+      context.workspace = session.workspace ?? workspace ?? context.workspace ?? null;
+      session._currentRunIdentity = {
+        runId,
+        turnId: `${runId}:turn-0`,
+        workspace: context.workspace,
+      };
       dispatchAgentEvent(session, createAgentEvent('run_started', {
         origin: 'runtime',
         runId,
-        payload: { input, workspace },
+        payload: { input, workspace: session._currentRunIdentity.workspace },
       }));
       dispatchAgentEvent(session, createAgentEvent('user_message', {
         origin: 'user',
@@ -348,35 +575,22 @@ async function runRuntime(argv, agent) {
         payload: { content: input },
       }));
       session._abortSignal = signal ?? null;
+      session._runApprovalRequired = body.requireApproval === true;
+      session._runApprovalResolved = false;
+      session._approvalTimeoutMs = Number.isFinite(Number(body.approvalTimeoutMs))
+        ? Math.max(1, Number(body.approvalTimeoutMs))
+        : undefined;
       supervisor?.setRunSignal(signal);
       session._onStep = (message) => emitRuntimeLog(session, message);
-      const result = await runRuntimeAgenticLoop(agent, session, input, {
+      await runRuntimeAgenticWorkflow(agent, session, input, {
         signal,
         timeoutMs,
         maxTurns,
         runId,
         pollBusy: supervisor?.pollBusy,
+        evaluate: body.evaluate !== false,
+        ...(maxReplans === undefined ? {} : { maxReplans }),
       });
-      if (!result.ok) {
-        dispatchAgentEvent(session, createAgentEvent('run_error', {
-          origin: 'runtime',
-          runId,
-          payload: {
-            runId,
-            message: result.timedOut
-              ? 'Runtime agentic loop timed out.'
-              : result.maxTurns
-                ? `Runtime agentic loop reached max turns (${maxTurns}).`
-                : 'Runtime agentic loop failed.',
-          },
-        }));
-        return;
-      }
-      dispatchAgentEvent(session, createAgentEvent('run_done', {
-        origin: 'runtime',
-        runId,
-        payload: { runId },
-      }));
     } catch (err) {
       if (err?.name === 'AbortError') {
         dispatchAgentEvent(session, createAgentEvent('run_cancelled', {
@@ -401,6 +615,10 @@ async function runRuntime(argv, agent) {
       supervisor?.setRunSignal(null);
       delete session._abortSignal;
       delete session._onStep;
+      delete session._currentRunIdentity;
+      delete session._runApprovalRequired;
+      delete session._runApprovalResolved;
+      delete session._approvalTimeoutMs;
     }
   }
 
@@ -408,19 +626,54 @@ async function runRuntime(argv, agent) {
     host,
     port,
     store,
-    session,
+    getContext: getWorkspaceContext,
     run: executeRun,
-    cancel: () => emitRuntimeLog(session, 'runtime: cancel requested'),
+    cancel: (context) => emitRuntimeLog(context.session, 'runtime: cancel requested'),
+    resume: ({ workspace }) => recoverRuntime({ workspace, manual: true }),
+    approve: async ({ workspace, runId, itemId, approvalId }) => {
+      const context = await getWorkspaceContext(workspace);
+      return context.approvalManager?.approve({ runId, itemId, approvalId }) ?? { approved: false };
+    },
+    configProfiles: async (context) => {
+      const profiles = listWikircProfiles(context.session.workspacePath);
+      return {
+        profiles: profiles.map((profile) => profile.name),
+        active: context.session.wikirc?.profile ?? null,
+        items: profiles.map((profile) => ({
+          name: profile.name,
+          fileName: profile.fileName,
+          default: Boolean(profile.default),
+        })),
+      };
+    },
+    useConfigProfile: async (context, profile) => {
+      const { summary, config } = applySessionWikircProfile(context.session, profile);
+      await refreshMcpRuntimeStatus(context.session);
+      dispatchAgentEvent(context.session, createAgentEvent('runtime_log', {
+        origin: 'runtime',
+        payload: { message: `runtime: config profile switched to ${context.session.wikirc?.profile ?? profile}` },
+      }));
+      return {
+        ok: true,
+        active: context.session.wikirc?.profile ?? profile,
+        fileName: context.session.wikirc?.fileName ?? null,
+        summary,
+        config,
+      };
+    },
     token: auth.token,
   });
-  supervisor = startActivitySupervisor(session);
+  const recovery = await recoverRuntime();
 
   console.log(`wiki-manager runtime listening on http://${host}:${port}`);
   console.log(`runtime state: ${store.dbPath}`);
+  if (recovery.resumed > 0 || recovery.interrupted > 0) {
+    console.log(`runtime recovery: resumed=${recovery.resumed} interrupted=${recovery.interrupted}`);
+  }
   if (auth.tokenPath) console.log(`runtime token: ${auth.tokenPath}`);
 
   const shutdown = async () => {
-    supervisor?.stop();
+    await Promise.all([...new Set(contexts.values())].map(async (v) => { (await v).supervisor?.stop(); }));
     await serverHandle.close();
     store.close();
     process.exit(0);

package/src/commands/slash.js

@@ -1,7 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join, relative } from 'node:path';
-import { createLlmClientFromWikiConfig } from '../agent/llm.js';
 import { composeServices, listServices, runWikiCli, serviceLogs, serviceStates, startService, stopService } from '../core/compose.js';
 import {
   applyMcpRuntimeStatus,
@@ -26,10 +25,10 @@ import {
 } from '../core/jobQueue.js';
 import {
   listWikircProfiles,
-  loadWikircProfile,
   resolveWikircProfile,
   summarizeWikircConfig,
 } from '../core/wikirc.js';
+import { applySessionWikircProfile } from '../core/sessionConfig.js';
 import { deleteWorkspaceAndFiles, startAgents, stopAgents } from '../core/wikiSetup.js';
 import {
   cleanDocumentUploads,
@@ -490,7 +489,7 @@ function publishDocumentActivity(session, activity) {
   return publishPayloadActivity(session, { _activity: activity }, { server: 'documents', tool: 'documents_convert_to_markdown' });
 }
 
-async function refreshMcpRuntimeStatus(session) {
+export async function refreshMcpRuntimeStatus(session) {
   session.mcp = buildMcpStatus(session);
   if (!session.workspacePath) return null;
   try {
@@ -546,25 +545,6 @@ function loadWorkspaceSystemPrompt(workspacePath) {
   return existsSync(promptPath) ? readFileSync(promptPath, 'utf8').trim() || null : null;
 }
 
-function loadSessionWikirc(session, profileName = 'default') {
-  if (!session.workspacePath) {
-    throw new Error('No workspace loaded. Use /use <workspace>.');
-  }
-  const loaded = loadWikircProfile(session.workspacePath, profileName);
-  session.wikirc = {
-    profile: loaded.profile.name,
-    fileName: loaded.profile.fileName,
-    path: loaded.profile.path,
-  };
-  session.wikircConfig = loaded.config;
-  session.language = loaded.config?.language ?? null;
-  session.llm = createLlmClientFromWikiConfig(loaded.config);
-  if (session.mcp?.production) {
-    session.mcp.production.activeConfigPath = loaded.profile.fileName;
-  }
-  return summarizeWikircConfig(loaded.profile, loaded.config);
-}
-
 function clearWorkspaceSession(session) {
   session.workspace = null;
   session.workspacePath = null;
@@ -720,7 +700,7 @@ export async function handleSlashCommand(line, context) {
       context.session.systemPrompt = loadWorkspaceSystemPrompt(workspace.workspacePath);
       try {
         step(`Workspace: loading ${workspace.name} config…`);
-        const summary = loadSessionWikirc(context.session, 'default');
+        const { summary } = applySessionWikircProfile(context.session, 'default');
         step(`Workspace: discovering ${workspace.name} MCP tools…`);
         await refreshMcpRuntimeStatus(context.session);
         return {
@@ -759,7 +739,7 @@ export async function handleSlashCommand(line, context) {
           return { output: 'Usage: /config use <default|name>' };
         }
         try {
-          const summary = loadSessionWikirc(context.session, profileName);
+          const { summary } = applySessionWikircProfile(context.session, profileName);
           await refreshMcpRuntimeStatus(context.session);
           return {
             output: [