210 lines
13 KiB
JavaScript
210 lines
13 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createHash } from 'node:crypto';
|
|
import { spawn } from 'node:child_process';
|
|
import { mkdirSync, readFileSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import { createInterface } from 'node:readline';
|
|
import { buildBundle, SOURCES } from '../src/bundle.mjs';
|
|
import { callTool, typedTools } from '../src/tools.mjs';
|
|
import * as runner from '../src/runner.mjs';
|
|
import { HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch } from './helpers.mjs';
|
|
import { Broker } from '../../bus/src/broker.mjs';
|
|
import { Store } from '../../bus/src/store.mjs';
|
|
import { createRequestStore } from '../../bus/src/request-store.mjs';
|
|
import { createRequestLifecycle } from '../../bus/src/request-lifecycle.mjs';
|
|
|
|
const reads = ['intake_status', 'intake_projects'];
|
|
const writes = ['intake_open', 'intake_propose'];
|
|
const intake = t => t.name.startsWith('intake_');
|
|
const shipped = name => JSON.parse(readFileSync(join(REPO, 'roles', `${name}.json`), 'utf8'));
|
|
const roleDefinition = role => role === 'chief' ? 'chief-of-staff' : role;
|
|
|
|
function bundle(t, role, harness, mutate) {
|
|
const resolved = resolvedFor(t, role, doc => {
|
|
if (role === 'assistant') doc.roles.assistant = { definition: 'assistant' };
|
|
doc.roles[role].vars = { ...doc.roles[role].vars, harness, model: 'claude-opus-5-5' };
|
|
mutate?.(doc);
|
|
});
|
|
const dir = scratch(t), workspace = join(dir, 'ws');
|
|
mkdirSync(workspace);
|
|
return buildBundle({ dir: join(dir, 'bundle'), resolved, contract: '# Fixture contract\n',
|
|
tracker: false, credentials: [], skillsDir: REPO_SKILLS, harness: HARNESS[harness], harnessVersion: 'fixture',
|
|
session: { run: 'intake-run', workspace, toolSocket: join(dir, 'tools.sock'), turnMarker: join(dir, 'turn.done') } });
|
|
}
|
|
|
|
for (const harness of ['pi', 'claude-code']) {
|
|
for (const role of ['pm', 'cto', 'coder', 'reviewer', 'assistant']) {
|
|
test(`${harness}: ${role} actual pre-task manifest exposes only its intake tools`, t => {
|
|
const b = bundle(t, role, harness);
|
|
const expected = role === 'pm' ? [...reads, ...writes] : role === 'cto' ? reads : [];
|
|
const prefix = harness === 'pi' ? '' : 'mcp__mosaic__';
|
|
assert.deepEqual(b.manifest.typed.filter(n => n.startsWith(prefix + 'intake_')).sort(), expected.map(n => prefix + n).sort());
|
|
const tools = JSON.parse(readFileSync(b.files.tools, 'utf8'));
|
|
assert.deepEqual(tools.filter(intake).map(t => t.name).sort(), expected.toSorted());
|
|
assert.deepEqual(b.policy.typed.filter(n => n.startsWith('intake_')).sort(), expected.toSorted());
|
|
assert.ok(!tools.some(t => t.name === 'intake_question'), 'no backing request.question verb');
|
|
for (const tool of tools.filter(intake)) {
|
|
assert.equal(tool.parameters.additionalProperties, false);
|
|
assert.equal(tool.parameters.properties.request.type, 'string');
|
|
}
|
|
assert.ok(!tools.some(t => t.name === 'task_create'), 'discovery needs no tracker');
|
|
});
|
|
}
|
|
}
|
|
|
|
test('PM intake writes and staff request follow the existing message.send grant', t => {
|
|
const muted = bundle(t, 'pm', 'pi', doc => { doc.roles.pm.vars['limits.authority'] = ['task.assign']; });
|
|
assert.deepEqual(muted.tools.filter(intake).map(t => t.name).sort(), reads.toSorted());
|
|
assert.ok(!muted.tools.some(t => t.name === 'request_staff'));
|
|
});
|
|
|
|
async function setup(t, harness = 'pi', { mute = false } = {}) {
|
|
const root = scratch(t, 'request-tools-'), store = new Store(root);
|
|
t.after(() => store.close());
|
|
const roles = Object.fromEntries(['pm', 'cto', 'coder', 'reviewer', 'assistant', 'chief'].map(role => {
|
|
const definition = roleDefinition(role);
|
|
return [role, { definition, authority: mute && role === 'pm' ? { withinRole: [], crossRole: [] } : shipped(definition).authority }];
|
|
}));
|
|
const business = { id: 'demo', human: 'jason', roles,
|
|
definitions: Object.fromEntries(Object.keys(roles).map(r => [roleDefinition(r), shipped(roleDefinition(r))])),
|
|
arbiters: { technical: 'cto', delivery: 'pm' },
|
|
launch: { by: 'chief', instances: ['pm', 'cto', 'coder', 'reviewer'], models: {}, limits: {} },
|
|
projects: { factory: { root: join(root, 'factory') } } };
|
|
const journal = createRequestStore(store);
|
|
const broker = new Broker({ store, businesses: { demo: business }, requestLifecycle: services => createRequestLifecycle({ journal, services: {
|
|
...services, listProjects: () => [{ business: 'demo', project: 'factory', name: 'Factory', tracker: { root: 1, project: 2 } }],
|
|
preparePlans: (state, args, source) => ['autonomous', 'guided'].map(mode => ({
|
|
version: 1, business: 'demo', request: state.request, project: args.project, name: args.name, chat_project: null, mode,
|
|
organization_revision: 'fixture-revision', source: { project: args.source_project, commit: 'a'.repeat(40), remote: null, forks: [] },
|
|
code_root: join(root, 'products/demo', args.project, 'code'), records_root: join(root, 'projects/demo', args.project),
|
|
tracker: { root: 1, project: args.tracker_project },
|
|
staff: { pm: 'pm', technical_reviewer: 'cto', coder: 'coder', reviewer: 'reviewer', chief: 'chief' },
|
|
intent: { text: source.text, sha256: createHash('sha256').update(source.text).digest('hex'), source_message: source.source_message, generated: false },
|
|
project_vars: {}, existing: false,
|
|
})), admitPlan: () => ({ ready: true }),
|
|
} }) });
|
|
const caps = { human: broker.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true }) };
|
|
const call = (role, verb, args = {}) => broker.request(caps[role], { verb, args });
|
|
const project = call('human', 'project.create', { name: 'Intake' }).id;
|
|
const thread = call('human', 'thread.create', { project, name: 'New product' }).id;
|
|
for (const role of Object.keys(roles)) {
|
|
caps[role] = broker.bindLaunch({ business: 'demo', role, run: role + '-run', harness, ...(role === 'assistant' ? { thread } : {}) });
|
|
call(role, 'role.claim');
|
|
}
|
|
const source = call('human', 'thread.send', { thread, body: 'Build a single-file timer.\nKeep the original intent.\n' });
|
|
const relay = call('assistant', 'message.send', { to: 'chief', body: `New product request ${source.request}`, in_reply_to: source.id });
|
|
call('chief', 'message.send', { to: 'pm', body: `Open request ${source.request}`, in_reply_to: relay.id });
|
|
const pm = bundle(t, 'pm', harness);
|
|
assert.equal(typeof runner.toolServer, 'function', 'exercise the production runner dispatch');
|
|
const socket = join(root, 'tools.sock');
|
|
const server = await runner.toolServer({ path: socket, tools: pm.tools, local: {}, client: { call: (verb, args) => call('pm', verb, args) } });
|
|
t.after(() => new Promise(resolve => server.close(resolve)));
|
|
return { root, store, broker, caps, call, source, pm, socket,
|
|
tool: (name, args) => callTool(socket, name, args) };
|
|
}
|
|
|
|
function mcp(t, toolsFile, socket) {
|
|
const child = spawn(process.execPath, [SOURCES.mcpServer, toolsFile, socket], { stdio: ['pipe', 'pipe', 'pipe'] });
|
|
const waiting = new Map();
|
|
let next = 0;
|
|
createInterface({ input: child.stdout }).on('line', line => {
|
|
const m = JSON.parse(line); waiting.get(m.id)?.(m); waiting.delete(m.id);
|
|
});
|
|
t.after(async () => {
|
|
const exited = new Promise(resolve => child.once('exit', resolve));
|
|
child.stdin.end();
|
|
await exited;
|
|
});
|
|
return async (name, args) => {
|
|
const id = ++next;
|
|
const response = new Promise(resolve => waiting.set(id, resolve));
|
|
child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method: 'tools/call', params: { name, arguments: args } }) + '\n');
|
|
const reply = await response;
|
|
assert.ok(!reply.error, reply.error?.message);
|
|
const result = reply.result;
|
|
assert.ok(!result.isError, result.content[0].text);
|
|
return JSON.parse(result.content[0].text);
|
|
};
|
|
}
|
|
|
|
for (const harness of ['pi', 'claude-code']) {
|
|
test(`${harness}: assistant through chief reaches PM intake and a pre-task new-project decision`, async t => {
|
|
const x = await setup(t, harness);
|
|
const tool = harness === 'claude-code' ? mcp(t, x.pm.files.tools, x.socket) : x.tool;
|
|
const args = { request: x.source.request };
|
|
const opened = await tool('intake_open', args);
|
|
assert.equal(opened.source_message, x.source.id);
|
|
assert.equal(opened.phase, 'selection');
|
|
assert.deepEqual(opened.tasks, []);
|
|
assert.deepEqual(await tool('intake_open', args), opened);
|
|
assert.deepEqual(await tool('intake_status', args), opened);
|
|
assert.deepEqual(await tool('intake_projects', args), [{ business: 'demo', project: 'factory', name: 'Factory', tracker: { root: 1, project: 2 } }]);
|
|
const proposed = await tool('intake_propose', { ...args, revision: opened.revision, op: 'timer-plan', source_project: 'factory', project: 'timer', name: 'Timer', tracker_project: 2 });
|
|
const d = x.store.get('SELECT * FROM decisions WHERE id=?', proposed.selection.decision);
|
|
assert.equal(d.action, 'project.bootstrap');
|
|
assert.equal(d.route_to, 'human');
|
|
assert.equal(d.blocking, 0);
|
|
assert.equal(d.task_ref, null);
|
|
assert.equal(d.requirement_ref, null);
|
|
assert.deepEqual(JSON.parse(d.options).map(o => o.key), ['autonomous', 'guided', 'existing']);
|
|
assert.equal(x.store.get("SELECT count(*) n FROM events WHERE kind='task.created'").n, 0);
|
|
assert.equal(x.store.get('SELECT body FROM messages WHERE id=?', x.source.id).body, 'Build a single-file timer.\nKeep the original intent.\n');
|
|
assert.throws(() => x.call('pm', 'decision.resolve', { id: d.id, choice: 'guided' }), /human-required/);
|
|
});
|
|
}
|
|
|
|
test('pre-task request_staff reaches the chief with roles and original request evidence', async t => {
|
|
const x = await setup(t);
|
|
const sent = await x.tool('request_staff', { request: x.source.request, roles: [{ role: 'cto', count: 1 }], note: 'Discovery before tasks' });
|
|
assert.equal(sent.to, 'chief');
|
|
const message = x.call('chief', 'message.receive').find(m => m.id === sent.message);
|
|
assert.equal(message.class, 'STAFF-REQUEST');
|
|
assert.match(message.body, new RegExp(x.source.request));
|
|
assert.match(message.body, /cto x1/);
|
|
assert.match(message.body, /Discovery before tasks/);
|
|
const body = JSON.parse(x.store.get("SELECT body FROM events WHERE kind='action.allowed' AND json_extract(body,'$.operation')='staff.request'").body);
|
|
assert.equal(body.staff_for, x.source.request);
|
|
assert.equal(body.action, 'message.send');
|
|
assert.equal(x.store.get('SELECT count(*) n FROM request_events').n, 0, 'staffing does not require an opened intake');
|
|
const task = await x.tool('request_staff', { task_ref: 'vikunja:1/2', roles: [{ role: 'coder', count: 1 }] });
|
|
assert.match(x.store.get('SELECT body FROM messages WHERE id=?', task.message).body, /Staff request for vikunja:1\/2:/);
|
|
});
|
|
|
|
test('request_staff rejects both/neither references, invalid or unreachable requests and wrong roles', async t => {
|
|
const x = await setup(t), roles = [{ role: 'coder', count: 1 }];
|
|
for (const args of [{ roles }, { roles, task_ref: 'vikunja:1/2', request: x.source.request }, { roles, request: '' }, { roles, request: null }, { roles, request: 'absent' }, { roles, request: x.source.id }])
|
|
await assert.rejects(x.tool('request_staff', args), /invalid-request|request-origin-refused/);
|
|
const foreign = x.call('human', 'message.send', { to: 'cto', body: 'Unrelated request' });
|
|
await assert.rejects(x.tool('request_staff', { roles, request: foreign.request }), /request-origin-refused/);
|
|
for (const role of ['cto', 'coder', 'reviewer', 'assistant', 'chief'])
|
|
assert.throws(() => x.call(role, 'staff.request', { roles, request: x.source.request }), /staff-request-refused/);
|
|
assert.equal(x.store.get("SELECT count(*) n FROM messages WHERE class='STAFF-REQUEST'").n, 0);
|
|
});
|
|
|
|
test('broker keeps wrong-role intake refusals, including the existing PM-only read boundary', async t => {
|
|
const x = await setup(t), args = { request: x.source.request };
|
|
const opened = await x.tool('intake_open', args);
|
|
for (const role of ['cto', 'coder', 'reviewer', 'assistant', 'chief']) {
|
|
for (const verb of ['request.open', 'request.get', 'request.projects'])
|
|
await assert.rejects(async () => x.call(role, verb, args), /request-access-refused/);
|
|
await assert.rejects(async () => x.call(role, 'request.propose', { ...args, revision: opened.revision, op: 'bad-role', source_project: 'factory', project: 'timer', name: 'Timer', tracker_project: 2 }), /request-access-refused/);
|
|
}
|
|
await assert.rejects(x.tool('intake_open', { request: x.source.id }), /request-origin-refused/);
|
|
await assert.rejects(x.tool('intake_status', { ...args, extra: true }), /invalid-request/);
|
|
await assert.rejects(x.tool('intake_propose', { ...args, revision: 0, op: 'bad-revision', source_project: 'factory', project: 'timer', name: 'Timer', tracker_project: 2 }), /invalid-request/);
|
|
await assert.rejects(x.tool('intake_question', args), /unknown-tool/);
|
|
});
|
|
|
|
test('pre-task staffing still requires PM message.send authority', async t => {
|
|
const x = await setup(t, 'pi', { mute: true });
|
|
await assert.rejects(x.tool('request_staff', { request: x.source.request, roles: [{ role: 'cto', count: 1 }] }), /decision-required/);
|
|
assert.equal(x.store.get("SELECT count(*) n FROM messages WHERE class='STAFF-REQUEST'").n, 0);
|
|
});
|
|
|
|
test('assistant cannot coordinate directly with PM or reviewer even with a request citation', async t => {
|
|
const x = await setup(t);
|
|
for (const to of ['pm', 'reviewer'])
|
|
assert.throws(() => x.call('assistant', 'message.send', { to, body: `Request ${x.source.request}`, in_reply_to: x.source.id }), /message-recipient-refused/);
|
|
});
|