@dotdrelle/wiki-manager 0.11.10 → 0.12.1

package/src/runtime/server.js

@@ -5,6 +5,7 @@ import { activeCacertPath } from '../core/cacert.js';
 import { normalizePlanPatch, rebasePlanPatch } from '../core/planPatch.js';
 import { validateContractInDev } from '../contracts/schemas.js';
 import { runtimeTokenFromEnv } from './auth.js';
+import { controlMessage } from './controlMessages.js';
 
 export function startRuntimeServer({
   host = '127.0.0.1',
@@ -85,6 +86,35 @@ export function startRuntimeServer({
         });
         return;
       }
+      if (request.method === 'GET') {
+        const taskRead = readTaskEndpoint(url);
+        if (taskRead) {
+          if (taskRead.kind === 'run_tasks') {
+            sendJson(response, 200, {
+              ok: true,
+              runId: taskRead.runId,
+              tasks: typeof store.listTasks === 'function' ? store.listTasks({ runId: taskRead.runId }) : [],
+            });
+            return;
+          }
+          if (taskRead.kind === 'task_attempts') {
+            sendJson(response, 200, {
+              ok: true,
+              taskId: taskRead.taskId,
+              attempts: typeof store.listTaskAttempts === 'function' ? store.listTaskAttempts({ taskId: taskRead.taskId }) : [],
+            });
+            return;
+          }
+          if (taskRead.kind === 'task_result') {
+            sendJson(response, 200, {
+              ok: true,
+              taskId: taskRead.taskId,
+              result: typeof store.getTaskResult === 'function' ? store.getTaskResult({ taskId: taskRead.taskId }) : null,
+            });
+            return;
+          }
+        }
+      }
       if (request.method === 'GET' && url.pathname === '/control') {
         const workspace = workspaceFromUrl(url);
         const context = await resolveContext({ workspace });
@@ -112,9 +142,11 @@ export function startRuntimeServer({
             return;
           }
           validateContractInDev('controlMessage', { ...body, action, input });
-          const result = handleControlMessage(context, store, input, {
+          const result = await handleControlMessage(context, store, input, {
             intent: body.intent,
             startNextControlRequest,
+            cancel,
+            approve,
           });
           sendJson(response, result.statusCode, result.body);
           return;
@@ -202,10 +234,6 @@ export function startRuntimeServer({
       }
       if (request.method === 'POST' && url.pathname === '/run') {
         const { body, context } = await resolveBodyContext(request, url);
-        if (context.running) {
-          sendJson(response, 409, { error: 'A runtime run is already active.' });
-          return;
-        }
         try {
           const input = String(body.input ?? body.prompt ?? '').trim();
           if (!input) {
@@ -213,6 +241,18 @@ export function startRuntimeServer({
             return;
           }
           validateContractInDev('runRequest', { ...body, input });
+          if (context.running) {
+            const item = enqueueControlRequest(context, input);
+            sendJson(response, 202, {
+              accepted: true,
+              queued: true,
+              kind: 'enqueue_run',
+              item,
+              ...controlStatus(context, store),
+              explanation: controlMessage(context?.session, 'queued_for_future_run'),
+            });
+            return;
+          }
           const accepted = startRuntimeRun(context, body);
           sendJson(response, 202, accepted);
         } catch (err) {
@@ -262,9 +302,15 @@ export function startRuntimeServer({
         const workspace = workspaceFromBody(body) ?? workspaceFromUrl(url);
         const result = await approve?.({
           workspace,
+          workspaceId: workspace,
           runId: url.searchParams.get('runId') ?? body.runId ?? null,
           itemId: url.searchParams.get('itemId') ?? body.itemId ?? null,
           approvalId: url.searchParams.get('approvalId') ?? body.approvalId ?? null,
+          scope: url.searchParams.get('scope') ?? body.scope ?? null,
+          taskId: url.searchParams.get('taskId') ?? body.taskId ?? null,
+          groupId: url.searchParams.get('groupId') ?? body.groupId ?? null,
+          planRevision: readOptionalNumber(url.searchParams.get('planRevision') ?? body.planRevision),
+          approvalClasses: readOptionalList(body.approvalClasses ?? body.approvalClass ?? url.searchParams.get('approvalClass')),
         });
         sendJson(response, result?.approved ? 202 : 404, result ?? { approved: false });
         return;
@@ -363,6 +409,20 @@ function workspaceFromBody(body) {
   return workspace == null ? null : String(workspace).trim() || null;
 }
 
+function readTaskEndpoint(url) {
+  const parts = url.pathname.split('/').filter(Boolean).map((part) => decodeURIComponent(part));
+  if (parts.length === 3 && parts[0] === 'runs' && parts[2] === 'tasks') {
+    return { kind: 'run_tasks', runId: parts[1] };
+  }
+  if (parts.length === 3 && parts[0] === 'tasks' && parts[2] === 'attempts') {
+    return { kind: 'task_attempts', taskId: parts[1] };
+  }
+  if (parts.length === 3 && parts[0] === 'tasks' && parts[2] === 'result') {
+    return { kind: 'task_result', taskId: parts[1] };
+  }
+  return null;
+}
+
 function controlStatus(context, store) {
   const workspace = context?.workspace ?? context?.session?.workspace ?? null;
   const state = runtimeState(context, store, { workspace });
@@ -419,29 +479,57 @@ function readOnlyControlResponse(kind, classification, status, explanation, { ac
   };
 }
 
-function handleControlMessage(context, store, input, { intent = null, startNextControlRequest = () => false } = {}) {
+function approvalRequestFromStatus(status) {
+  const runId = status.runId ?? status.runs?.find((run) => run.status === 'running' || run.status === 'pending_approval')?.id ?? null;
+  const pending = (status.approvals ?? []).filter((approval) => approval.status === 'pending_approval');
+  const classes = [...new Set(pending.flatMap((approval) => readOptionalList(approval.approvalClasses ?? approval.approvalClass)))];
+  return {
+    workspace: status.workspace ?? null,
+    workspaceId: status.workspace ?? null,
+    runId,
+    scope: 'run',
+    planRevision: status.planRevision ?? null,
+    approvalClasses: classes.length > 0 ? classes : ['default'],
+  };
+}
+
+async function handleControlMessage(context, store, input, { intent = null, startNextControlRequest = () => false, cancel = null, approve = null } = {}) {
   const status = controlStatus(context, store);
   const classification = classifyControlMessage(input, status, intent);
   if (classification.kind === 'observe') {
     return readOnlyControlResponse('observe', classification, status, explainControlState(status));
   }
-  if (classification.kind === 'mutate') {
+  if (classification.kind === 'cancel') {
+    if (context.running && context.currentAbortController) {
+      context.currentAbortController.abort();
+      await cancel?.(context);
+      return readOnlyControlResponse('cancel', classification, controlStatus(context, store), 'Runtime cancellation requested.', { accepted: true });
+    }
+    return readOnlyControlResponse('cancel', classification, status, 'No active run to cancel.', { accepted: false });
+  }
+  if (classification.kind === 'approve') {
+    const result = await approve?.(approvalRequestFromStatus(status));
+    return readOnlyControlResponse('approve', classification, controlStatus(context, store), result?.approved
+      ? 'Approval grant recorded for the current run revision.'
+      : 'Approval intent recorded; no pending approval was available to grant.', { accepted: result?.approved === true, extra: { approval: result ?? null } });
+  }
+  if (classification.kind === 'modify_run') {
     const proposal = storeControlProposal(context, input, classification, status);
     return {
       statusCode: 202,
       body: {
         accepted: true,
-        kind: 'mutate',
+        kind: 'modify_run',
         classification,
         proposal,
         ...controlStatus(context, store),
-        explanation: 'Plan patch proposed. Approve it explicitly to apply it to the active plan.',
+        explanation: controlMessage(context?.session, 'plan_patch_proposed'),
       },
     };
   }
-  if (classification.kind === 'enqueue') {
+  if (classification.kind === 'enqueue_run') {
     const item = enqueueControlRequest(context, input);
-    // Unlike `mutate`, this may synchronously start a queued run (see
+    // Unlike `modify_run`, this may synchronously start a queued run (see
     // startNextControlRequest), which can change running/plan/status — a full
     // controlStatus() recompute is required here, not just controlQueue.
     void startNextControlRequest(context);
@@ -449,28 +537,29 @@ function handleControlMessage(context, store, input, { intent = null, startNextC
       statusCode: 202,
       body: {
         accepted: true,
-        kind: 'enqueue',
+        kind: 'enqueue_run',
         classification,
         item,
         ...controlStatus(context, store),
+        explanation: controlMessage(context?.session, 'queued_for_future_run'),
       },
     };
   }
   if (classification.kind === 'ambiguous') {
-    return readOnlyControlResponse('ambiguous', classification, status, 'The runtime cannot safely classify this message.', {
+    return readOnlyControlResponse('ambiguous', classification, status, controlMessage(context?.session, 'ambiguous_control'), {
       accepted: false,
       extra: {
         choices: [
           { action: 'message', intent: 'observe', label: 'Ask about this run' },
-          { action: 'message', intent: 'mutate', label: 'Propose a change to this run' },
-          { action: 'enqueue', intent: 'enqueue', label: 'Queue as a future run' },
+          { action: 'message', intent: 'modify_run', label: 'Propose a change to this run' },
+          { action: 'enqueue', intent: 'enqueue_run', label: 'Queue as a future run' },
         ],
       },
     });
   }
   return readOnlyControlResponse('converse', classification, status, status.running
-    ? 'Runtime run is still active. This message was treated as conversation and did not create a queued run.'
-    : 'Runtime is idle. This message was treated as conversation and did not create a run.');
+    ? controlMessage(context?.session, 'converse_while_running')
+    : controlMessage(context?.session, 'converse_while_idle'));
 }
 
 function enqueueControlRequest(context, input) {
@@ -510,7 +599,7 @@ function storeControlProposal(context, input, classification, status) {
     origin: 'runtime',
     runId: context.currentRunId ?? status.runId ?? null,
     workspace: proposal.workspace,
-    payload: { input, intent: 'mutate', classification },
+    payload: { input, intent: 'modify_run', classification },
   }));
   dispatchAgentEvent(context.session, createAgentEvent('plan_patch_proposed', {
     origin: 'runtime',
@@ -636,17 +725,34 @@ function classifyControlMessage(input, status, forcedIntent = null) {
   // Caller (the /control message route) already trims and rejects empty input.
   const lower = String(input ?? '').toLowerCase();
   const intent = forcedIntent ? String(forcedIntent).toLowerCase() : null;
-  if (['observe', 'converse', 'mutate', 'enqueue'].includes(intent)) {
-    return { kind: intent, confidence: 1, reason: 'explicit_intent' };
+  const explicit = {
+    observe: 'observe',
+    converse: 'converse',
+    approve: 'approve',
+    modify_run: 'modify_run',
+    mutate: 'modify_run',
+    enqueue_run: 'enqueue_run',
+    enqueue: 'enqueue_run',
+    cancel: 'cancel',
+    ambiguous: 'ambiguous',
+  }[intent];
+  if (explicit) {
+    return { kind: explicit, confidence: 1, reason: 'explicit_intent' };
+  }
+  if (/\b(valide tout|approve all|approve|approuve|valid[eé]|ok pour tout|go pour tout)\b/i.test(lower)) {
+    return { kind: 'approve', confidence: 0.86, reason: 'approval_request' };
+  }
+  if (/\b(cancel|annule|stop|arr[eê]te|interromps|abort)\b/i.test(lower)) {
+    return { kind: 'cancel', confidence: 0.86, reason: 'cancel_request' };
+  }
+  if (/\b(plus tard|later|ensuite|apr[eè]s ce run|enqueue|mets en file|met en file|futur|next run|future run)\b/i.test(lower)) {
+    return { kind: 'enqueue_run', confidence: 0.8, reason: 'future_run_request' };
   }
   if (/\b(o[uù] en es[t-]|status|statut|progress|progression|build|run|job|queue|file|logs?|explique|explain|inspect|show|montre|quoi de neuf)\b/i.test(lower)) {
     return { kind: 'observe', confidence: 0.86, reason: 'status_or_explanation_request' };
   }
   if (status.running && /\b(ajoute|add|change|modifie|modify|remplace|replace|retire|remove|skip|ignore|apr[eè]s|before|after|chaque|each|plan|step|t[aâ]che)\b/i.test(lower)) {
-    return { kind: 'mutate', confidence: 0.78, reason: 'active_run_change_request' };
-  }
-  if (/\b(plus tard|later|ensuite|apr[eè]s ce run|apr[eè]s|enqueue|queue|mets en file|met en file|futur|next run|future run)\b/i.test(lower)) {
-    return { kind: 'enqueue', confidence: 0.8, reason: 'future_run_request' };
+    return { kind: 'modify_run', confidence: 0.78, reason: 'active_run_change_request' };
   }
   if (status.running && /\b(lance|run|g[eé]n[eè]re|build|export|cr[eé]e|create|send|envoie|ingest|convert|importe|import)\b/i.test(lower)) {
     return { kind: 'ambiguous', confidence: 0.45, reason: 'active_run_action_is_ambiguous' };
@@ -688,6 +794,18 @@ function readRequiredPatchId(body, response) {
   return patchId;
 }
 
+function readOptionalNumber(value) {
+  if (value == null || value === '') return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function readOptionalList(value) {
+  if (value == null || value === '') return [];
+  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
+  return String(value).split(',').map((item) => item.trim()).filter(Boolean);
+}
+
 function readJson(request) {
   return new Promise((resolve, reject) => {
     let raw = '';