@tablation/crew 0.99.0 → 0.99.1

package/dist/cli.js

@@ -83,6 +83,25 @@ function routePeriscopeProblems(o) {
 function previewHostFinding(message) {
   return /does not resolve/.test(message) ? { severity: "attention", kind: "preview_host_unresolvable", message } : { severity: "blocker", kind: "preview_host", message };
 }
+var refId = (v) => typeof v === "string" ? v : v && typeof v === "object" && typeof v.id === "string" ? v.id : void 0;
+function duplicateLivePeriscopes(rows, tagOf, shipName2, route2) {
+  const byTicket = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const t = refId(r.issue_id);
+    if (t) byTicket.set(t, [...byTicket.get(t) ?? [], r]);
+  }
+  const out = [];
+  for (const [t, rs] of byTicket) {
+    if (rs.length < 2) continue;
+    out.push({
+      severity: "attention",
+      kind: "periscope_duplicate_live",
+      ...route2 ? { route: route2 } : {},
+      message: `${tagOf(t)} has ${rs.length} live Periscopes rows (${rs.map((r) => `${r.id} on ${shipName2(r.ship_id)}${r.url ? ` ${r.url}` : ""}`).join("; ")}) \u2014 the periscope_url rollup assumes one; end all but one with \`crew periscope down\``
+    });
+  }
+  return out;
+}
 
 // src/periscope-state.ts
 import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
@@ -7672,6 +7691,30 @@ var Tracker = class {
       limit: 200
     });
   }
+  /**
+   * Every `live` Periscopes row on any ship (CREW-2871), for the one-per-issue
+   * guard and doctor. Empty without the table.
+   */
+  async livePeriscopesAllShips() {
+    const modelId = this.route.resolved?.periscopesModelId;
+    if (!modelId) return [];
+    return this.client.records.list(modelId, {
+      filters: encodeFilters([{ columnName: "state", operator: "EQ", value: "live" }]),
+      limit: 500
+    });
+  }
+  /** The `live` Periscopes rows of one ticket, on any ship (CREW-2871). */
+  async livePeriscopesForTicket(ticketRecordId) {
+    const modelId = this.route.resolved?.periscopesModelId;
+    if (!modelId) return [];
+    return this.client.records.list(modelId, {
+      filters: encodeFilters([
+        { columnName: "issue_id", operator: "EQ", value: ticketRecordId },
+        { columnName: "state", operator: "EQ", value: "live" }
+      ]),
+      limit: 50
+    });
+  }
   /** Patches one Periscopes row (EPIC-077). */
   async updatePeriscope(rowId, fields) {
     const modelId = this.route.resolved?.periscopesModelId;
@@ -7696,12 +7739,12 @@ var Tracker = class {
     const conds = [{ columnName: "ship_id", operator: "EQ", value: shipId }];
     if (states?.length) conds.push({ columnName: "state", operator: "IN", value: states });
     const rows = await this.client.records.list(modelId, { filters: encodeFilters(conds), limit: 200 });
-    const refId = (v) => typeof v === "string" ? v : v && typeof v === "object" && typeof v.id === "string" ? v.id : void 0;
-    const ids = [...new Set(rows.map((r) => refId(r.issue_id)).filter((x) => !!x))];
+    const refId2 = (v) => typeof v === "string" ? v : v && typeof v === "object" && typeof v.id === "string" ? v.id : void 0;
+    const ids = [...new Set(rows.map((r) => refId2(r.issue_id)).filter((x) => !!x))];
     const tickets = new Map((await this.ticketsByIds(ids)).map((t) => [t.id, t]));
     const out = [];
     for (const row of rows) {
-      const t = tickets.get(refId(row.issue_id) ?? "");
+      const t = tickets.get(refId2(row.issue_id) ?? "");
       if (t) out.push({ row, ticket: t });
     }
     return out.sort((a, b) => String(b.row.started_at ?? "").localeCompare(String(a.row.started_at ?? "")));
@@ -17710,6 +17753,13 @@ import { existsSync as existsSync35, mkdirSync as mkdirSync21, readFileSync as r
 import { join as join37 } from "path";
 var PeriscopeError = class extends Error {
 };
+var LivePeriscopeError = class extends PeriscopeError {
+  data;
+  constructor(tag, number, live) {
+    super(`${tag} already has a live periscope on ${live.ship}: ${live.url} (worktree ${live.worktree}) \u2014 run \`crew periscope down ${number} --keep|--discard\` on ${live.ship}, or resume it there with \`crew periscope up --resume ${number}\``);
+    this.data = { refused: "live_periscope_exists", ...live };
+  }
+};
 var priorDir = (stateDir) => join37(stateDir, "periscope-priors");
 var priorPath = (stateDir, ticketRecordId) => join37(priorDir(stateDir), `${ticketRecordId}.json`);
 function removePeriscopePrior(stateDir, ticketRecordId) {
@@ -17776,6 +17826,10 @@ function periscopeCaps(l) {
     idleMinutes: l.periscopeIdleMinutes ?? DEFAULT_PERISCOPE_IDLE_MINUTES2
   };
 }
+async function assertNoLivePeriscope(e, t, number) {
+  const live = (await e.liveRows(t.id))[0];
+  if (live) throw new LivePeriscopeError(t.tag, number, live);
+}
 async function existingRefusal(e, t) {
   if (t.closed) return `${t.tag} is ${t.status}; a closed ticket cannot be periscoped`;
   if (e.repoId && t.repoId !== e.repoId) return `${t.tag} belongs to a different repository than ${e.repoName}`;
@@ -17834,6 +17888,7 @@ async function runPeriscopeUp(d, args) {
     if (!ex) throw new PeriscopeError("--issue is not supported here");
     prior = await ex.load(args.issue);
     if (!prior) throw new PeriscopeError(`no ticket numbered ${args.issue} on this route`);
+    await assertNoLivePeriscope(ex, prior, args.issue);
     const refused = await existingRefusal(ex, prior);
     if (refused) throw new PeriscopeError(refused);
     const unsafe = d.baseProblem();
@@ -20311,6 +20366,25 @@ var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname22(process.execPath)
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
+async function duplicateLivePeriscopeProblems(route2, ship) {
+  try {
+    const tr = new Tracker(route2, ship);
+    const rows = await tr.livePeriscopesAllShips();
+    const refOf = (v) => typeof v === "string" ? v : v?.id;
+    const counts = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const t = refOf(r.issue_id);
+      if (t) counts.set(t, (counts.get(t) ?? 0) + 1);
+    }
+    const dupIds = [...counts].filter(([, n]) => n > 1).map(([t]) => t);
+    if (dupIds.length === 0) return [];
+    const tags = new Map((await tr.ticketsByIds(dupIds)).map((t) => [t.id, t.issue_tag ?? t.issue_id]));
+    const ships = new Map((await tr.shipRows()).map((x) => [x.id, x.name ?? x.id]));
+    return duplicateLivePeriscopes(rows, (id) => tags.get(id) ?? id, (id) => id ? ships.get(id) ?? id : "an unknown ship", route2.route);
+  } catch {
+    return [];
+  }
+}
 function renderShipLine(s, issueLabelById) {
   const name = s.name ?? "(unnamed)";
   if (!s.last_seen) return `${name.padEnd(20)} never seen`;
@@ -24371,6 +24445,10 @@ ${where.join("\n")}`);
               const row = crewP.find((r) => r.id === assigneeId);
               return row?.agent_id ? row.name ?? assigneeId : void 0;
             },
+            liveRows: async (ticketRecordId) => {
+              const [rows, ships] = [await trackerP.livePeriscopesForTicket(ticketRecordId), await trackerP.shipRows()];
+              return rows.map((r) => ({ ship: ships.find((x) => x.id === r.ship_id)?.name ?? r.ship_id ?? "an unknown ship", url: r.url ?? "", worktree: r.worktree }));
+            },
             hasLiveRun: (ticketRecordId) => liveRuns(cfg.ship.stateDir).some((r) => r.ticketRecordId === ticketRecordId),
             hold: async (id) => {
               const auth = await trackerP.authorshipProbe();
@@ -24394,6 +24472,7 @@ ${where.join("\n")}`);
           if (a.issue) {
             const t = await deps.existing.load(a.issue);
             if (!t) throw new PeriscopeError(`no ticket numbered ${a.issue} on this route`);
+            await assertNoLivePeriscope(deps.existing, t, a.issue);
             const refused = await existingRefusal(deps.existing, t);
             if (refused) throw new PeriscopeError(refused);
             say("dry-run", `would hold ${t.tag} (status ${t.status} stays) for ${pairId}, cut or reuse its worktree for ${a.repo}, run setup${a.isolate ? ", isolate" : ""}, ports, handoff and preview on ${deps.host}, and record a Periscopes row`);
@@ -24417,6 +24496,8 @@ ${where.join("\n")}`);
       } catch (e) {
         if (e instanceof PeriscopeError || e instanceof ConfigError) {
           process.stderr.write(`crew periscope: ${e.message}
+`);
+          if (e instanceof LivePeriscopeError && jsonP) process.stdout.write(`${JSON.stringify(e.data)}
 `);
           process.exit(1);
         }
@@ -25206,6 +25287,7 @@ watermark:  ${state.watermark()}
           const { settled } = await settleRepos(reposOf(route2), (t) => t.name, (t) => resolveOneRepo(route2, t));
           const tablePresent = flag("offline") ? void 0 : (await new Tracker(route2, cfg.ship).periscopesStatus().catch(() => ({ present: true }))).present;
           problems.push(...routePeriscopeProblems({ route: route2.route, hosts: true, repos: settled.map((r) => ({ name: r.name, hasPreviewHook: !!r.config.hooks.preview })), tablePresent }));
+          if (!flag("offline")) problems.push(...await duplicateLivePeriscopeProblems(route2, cfg.ship));
         }
         problems.push(...attentionProblems(openShipAttention(state), problems));
         if (problems.some((p) => p.severity === "blocker")) process.exitCode = 1;
@@ -25351,6 +25433,12 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
           process.stdout.write(`periscopes:      ${f.severity.toUpperCase()} ${f.message}
 `);
         }
+        if (!flag("offline")) {
+          for (const f of await duplicateLivePeriscopeProblems(route2, cfg.ship)) {
+            process.stdout.write(`periscopes:      ${f.severity.toUpperCase()} ${f.message}
+`);
+          }
+        }
       }
       process.stdout.write(
         !periscopes.present ? "periscopes:      Periscopes table absent \u2014 this workspace cannot host periscopes\n" : periscopes.missing.length === 0 ? `periscopes:      Periscopes table present (${periscopes.modelId})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.99.0",
+  "version": "0.99.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",