@vecteur/cli 0.3.1 → 0.4.0

package/src/credentials.js

@@ -5,21 +5,20 @@ import { dirname, join } from "node:path";
 import { CliError } from "./errors.js";
 
 /**
- * ONE PERSISTENT LOGIN — SRD 06's release bar for this door, beside "the same product from any
- * working directory".
+ * PERSISTENT LOGINS, ONE FILE, PER ORIGIN.
  *
- * Before this, `configuration()` read `VECTEUR_TOKEN` from the environment and nothing else, so
- * "logged in" lasted exactly as long as one shell. Every new terminal, every cron line and every
- * `cd` into a project began by pasting a credential again — which is not a login, and it is the
- * habit that puts secrets in shell history.
+ * SRD 06's release bar for this door is "one persistent login, the same product from any
+ * working directory". Before persistence, `configuration()` read `VECTEUR_TOKEN` from the
+ * environment and nothing else, so "logged in" lasted one shell.
  *
- * THE TOKEN IS NEVER AN ARGUMENT. `vecteur login` reads it from stdin. A credential passed as
- * `--token vct_…` is visible in `ps`, in `/proc/<pid>/cmdline` to every local user, and in the
- * shell history file afterwards — the exact exposure `SHIP-007` exists to rotate away in this
- * same product. A door that ships a convenient way to make that mistake has shipped the mistake.
+ * THE TOKEN IS NEVER AN ARGUMENT and is never printed, not even a prefix. `vecteur login`
+ * acquires it through the browser device grant. A credential passed as `--token vct_…` is
+ * visible in `ps`, in `/proc/<pid>/cmdline` to every local user, and in the shell history
+ * file afterwards — the exact exposure `SHIP-007` exists to rotate away in this same product.
  *
  * The store lives OUTSIDE every git tree, one file, 0600 — the same shape `scripts/with-secrets.py`
- * holds the fleet's own store in, for the same reason.
+ * holds the fleet's own store in, for the same reason. One file is the only store; there is no
+ * second reader.
  */
 const FILE_MODE = 0o600;
 const DIRECTORY_MODE = 0o700;
@@ -32,13 +31,65 @@ export function credentialsPath(env = process.env) {
   return join(base, "vecteur", "credentials.json");
 }
 
-/** `{ origin, token }` as stored, or `null` when nobody has logged in on this machine. */
+function persistStore(store, env) {
+  const path = credentialsPath(env);
+  mkdirSync(dirname(path), { recursive: true, mode: DIRECTORY_MODE });
+  // Written 0600 AT CREATION, not chmod'ed after: between an 0644 create and a chmod there is a
+  // window in which any local user can read the token, and on a shared machine that window is
+  // the whole exposure.
+  writeFileSync(path, `${JSON.stringify({ current: store.current, logins: store.logins }, null, 2)}\n`, {
+    mode: FILE_MODE,
+  });
+  chmodSync(path, FILE_MODE);   // an existing file keeps its old mode through writeFileSync
+  return path;
+}
+
+function unreadable(env) {
+  return new CliError("credentials_unreadable",
+    `${credentialsPath(env)} is not readable JSON — run \`vecteur logout --local\` and log in again`);
+}
+
+function isLogin(value) {
+  return value && typeof value === "object" && !Array.isArray(value)
+    && typeof value.token === "string"
+    && Object.keys(value).every(key => ["token", "project_id"].includes(key))
+    && (value.project_id === undefined || (typeof value.project_id === "string" && value.project_id.length > 0));
+}
+
+function fromLegacy(parsed) {
+  // Migrated in place: the 0.4.0 file is exactly `{origin, token}` strings, which is already
+  // one valid login, so rewriting it as `{current, logins}` keeps the credential and one store.
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+    && Object.keys(parsed).sort().join("\n") === "origin\ntoken"
+    && typeof parsed.origin === "string" && typeof parsed.token === "string"
+    ? { current: parsed.origin, logins: { [parsed.origin]: { token: parsed.token } } }
+    : null;
+}
+
+function fromStore(parsed) {
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+    && Object.keys(parsed).sort().join("\n") === "current\nlogins"
+    && typeof parsed.current === "string" && parsed.current.length > 0
+    && parsed.logins && typeof parsed.logins === "object" && !Array.isArray(parsed.logins)
+    && Object.entries(parsed.logins).every(([origin, login]) => origin.length > 0
+      && (typeof login === "string" || isLogin(login)))
+    && Object.hasOwn(parsed.logins, parsed.current)
+    ? { current: parsed.current, logins: Object.fromEntries(Object.entries(parsed.logins).map(([origin, login]) =>
+      [origin, typeof login === "string" ? { token: login } : login])) }
+    : null;
+}
+
+/**
+ * Per-origin `{token, project_id?}` logins, or `null` when nobody has logged in.
+ * Both legacy single-origin and string-map stores migrate in place on first read.
+ */
 export function readCredentials(env = process.env) {
   let raw;
   try {
     raw = readFileSync(credentialsPath(env), "utf8");
-  } catch {
-    return null;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw unreadable(env);
   }
   let parsed;
   try {
@@ -46,30 +97,66 @@ export function readCredentials(env = process.env) {
   } catch {
     // A corrupt store is a typed refusal, not a silent fall back to "not logged in": the second
     // reads as "run login again" and loses the fact that a credential IS there and unreadable.
-    throw new CliError("credentials_unreadable",
-      `${credentialsPath(env)} is not readable JSON — run \`vecteur logout\` and log in again`);
+    throw unreadable(env);
   }
-  if (!parsed || typeof parsed !== "object" ||
-      typeof parsed.origin !== "string" || typeof parsed.token !== "string") {
-    throw new CliError("credentials_unreadable",
-      `${credentialsPath(env)} does not hold an origin and a token`);
+  const store = fromStore(parsed);
+  if (store) {
+    if (Object.values(parsed.logins).some(login => typeof login === "string")) persistStore(store, env);
+    return store;
   }
-  return { origin: parsed.origin, token: parsed.token };
+  const migrated = fromLegacy(parsed);
+  if (!migrated) throw unreadable(env);
+  persistStore(migrated, env);
+  return migrated;
 }
 
 export function writeCredentials({ origin, token }, env = process.env) {
-  const path = credentialsPath(env);
-  mkdirSync(dirname(path), { recursive: true, mode: DIRECTORY_MODE });
-  // Written 0600 AT CREATION, not chmod'ed after: between an 0644 create and a chmod there is a
-  // window in which any local user can read the token, and on a shared machine that window is
-  // the whole exposure.
-  writeFileSync(path, `${JSON.stringify({ origin, token }, null, 2)}\n`, { mode: FILE_MODE });
-  chmodSync(path, FILE_MODE);   // an existing file keeps its old mode through writeFileSync
-  return path;
+  const saved = readCredentials(env) ?? { current: origin, logins: {} };
+  saved.logins[origin] = { token };
+  saved.current = origin;
+  return persistStore(saved, env);
+}
+
+export function setCurrentOrigin(origin, env = process.env) {
+  const saved = readCredentials(env);
+  if (!saved || !Object.hasOwn(saved.logins, origin) || saved.current === origin) return;
+  saved.current = origin;
+  persistStore(saved, env);
 }
 
-export function clearCredentials(env = process.env) {
+export function clearCredentials(env = process.env, origin = undefined) {
   const path = credentialsPath(env);
-  rmSync(path, { force: true });
+  if (origin === undefined) {
+    rmSync(path, { force: true });
+    return path;
+  }
+  let saved;
+  try {
+    saved = readCredentials(env);
+  } catch {
+    rmSync(path, { force: true });
+    return path;
+  }
+  if (!saved) {
+    rmSync(path, { force: true });
+    return path;
+  }
+  delete saved.logins[origin];
+  if (!Object.keys(saved.logins).length) {
+    rmSync(path, { force: true });
+    return path;
+  }
+  if (saved.current === origin) saved.current = Object.keys(saved.logins).sort()[0];
+  persistStore(saved, env);
   return path;
 }
+
+/** Selection is an id only; every use resolves it against the live authorized list. */
+export function selectProject(origin, projectId, env = process.env) {
+  if (env.VECTEUR_TOKEN) throw new CliError("persistent_login_required",
+    "project use requires a persistent login; unset VECTEUR_TOKEN and run `vecteur login`");
+  const saved = readCredentials(env);
+  if (!saved?.logins[origin]) throw new CliError("persistent_login_required", "run `vecteur login` first");
+  saved.logins[origin].project_id = projectId;
+  persistStore(saved, env);
+}

package/src/download.js

@@ -0,0 +1,42 @@
+import { randomUUID } from "node:crypto";
+import { link, open, unlink } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
+
+import { CliError } from "./errors.js";
+
+function defaultName(casRef) {
+  return `artifact-${casRef.slice("sha256:".length, "sha256:".length + 12)}`;
+}
+
+/**
+ * Stream admitted bytes to a private sibling, then publish with an atomic no-overwrite link.
+ * A remote filename never reaches this path: the caller either supplies --output or receives
+ * a digest-derived basename, so traversal and shell metacharacters cannot arrive from RunWire.
+ */
+export async function downloadArtifact(client, casRef, projectId, output) {
+  const target = resolve(output ?? defaultName(casRef));
+  const temporary = resolve(dirname(target), `.vecteur-${basename(target)}-${randomUUID()}.part`);
+  let handle;
+  try {
+    handle = await open(temporary, "wx", 0o600);
+    const result = await client.artifactGet(casRef, projectId, chunk => handle.writeFile(chunk));
+    await handle.sync();
+    await handle.close();
+    handle = undefined;
+    try {
+      await link(temporary, target);
+    } catch (error) {
+      if (error?.code === "EEXIST") {
+        throw new CliError("output_exists", `refusing to overwrite ${target}`);
+      }
+      throw error;
+    }
+    return { ...result, path: target };
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    throw new CliError("download_failed", `could not safely write ${target}`);
+  } finally {
+    if (handle) await handle.close().catch(() => {});
+    await unlink(temporary).catch(() => {});
+  }
+}

package/src/format.js

@@ -1,4 +1,8 @@
-import { ORIGIN_KINDS, ORIGIN_WORD } from "./contract.js";
+import {
+  ORIGIN_KINDS, ORIGIN_WORD, TERMINAL_FIELDS, TERMINAL_RECOVERY_DECLARATIONS,
+  validateArtifact, validateSynthesis,
+} from "./contract.js";
+import { CliError } from "./errors.js";
 
 export function canonicalJson(value) {
   validateNumbers(value);
@@ -67,13 +71,134 @@ export function inputLines(inputs) {
     // (orbit.csv)" is an answer. It is omitted only when the origin does not carry one.
     const ref = typeof row?.origin?.ref === "string" && row.origin.ref
       ? ` ${row.origin.ref}` : "";
-    return `    ${row?.name ?? "?"} = ${JSON.stringify(row?.value)}${unit}  (${word}${ref})`;
+    const rendered = `${row?.name ?? "?"} = ${JSON.stringify(row?.value)}${unit}  (${word}${ref})`;
+    return `    ${plainLine(rendered)}`;
   });
 }
 
-export function human(value) {
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", `'"'"'`)}'`;
+}
+
+function safeArtifactName(artifact) {
+  const leaf = artifact.filename.replaceAll("\\", "/").split("/").at(-1);
+  if (!leaf || leaf === "." || leaf === ".." || leaf.startsWith("-") || leaf.startsWith(".")) {
+    return `artifact-${artifact.cas_ref.slice("sha256:".length, "sha256:".length + 12)}`;
+  }
+  return leaf;
+}
+
+function terminalPresentation(value) {
+  const terminalEvent = value.events.at(-1);
+  if (terminalEvent?.kind !== "terminal") {
+    throw new CliError("terminal_invalid", "Run record has no final terminal event");
+  }
+  const payload = terminalEvent.payload;
+  const allowed = new Set([...TERMINAL_FIELDS, "terminal"]);
+  if (Object.keys(payload).some(key => !allowed.has(key))) {
+    throw new CliError("terminal_invalid", "Run terminal carries an undeclared field");
+  }
+  if (payload.state !== undefined && payload.terminal !== undefined
+      && payload.state !== payload.terminal) {
+    throw new CliError("terminal_mismatch", "Run terminal carries conflicting states");
+  }
+  const state = payload.state ?? payload.terminal;
+  if (state !== value.terminal) {
+    throw new CliError("terminal_mismatch", "Run terminal event disagrees with its record");
+  }
+  const syntheses = value.events.filter(event => event.kind === "synthesis").map(event => event.payload);
+  const synthesis = syntheses.at(-1) ?? null;
+  if (synthesis !== null && !validateSynthesis(synthesis)) {
+    throw new CliError("synthesis_invalid", "Run carries malformed synthesis");
+  }
+  if (["ok", "partial"].includes(state)
+      && (!synthesis || synthesis.terminal !== state)) {
+    throw new CliError("synthesis_invalid", `Run terminal ${state} disagrees with its synthesis`);
+  }
+  if (payload.answer !== undefined
+      && (!synthesis || payload.answer !== synthesis.answer)) {
+    throw new CliError("synthesis_invalid", "Run terminal answer differs from its synthesis");
+  }
+
+  const defect = payload.defect;
+  const recovery = payload.recovery;
+  if (!["ok", "partial"].includes(state) && defect === undefined) {
+    throw new CliError("recovery_invalid", `Run terminal ${state} carries no typed cause/recovery`);
+  }
+  if ((defect === undefined) !== (recovery === undefined)) {
+    throw new CliError("recovery_invalid", "Run terminal cause and recovery must travel together");
+  }
+  if (defect !== undefined) {
+    const declarations = TERMINAL_RECOVERY_DECLARATIONS[defect];
+    if (!declarations || !Array.isArray(recovery) || recovery.length === 0) {
+      throw new CliError("recovery_invalid", "Run terminal recovery is not owner-declared");
+    }
+    for (const action of recovery) {
+      const fields = action && typeof action === "object" && !Array.isArray(action)
+        ? Object.keys(action).sort().join(",") : "";
+      const declaration = declarations.find(([capability]) => capability === action?.capability);
+      const argumentsValue = action?.arguments;
+      if (fields !== "arguments,capability" || !declaration || !argumentsValue
+          || typeof argumentsValue !== "object" || Array.isArray(argumentsValue)
+          || Object.keys(argumentsValue).sort().join(",") !== [...declaration[1]].sort().join(",")
+          || Object.values(argumentsValue).some(item => !(
+            (typeof item === "string" && item.length > 0)
+            || (Number.isSafeInteger(item) && item > 0)
+          ))) {
+        throw new CliError("recovery_invalid", "Run terminal recovery action is malformed");
+      }
+    }
+  }
+  return { state, answer: payload.answer, defect, recovery: recovery ?? [] };
+}
+
+function recoveryLine(action) {
+  const args = Object.entries(action.arguments)
+    .map(([name, value]) => `${name}=${JSON.stringify(value)}`).join(" ");
+  return `Recovery: ${action.capability}${args ? ` ${args}` : ""}`;
+}
+
+export function humanRun(value, { projectId, cost } = {}) {
+  const terminal = terminalPresentation(value);
+  const origins = value.events.flatMap(event => event.kind === "step_finished"
+    ? inputLines(event.payload?.step?.inputs ?? event.payload?.inputs) : []);
+  const artifacts = value.events.filter(event => event.kind === "artifact").map(event => event.payload);
+  if (!artifacts.every(validateArtifact)) {
+    throw new CliError("artifact_invalid", "Run carries malformed artifact metadata");
+  }
+  const lines = [];
+  if (terminal.answer !== undefined) lines.push(terminal.answer, "");
+  if (origins.length) lines.push("Inputs and origins:", ...origins, "");
+  if (artifacts.length) {
+    lines.push("Artifacts:");
+    for (const artifact of artifacts) {
+      lines.push(`  ${artifact.filename} (${artifact.kind}, ${artifact.id})`);
+      const project = projectId ? ` --project ${shellQuote(projectId)}` : "";
+      lines.push(`    vecteur artifact get ${shellQuote(artifact.cas_ref)} --output ${shellQuote(safeArtifactName(artifact))}${project}`);
+    }
+    lines.push("");
+  }
+  lines.push(`Run: ${plainLine(value.run_id)}`, `Terminal: ${terminal.state}`);
+  if (terminal.defect !== undefined) lines.push(`Cause: ${terminal.defect}`);
+  lines.push(...terminal.recovery.map(recoveryLine));
+  if (cost) lines.push("", humanCost(cost).trimEnd());
+  return `${lines.join("\n")}\n`;
+}
+
+export function humanCost(value) {
+  const lines = [`Project cost (UTC month, ${value.coverage} coverage):`];
+  for (const [label, amount] of [
+    ["Used", value.display.used], ["Limit", value.display.limit], ["Remaining", value.display.remaining],
+  ]) {
+    if (amount !== null) lines.push(`  ${label}: ${amount}`);
+  }
+  if (value.display.used === null) lines.push("  No exact amount is available.");
+  return `${lines.join("\n")}\n`;
+}
+
+export function human(value, options = {}) {
   if (value && typeof value === "object" && typeof value.run_id === "string") {
-    return `Run ${value.run_id}: ${value.terminal ?? value.state_hash ?? "accepted"}\n`;
+    return humanRun(value, options);
   }
   if (value && typeof value === "object" && typeof value.name === "string") {
     return `${value.name} (${value.id})\n`;
@@ -82,10 +207,24 @@ export function human(value) {
 }
 
 export function progress(event) {
-  const head = `[${event.seq}] ${event.kind}\n`;
-  // A finished step is where a run's evidence becomes visible: its inputs each carry an
-  // origin. Every other kind keeps the one-line shape.
-  if (event?.kind !== "step_finished") return head;
+  if (event?.kind === "step_started") {
+    const title = plainLine(event.payload?.title ?? "");
+    return title.trim() ? `Starting: ${title}\n` : "Starting\n";
+  }
+  if (event?.kind === "step_label") {
+    const label = plainLine(event.payload?.label ?? "");
+    return label.trim() ? `Working: ${label}\n` : "";
+  }
+  if (event?.kind === "artifact") {
+    return `File ready: ${plainLine(event.payload.filename)}\n`;
+  }
+  if (event?.kind !== "step_finished") return "";
   const lines = inputLines(event?.payload?.step?.inputs ?? event?.payload?.inputs);
+  const title = plainLine(event.payload?.step?.title ?? event.payload?.title ?? "");
+  const head = title.trim() ? `Finished: ${title}\n` : "Finished\n";
   return lines.length ? `${head}${lines.join("\n")}\n` : head;
 }
+
+function plainLine(value) {
+  return String(value).replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ");
+}

package/src/mcp.js

@@ -1,7 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import * as z from "zod/v4";
 
-import { CliError, VecteurClient } from "./client.js";
+import { CliError, VecteurClient, redact } from "./client.js";
 import { EVENT_KINDS } from "./contract.js";
 import { canonicalJson } from "./format.js";
 
@@ -19,23 +20,33 @@ const eventOutput = z.object({
 }).strict();
 const memberOutput = z.object({
   user_id: z.string().min(1), email: z.string().min(1), display_name: z.string().min(1),
-  role: z.enum(["OWNER", "ADMIN", "EDITOR", "VIEWER"]),
+  role: z.enum(["OWNER", "EDITOR", "VIEWER"]),
 }).strict();
 const projectOutput = z.object({
   id: z.string().min(1), name: z.string().min(1), org_id: z.string().min(1),
-  workspace_id: z.string().min(1), role: z.enum(["OWNER", "ADMIN", "EDITOR", "VIEWER"]),
-  role_source: z.enum(["workspace", "project"]), members: z.array(memberOutput),
+  workspace_id: z.string().min(1), role: z.enum(["OWNER", "EDITOR", "VIEWER"]),
+  members: z.array(memberOutput),
   created_at: z.number().int().safe(), updated_at: z.number().int().safe(),
 }).strict();
+const billableDimensionsOutput = z.object({
+  uncached_input: z.number().int().safe().nonnegative(),
+  cache_read: z.number().int().safe().nonnegative(),
+  cache_write: z.number().int().safe().nonnegative(),
+  output: z.number().int().safe().nonnegative(),
+  cache_write_class: z.string().min(1).nullable().optional(),
+  cache_write_duration_s: z.number().int().safe().nonnegative().nullable().optional(),
+  provider_tier: z.string().min(1).nullable().optional(),
+  long_context_band: z.string().min(1).nullable().optional(),
+}).strict();
 const admittedOutput = z.object({
   run_id: z.string().min(1), state_hash: z.string().min(1), result_hash: z.string().min(1),
-  profile: z.string().min(1),
+  requested_route_id: z.string().min(1), profile: z.string().min(1),
   terminal: z.enum(["ok", "partial", "blocked", "refused", "infeasible_physics", "capability_gap"]),
+  duration_seconds: z.number().int().safe().nonnegative().nullable().optional(),
   usage: z.object({
-    state: z.enum(["recorded", "usage_unavailable"]), provider: z.string().min(1),
-    model_id: z.string().min(1), input_tokens: z.number().int().safe().nonnegative().nullable(),
-    output_tokens: z.number().int().safe().nonnegative().nullable(),
-    cost_usd: z.number().finite().nonnegative().nullable(),
+    coverage: z.enum(["complete", "incomplete"]), provider_id: z.string().min(1),
+    model_id: z.string().min(1), observed_at: z.number().int().safe().nonnegative(),
+    billable_dimensions: z.array(billableDimensionsOutput).min(1),
   }).strict(),
   events: z.array(eventOutput),
 }).strict();
@@ -96,3 +107,29 @@ export function createVecteurMcpServer(client = new VecteurClient(), shutdownSig
 
   return server;
 }
+
+export function serveVecteurMcp() {
+  const shutdown = new AbortController();
+  const handle = serveStdio(() => createVecteurMcpServer(undefined, shutdown.signal), {
+    onerror(error) {
+      process.stderr.write(`mcp_transport_error: ${redact(error?.message ?? "MCP transport failed")}\n`);
+    },
+  });
+
+  let closing;
+  function close() {
+    if (!closing) {
+      shutdown.abort();
+      closing = handle.close().catch((error) => {
+        process.stderr.write(`mcp_close_error: ${redact(error?.message ?? "MCP close failed")}\n`);
+        process.exitCode = 1;
+      });
+    }
+    return closing;
+  }
+
+  process.stdin.once("end", () => { void close(); });
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.once(signal, () => { void close(); });
+  }
+}

package/src/projects.js

@@ -0,0 +1,42 @@
+import { CliError } from "./errors.js";
+
+/** Resolve only server-authorized objects. Ids take precedence over names. */
+export function resolveNamed(rows, value, kind) {
+  const byId = rows.find(row => row.id === value);
+  if (byId) return byId;
+  const matches = rows.filter(row => row.name === value);
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) throw new CliError(`${kind}_ambiguous`,
+    `${value} matches multiple ${kind}s: ${matches.map(row => row.id).join(", ")}; use an id`);
+  throw new CliError(`${kind}_not_found`,
+    `${value} is not an authorized ${kind}; available: ${describe(rows)}`);
+}
+
+const describe = rows => rows.map(row => `${row.name} (${row.id})`).join(", ") || "none";
+
+export function resolveWorkspace(account, value) {
+  const rows = account.workspaces;
+  if (value !== undefined) return resolveNamed(rows, value, "workspace").id;
+  if (rows.length === 1) return rows[0].id;
+  throw new CliError("workspace_required", `Choose --workspace <name-or-id>: ${describe(rows)}`);
+}
+
+export async function resolveRunProject(client, explicitId) {
+  if (explicitId !== undefined) return explicitId;
+  const selected = client.config.projectId;
+  if (!selected) throw new CliError("project_selection_required",
+    "Select a Project with `vecteur project use <name-or-id>` after persistent login, or pass --project <id>");
+  const projects = await client.projectList();
+  if (!projects.some(project => project.id === selected)) {
+    throw new CliError("project_not_found",
+      `Selected Project ${selected} is no longer authorized; run \`vecteur project use <name-or-id>\``);
+  }
+  return selected;
+}
+
+export function humanProjects(value) {
+  const rows = value.projects.map(project =>
+    `${project.id === value.selected_project_id ? "*" : " "} ${project.name} (${project.id}) ${project.role}`);
+  const allowance = value.active_projects;
+  return [...rows, `Active projects: ${allowance.current} / ${allowance.maximum ?? "Contract limit"}`].join("\n") + "\n";
+}

package/bin/vecteur-mcp.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-import { serveStdio } from "@modelcontextprotocol/server/stdio";
-
-import { redact } from "../src/client.js";
-import { createVecteurMcpServer } from "../src/mcp.js";
-
-const shutdown = new AbortController();
-const handle = serveStdio(() => createVecteurMcpServer(undefined, shutdown.signal), {
-  onerror(error) {
-    process.stderr.write(`mcp_transport_error: ${redact(error?.message ?? "MCP transport failed")}\n`);
-  },
-});
-
-let closing;
-function close() {
-  if (!closing) {
-    shutdown.abort();
-    closing = handle.close().catch((error) => {
-      process.stderr.write(`mcp_close_error: ${redact(error?.message ?? "MCP close failed")}\n`);
-      process.exitCode = 1;
-    });
-  }
-  return closing;
-}
-
-process.stdin.once("end", () => { void close(); });
-for (const signal of ["SIGINT", "SIGTERM"]) {
-  process.once(signal, () => { void close(); });
-}