kenaz 0.3.11 → 0.3.12

package/core/.collaboration/core/task-2288-followups.test.js

@@ -9,11 +9,10 @@ const { spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const cp = require('child_process');
 
 const TASKAPI = path.join(__dirname, 'task-api.js');
 const TASKJSON = path.join(__dirname, 'task-api-json.js');
-const { TaskAPI, toYAML } = require('./task-api.js');
+const { toYAML } = require('./task-api.js');
 
 const SB = fs.mkdtempSync(path.join(os.tmpdir(), 't2288_'));
 const tasksDir = path.join(SB, '.kenaz', 'tasks');
@@ -37,20 +36,6 @@ const field = (id, k) => (findCard(id).text.match(new RegExp('^' + k + ':\\s*(.*
 const mkActive = (id) => fs.writeFileSync(path.join(tasksDir, 'active', id + '_t.yaml'),
   toYAML({ id, title: 't2288 ' + id, priority: 'P2', status: 'in_progress' }));
 
-// --- spawn counting seam (same as TASK_2264) ---
-let phases = [];
-const realSpawn = cp.spawn;
-cp.spawn = function (cmd, argv, opts) {
-  const script = Array.isArray(argv) ? argv.find(a => typeof a === 'string' && a.includes('const CFG')) : null;
-  if (script) {
-    const m = script.match(/"phase":"(before|after)"/);
-    phases.push(m ? m[1] : '?');
-    return { unref() {}, on() {} };
-  }
-  return realSpawn.apply(this, arguments);
-};
-const afters = () => phases.filter(p => p === 'after').length;
-
 (async () => {
   try {
     // ---- (1) actual-hours validation (CLI, subprocess so spawn patch is irrelevant) ----
@@ -90,30 +75,10 @@ const afters = () => phases.filter(p => p === 'after').length;
       check('Z3 task-api-json emits estimated_hours 0 as 0', p2 && p2.estimated_hours === 0, JSON.stringify(p2 && p2.estimated_hours) + j2.stderr);
       check('Z4 task-api-json emits actual_hours 0 as 0', p2 && p2.actual_hours === 0, JSON.stringify(p2 && p2.actual_hours));
     }
-
-    // ---- (3) single 'after' capture ----
-    const api = new TaskAPI({ tasksDir, projectPath: SB });
-    for (const envName of ['FORMATION_HEADLESS', 'FORMATION_SCHEDULER']) {
-      const id = envName === 'FORMATION_HEADLESS' ? 'TASK_9111' : 'TASK_9112';
-      mkActive(id); phases = [];
-      process.env[envName] = '1';
-      try { await api.completeTask(id, {}); } finally { delete process.env[envName]; }
-      check(`R1 ${envName}: caller's post-complete owns 'after'; moveTask schedules none`, afters() === 0, JSON.stringify(phases));
-    }
-    mkActive('TASK_9113'); phases = [];
-    process.env.FORMATION_HEADLESS = '1';
-    try { await api.completeTask('TASK_9113', { skipPostComplete: true }); } finally { delete process.env.FORMATION_HEADLESS; }
-    check('R2 control: headless + skipPostComplete (nobody else measures) keeps exactly 1 capture', afters() === 1, JSON.stringify(phases));
-    mkActive('TASK_9114'); phases = [];
-    await api.moveTask('TASK_9114', 'done');
-    check('R3 control: bare move done captures exactly once', afters() === 1, JSON.stringify(phases));
-    mkActive('TASK_9115'); phases = [];
-    await api.completeTask('TASK_9115', { dryRun: true, skipGit: true, skipArchive: true });
-    check('R4 control: in-process complete (TASK_2264) still schedules none', afters() === 0, JSON.stringify(phases));
+    // (3) the single 'after' memory-health capture checks were removed with the capture itself (TASK_2411)
   } catch (e) {
     check('no exception', false, e && e.stack);
   } finally {
-    cp.spawn = realSpawn;
     try { fs.rmSync(SB, { recursive: true, force: true }); } catch { /* best effort */ }
   }
   console.log(`\n${pass} passed, ${fail} failed`);

package/core/.collaboration/core/task-2421-replica.test.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+/**
+ * TASK_2421 -- shared-room card replicas, unknown-id lookup, import, alias,
+ * local_fallback warning. Uses a local stub relay (never the real relay) and
+ * temp project dirs. YGGDRASIL_PUBLISHABLE_KEY is set so ~/.kenaz is never read.
+ */
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const { execFile } = require('child_process');
+const { TaskAPI } = require('./task-api.js');
+
+process.env.YGGDRASIL_PUBLISHABLE_KEY = 'test-key';
+const CLI = path.join(__dirname, 'task-api.js');
+
+function startRelay({ failAllocate = false } = {}) {
+  const state = { rows: new Map(), nextId: 9000, posts: [], patches: [], authSeen: [] };
+  const server = http.createServer((req, res) => {
+    let body = '';
+    req.on('data', (c) => { body += c; });
+    req.on('end', () => {
+      state.authSeen.push(req.headers.authorization);
+      const url = new URL(req.url, 'http://x');
+      const json = (code, obj) => { res.writeHead(code, { 'Content-Type': 'application/json' }); res.end(JSON.stringify(obj)); };
+      if (req.method === 'POST' && url.pathname === '/api/tasks/allocate-ids') {
+        if (failAllocate) return json(500, { error: 'down' });
+        const start = state.nextId; state.nextId += 20;
+        return json(200, { start, end: start + 19 });
+      }
+      if (req.method === 'POST' && url.pathname === '/api/tasks') {
+        const b = JSON.parse(body); state.posts.push(b);
+        state.rows.set(b.task_id, { ...b, claimed_by: null, assigned_to: b.assigned_to || null });
+        return json(200, state.rows.get(b.task_id));
+      }
+      if (req.method === 'PATCH' && url.pathname.startsWith('/api/tasks/')) {
+        const id = decodeURIComponent(url.pathname.split('/').pop());
+        const b = JSON.parse(body); state.patches.push({ id, ...b });
+        const row = state.rows.get(id);
+        if (!row) return json(409, { error: 'conflict' });
+        for (const k of ['status', 'title', 'description', 'priority', 'full_yaml']) if (b[k] != null) row[k] = b[k];
+        return json(200, row);
+      }
+      if (req.method === 'GET' && url.pathname === '/api/tasks') {
+        const wanted = (url.searchParams.get('status') || 'pool').split(',');
+        return json(200, [...state.rows.values()].filter(r => wanted.includes(r.status)));
+      }
+      json(404, {});
+    });
+  });
+  return new Promise((resolve) => server.listen(0, '127.0.0.1', () => {
+    resolve({ state, server, url: `ws://127.0.0.1:${server.address().port}` });
+  }));
+}
+
+function mkProject(yamlText) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'task2421-'));
+  fs.mkdirSync(path.join(root, '.kenaz', 'tasks'), { recursive: true });
+  if (yamlText) fs.writeFileSync(path.join(root, '.kenaz', 'yggdrasil.yaml'), yamlText);
+  return { root, api: new TaskAPI({ projectPath: root, tasksDir: path.join(root, '.kenaz', 'tasks') }) };
+}
+
+const cfg = (url, extra = '') => `enabled: true\nrelay_url: "${url}"\nyggdrasil_project: room\nnode_name: node-A\n${extra}`;
+const card = (extra = {}) => ({ title: 'Replica me', description: 'desc', priority: 'P1', requirements: ['r1'], acceptance_criteria: ['a1'], force: true, ...extra });
+
+function cli(root, args) {
+  return new Promise((resolve) => {
+    execFile(process.execPath, [CLI, '--project-path', root, ...args], { env: process.env, timeout: 30000 },
+      (err, stdout, stderr) => resolve({ code: err ? (err.code || 1) : 0, stdout, stderr }));
+  });
+}
+
+const tests = [];
+const test = (n, f) => tests.push([n, f]);
+
+test('shared room: create publishes a non-pool read-only replica', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(cfg(relay.url));
+  const t = await api.createTask(card({ alias: '791-17' }));
+  assert.strictEqual(relay.state.posts.length, 1);
+  const p = relay.state.posts[0];
+  assert.strictEqual(p.task_id, t.id);
+  assert.strictEqual(p.status, 'assigned', 'must not be claimable pool work');
+  assert.ok(!p.assigned_to, 'no assigned_to so creator inbox (pool_pull) stays clean');
+  assert.strictEqual(p.created_by, 'node-A');
+  assert.ok(/replica: true/.test(p.full_yaml) && /791-17/.test(p.full_yaml) && /origin_node: node-A/.test(p.full_yaml));
+  assert.ok(relay.state.authSeen.every(a => a === 'Bearer test-key'));
+  assert.strictEqual(t.replica_published, true);
+  relay.server.close();
+});
+
+test('opted out (share_cards: false) -> no replica; ids still from relay', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(cfg(relay.url, 'share_cards: false\n'));
+  const t = await api.createTask(card());
+  assert.strictEqual(relay.state.posts.length, 0);
+  assert.ok(/^TASK_9\d{3}$/.test(t.id));
+  relay.server.close();
+});
+
+test('not a shared room (no yggdrasil config) -> no relay traffic', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(null);
+  await api.createTask(card());
+  assert.strictEqual(relay.state.posts.length, 0);
+  relay.server.close();
+});
+
+test('relay down: local create still succeeds with one replica warning', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(cfg(relay.url));
+  const first = await api.createTask(card()); // gets a lease while relay is up
+  await new Promise(r => relay.server.close(r));
+  const warns = [];
+  const orig = console.warn; console.warn = (...a) => warns.push(a.join(' '));
+  let t;
+  try { t = await api.createTask(card({ title: 'Second' })); } finally { console.warn = orig; }
+  assert.ok(t && t.id && t.id !== first.id);
+  assert.ok(fs.existsSync(t._file_path), 'local card written');
+  assert.strictEqual(t.replica_published, false);
+  assert.strictEqual(warns.filter(w => /replica not published/.test(w)).length, 1);
+});
+
+test('local_fallback in a shared room warns loudly (stderr + create output)', async () => {
+  const { api, root } = mkProject(cfg('ws://127.0.0.1:1')); // unreachable relay, no lease
+  const r = await cli(root, ['create', '--title', 'Fallback', '--force']);
+  assert.strictEqual(r.code, 0, r.stderr);
+  assert.ok(/ID COLLISION RISK/.test(r.stderr), 'stderr warning');
+  assert.ok(/⚠️.*locally because the relay is unreachable/.test(r.stdout), 'create output warning');
+  assert.ok(api);
+});
+
+test('solo project local id allocation prints no collision warning', async () => {
+  const { root } = mkProject(null);
+  const r = await cli(root, ['create', '--title', 'Solo', '--force']);
+  assert.strictEqual(r.code, 0, r.stderr);
+  assert.ok(!/COLLISION/.test(r.stderr + r.stdout));
+});
+
+test('get unknown id shows replica with owner node; mutations explain, create no local file', async () => {
+  const relay = await startRelay();
+  const a = mkProject(cfg(relay.url));
+  const t = await a.api.createTask(card());
+  // node B: same room, empty local store
+  const b = mkProject(cfg(relay.url).replace('node-A', 'node-B'));
+  const g = await cli(b.root, ['get', t.id]);
+  assert.strictEqual(g.code, 0, g.stderr);
+  const out = JSON.parse(g.stdout);
+  assert.strictEqual(out.read_only_replica, true);
+  assert.strictEqual(out.title, 'Replica me');
+  assert.ok(/read-only replica; card lives on node node-A/.test(out.replica_notice));
+  assert.ok(/task-api\.js pull /.test(out.replica_notice));
+  for (const args of [['move', t.id, 'active'], ['update', t.id, '--title', 'x'], ['complete', t.id]]) {
+    const r = await cli(b.root, args);
+    assert.notStrictEqual(r.code, 0, args.join(' '));
+    assert.ok(/read-only replica; card lives on node node-A/.test(r.stderr + r.stdout), args.join(' ') + ': ' + r.stderr);
+  }
+  const files = fs.readdirSync(path.join(b.root, '.kenaz', 'tasks'), { recursive: true }).filter(f => /TASK_/.test(String(f)));
+  assert.strictEqual(files.length, 0, 'no broken local file: ' + files.join(','));
+  // truly unknown id still says not found
+  const miss = await cli(b.root, ['get', 'TASK_424242']);
+  assert.notStrictEqual(miss.code, 0);
+  assert.ok(/任務不存在/.test(miss.stderr));
+  relay.server.close();
+});
+
+test('status changes on the owner keep the replica current', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(cfg(relay.url));
+  const t = await api.createTask(card());
+  await api.moveTask(t.id, 'active');
+  assert.strictEqual(relay.state.rows.get(t.id).status, 'in_progress');
+  await api.updateTask(t.id, { title: 'Renamed' });
+  assert.strictEqual(relay.state.rows.get(t.id).title, 'Renamed');
+  relay.server.close();
+});
+
+test('pull imports a local copy marked with origin node', async () => {
+  const relay = await startRelay();
+  const a = mkProject(cfg(relay.url));
+  const t = await a.api.createTask(card({ alias: '791-18' }));
+  const b = mkProject(cfg(relay.url).replace('node-A', 'node-B'));
+  const r = await cli(b.root, ['pull', t.id]);
+  assert.strictEqual(r.code, 0, r.stderr);
+  const local = await b.api.getTask(t.id);
+  assert.ok(local, 'local copy exists');
+  assert.strictEqual(local.origin_node, 'node-A');
+  assert.strictEqual(local.title, 'Replica me');
+  assert.strictEqual(local.alias, '791-18');
+  const again = await cli(b.root, ['pull', t.id]);
+  assert.notStrictEqual(again.code, 0);
+  relay.server.close();
+});
+
+test('alias: create/update/get/search resolve to the TASK id', async () => {
+  const { api, root } = mkProject(null);
+  const t = await api.createTask(card({ alias: '791-17' }));
+  const g = await cli(root, ['get', '791-17']);
+  assert.strictEqual(g.code, 0, g.stderr);
+  assert.strictEqual(JSON.parse(g.stdout).id, t.id);
+  const s = await cli(root, ['search', '791-17']);
+  assert.ok(s.stdout.includes(t.id));
+  const u = await cli(root, ['update', t.id, '--alias', '791-99']);
+  assert.strictEqual(u.code, 0, u.stderr);
+  const g2 = await cli(root, ['get', '791-99']);
+  assert.strictEqual(JSON.parse(g2.stdout).id, t.id);
+});
+
+test('get by alias of a replica that exists only on the relay', async () => {
+  const relay = await startRelay();
+  const a = mkProject(cfg(relay.url));
+  const t = await a.api.createTask(card({ alias: '791-20' }));
+  const b = mkProject(cfg(relay.url).replace('node-A', 'node-B'));
+  const g = await cli(b.root, ['get', '791-20']);
+  assert.strictEqual(g.code, 0, g.stderr);
+  assert.strictEqual(JSON.parse(g.stdout).id, t.id);
+  relay.server.close();
+});
+
+(async () => {
+  let failed = 0;
+  for (const [name, fn] of tests) {
+    try { await fn(); console.log(`  ok   ${name}`); }
+    catch (e) { failed++; console.log(`  FAIL ${name}\n       ${e && e.stack || e}`); }
+  }
+  console.log(`\n${tests.length - failed}/${tests.length} passed`);
+  process.exit(failed ? 1 : 0);
+})();