@tablation/crew 0.98.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";
@@ -1602,6 +1621,28 @@ import { dirname as dirname3, join as join9 } from "path";
 var ForgeError = class extends Error {
 };
 var DEFAULT_FORGE_USERNAME = "x-access-token";
+var DEFAULT_FORGE_HOST = "github.com";
+var FORGE_DESCRIPTORS = {
+  github: {
+    kind: "github",
+    httpsUrl: (host, remote) => `https://${host}/${remote}.git`,
+    sshUrl: (host, remote) => `git@${host}:${remote}.git`,
+    credentialUsername: DEFAULT_FORGE_USERNAME
+  },
+  gitlab: {
+    kind: "gitlab",
+    httpsUrl: (host, remote) => `https://${host}/${remote}.git`,
+    sshUrl: (host, remote) => `git@${host}:${remote}.git`,
+    credentialUsername: "oauth2"
+  }
+};
+function normalizeForgeHost(host) {
+  const h = host?.trim().toLowerCase().replace(/^[a-z][a-z0-9+.-]*:\/\//, "").replace(/\/+$/, "");
+  return h || DEFAULT_FORGE_HOST;
+}
+function forgeDescriptorFor(host) {
+  return normalizeForgeHost(host).includes("gitlab") ? FORGE_DESCRIPTORS.gitlab : FORGE_DESCRIPTORS.github;
+}
 var DEFAULT_KEYCHAIN_SERVICE = "crew-forge";
 function defaultTokenFilePath(stateDir, host) {
   return join9(stateDir, "forges", `${host.replace(/[^a-z0-9.-]/gi, "_")}.token`);
@@ -1814,7 +1855,7 @@ function parseForges(raw) {
       throw new ForgeError(`${where}.token.source must be one of: ${Object.keys(TOKEN_SOURCES).join(", ")}`);
     }
     out[host.toLowerCase()] = {
-      username: typeof e.username === "string" && e.username ? e.username : DEFAULT_FORGE_USERNAME,
+      username: typeof e.username === "string" && e.username ? e.username : forgeDescriptorFor(host).credentialUsername,
       token
     };
   }
@@ -2932,6 +2973,7 @@ function parseResolved(raw, m, where) {
     reposModelId: raw.reposModelId,
     repoNames: raw.repoNames,
     repoRemotes: raw.repoRemotes,
+    repoForgeHosts: raw.repoForgeHosts,
     models: {
       issues: m.req(raw.models?.issues, `${where}.resolved.models.issues`),
       comments: m.req(raw.models?.comments, `${where}.resolved.models.comments`),
@@ -3437,23 +3479,29 @@ function reposOf(r) {
   if (r.dirIsCloneBase) {
     const [workspace2] = splitRoute(r.route);
     const remotes2 = r.resolved?.repoRemotes ?? {};
+    const hosts = r.resolved?.repoForgeHosts ?? {};
     return Object.entries(r.resolved?.repoNames ?? {}).map(([id, name]) => ({
       name,
       dir: defaultRepoDir(r.reposBasePath, workspace2, name),
-      remote: remotes2[id]
+      remote: remotes2[id],
+      ...hosts[id] ? { forgeHost: hosts[id] } : {}
     }));
   }
   if (trackerNames.length <= 1) return [{ name: basename3(r.dir), dir: r.dir }];
   const remotes = r.resolved?.repoRemotes ?? {};
   const remoteByName = {};
+  const hostByName = {};
   for (const [id, name] of Object.entries(r.resolved.repoNames)) {
     if (remotes[id]) remoteByName[name] = remotes[id];
+    const h = r.resolved?.repoForgeHosts?.[id];
+    if (h) hostByName[name] = h;
   }
   const [workspace] = splitRoute(r.route);
   return trackerNames.map((name) => ({
     name,
     dir: defaultRepoDir(r.reposBasePath, workspace, name),
-    remote: remoteByName[name]
+    remote: remoteByName[name],
+    ...hostByName[name] ? { forgeHost: hostByName[name] } : {}
   }));
 }
 function passengerRepoTargets(r) {
@@ -3469,10 +3517,12 @@ function passengerCheckoutTargets(r) {
   const remotes = r.resolved?.repoRemotes ?? {};
   return passengerRepoTargets(r).map((t) => {
     const id = repoIdForName(r, t.name);
+    const forgeHost = t.forgeHost ?? (id ? r.resolved?.repoForgeHosts?.[id] : void 0);
     return {
       name: t.name,
       dir: passengerCheckoutDir(r.reposBasePath, workspace, t.name),
-      remote: t.remote ?? (id ? remotes[id] : void 0)
+      remote: t.remote ?? (id ? remotes[id] : void 0),
+      ...forgeHost ? { forgeHost } : {}
     };
   });
 }
@@ -4780,8 +4830,10 @@ function setForgeTokenHosts(hosts) {
 }
 function cloneUrlFor(remote, opts = {}) {
   const origin = opts.originUrl?.trim() ?? "";
-  const scheme = tokenHosts.has("github.com") ? "https" : /^https?:\/\//i.test(origin) ? "https" : /^(git@|ssh:\/\/)/i.test(origin) ? "ssh" : opts.scheme ?? "ssh";
-  return scheme === "https" ? `https://github.com/${remote}.git` : `git@github.com:${remote}.git`;
+  const host = normalizeForgeHost(opts.host);
+  const scheme = tokenHosts.has(host) ? "https" : /^https?:\/\//i.test(origin) ? "https" : /^(git@|ssh:\/\/)/i.test(origin) ? "ssh" : opts.scheme ?? "ssh";
+  const forge = forgeDescriptorFor(host);
+  return scheme === "https" ? forge.httpsUrl(host, remote) : forge.sshUrl(host, remote);
 }
 function originUrlOf(dir, remoteName) {
   try {
@@ -5244,7 +5296,7 @@ function probePushAuth(o, run2 = realGit, baseEnv = process.env) {
     const raw = (err3.stderr ? String(err3.stderr) : err3.message).trim().split("\n").filter(Boolean).slice(-2).join(" / ");
     const detail = raw || "push dry-run failed";
     const f = o.forge;
-    if (!f) return { state: "failed", detail, hint: pushAuthHint(o.remoteUrl) };
+    if (!f) return { state: "failed", detail: hostOfRemote(o.remoteUrl) ? `${hostOfRemote(o.remoteUrl)}: ${detail}` : detail, hint: pushAuthHint(o.remoteUrl) };
     if (!f.hasToken) {
       return {
         state: "failed",
@@ -7639,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;
@@ -7663,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 ?? "")));
@@ -13156,7 +13232,8 @@ function planRepoClone(i) {
   const basePath = String(m.get("reposBasePath") ?? (isMap(ship) ? ship.get("reposBasePath") : void 0) ?? "~/Crew");
   const target = i.dir ? expandDir(i.dir, i.base) : join29(expandDir(basePath, i.base), i.route.split("/")[0], name);
   const add = planRepoAdd({ text: i.text, base: i.base, route: i.route, path: target, origin: remote, resolved: i.resolved, name, isCheckout: i.isCheckout });
-  return { ...add, remote, target };
+  const forgeHost = i.resolved?.repoForgeHosts?.[id];
+  return { ...add, remote, target, ...forgeHost ? { forgeHost } : {} };
 }
 
 // src/doctor-fix.ts
@@ -15282,7 +15359,7 @@ function runForge(a, io) {
     const doc = parseDocument4(io.readFile(io.configFile));
     doc.setIn(["ship", "forges", host, "token"], tok);
     io.writeFile(io.configFile, doc.toString());
-    io.forges = { ...io.forges ?? {}, [host]: { username: "x-access-token", token: tok } };
+    io.forges = { ...io.forges ?? {}, [host]: { username: forgeDescriptorFor(host).credentialUsername, token: tok } };
     existing = forgeFor(io.forges, host);
   }
   if (existing.entry.token.source === "env") {
@@ -16279,6 +16356,10 @@ async function discover(o) {
       repos.filter((r) => r.remote).map((r) => [r.id, r.remote])
     );
     if (Object.keys(remotes).length > 0) out.repoRemotes = remotes;
+    const forgeHosts = Object.fromEntries(
+      repos.filter((r) => r.forge_host?.trim()).map((r) => [r.id, r.forge_host.trim().toLowerCase()])
+    );
+    if (Object.keys(forgeHosts).length > 0) out.repoForgeHosts = forgeHosts;
   }
   if (o.area) {
     if (!out.areaModelId) problems.push(`--area given but this project has no "Projects" table`);
@@ -17672,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) {
@@ -17738,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}`;
@@ -17796,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();
@@ -18432,7 +18525,8 @@ function passengerCheckoutSyncSpecs(cfg, workspaceId) {
         gitRemoteName: effective.branch.remote,
         base: effective.branch.base,
         originUrl: ordinary ? originUrlOf(ordinary.dir, effective.branch.remote) : null,
-        cloneScheme: cfg.ship.cloneScheme
+        cloneScheme: cfg.ship.cloneScheme,
+        ...target.forgeHost ? { forgeHost: target.forgeHost } : {}
       });
     }
   }
@@ -18442,7 +18536,7 @@ function syncAllPassengerCheckouts(cfg) {
   return passengerCheckoutSyncSpecs(cfg).map((spec) => ({
     name: spec.name,
     workspaceId: spec.workspaceId,
-    outcome: syncPassengerCheckout(spec.dir, spec.remote, spec.gitRemoteName, spec.base, { originUrl: spec.originUrl, scheme: spec.cloneScheme })
+    outcome: syncPassengerCheckout(spec.dir, spec.remote, spec.gitRemoteName, spec.base, { originUrl: spec.originUrl, scheme: spec.cloneScheme, host: spec.forgeHost })
   }));
 }
 
@@ -18815,7 +18909,7 @@ function createSyncDaemonServer(targets, secret) {
     try {
       const synced = targets.map((t) => ({
         name: t.name,
-        outcome: syncPassengerCheckout(t.dir, t.remote, t.gitRemoteName, t.base, { originUrl: t.originUrl, scheme: t.cloneScheme })
+        outcome: syncPassengerCheckout(t.dir, t.remote, t.gitRemoteName, t.base, { originUrl: t.originUrl, scheme: t.cloneScheme, host: t.forgeHost })
       }));
       res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ synced }));
     } catch (error) {
@@ -19511,7 +19605,7 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
       const target = repoTargetFor(route2, result.ticket.repo_id);
       ticketRepo = target?.name;
       try {
-        if (target && ensureRepoCheckout(target.dir, target.remote, { scheme: ship.cloneScheme })) {
+        if (target && ensureRepoCheckout(target.dir, target.remote, { scheme: ship.cloneScheme, host: target.forgeHost })) {
           emit.emit(`cloned ${target.name} into ${target.dir}`, { step: "select", role });
         }
       } catch (e) {
@@ -20272,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`;
@@ -21828,7 +21941,7 @@ ${cu.tail.trimEnd()}
             const target = repoTargetFor(w.route, result.ticket.repo_id);
             fleetTicketRepo = target?.name;
             try {
-              if (target && ensureRepoCheckout(target.dir, target.remote, { scheme: cfg.ship.cloneScheme })) {
+              if (target && ensureRepoCheckout(target.dir, target.remote, { scheme: cfg.ship.cloneScheme, host: target.forgeHost })) {
                 wemit.emit(`cloned ${target.name} into ${target.dir}`, { step: "select", role: w.role });
               }
             } catch (e) {
@@ -22045,7 +22158,7 @@ ${cu.tail.trimEnd()}
             const target = repoTargetFor(route2, result.ticket.repo_id);
             ticketRepo = target?.name;
             try {
-              if (target && ensureRepoCheckout(target.dir, target.remote, { scheme: cfg.ship.cloneScheme })) {
+              if (target && ensureRepoCheckout(target.dir, target.remote, { scheme: cfg.ship.cloneScheme, host: target.forgeHost })) {
                 emit.emit(`cloned ${target.name} into ${target.dir}`, { step: "select", role: current });
               }
             } catch (e) {
@@ -22785,7 +22898,7 @@ ${cu.tail.trimEnd()}
           }
           say("cloning", { remote: plan2.remote, target: plan2.target }, `cloning ${plan2.remote} into ${plan2.target}`);
           try {
-            ensureRepoCheckout(plan2.target, plan2.remote, { scheme: cfg.ship.cloneScheme ?? "https" });
+            ensureRepoCheckout(plan2.target, plan2.remote, { scheme: cfg.ship.cloneScheme ?? "https", host: plan2.forgeHost });
           } catch (e) {
             if (!(e instanceof GitError)) throw e;
             const authHint = /authentication failed|could not read (username|password)|permission denied|terminal prompts disabled|repository not found/i.test(e.message) ? "\n  hint: git could not authenticate \u2014 run `gh auth login` (or add an SSH key and set ship.cloneScheme: ssh), then re-run" : "";
@@ -23375,6 +23488,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           reposModelId: found.reposModelId,
           repoNames: found.repoNames,
           repoRemotes: found.repoRemotes,
+          repoForgeHosts: found.repoForgeHosts,
           models: found.models,
           seats: found.seats,
           holds: found.holds.map((h) => ({ id: h.id, role: h.name })),
@@ -24331,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();
@@ -24354,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`);
@@ -24377,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);
         }
@@ -25166,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;
@@ -25311,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.98.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",