@dotdrelle/wiki-manager 0.15.42 → 0.15.48

package/src/runtime/server.test.js

@@ -1,7 +1,11 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { createInteractiveSession, ensureInteractiveAssistantMessage } from '../cli/wiki-manager.js';
+import { postRuntimeRun } from './client.js';
 import { approvalRequestFromStatus, runtimeState, startRuntimeServer as startRuntimeServerImpl } from './server.js';
 
 // Most server tests exercise endpoint behavior rather than authentication. Keep
@@ -11,6 +15,45 @@ function startRuntimeServer(options) {
   return startRuntimeServerImpl({ token: '', ...options });
 }
 
+test('runtime run client surfaces the server error instead of only the HTTP status', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => new Response(JSON.stringify({
+    error: 'Workspace services are unavailable. Start them with /start all, then retry.',
+    code: 'services_unavailable',
+  }), {
+    status: 400,
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+  try {
+    await assert.rejects(
+      postRuntimeRun('build the wiki', { workspace: 'demo' }),
+      (error) => {
+        assert.equal(error.message, 'Runtime run failed: HTTP 400 — Workspace services are unavailable. Start them with /start all, then retry.');
+        assert.equal(error.status, 400);
+        assert.equal(error.code, 'services_unavailable');
+        return true;
+      },
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('runtime run client keeps the HTTP fallback without a JSON error body', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => new Response('Bad request', { status: 400 });
+
+  try {
+    await assert.rejects(
+      postRuntimeRun('build the wiki', { workspace: 'demo' }),
+      /Runtime run failed: HTTP 400/,
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
 test('approval fallback derives classes from waiting tasks when the approval queue is missing', () => {
   const request = approvalRequestFromStatus({
     workspace: 'acme',
@@ -1485,6 +1528,304 @@ test('runtime server handle drains a pre-existing hydrated control request', asy
   }
 });
 
+test('POST /run compiles a workspace skill into a sequential runtime chain', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'runtime-skill-'));
+  mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'skills', 'wiki-sync.md'), '---\nname: wiki-sync\nparams:\n  - source\n---\nExport the source.\n\nThen ingest the files.');
+  const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
+  const context = { workspace: 'acme', session, running: false, currentAbortController: null };
+  let startedBody = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => ({ status: 'idle', plan: [], queue: [], approvals: [] }), listEvents: () => [] },
+      getContext: async () => context,
+      run: async (_context, body) => { startedBody = body; return new Promise(() => {}); },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/run?workspace=acme`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ input: '/wiki-sync docs' }) });
+    const body = await response.json();
+    assert.equal(response.status, 202);
+    assert.equal(body.kind, 'skill_chain');
+    assert.equal(body.objectives, 2);
+    assert.equal(session.controlQueue.length, 2);
+    assert.equal(session.controlQueue[0].status, 'running');
+    assert.equal(session.controlQueue[1].status, 'queued');
+    assert.equal(session.controlQueue[0].chainId, session.controlQueue[1].chainId);
+    assert.equal('capabilityPlan' in session.controlQueue[0], false);
+    assert.equal(session.controlQueue[0].input, '/wiki-sync source="docs"');
+    assert.equal(session.controlQueue[0].skillExecution, 'orchestrated');
+    assert.match(startedBody.input, /Export the source/);
+    assert.equal(startedBody.publicInput, '/wiki-sync source="docs"');
+    assert.equal(startedBody.skillChain.execution, 'orchestrated');
+    assert.equal(startedBody.requireApproval, true);
+    assert.notEqual(startedBody.autoApprove, true);
+    assert.deepEqual(session.agentProjection.conversation, [
+      { role: 'user', content: '/wiki-sync docs' },
+    ]);
+    assert.doesNotMatch(JSON.stringify(session.agentEvents), /Export the source|Then ingest the files/);
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('POST /turn deterministically compiles an explicit skill invocation', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'runtime-skill-turn-'));
+  mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'skills', 'wiki-build.md'), '---\nname: wiki-build\nparams:\n  - template\n---\nBuild the requested template.');
+  const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
+  const context = { workspace: 'acme', session, running: false, currentAbortController: null };
+  const turns = [];
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => ({ status: 'idle', plan: [], queue: [], approvals: [] }), listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+      turn: async (_context, body) => { turns.push(body); return { ok: true }; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/turn?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ input: '/wiki-build overview', mode: 'agent' }),
+    });
+    const body = await response.json();
+    assert.equal(response.status, 202);
+    assert.equal(body.kind, 'skill_chain');
+    assert.equal(body.skill, 'wiki-build');
+    assert.equal(turns.length, 0);
+    assert.equal(session.controlQueue.length, 1);
+    assert.equal(session.controlQueue[0].input, '/wiki-build template="overview"');
+    assert.deepEqual(session.agentProjection.conversation, [
+      { role: 'user', content: '/wiki-build overview' },
+    ]);
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('POST /turn keeps informational skill and build questions conversational', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'runtime-skill-question-'));
+  mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'skills', 'new-template.md'), '---\nname: new-template\nparams:\n  - family\n---\nCreate one template.');
+  const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
+  const context = { workspace: 'acme', session, running: false, currentAbortController: null };
+  const turns = [];
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => ({ status: 'idle', plan: [], queue: [], approvals: [] }), listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+      turn: async (_context, body) => { turns.push(body); return { ok: true }; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    for (const input of ['Comment fonctionne new-template ?', "Qu'est-ce qu'un build ?"]) {
+      const response = await fetch(`http://127.0.0.1:${handle.port}/turn?workspace=acme`, {
+        method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ input, mode: 'agent' }),
+      });
+      const body = await response.json();
+      assert.equal(response.status, 202);
+      assert.equal(body.kind, 'turn');
+    }
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.deepEqual(turns.map((body) => body.input), [
+      'Comment fonctionne new-template ?',
+      "Qu'est-ce qu'un build ?",
+    ]);
+    assert.equal(session.controlQueue.length, 0);
+    assert.equal(context.running, false);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('POST /run accepts named skill arguments and deduplicates an explicit retry key', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'runtime-named-skill-'));
+  mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'skills', 'deliver.md'), '---\nname: deliver\nparams:\n  - template\n  - polish\n---\nDeliver the output.');
+  const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
+  const context = { workspace: 'acme', session, running: false, currentAbortController: null };
+  const persisted = new Map();
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: {
+        dbPath: ':memory:', getState: () => ({ status: 'idle', plan: [], queue: [], approvals: [] }), listEvents: () => [],
+        findSkillRun: ({ idempotencyKey }) => persisted.get(idempotencyKey) ?? null,
+        persistSkillRun: ({ idempotencyKey, chainId }) => persisted.set(idempotencyKey, chainId),
+      },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    const request = () => fetch(`http://127.0.0.1:${handle.port}/run?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ input: '/deliver', skillName: 'deliver', skillArguments: { template: 'Quarterly report' }, idempotencyKey: 'retry-1' }),
+    });
+    const first = await (await request()).json();
+    const second = await (await request()).json();
+    assert.equal(first.accepted, true);
+    assert.equal(second.deduplicated, true);
+    assert.equal(second.chainId, first.chainId);
+    assert.equal(session.controlQueue.length, 1);
+    assert.equal('input' in first.items[0], false);
+    assert.equal('objectives' in first, false);
+    assert.equal(session.controlQueue[0].input, '/deliver template="Quarterly report"');
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('POST /run does not unlock a reserved skill with a mismatched skillName', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'runtime-reserved-skill-'));
+  mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'skills', 'status.md'), '---\nname: status\nparams: []\n---\nRun the workspace status skill.');
+  const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
+  const context = { workspace: 'acme', session, running: false, currentAbortController: null };
+  let received = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => ({ status: 'idle', plan: [], queue: [], approvals: [] }), listEvents: () => [] },
+      getContext: async () => context,
+      run: async (_context, body) => { received = body; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/run?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ input: '/status', skillName: 'anything' }),
+    });
+    const body = await response.json();
+    assert.equal(response.status, 202);
+    assert.notEqual(body.kind, 'skill_chain');
+    assert.equal(session.controlQueue.length, 0);
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(received.input, '/status');
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('structured named arguments unlock a reserved skill only when input names the same skill', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'runtime-structured-reserved-'));
+  mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'skills', 'status.md'), '---\nname: status\n---\nRun workspace status.');
+  const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
+  const context = { workspace: 'acme', session, running: false, currentAbortController: null };
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => ({ status: 'idle', plan: [], queue: [], approvals: [] }), listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    const post = (input) => fetch(`http://127.0.0.1:${handle.port}/run?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ input, skillName: 'status', skillArguments: {} }),
+    });
+    const mismatch = await post('/deliver');
+    assert.equal(mismatch.status, 400);
+    assert.equal((await mismatch.json()).code, 'skill_name_mismatch');
+    const explicit = await post('/status');
+    assert.equal(explicit.status, 202);
+    assert.equal((await explicit.json()).skill, 'status');
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('legacy placeholders consume only their own parameter', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'runtime-partial-placeholder-'));
+  mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'skills', 'partial.md'), '---\nname: partial\nparams:\n  - a\n  - b\n---\nUse {a}.\n\nThen process the remaining input.');
+  const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
+  const context = { workspace: 'acme', session, running: false, currentAbortController: null };
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => ({ status: 'idle', plan: [], queue: [], approvals: [] }), listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/run?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ input: '/partial alpha beta' }),
+    });
+    const body = await response.json();
+    assert.equal(response.status, 202);
+    assert.deepEqual(body.deprecatedPlaceholders, ['a']);
+    assert.equal(session.controlQueue.length, 2);
+    for (const item of session.controlQueue) assert.equal(item.input, '/partial a="alpha" b="beta"');
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('POST /control cancel_item returns a readable non-error for a non-queued item', async (t) => {
+  const session = { workspace: 'acme', controlQueue: [{ id: 'done-item', status: 'done', input: 'done' }] };
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => ({ status: 'idle', plan: [], queue: [], approvals: [] }), listEvents: () => [] },
+      getContext: async () => ({ workspace: 'acme', session, running: false }), run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ action: 'cancel_item', id: 'done-item' }) });
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json().then(({ cancelled, reason }) => ({ cancelled, reason })), { cancelled: false, reason: 'not_queued' });
+  } finally { await handle.close(); }
+});
+
 test('runtime server exposes config profile list and switch endpoints', async (t) => {
   const context = {
     workspace: 'acme',
@@ -1816,8 +2157,9 @@ test('redo truncation drops the aftermath of one question and refuses during a r
     const ok = await post({ index: 0 });
     assert.equal(ok.status, 200);
     assert.deepEqual(await ok.json(), { truncated: true, index: 0, removedEvents: 1 });
-    // Keeps the question (sequence 1) and drops everything recorded after it.
-    assert.deepEqual(deleted, { sequence: 1, workspace: 'demo' });
+    // Drops the question (sequence 1) along with everything after it: the
+    // caller resubmits it, so keeping it here showed the same message twice.
+    assert.deepEqual(deleted, { sequence: 0, workspace: 'demo' });
     // getState prefers the in-memory projection, so the deleted answers would
     // survive in RAM without this rehydration.
     assert.equal(hydrated, true);