cawdev-cli 0.9.0

package/mcp/smoke.mjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+// A scripted JSON-RPC session against tools/mcp/server.mjs, over real stdio.
+//
+//   CAWDEV_URL=… CAWDEV_TOKEN=… node tools/mcp/smoke.mjs [project]
+//
+// This is what CI runs against the compose stack. It drives the server the way
+// a client does — spawn, write lines to stdin, read lines from stdout — rather
+// than importing its functions, because the parts most likely to break are the
+// transport and the framing, and importing would skip exactly those.
+
+import { spawn } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+// The project must be named explicitly. This test CREATES an entry and then
+// declines it, and entries cannot be deleted — so falling back to
+// CAWDEV_PROJECT would quietly leave test artifacts in whatever real roadmap
+// the environment happened to point at. It did exactly that once.
+const project = process.argv[2];
+if (!project) {
+  console.error(
+    'Usage: node tools/mcp/smoke.mjs <project>\n\n' +
+      'Name the project explicitly: this test creates a roadmap entry and declines it, and\n' +
+      'entries cannot be deleted. Use a scratch project, not one whose roadmap you care about.',
+  );
+  process.exit(2);
+}
+
+const server = spawn(process.execPath, [join(here, 'server.mjs')], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  env: process.env,
+});
+
+let buffer = '';
+const waiting = new Map();
+
+server.stdout.on('data', (chunk) => {
+  buffer += chunk;
+  let newline;
+  while ((newline = buffer.indexOf('\n')) !== -1) {
+    const line = buffer.slice(0, newline).trim();
+    buffer = buffer.slice(newline + 1);
+    if (!line) continue;
+
+    const message = JSON.parse(line);
+    const resolve = waiting.get(message.id);
+    if (resolve) {
+      waiting.delete(message.id);
+      resolve(message);
+    }
+  }
+});
+
+let nextId = 1;
+
+function request(method, params) {
+  const id = nextId++;
+  return new Promise((resolve, reject) => {
+    waiting.set(id, resolve);
+    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+    setTimeout(() => reject(new Error(`${method} timed out after 20s`)), 20_000).unref();
+  });
+}
+
+function notify(method, params) {
+  server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`);
+}
+
+const checks = [];
+function check(description, condition, detail = '') {
+  checks.push({ description, ok: Boolean(condition), detail });
+  console.log(`${condition ? 'ok  ' : 'FAIL'}  ${description}${detail && !condition ? `\n        ${detail}` : ''}`);
+}
+
+/** Tool results carry their text in content[0]; a refusal sets isError. */
+function textOf(result) {
+  return result?.content?.map((part) => part.text).join('\n') ?? '';
+}
+
+try {
+  const initialize = await request('initialize', {
+    protocolVersion: '2024-11-05',
+    capabilities: {},
+    clientInfo: { name: 'cawdev-smoke', version: '1' },
+  });
+  check('initialize answers with a server name', initialize.result?.serverInfo?.name === 'cawdev',
+    JSON.stringify(initialize));
+  check('initialize declares the tools capability', initialize.result?.capabilities?.tools !== undefined);
+  notify('notifications/initialized');
+
+  const list = await request('tools/list');
+  const names = (list.result?.tools ?? []).map((tool) => tool.name);
+  check('tools/list returns the roadmap and changelog verbs', names.includes('roadmap_list')
+    && names.includes('roadmap_set_status') && names.includes('roadmap_comment')
+    && names.includes('changelog_add'),
+    names.join(', '));
+  check('every tool has a description and an input schema',
+    (list.result?.tools ?? []).every((tool) => tool.description && tool.inputSchema));
+
+  // The guarantee that matters more than any feature.
+  check('there is no delete tool, for roadmap or changelog',
+    !names.some((name) => name.includes('delete') || name.includes('remove')),
+    names.join(', '));
+
+  const where = await request('tools/call', { name: 'roadmap_where', arguments: {} });
+  check('roadmap_where says which platform and who we are',
+    textOf(where.result).includes('platform:') && textOf(where.result).includes('you are:'),
+    textOf(where.result));
+
+  const statuses = await request('tools/call', { name: 'roadmap_statuses', arguments: {} });
+  // R84 retired CODING; IN_DEVELOPMENT is the status that carries a branch now.
+  check('roadmap_statuses says what IN DEVELOPMENT requires',
+    /IN DEVELOPMENT\s+\(requires a branch\)/.test(textOf(statuses.result)),
+    textOf(statuses.result));
+
+  const listed = await request('tools/call', {
+    name: 'roadmap_list',
+    arguments: { project, brief: true },
+  });
+  check('roadmap_list returns entries', !listed.result?.isError && textOf(listed.result).includes('R1'),
+    textOf(listed.result));
+
+  const created = await request('tools/call', {
+    name: 'roadmap_create',
+    arguments: {
+      project,
+      title: 'smoke test entry (safe to decline)',
+      body: 'Created by tools/mcp/smoke.mjs.',
+    },
+  });
+  check('roadmap_create makes an entry', !created.result?.isError
+    && /Created R\d+/.test(textOf(created.result)), textOf(created.result));
+
+  const number = Number(/Created R(\d+)/.exec(textOf(created.result))?.[1]);
+
+  // A status that is not given what it requires must come back as a readable
+  // refusal, not a crash — and the message should say what is missing.
+  const refused = await request('tools/call', {
+    name: 'roadmap_set_status',
+    arguments: { project, number, status: 'IN_DEVELOPMENT' },
+  });
+  check('IN DEVELOPMENT without a branch is refused, readably',
+    refused.result?.isError && /branch/i.test(textOf(refused.result)),
+    textOf(refused.result));
+
+  const moved = await request('tools/call', {
+    name: 'roadmap_set_status',
+    arguments: { project, number, status: 'IN_DEVELOPMENT', branch: 'smoke-test' },
+  });
+  check('IN DEVELOPMENT with a branch is accepted', !moved.result?.isError
+    && textOf(moved.result).includes('smoke-test'), textOf(moved.result));
+
+  // R37: the argument, beside the decision. An agent that can read the
+  // discussion stops re-proposing what was talked out months ago, so
+  // roadmap_get has to actually carry it.
+  const commented = await request('tools/call', {
+    name: 'roadmap_comment',
+    arguments: { project, number, body: 'A smoke-test comment. It cannot be deleted.' },
+  });
+  // R127: the reply says "card N", not "RN" — this call never reads the card,
+  // so it does not know the kind and a prefix would be a guess.
+  check('roadmap_comment says something beside the entry', !commented.result?.isError
+    && /Commented on card \d+/.test(textOf(commented.result)), textOf(commented.result));
+
+  const fetched = await request('tools/call', {
+    name: 'roadmap_get',
+    arguments: { project, number },
+  });
+  check('roadmap_get carries the discussion, not just the body',
+    !fetched.result?.isError
+      && textOf(fetched.result).includes('the discussion')
+      && textOf(fetched.result).includes('A smoke-test comment.'),
+    textOf(fetched.result));
+
+  const declined = await request('tools/call', {
+    name: 'roadmap_decline',
+    arguments: {
+      project,
+      number,
+      reason: 'A smoke-test entry. Declined so it leaves a trace rather than vanishing.',
+    },
+  });
+  check('roadmap_decline closes it with a reason', !declined.result?.isError
+    && textOf(declined.result).includes('DECLINED'), textOf(declined.result));
+
+  // R199: feedback that is not a card. The smoke token holds roadmap:write,
+  // which covers backlog:write, so this is the same door an ordinary session
+  // files through. A backlog item is not an entry — it has no number — and it
+  // stays pending until a person triages it, which this script cannot do.
+  const filed = await request('tools/call', {
+    name: 'backlog_file',
+    arguments: {
+      project,
+      kind: 'FEATURE',
+      title: 'smoke test feedback (safe to refuse)',
+      body: 'Filed by tools/mcp/smoke.mjs. Refuse it.',
+    },
+  });
+  check('backlog_file files feedback as pending, not as a card', !filed.result?.isError
+    && /as pending/.test(textOf(filed.result)) && !/Created [Ri]\d+/.test(textOf(filed.result)),
+    textOf(filed.result));
+
+  const changelog = await request('tools/call', {
+    name: 'changelog_list',
+    arguments: { project },
+  });
+  check('changelog_list works', !changelog.result?.isError, textOf(changelog.result));
+
+  const unknown = await request('tools/call', { name: 'roadmap_teleport', arguments: {} });
+  check('an unknown tool is a protocol error, not a crash', unknown.error?.code === -32602,
+    JSON.stringify(unknown));
+} finally {
+  server.stdin.end();
+}
+
+const failed = checks.filter((entry) => !entry.ok);
+console.log(`\n${checks.length - failed.length}/${checks.length} checks passed.`);
+process.exit(failed.length ? 1 : 0);

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "cawdev-cli",
+  "version": "0.9.0",
+  "description": "cawdev's terminal client and runner daemon — zero dependencies, on purpose",
+  "type": "module",
+  "bin": {
+    "cawdev": "./runner/cawdev.mjs"
+  },
+  "files": [
+    "runner",
+    "lib",
+    "mcp",
+    "!**/*.test.mjs",
+    "!runner/test-platform.mjs"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "UNLICENSED"
+}