@tablation/crew 0.67.2 → 0.68.1

package/dist/cli.js

@@ -2662,6 +2662,14 @@ function resolveApiKey(r) {
     `route "${r.route}": no API key (looked for, in order: apiKey; ${r.apiKeyVar ?? "VAR"} in ${r.apiKeyFile ?? "<unset>"}; CREW_API_KEY in the environment)`
   );
 }
+function credentialSource(r) {
+  if (r.apiKey) return KEYCHAIN_ELIGIBLE_ROUTES.has(r) ? "keychain" : "inline";
+  if (r.apiKeyFile && r.apiKeyVar && existsSync7(r.apiKeyFile)) {
+    const re = new RegExp(`^${r.apiKeyVar}=`);
+    if (readFileSync6(r.apiKeyFile, "utf8").split("\n").some((l) => re.test(l))) return "apiKeyFile";
+  }
+  return process.env.CREW_API_KEY?.trim() ? "CREW_API_KEY" : "none";
+}
 var KEYCHAIN_ELIGIBLE_ROUTES = /* @__PURE__ */ new WeakSet();
 async function hydrateApiKeys(routes, getStore = getSessionStore) {
   let store;
@@ -3879,6 +3887,9 @@ function ticketMentions(text) {
 var TicketAttributionTracker = class {
   #tokensByTicket = /* @__PURE__ */ new Map();
   #current;
+  /** Tracker record uuid → ticket key, learned when a write names both (a claim resolves the key from the last mention). */
+  #keyByRecord = /* @__PURE__ */ new Map();
+  #lastBy = {};
   /** The ticket key most recently named in the transcript, or undefined before any. */
   get current() {
     return this.#current;
@@ -3895,6 +3906,37 @@ var TicketAttributionTracker = class {
     if (this.#current === void 0 || tokens <= 0) return;
     this.#tokensByTicket.set(this.#current, (this.#tokensByTicket.get(this.#current) ?? 0) + tokens);
   }
+  /**
+   * Record a tool call if it is a ticket-targeted tracker write (claim,
+   * hand-off or comment). The ticket key comes from a record uuid seen on an
+   * earlier write when known, else from the key last named in the transcript
+   * (a claim or hand-off announces its ticket). A comment on a record never
+   * seen before is ignored: its uuid cannot be resolved to a key.
+   */
+  noteWrite(tool, input) {
+    const w = classifyWrite(tool, input);
+    if (!w) return;
+    let key = w.recordId ? this.#keyByRecord.get(w.recordId) : void 0;
+    if (w.kind !== "comment") key ??= this.#current;
+    if (!key) return;
+    if (w.kind !== "comment" && w.recordId) this.#keyByRecord.set(w.recordId, key);
+    this.#lastBy[w.kind] = key;
+  }
+  /**
+   * How the attribution is decided: a hand-off write beats a claim, a claim
+   * beats a comment (so a follow-up ticket filed or commented on while
+   * working never displaces the claimed one), and any write beats the
+   * mention-token heuristic, which is only the fallback for runs that made
+   * no ticket-targeted write. The pre-run hint is last.
+   */
+  decide(hint) {
+    for (const by of ["handoff", "claim", "comment"]) {
+      const ticket = this.#lastBy[by];
+      if (ticket) return { ticket, by };
+    }
+    if (this.#tokensByTicket.size > 0) return { ticket: this.winner(hint), by: "mentions" };
+    return { ticket: hint, by: "hint" };
+  }
   /**
    * The ticket key the run spent the most tokens on, or `fallback` (the
    * pre-run poll hint) when the transcript never named one — an
@@ -3918,6 +3960,20 @@ function isClaimWrite(tool, input) {
   const body = input?.body;
   return typeof body === "object" && body !== null && body.status === "in_progress";
 }
+var HANDOFF_STATUSES = /* @__PURE__ */ new Set(["fixed", "verified", "needs_info", "accepted"]);
+function classifyWrite(tool, input) {
+  if (!tool) return void 0;
+  const body = input?.body;
+  if (typeof body !== "object" || body === null) return void 0;
+  const b = body;
+  if (/records_controller_update$/.test(tool)) {
+    const recordId = typeof input?.recordId === "string" ? input.recordId : void 0;
+    if (b.status === "in_progress" || b.status === "qa") return { kind: "claim", recordId };
+    if (typeof b.status === "string" && HANDOFF_STATUSES.has(b.status)) return { kind: "handoff", recordId };
+  }
+  if (/records_controller_create$/.test(tool) && typeof b.ticket_id === "string") return { kind: "comment", recordId: b.ticket_id };
+  return void 0;
+}
 
 // src/agent.ts
 var DIGEST_MAX_AGE_SECONDS = 600;
@@ -4208,6 +4264,7 @@ var RunObserver = class {
     let turnText = "";
     for (const ev of events) if ((ev.kind === "thought" || ev.kind === "text") && ev.text) this.attribution.note(ev.text);
     for (const ev of events) {
+      if (ev.kind === "tool") this.attribution.noteWrite(ev.tool, ev.input);
       if (ev.kind === "tool" && isClaimWrite(ev.tool, ev.input)) {
         const claimed = this.attribution.current;
         if (claimed && claimed !== this.liveTicket) {
@@ -4292,12 +4349,13 @@ function writeRunMeta(id, startedAt, liveTicket, extra) {
   }
 }
 async function finishRun(id, obs, emit, startedAt, end, agentLogKey) {
-  const attributedTicket = obs.attribution.winner(obs.liveTicket);
+  const { ticket: attributedTicket, by: attributedBy } = obs.attribution.decide(obs.liveTicket);
   const identity = { toolchain: id.toolchain, harness: id.harness, provider: id.provider };
   const { result } = obs;
   try {
     writeRunMeta(id, startedAt, obs.liveTicket, {
       attributedTicket: attributedTicket ?? null,
+      attributedBy,
       running: void 0,
       exitCode: end.code,
       ...end.interrupted ? { interrupted: end.interrupted } : {},
@@ -11674,6 +11732,61 @@ function formatProjectsReport(report) {
 `;
 }
 
+// src/whoami.ts
+async function buildWhoami(routes, deps = {}) {
+  const doFetch = deps.fetch ?? fetch;
+  return Promise.all(routes.map(async (route) => {
+    const credential = credentialSource(route);
+    try {
+      const key = resolveApiKey(route);
+      const q = route.resolved ? `?workspaceId=${encodeURIComponent(route.resolved.workspaceId)}` : "";
+      const res = await doFetch(`${route.baseUrl.replace(/\/+$/, "")}/api/auth/me${q}`, {
+        headers: { Authorization: `Bearer ${key}`, "User-Agent": deps.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
+      });
+      if (res.status === 401 || res.status === 403) {
+        return { route: route.route, ok: false, credential, error: `key rejected by ${route.baseUrl} (HTTP ${res.status}): expired or revoked, re-run crew connect` };
+      }
+      if (!res.ok) return { route: route.route, ok: false, credential, error: `/auth/me answered HTTP ${res.status}` };
+      const me = await res.json();
+      const operatorId = route.resolved?.operator ?? null;
+      let operatorName = null;
+      if (operatorId && deps.operatorName) {
+        try {
+          operatorName = await deps.operatorName(route, operatorId) ?? null;
+        } catch {
+        }
+      }
+      return {
+        route: route.route,
+        ok: true,
+        credential,
+        identity: { id: me.id ?? null, email: me.email ?? null, name: me.name ?? null },
+        role: typeof me.role === "string" ? me.role : null,
+        operator: { id: operatorId, name: operatorName }
+      };
+    } catch (e) {
+      return { route: route.route, ok: false, credential, error: e.message };
+    }
+  }));
+}
+function formatWhoami(report) {
+  const lines = [];
+  for (const r of report) {
+    lines.push(`route ${r.route}`);
+    if (!r.ok) {
+      lines.push(`  error: ${r.error}`, `  credential: ${r.credential}`);
+      continue;
+    }
+    const who2 = [r.identity.name, r.identity.email ? `<${r.identity.email}>` : null].filter(Boolean).join(" ");
+    lines.push(`  signed in as: ${who2 || r.identity.id || "(unknown)"}${r.identity.id ? ` (${r.identity.id})` : ""}`);
+    lines.push(`  role: ${r.role ?? "(unknown)"}`);
+    lines.push(`  operator: ${r.operator.id ? `${r.operator.name ?? "(unnamed)"} (${r.operator.id})` : "(not linked)"}`);
+    lines.push(`  credential: ${r.credential}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+
 // src/cli.ts
 import { StaleWriteError as StaleWriteError9 } from "@tablation/client";
 
@@ -15477,6 +15590,7 @@ function usage() {
   crew watch [route]             live view of what the crew is doing
   crew status [route] [--json]   paused/running state; --json for a machine reader
   crew projects [--route R] [--json]   the Projects rows each route can read (id, name, prefix, work mode)
+  crew whoami [route] [--json]   the signed-in identity, key role, operator Crew row and credential source per route
   crew reload                    make the running daemon re-read crew.yaml (--now: restart it immediately)
   crew doctor [route] [--fix] [--offline] [--json]   preflight; --fix enables clean routes and offers crew install;
                                  --offline skips push probes; --json prints push-auth and tool checks only
@@ -15698,7 +15812,7 @@ if (command === "passenger-sync-daemon") {
   const DAEMON_SUBCOMMANDS = /* @__PURE__ */ new Set(["start", "stop", "status", "restart"]);
   const worktreeArgs = command === "worktree" ? splitWorktreeArgs(positional, cfg.routes.map((r) => r.route)) : void 0;
   const named = worktreeArgs ? worktreeArgs.route : command === "daemon" && DAEMON_SUBCOMMANDS.has(positional[1] ?? "") ? positional[2] : positional[1];
-  const fleetWide = command === "inbox" || command === "connect" || command === "disconnect" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "projects" || releaseFleetWide || command === "pause" || command === "resume" || command === "reload" || FLEET_CAPABLE.has(command) && !named && cfg.routes.length > 1 || worktreeArgs !== void 0 && !named && cfg.routes.length > 1;
+  const fleetWide = command === "inbox" || command === "connect" || command === "disconnect" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "projects" || command === "whoami" || releaseFleetWide || command === "pause" || command === "resume" || command === "reload" || FLEET_CAPABLE.has(command) && !named && cfg.routes.length > 1 || worktreeArgs !== void 0 && !named && cfg.routes.length > 1;
   let route;
   try {
     route = fleetWide ? cfg.routes[0] : findRoute(cfg, named);
@@ -18902,6 +19016,23 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       if (results.some((r) => !r.ok)) process.exitCode = 1;
       break;
     }
+    case "whoami": {
+      const only = value("route") ?? positional[1];
+      const wanted = only ? cfg.routes.filter((r) => r.route === only) : cfg.routes;
+      if (only && wanted.length === 0) {
+        process.stderr.write(`crew whoami: no route "${only}" (have: ${cfg.routes.map((r) => r.route).join(", ")})
+`);
+        process.exit(2);
+      }
+      const report = await buildWhoami(wanted, {
+        userAgent: cfg.ship.userAgent,
+        operatorName: async (r, id) => (await new Tracker(r, cfg.ship).crewRows()).find((c) => c.id === id)?.name
+      });
+      process.stdout.write(flag("json") ? `${JSON.stringify(report.length === 1 && only ? report[0] : report, null, 2)}
+` : formatWhoami(report));
+      if (report.some((r) => !r.ok)) process.exitCode = 1;
+      break;
+    }
     case "projects": {
       const only = value("route") ?? positional[1];
       const wanted = only ? cfg.routes.filter((r) => r.route === only) : cfg.routes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.67.2",
+  "version": "0.68.1",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",