@dotdrelle/wiki-manager 0.15.93 → 0.15.96

package/src/runtime/server.test.js

@@ -1733,6 +1733,93 @@ test('POST /turn keeps informational skill and build questions conversational',
   }
 });
 
+test('POST /turn answers a run status question from the runtime instead of the model', async (t) => {
+  const session = { workspace: 'acme', controlQueue: [] };
+  const context = { workspace: 'acme', session, running: true, currentAbortController: null };
+  const status = {
+    status: 'running',
+    running: true,
+    plan: [{ step: 1, description: 'Build TechSections', status: 'running' }],
+    queue: [],
+    controlQueue: [],
+    approvals: [],
+    conversation: [],
+  };
+  let turns = 0;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => status, listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+      turn: async () => { turns += 1; return { ok: true }; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    // The model once mistook the runtime runId for a production job id and
+    // answered "job not found". The runtime answers its own status.
+    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: 'donne le status du job en cours', mode: 'agent' }),
+    });
+    const body = await response.json();
+    assert.equal(response.status, 200);
+    assert.equal(body.kind, 'observe');
+    assert.match(body.explanation, /Build TechSections/);
+    assert.equal(turns, 0);
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('POST /turn treats a bare confirmation during a run as a status check', async (t) => {
+  const session = { workspace: 'acme', controlQueue: [] };
+  const context = { workspace: 'acme', session, running: true, currentAbortController: null };
+  const status = {
+    status: 'running',
+    running: true,
+    plan: [{ step: 1, description: 'Rebuild the wiki', status: 'running' }],
+    queue: [],
+    controlQueue: [],
+    approvals: [],
+    conversation: [],
+  };
+  let turns = 0;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => status, listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+      turn: async () => { turns += 1; return { ok: true }; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    // "oui" answers the launch acknowledgement. It must reach the runtime's
+    // status, not a read-only chat turn that lectures about switching modes.
+    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: 'oui', mode: 'agent' }),
+    });
+    const body = await response.json();
+    assert.equal(response.status, 200);
+    assert.equal(body.kind, 'observe');
+    assert.equal(turns, 0);
+  } finally {
+    context.currentAbortController?.abort();
+    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 });

package/src/runtime/skillRun.js

@@ -165,7 +165,7 @@ export async function generateSkillAcknowledgment(session, { publicInput, object
       // slow provider must not block the skill-launch HTTP response forever.
       const reply = await llm.complete({
         system: 'You are Donna, the workspace assistant. You acknowledge a launched workflow in the user\'s language. Be concise: exactly one short sentence.',
-        input: `The user just launched the workspace skill ${publicInput}. It was compiled into ${count} step(s) and is now running.\n\nWrite ONE short sentence in ${language} that confirms the launch, echoes the skill and its arguments, and says progress will be reported. Return only that sentence, nothing else.`,
+        input: `The user just launched the workspace skill ${publicInput}. It was compiled into ${count} step(s) and is now running.\n\nWrite ONE short sentence in ${language} that confirms the launch, echoes the skill and its arguments, and says progress will be reported. Do not ask a question, do not propose options, and do not offer to check, monitor or cancel anything: the runtime reports progress on its own and this acknowledgement is not a decision point. Return only that sentence, nothing else.`,
         signal: AbortSignal.timeout(8_000),
       });
       const text = String(reply ?? '').trim();

package/src/runtime/skillRun.test.js

@@ -94,6 +94,9 @@ test('generateSkillAcknowledgment asks Donna in the session language and echoes
   assert.equal(calls.length, 1);
   assert.match(calls[0].input, /es/);
   assert.match(calls[0].input, /\/deliver deliverable="Informe"/);
+  // The acknowledgement is not a decision point: it must not invite the user
+  // into a dialog the runtime cannot act on.
+  assert.match(calls[0].input, /Do not ask a question/);
 });
 
 test('generateSkillAcknowledgment degrades to a neutral message without an LLM client', async () => {

package/src/runtime/totp.js

@@ -0,0 +1,87 @@
+import { createHmac, randomBytes, timingSafeEqual, createHash } from 'node:crypto';
+
+/*
+ RFC 6238 TOTP with the defaults every authenticator app ships:
+ HMAC-SHA1, 6 digits, 30-second period. Self-contained — no dependency.
+
+ The secret is base32 (RFC 4648, no padding, uppercase), 20 bytes by default.
+ Verification accepts a ±1 window so a drifting clock or a code typed at the
+ end of its period is not a refusal, and compares DIGESTS (constant-time),
+ never the raw strings.
+ */
+
+const BASE32_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+
+export function base32Encode(buffer) {
+  let bits = 0;
+  let value = 0;
+  let output = '';
+  for (const byte of buffer) {
+    value = (value << 8) | byte;
+    bits += 8;
+    while (bits >= 5) {
+      output += BASE32_ALPHABET[(value >>> (bits - 5)) & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) output += BASE32_ALPHABET[(value << (5 - bits)) & 31];
+  return output;
+}
+
+export function base32Decode(input) {
+  const clean = String(input ?? '').toUpperCase().replace(/[^A-Z2-7]/g, '');
+  let bits = 0;
+  let value = 0;
+  const output = [];
+  for (const char of clean) {
+    value = (value << 5) | BASE32_ALPHABET.indexOf(char);
+    bits += 5;
+    if (bits >= 8) {
+      output.push((value >>> (bits - 8)) & 0xff);
+      bits -= 8;
+    }
+  }
+  return Buffer.from(output);
+}
+
+export function generateTotpSecret(bytes = 20) {
+  return base32Encode(randomBytes(bytes));
+}
+
+export function totpCode(secret, timestamp = Date.now(), { digits = 6, period = 30 } = {}) {
+  const counter = Math.floor(Number(timestamp) / 1000 / period);
+  const message = Buffer.alloc(8);
+  message.writeBigUInt64BE(BigInt(counter));
+  const digest = createHmac('sha1', base32Decode(secret)).update(message).digest();
+  const offset = digest[digest.length - 1] & 0x0f;
+  const binary =
+    ((digest[offset] & 0x7f) << 24) |
+    ((digest[offset + 1] & 0xff) << 16) |
+    ((digest[offset + 2] & 0xff) << 8) |
+    (digest[offset + 3] & 0xff);
+  return String(binary % 10 ** digits).padStart(digits, '0');
+}
+
+export function digestEqual(left, right) {
+  const a = createHash('sha256').update(String(left ?? '')).digest();
+  const b = createHash('sha256').update(String(right ?? '')).digest();
+  return timingSafeEqual(a, b);
+}
+
+export function normalizeTotpCode(code) {
+  return String(code ?? '').replace(/\D/g, '').padStart(6, '0').slice(0, 6);
+}
+
+export function verifyTotp(secret, code, { window = 1, period = 30, timestamp = Date.now() } = {}) {
+  const wanted = normalizeTotpCode(code);
+  for (let step = -window; step <= window; step++) {
+    const candidate = totpCode(secret, timestamp + step * period * 1000, { period });
+    if (digestEqual(candidate, wanted)) return true;
+  }
+  return false;
+}
+
+export function otpauthUri(secret, { label = 'wiki', issuer = 'wikiLLM' } = {}) {
+  const params = new URLSearchParams({ secret, issuer, digits: '6', period: '30', algorithm: 'SHA1' });
+  return `otpauth://totp/${encodeURIComponent(`${issuer}:${label}`)}?${params.toString()}`;
+}

package/src/runtime/totp.test.js

@@ -0,0 +1,80 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  base32Decode,
+  base32Encode,
+  generateTotpSecret,
+  normalizeTotpCode,
+  otpauthUri,
+  totpCode,
+  verifyTotp,
+} from './totp.js';
+
+test('base32 round-trips arbitrary bytes', () => {
+  const bytes = Buffer.from([0, 1, 2, 0x7f, 0x80, 0xff, 0x41, 0x42]);
+  assert.equal(base32Encode(bytes), 'AAAQE74A75AUE');
+  assert.deepEqual(base32Decode(base32Encode(bytes)), bytes);
+  // Decoding tolerates lowercase and padding noise.
+  assert.deepEqual(base32Decode('aaaQE74a75aue==='), bytes);
+});
+
+test('generateTotpSecret returns a 32-char base32 secret of 20 bytes', () => {
+  const secret = generateTotpSecret();
+  assert.match(secret, /^[A-Z2-7]{32}$/);
+  assert.equal(base32Decode(secret).length, 20);
+});
+
+// RFC 6238 test vectors (Appendix B), SHA-1, 20-byte ASCII secret
+// "12345678901234567890" — encoded in base32 as the well-known
+// GEZDGNBVGY3TQOJQ GEZDGNBVGY3TQOJQ.
+const RFC_SECRET = 'GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ';
+
+test('totpCode matches the RFC 6238 vectors (8 digits, then 6)', () => {
+  const vectors = [
+    [59, '94287082'],
+    [1111111109, '07081804'],
+    [1111111111, '14050471'],
+    [1234567890, '89005924'],
+    [2000000000, '69279037'],
+    [20000000000, '65353130'],
+  ];
+  for (const [time, expected8] of vectors) {
+    assert.equal(totpCode(RFC_SECRET, time * 1000, { digits: 8 }), expected8, `T=${time}`);
+    assert.equal(totpCode(RFC_SECRET, time * 1000), expected8.slice(2), `T=${time} 6 digits`);
+  }
+});
+
+test('verifyTotp accepts the current step and the ±1 window', () => {
+  const secret = generateTotpSecret();
+  const now = 1_700_000_000_000;
+  const code = totpCode(secret, now);
+  assert.equal(verifyTotp(secret, code, { timestamp: now }), true);
+  assert.equal(verifyTotp(secret, code, { timestamp: now + 30_000 }), true);
+  assert.equal(verifyTotp(secret, code, { timestamp: now - 30_000 }), true);
+  assert.equal(verifyTotp(secret, code, { timestamp: now + 60_000 }), false);
+  assert.equal(verifyTotp(secret, code, { timestamp: now - 60_000 }), false);
+});
+
+test('verifyTotp normalizes spacing and a wrong code is refused', () => {
+  const secret = generateTotpSecret();
+  const now = 1_700_000_000_000;
+  const code = totpCode(secret, now);
+  assert.equal(verifyTotp(secret, ` ${code.slice(0, 3)} ${code.slice(3)} `, { timestamp: now }), true);
+  assert.equal(verifyTotp(secret, '000000', { timestamp: now }), false);
+});
+
+test('normalizeTotpCode keeps six digits', () => {
+  assert.equal(normalizeTotpCode(' 123 456 '), '123456');
+  assert.equal(normalizeTotpCode('42'), '000042');
+  assert.equal(normalizeTotpCode('1234567'), '123456');
+});
+
+test('otpauthUri carries the standard parameters', () => {
+  const uri = otpauthUri('ABCDEF', { label: 'demo', issuer: 'wikiLLM' });
+  assert.ok(uri.startsWith('otpauth://totp/wikiLLM%3Ademo?'));
+  assert.ok(uri.includes('secret=ABCDEF'));
+  assert.ok(uri.includes('issuer=wikiLLM'));
+  assert.ok(uri.includes('digits=6'));
+  assert.ok(uri.includes('period=30'));
+  assert.ok(uri.includes('algorithm=SHA1'));
+});

package/src/runtime/totpLogin.js

@@ -0,0 +1,123 @@
+import { spawn } from 'node:child_process';
+import { setTimeout as sleep } from 'node:timers/promises';
+
+/*
+ The interactive entry gate: `wiki-manager login` opens the runtime's TOTP
+ login page in the browser and polls until a session exists. The shell startup
+ runs the same flow when a session is required and missing.
+
+ Headless/CI never passes through here — it uses the runtime bearer token, not
+ the human session.
+ */
+
+export function runtimeBaseUrl(runtime) {
+  const base = String(runtime?.url ?? process.env.WIKI_MANAGER_RUNTIME_URL ?? 'http://127.0.0.1:7788');
+  return base.replace(/\/+$/, '');
+}
+
+export function loginPageUrl(runtime) {
+  return `${runtimeBaseUrl(runtime)}/login`;
+}
+
+// Returns a promise that reflects the real outcome: spawn() itself does not
+// throw for a missing opener (e.g. no xdg-open on a headless box) — that
+// surfaces asynchronously as an 'error' event — so callers that want to fall
+// back on failure need this to actually reject rather than resolve blindly.
+export function openBrowser(url) {
+  const target = String(url);
+  const options = { detached: true, stdio: 'ignore' };
+  return new Promise((resolveOpen, rejectOpen) => {
+    let child = null;
+    if (process.platform === 'darwin') {
+      child = spawn('open', [target], options);
+    } else if (process.platform === 'win32') {
+      child = spawn('cmd', ['/c', 'start', '', target], options);
+    } else {
+      child = spawn('xdg-open', [target], options);
+    }
+    child.once('error', rejectOpen);
+    child.once('spawn', () => {
+      child.unref?.();
+      resolveOpen();
+    });
+  });
+}
+
+export async function fetchLoginStatus(runtime) {
+  try {
+    const response = await fetch(`${runtimeBaseUrl(runtime)}/login/status`, {
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+// /logout requires the session's own token as proof of possession (it sits
+// before the bearer gate by design). The CLI runs on the same host as the
+// runtime, so it reads the active token itself — see currentSessionToken in
+// loginSession.js — rather than calling this without proof.
+export async function revokeRuntimeSession(runtime, token = null) {
+  try {
+    const response = await fetch(`${runtimeBaseUrl(runtime)}/logout`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ token }),
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!response.ok) return false;
+    const payload = await response.json().catch(() => ({}));
+    return payload?.revoked === true;
+  } catch {
+    return false;
+  }
+}
+
+/*
+ Requires a valid TOTP session on the runtime, opening the login page and
+ polling when one is missing. Returns:
+   { ok: true }            — session active (or nothing to do: disabled /
+                             runtime unreachable, which the caller announces).
+   { ok: false, error }    — the user did not log in within the timeout.
+ */
+export async function requestTotpSession(runtime, { timeoutMs = 5 * 60 * 1000, open = true, quiet = false } = {}) {
+  const status = await fetchLoginStatus(runtime);
+  // Every caller reaches this only after ensureRuntime() already confirmed
+  // the runtime is up via /health, so a /login/status failure right here is
+  // a real problem (route error, blip), not "nothing to gate" — fail CLOSED,
+  // matching the documented contract for the same scenario in serve, and say
+  // so instead of silently letting the shell start with no TOTP check at all.
+  if (!status) {
+    return { ok: false, error: `Could not reach the runtime's login status (${runtimeBaseUrl(runtime)}/login/status) — refusing to skip the TOTP check.` };
+  }
+  if (!status.enabled) return { ok: true, reason: 'totp_disabled' };
+  if (status.sessionActive) return { ok: true, expiresAt: status.sessionExpiresAt, reason: 'already_active' };
+
+  const url = loginPageUrl(runtime);
+  if (!quiet) console.log(`\x1b[33mTOTP login required — ${url}\x1b[0m`);
+  if (open) {
+    try {
+      await openBrowser(url);
+    } catch {
+      if (!quiet) console.log(`Open ${url} and enter the code from your authenticator.`);
+    }
+  } else if (!quiet) {
+    console.log(`Open ${url} in your browser and enter the code from your authenticator.`);
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const current = await fetchLoginStatus(runtime);
+    if (current?.sessionActive) {
+      if (!quiet) {
+        const until = new Date(current.sessionExpiresAt).toLocaleString();
+        console.log(`\x1b[32mSession active until ${until}\x1b[0m`);
+      }
+      return { ok: true, expiresAt: current.sessionExpiresAt, reason: 'logged_in' };
+    }
+    await sleep(1000);
+  }
+  return { ok: false, error: `No TOTP session after ${Math.round(timeoutMs / 60_000)} min — run "wiki-manager login" to retry.` };
+}