@dotdrelle/wiki-manager 0.11.9 → 0.12.0

package/src/runtime/server.js

@@ -85,6 +85,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 +141,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 +233,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 +240,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: 'Request queued for a future run.',
+            });
+            return;
+          }
           const accepted = startRuntimeRun(context, body);
           sendJson(response, 202, accepted);
         } catch (err) {
@@ -262,9 +301,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 +408,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,19 +478,47 @@ 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),
@@ -439,9 +526,9 @@ function handleControlMessage(context, store, input, { intent = null, startNextC
       },
     };
   }
-  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,10 +536,11 @@ function handleControlMessage(context, store, input, { intent = null, startNextC
       statusCode: 202,
       body: {
         accepted: true,
-        kind: 'enqueue',
+        kind: 'enqueue_run',
         classification,
         item,
         ...controlStatus(context, store),
+        explanation: 'Request queued for a future run.',
       },
     };
   }
@@ -462,8 +550,8 @@ function handleControlMessage(context, store, input, { intent = null, startNextC
       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' },
         ],
       },
     });
@@ -510,7 +598,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 +724,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 +793,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 = '';

package/src/runtime/server.test.js

@@ -128,6 +128,64 @@ test('runtime server shutdown endpoint closes the listener', async (t) => {
   }));
 });
 
+test('runtime server exposes task assignment attempt and result read endpoints', async (t) => {
+  const taskId = 'run-1:task-a';
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      token: 'runtime-secret',
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+        listTasks: ({ runId }) => runId === 'run-1' ? [{ id: taskId, runId, status: 'done' }] : [],
+        listTaskAttempts: ({ taskId: requested }) => requested === taskId ? [{
+          attemptId: 'attempt-1',
+          taskId,
+          runId: 'run-1',
+          status: 'done',
+          jobId: 'job-1',
+        }] : [],
+        getTaskResult: ({ taskId: requested }) => requested === taskId ? {
+          attemptId: 'attempt-1',
+          taskId,
+          status: 'succeeded',
+          outputRefs: [{ type: 'file', ref: 'deliverables/a.md' }],
+          metrics: { durationMs: 7 },
+        } : null,
+      },
+      session: {},
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const headers = { authorization: 'Bearer runtime-secret' };
+    const tasksResponse = await fetch(`http://127.0.0.1:${handle.port}/runs/run-1/tasks`, { headers });
+    assert.equal(tasksResponse.status, 200);
+    assert.deepEqual((await tasksResponse.json()).tasks, [{ id: taskId, runId: 'run-1', status: 'done' }]);
+
+    const encodedTaskId = encodeURIComponent(taskId);
+    const attemptsResponse = await fetch(`http://127.0.0.1:${handle.port}/tasks/${encodedTaskId}/attempts`, { headers });
+    assert.equal(attemptsResponse.status, 200);
+    assert.equal((await attemptsResponse.json()).attempts[0].attemptId, 'attempt-1');
+
+    const resultResponse = await fetch(`http://127.0.0.1:${handle.port}/tasks/${encodedTaskId}/result`, { headers });
+    assert.equal(resultResponse.status, 200);
+    assert.equal((await resultResponse.json()).result.metrics.durationMs, 7);
+  } finally {
+    await handle.close();
+  }
+});
+
 test('runtime server accepts only one active run', async (t) => {
   let releaseRun;
   let runCount = 0;
@@ -157,7 +215,6 @@ test('runtime server accepts only one active run', async (t) => {
 
   try {
     const url = `http://127.0.0.1:${handle.port}/run`;
-    let acceptedRun = null;
     const [first, second] = await Promise.all([
       fetch(url, {
         method: 'POST',
@@ -171,9 +228,11 @@ test('runtime server accepts only one active run', async (t) => {
       }),
     ]);
 
-    assert.deepEqual([first.status, second.status].sort(), [202, 409]);
-    const accepted = first.status === 202 ? first : second;
-    acceptedRun = await accepted.json();
+    assert.deepEqual([first.status, second.status], [202, 202]);
+    const bodies = [await first.json(), await second.json()];
+    const acceptedRun = bodies.find((body) => body.accepted && !body.queued);
+    const queuedRun = bodies.find((body) => body.queued);
+    assert.equal(queuedRun.kind, 'enqueue_run');
     assert.equal(acceptedRun.accepted, true);
     assert.match(acceptedRun.runId, /^[0-9a-f-]{36}$/);
     assert.equal(runCount, 1);
@@ -336,12 +395,13 @@ test('runtime server isolates active runs by workspace', async (t) => {
     ]);
     assert.deepEqual([juno.status, docs.status], [202, 202]);
 
-    const conflict = await fetch(`${url}?workspace=juno`, {
+    const queued = await fetch(`${url}?workspace=juno`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ input: 'third' }),
     });
-    assert.equal(conflict.status, 409);
+    assert.equal(queued.status, 202);
+    assert.equal((await queued.json()).queued, true);
     assert.deepEqual(runWorkspaces.sort(), ['docs', 'juno']);
   } finally {
     releases.get('juno')?.();
@@ -521,9 +581,15 @@ test('runtime server exposes approval endpoint', async (t) => {
     assert.equal(response.status, 202);
     assert.deepEqual(approved, {
       workspace: 'juno',
+      workspaceId: 'juno',
       runId: 'run-1',
       itemId: 'item-1',
       approvalId: null,
+      scope: null,
+      taskId: null,
+      groupId: null,
+      planRevision: null,
+      approvalClasses: [],
     });
     assert.deepEqual(await response.json(), { approved: true, runId: 'run-1', itemId: 'item-1' });
   } finally {
@@ -705,6 +771,70 @@ test('runtime server control message observes an active run without enqueueing',
   }
 });
 
+test('runtime server control message handles approve and cancel intents during an active run', async (t) => {
+  const session = {
+    workspace: 'juno',
+    controlQueue: [],
+  };
+  const abortController = new AbortController();
+  let cancelled = false;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({
+          status: 'running',
+          plan: [{ step: 1, description: 'Build documents', status: 'running' }],
+          queue: [],
+          approvals: [],
+          summary: null,
+        }),
+        listEvents: () => [],
+      },
+      getContext: async () => ({
+        workspace: 'juno',
+        session,
+        running: true,
+        currentAbortController: abortController,
+      }),
+      cancel: async () => { cancelled = true; },
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const approveResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'message', input: 'valide tout' }),
+    });
+    assert.equal(approveResponse.status, 200);
+    assert.equal((await approveResponse.json()).kind, 'approve');
+
+    const cancelResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'message', input: 'annule le run' }),
+    });
+    assert.equal(cancelResponse.status, 200);
+    assert.equal((await cancelResponse.json()).kind, 'cancel');
+    assert.equal(cancelled, true);
+    assert.equal(abortController.signal.aborted, true);
+    assert.equal(session.controlQueue.length, 0);
+  } finally {
+    await handle.close();
+  }
+});
+
 test('runtime server control message records active plan mutation as a proposal', async (t) => {
   const session = {
     workspace: 'juno',
@@ -765,7 +895,7 @@ test('runtime server control message records active plan mutation as a proposal'
     });
     assert.equal(response.status, 202);
     const body = await response.json();
-    assert.equal(body.kind, 'mutate');
+    assert.equal(body.kind, 'modify_run');
     assert.equal(body.proposal.status, 'proposed');
     assert.equal(body.proposal.input, 'Ajoute un envoi après chaque génération');
     assert.equal(session.agentProjection.planPatches[0].status, 'proposed');