cortad 0.3.1 → 0.3.2

package/lib/calls.mjs

@@ -0,0 +1,23 @@
+// What Cortad counts about its own tools: which one an agent called, from which client, how long it
+// took, how much text came back and, when it failed, under which code. The arguments and the answer
+// stay on this machine. Sent with the machine's own key, and a count that is lost is never retried:
+// it must not cost the tool call it describes.
+import { randomUUID } from "node:crypto";
+
+const text = (v, max) => (typeof v === "string" && v ? v.slice(0, max) : undefined);
+
+export function makeReport({ api, token, version, fetchImpl = fetch, sessionId = randomUUID() }) {
+  return async ({ tool, durationMs, outputChars, errorCode, error, clientName, clientVersion }) => {
+    const key = token();
+    if (!key) return;
+    const call = { tool, durationMs, outputChars, errorCode, error: text(error?.split("\n")[0], 512), clientName: text(clientName, 80), clientVersion: text(clientVersion, 40), serverVersion: version, sessionId };
+    try {
+      await fetchImpl(`${api}/mcp/calls`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+        body: JSON.stringify([call]),
+        signal: AbortSignal.timeout(3000),
+      });
+    } catch { /* lost */ }
+  };
+}

package/lib/cli.mjs

@@ -6,6 +6,7 @@ import { makeCode } from "./fresh.mjs";
 import { dropNews, homeOf, wasHeard, projectOf, readPending, readToken, takeNews, writePending } from "./home.mjs";
 import { readRunner } from "./runner.mjs";
 import { markRun, putBack, writesDirOf } from "./writes.mjs";
+import { makeReport } from "./calls.mjs";
 import { serveMcp, TOOLS } from "./mcp.mjs";
 import { SHOW } from "./read-text.mjs";
 import { answeringText, notStartedText } from "./text.mjs";
@@ -66,7 +67,8 @@ export async function main(argv, { root = process.cwd(), env = process.env, stdo
   }
   if (mcp) {
     const atRunner = asRunner(verbs, { runnerVersion: () => readRunner(project)?.version, runAt: (version, name, args) => runAt(version, name, args, { root, env }) });
-    const code = await serveMcp({ verbs: atRunner, version: VERSION, spec: npxName(cliSpec({ env })), log: (line) => stderr.write(`${line}\n`) });
+    const code = await serveMcp({ verbs: atRunner, version: VERSION, spec: npxName(cliSpec({ env })), log: (line) => stderr.write(`${line}\n`),
+      report: makeReport({ api: `${origin.origin}/api`, token: () => readToken(project), version: VERSION }) });
     for (const child of children) try { child.kill("SIGTERM"); } catch { /* gone */ }
     return code;
   }
@@ -88,7 +90,7 @@ export async function main(argv, { root = process.cwd(), env = process.env, stdo
   // `--json '<arguments>'`: the MCP server of another version asking this one to run its tool.
   const json = rest[0] === "--json";
   const out = await verbs[command.replace(/-/g, "_")](json ? jsonArgs(rest[1]) : argsOf(command, rest));
-  stdout.write(`${json ? JSON.stringify({ text: out.text, ...(out.isError ? { isError: true } : {}), ...(out.structured ? { structured: out.structured } : {}) }) : out.text}\n`);
+  stdout.write(`${json ? JSON.stringify({ text: out.text, ...(out.isError ? { isError: true, code: out.code, why: out.why } : {}), ...(out.structured ? { structured: out.structured } : {}) }) : out.text}\n`);
   return out.isError ? 1 : 0;
 }
 

package/lib/mcp.mjs

@@ -64,8 +64,17 @@ const error = (id, code, message) => ({ jsonrpc: "2.0", id, error: { code, messa
 const result = (id, value) => ({ jsonrpc: "2.0", id, result: value });
 
 // Serves until stdin closes. `verbs` is lib/verbs.mjs's object; `version` is the package's.
-export function serveMcp({ verbs, version, spec, input = process.stdin, output = process.stdout, log = () => {} }) {
+// `report` is lib/calls.mjs: handed each tool call once it has answered, and awaited before the exit.
+export function serveMcp({ verbs, version, spec, input = process.stdin, output = process.stdout, log = () => {}, report = async () => {} }) {
   return new Promise((resolve) => {
+    let client = {};
+    const sending = new Set();
+    const count = (tool, began, text, failure) => {
+      const sent = Promise.resolve(report({ tool, durationMs: Date.now() - began, outputChars: text.length, ...failure, ...client })).catch(() => {}).finally(() => sending.delete(sent));
+      sending.add(sent);
+    };
+    let closed = false;
+    const close = () => { if (!closed) { closed = true; void Promise.all(sending).then(() => resolve(0)); } };
     const send = (msg) => output.write(`${JSON.stringify(msg)}\n`);
     let buffer = "";
     input.setEncoding("utf8");
@@ -78,8 +87,8 @@ export function serveMcp({ verbs, version, spec, input = process.stdin, output =
         if (line) void handle(line);
       }
     });
-    input.on("end", () => resolve(0));
-    input.on("close", () => resolve(0));
+    input.on("end", close);
+    input.on("close", close);
 
     async function handle(line) {
       let msg;
@@ -87,9 +96,11 @@ export function serveMcp({ verbs, version, spec, input = process.stdin, output =
       if (!msg || typeof msg !== "object" || Array.isArray(msg)) { send(error(null, -32600, "invalid request")); return; }
       const { id, method, params } = msg;
       const notification = id === undefined || id === null;
+      const began = Date.now();
       try {
         switch (method) {
           case "initialize":
+            client = { clientName: params?.clientInfo?.name, clientVersion: params?.clientInfo?.version };
             return send(result(id, { protocolVersion: PROTOCOL, capabilities: { tools: {} }, serverInfo: { name: "cortad", version }, instructions: instructions(spec) }));
           case "notifications/initialized":
           case "notifications/cancelled":
@@ -101,8 +112,12 @@ export function serveMcp({ verbs, version, spec, input = process.stdin, output =
           case "tools/call": {
             const name = params?.name;
             const verb = NAMES.has(name) && Object.hasOwn(verbs, name) ? verbs[name] : null;
-            if (!verb) return send(result(id, { content: [{ type: "text", text: `No tool ${String(name)}.` }], isError: true }));
+            if (!verb) {
+              count("unknown", began, "", { errorCode: "unknown_tool" });
+              return send(result(id, { content: [{ type: "text", text: `No tool ${String(name)}.` }], isError: true }));
+            }
             const out = await verb(params?.arguments ?? {});
+            count(name, began, out.text, out.isError ? { errorCode: out.code ?? "refused", error: out.why } : {});
             const structured = out.structured && typeof out.structured === "object" && !Array.isArray(out.structured) ? { structuredContent: out.structured } : {};
             return send(result(id, { content: [{ type: "text", text: out.text }], ...structured, ...(out.isError ? { isError: true } : {}) }));
           }
@@ -111,6 +126,7 @@ export function serveMcp({ verbs, version, spec, input = process.stdin, output =
         }
       } catch (err) {
         log(`mcp ${method}: ${err?.stack ?? err}`);
+        if (method === "tools/call") count(NAMES.has(params?.name) ? params.name : "unknown", began, "", { errorCode: "internal" });
         if (!notification) send(result(id, { content: [{ type: "text", text: `Cortad could not answer: ${String(err?.message ?? err)}` }], isError: true }));
       }
     }

package/lib/verbs.mjs

@@ -58,7 +58,13 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
     try { data = text ? JSON.parse(text) : null; } catch { data = { error: text.slice(0, 200) }; }
     return { status: res.status, ok: res.ok, data };
   };
-  const failed = (res) => ({ text: res.data?.why ?? res.data?.error ?? `Cortad answered ${res.status}.`, data: res.data, isError: true });
+  // `code` and `why` are what lib/calls.mjs counts a failure under. `why` is set only where the
+  // sentence is Cortad's own: a failure that quotes the app's output carries a code and no words.
+  const failed = (res) => {
+    const text = res.data?.why ?? res.data?.error ?? `Cortad answered ${res.status}.`;
+    const code = res.status ? `http_${res.status}` : text === NOT_CONNECTED ? "not_connected" : "unreachable";
+    return { text, data: res.data, isError: true, code, why: text };
+  };
   const iso = () => new Date(now()).toISOString();
   const heard = (id) => { try { seen(String(id)); } catch { /* said once more by the hook */ } };
   // Empty for an app the connect command found already running.
@@ -108,8 +114,8 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
       const said = [restarted.length ? restartedText(restarted) : "", mine?.stale ? testedLine(mine) : ""];
       return { text: startedText(res.data, kind, args.findingId, said), data: res.data };
     }
-    if (res.status === 402) return { text: refusedText(res.data), data: res.data, isError: true };
-    if (res.status === 409) return { text: `${res.data?.why ?? "The run could not start."}\nNothing ran.`, data: res.data, isError: true };
+    if (res.status === 402) return { text: refusedText(res.data), data: res.data, isError: true, code: "plan_spent" };
+    if (res.status === 409) return { text: `${res.data?.why ?? "The run could not start."}\nNothing ran.`, data: res.data, isError: true, code: "run_refused" };
     return failed(res);
   };
 
@@ -119,20 +125,20 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
   // if none holds the app, and the run is posted in the background once it can be.
   const start = async (args, kind) => {
     const here = runner();
-    if (here?.state === "failed") return { text: notStartedText(here), data: { app: here }, isError: true };
+    if (here?.state === "failed") return { text: notStartedText(here), data: { app: here }, isError: true, code: "app_not_started" };
     const before = await call("GET", "/mcp/status?quiet=1");
     if (!before.ok) return failed(before);
     if (here?.state === "up" && before.data.app?.state === "ready-to-test") {
       const idle = !before.data.run || finished(before.data.run);
       const got = code && idle ? await code.fresh() : {};
-      if (got.error) return { text: `${got.error}\nNothing ran.`, isError: true };
+      if (got.error) return { text: `${got.error}\nNothing ran.`, isError: true, code: "app_not_started" };
       return post(args, kind, got.restarted, before.data);
     }
     pending.write({ kind, startedAt: iso(), after: before.data.run?.jobId ?? null });
     const began = await startApp(args, kind);
     if (!began.ok) {
       pending.write({ kind, startedAt: iso(), error: began.why });
-      return { text: began.why, isError: true };
+      return { text: began.why, isError: true, code: "app_not_started" };
     }
     return { text: here?.state === "up" ? upWaitingText(here, before.data.app) : STARTING, data: { pending: true } };
   };
@@ -153,8 +159,8 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
       p = pending.read() ?? p;
     }
     if (p.jobId) return { id: p.jobId };
-    if (p.error) return { text: `${p.error}\nnext: status`, isError: true };
-    if (stale()) return { text: "The process starting your app for the run ended without a result.\nNothing ran.\nnext: status", isError: true };
+    if (p.error) return { text: `${p.error}\nnext: status`, isError: true, code: "app_not_started" };
+    if (stale()) return { text: "The process starting your app for the run ended without a result.\nNothing ran.\nnext: status", isError: true, code: "app_not_started" };
     return { text: waitingText(p, now(), READY_MS, runner(), latest.data.app) };
   };
 
@@ -192,7 +198,7 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
   // verb alone, since an MCP call is cut at about 60 seconds. A run playing when it starts is that run,
   // and so is a finished one the agent has not read: a first run can end before the agent starts this.
   const wait = async () => {
-    if (!(typeof token === "function" ? token() : token)) return { text: NOT_CONNECTED, isError: true };
+    if (!(typeof token === "function" ? token() : token)) return { text: NOT_CONNECTED, isError: true, code: "not_connected", why: NOT_CONNECTED };
     const began = now();
     let id = null;
     let goneAt = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortad",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Connects the AI app on your machine to Cortad for test conversations, and gives your coding agent the MCP and skill to run them. No dependencies.",
   "bin": {
     "cortad": "local.mjs"
@@ -11,6 +11,7 @@
     "lib/app-port.mjs",
     "lib/auto-reach.mjs",
     "lib/backing.mjs",
+    "lib/calls.mjs",
     "lib/cli.mjs",
     "lib/contact-text.mjs",
     "lib/data.mjs",