cortad 0.3.1 → 0.3.3

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/local.mjs

@@ -133,15 +133,10 @@ if (viaToken) await holdProject();
 
 // ---- what leaves the machine: the source git would commit, and nothing git is told to ignore
 const SKIP_DIR = /^(node_modules|\.git|dist|build|out|coverage|vendor|venv|\.venv|env|target|tmp|\.next|\.nuxt|\.turbo|\.cache|__pycache__|\.terraform|\.wrangler|\.svelte-kit|\.output|\.parcel-cache|\.idea|\.vscode|secrets?|\.secrets?)$/i;
-// Env files by any name (scripts/books.env is one), keys, and data rather than code.
-const SKIP_FILE = /^\.env(\..*)?$|^\.envrc$|\.env$|\.(pem|key|p12|pfx|jks|keystore|sqlite|sqlite3|db|log|lock|map|zip|tar|gz|tgz|7z|rar|png|jpe?g|gif|webp|ico|svg|mp3|mp4|wav|mov|pdf|woff2?|ttf|otf|eot|bin|exe|dll|so|dylib|wasm|onnx|pt|pth|safetensors|parquet|csv|tsv|jsonl|ndjson|xlsx?|numbers|DS_Store)$/i;
-const MAX_FILE = 1_000_000;
-// A JSON or YAML file this large is a dataset (exports, catalogues, fixtures), not code or a prompt,
-// and datasets are where projects keep what they would never paste into a chat.
-const MAX_DATA = 200_000;
-const DATA_FILE = /\.(json|ya?ml)$/i;
-const MANIFEST_FILE = /^(package|tsconfig|composer|app|manifest)\.json$/i;
-const MAX_TOTAL = 80_000_000;
+// Env files by any name (scripts/books.env is one), keys, credentials, media and compiled output.
+const SKIP_FILE = /^\.env(\..*)?$|^\.envrc$|\.env$|\.(pem|key|p12|pfx|jks|keystore|sqlite|sqlite3|db|log|lock|map|zip|tar|gz|tgz|7z|rar|png|jpe?g|gif|webp|ico|svg|mp3|mp4|wav|mov|pdf|woff2?|ttf|otf|eot|bin|exe|dll|so|dylib|wasm|onnx|pt|pth|safetensors|numbers|DS_Store)$/i;
+const MAX_FILE = 25_000_000;
+const MAX_TOTAL = 256_000_000;
 const ENV_FILE = /^\.env(\.(local|staging|stage|development|dev|test|example|sample))?$/;
 
 function walk(dir, depth, out, envs, total) {
@@ -156,7 +151,6 @@ function walk(dir, depth, out, envs, total) {
     let size;
     try { size = statSync(full).size; } catch { continue; }
     if (size > MAX_FILE || total + size > MAX_TOTAL) continue;
-    if (size > MAX_DATA && DATA_FILE.test(e.name) && !MANIFEST_FILE.test(e.name)) continue;
     if (!shareable(relative(root, full), false)) continue;
     out.push(relative(root, full));
     total += size;
@@ -1150,8 +1144,8 @@ if (explain) {
     `talks to        ${origin.origin}, localhost (your app's port only), and your own model providers, to ask each which models your key can use`,
     `would send      ${files.length} source files, ${Math.round(bytes / 1024)} KB, once${listed ? " (what git would commit)" : ""}`,
     ...(kept.length ? [`kept here       ${kept.length} file${kept.length === 1 ? " that holds" : "s that hold"} keys: ${kept.slice(0, 6).join(", ")}${kept.length > 6 ? ", ..." : ""}`] : []),
-    ...(left.length ? [`also not sent   ${left.length} tracked data, media or lock file${left.length === 1 ? "" : "s"}: ${left.slice(0, 6).join(", ")}${left.length > 6 ? ", ..." : ""}`] : []),
-    `not sent        anything git ignores, env files (${envFiles.length} here: ${envFiles.slice(0, 6).map(rel).join(", ") || "none"}), key files, data files, node_modules, .git`,
+    ...(left.length ? [`also not sent   ${left.length} tracked media or lock file${left.length === 1 ? "" : "s"}: ${left.slice(0, 6).join(", ")}${left.length > 6 ? ", ..." : ""}`] : []),
+    `not sent        anything git ignores, env files (${envFiles.length} here: ${envFiles.slice(0, 6).map(rel).join(", ") || "none"}), key files, node_modules, .git`,
     `env files       values read here only: to hide them in replies, to sign in a test account, and to ask your providers what your keys reach. Variable names and whether a switch is on or off go up; no value does`,
     `would start     ${flag("--port") ? `nothing: uses your app on port ${flag("--port")}` : plan?.cmd ? `${plan.cmd}   (in ${rel(plan.cwd)})` : plan?.noServer ? "nothing: this repository has no server to run" : "asks you how your app starts"}`,
     `would raise     ${flag("--port") ? "nothing: your app's own request limits stay as they are" : `${Object.keys(liftedLimits(envFiles, files.map((f) => join(root, f)))).join(", ") || "no request limits found"}   (only after your yes, for this session only)`}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortad",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "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",