@tablation/crew 0.13.2 → 0.14.0

package/dist/cli.js

@@ -86,6 +86,7 @@ var BRANCH_KEYS = /* @__PURE__ */ new Set(["base", "name", "push", "remote"]);
 var PLACEHOLDER = /\{(key|number|slug|role|prefix|tag)\}/g;
 var RELEASE_KEYS = /* @__PURE__ */ new Set([
   "mode",
+  "ship",
   "ci",
   "verify",
   "versioning",
@@ -202,6 +203,16 @@ function parseRepoConfig(text, file) {
   if (!MODES.includes(mode)) {
     throw new RepoConfigError(`${file}: release.mode must be one of ${MODES.join("|")} (got "${mode}")`);
   }
+  let ship = null;
+  if (raw.release?.ship !== void 0 && raw.release?.ship !== null) {
+    ship = String(raw.release.ship).trim();
+    if (ship === "") throw new RepoConfigError(`${file}: release.ship is empty`);
+    if (mode !== "local" && mode !== "integrate") {
+      throw new RepoConfigError(
+        `${file}: release.ship only applies to release.mode "local" or "integrate" (got "${mode}") \u2014 CI-mode repos keep multi-ship merging, protected by the board lock and the fast-forward-only push`
+      );
+    }
+  }
   const provider = String(raw.release?.ci?.provider ?? "none");
   if (!PROVIDERS.includes(provider)) {
     throw new RepoConfigError(
@@ -301,6 +312,7 @@ function parseRepoConfig(text, file) {
     labels,
     release: {
       mode,
+      ship,
       ci: { provider, ref: raw.release?.ci?.ref ? String(raw.release.ci.ref) : void 0 },
       verify,
       versioning,
@@ -451,6 +463,9 @@ function resolveRepoConfig(repo, ship, dir) {
     labels,
     release: {
       mode,
+      // Repo-only, like `platform`: which ship releases a repo is a fact the
+      // repo declares (CREW-1384), never something a ship's own fallback sets.
+      ship: repo?.release.ship ?? null,
       ci: {
         provider,
         ref: pick("release.ci.ref", repo?.release.ci.ref, ship?.release?.ci?.ref, void 0)
@@ -522,6 +537,11 @@ function validateEffective(cfg) {
   if (cfg.release.mode === "local" && !cfg.hooks.deploy) {
     problems.push('release.mode "local" needs a deploy hook');
   }
+  if (cfg.release.ship && cfg.release.mode !== "local" && cfg.release.mode !== "integrate") {
+    problems.push(
+      `release.ship "${cfg.release.ship}" only applies to release.mode "local" or "integrate" (this ship's settings make it "${cfg.release.mode}") \u2014 CI-mode repos keep multi-ship merging`
+    );
+  }
   if (cfg.release.mode === "external" && !cfg.hooks.merged) {
     problems.push(
       'release.mode "external" without a merged hook \u2014 the crew hands work off and then has no reliable way to learn whether it landed'
@@ -2639,14 +2659,16 @@ var SHELL_WORDS = /* @__PURE__ */ new Set([
 
 // src/board-lock.ts
 import { StaleWriteError } from "@tablation/client";
+function releaseLockScope(route, repo) {
+  return `${route}/${repo}`;
+}
 async function acquireBoardLock(client2, modelId, scope, holderLabel, ttlMs) {
   if (!modelId) return { ok: true, release: async () => {
   } };
   const filters = JSON.stringify([{ columnName: "scope", operator: "EQ", value: scope }]);
   const rows = await client2.list(modelId, { filters, limit: 1 });
   const row = rows[0];
-  if (!row) return { ok: true, release: async () => {
-  } };
+  if (!row) return { ok: false, reason: "missing" };
   const age = Date.now() - new Date(row.updated_at).getTime();
   const free = !row.holder || row.holder === holderLabel || age > ttlMs;
   if (!free) return { ok: false, heldBy: row.holder ?? void 0, reason: "held" };
@@ -2667,6 +2689,39 @@ async function acquireBoardLock(client2, modelId, scope, holderLabel, ttlMs) {
     }
   };
 }
+async function lockRowState(client2, modelId, scope) {
+  const rows = await client2.list(modelId, { filters: scopeFilter(scope), limit: 1 });
+  const row = rows[0];
+  if (!row) return { exists: false };
+  return { exists: true, ...row.holder ? { holder: row.holder, since: row.updated_at } : {} };
+}
+var scopeFilter = (scope) => JSON.stringify([{ columnName: "scope", operator: "EQ", value: scope }]);
+async function ensureLockRows(client2, modelId, scopes) {
+  const created = [];
+  for (const scope of scopes) {
+    const filters = scopeFilter(scope);
+    if ((await client2.list(modelId, { filters, limit: 1 })).length > 0) continue;
+    let mine;
+    try {
+      mine = await client2.create(modelId, { scope, holder: "" });
+    } catch (e) {
+      const status2 = e.status;
+      if (status2 === 409 || status2 === 400) {
+        if ((await client2.list(modelId, { filters, limit: 1 })).length > 0) continue;
+      }
+      throw e;
+    }
+    const all = await client2.list(modelId, { filters, limit: 20 });
+    const keeper = [...all].sort((a, b) => (a.created_at ?? "").localeCompare(b.created_at ?? "") || a.id.localeCompare(b.id))[0];
+    if (keeper && keeper.id !== mine.id) {
+      await client2.remove(modelId, mine.id).catch(() => {
+      });
+      continue;
+    }
+    created.push(scope);
+  }
+  return created;
+}
 
 // src/tracker.ts
 function ticketBranchContext(t) {
@@ -3036,13 +3091,18 @@ var Tracker = class {
   /**
    * Claim a board-visible lock for `scope` (ISSUE-394) — see board-lock.ts
    * for the CAS mechanics. Resolves to `{ ok: true }` immediately, with a
-   * no-op release, when this workspace has no Locks table or no row
-   * provisioned for `scope`: a route that has not adopted board
-   * locking keeps behaving exactly as it always has.
+   * no-op release, only when this workspace has no Locks table at all. A
+   * Locks table with no row for `scope` is `{ ok: false, reason: 'missing' }`
+   * (CREW-1384): `crew connect` provisions the row.
    */
   acquireBoardLock(scope, holderLabel, ttlMs) {
     return acquireBoardLock(this.client.records, this.route.resolved?.locksModelId, scope, holderLabel, ttlMs);
   }
+  /** The Locks row for `scope` — present? held by whom? Undefined when this workspace has no Locks table. */
+  async lockState(scope) {
+    const model = this.route.resolved?.locksModelId;
+    return model ? lockRowState(this.client.records, model, scope) : void 0;
+  }
   /**
    * Reports one crew member's live status (ISSUE-325) — "Working" for the
    * duration of an agent run, "Idle" once it ends.
@@ -6673,6 +6733,24 @@ Still failing: ${n.detail ?? n.headline}`, memberId);
 // src/cli.ts
 import { StaleWriteError as StaleWriteError8 } from "@tablation/client";
 
+// src/release-ship.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function releaserFor(release, shipName2) {
+  const named = release.ship;
+  if (!named || release.mode !== "local" && release.mode !== "integrate") return { releases: true, releaser: named ?? null };
+  return { releases: named.trim() === shipName2.trim(), releaser: named };
+}
+function nonReleaserNote(repo, releaser) {
+  return `release for ${repo} runs on ${releaser}`;
+}
+function missingReleaserWarning(repo, release, ships, now = Date.now()) {
+  if (release.ship || release.mode !== "local" && release.mode !== "integrate") return null;
+  const live = ships.filter((s) => s.last_seen && now - Date.parse(s.last_seen) <= DAY_MS);
+  if (live.length < 2) return null;
+  const names = live.map((s) => s.name ?? "?").join(", ");
+  return `${repo}: release.mode "${release.mode}" with no release.ship, and ${live.length} ships seen in the last day (${names}) \u2014 every one of them will try to release it. Set release.ship in .crew.yaml.`;
+}
+
 // src/watch.ts
 import { watch as watchFile, existsSync as existsSync10, statSync as statSync5, openSync as openSync2, readSync, closeSync as closeSync2 } from "fs";
 var E = "\x1B[";
@@ -7455,6 +7533,35 @@ async function patch(o, path, body) {
   if (!res.ok) throw new ConnectHttpError(res.status, path, res.statusText);
   return await res.json();
 }
+async function del(o, path) {
+  const res = await fetch(`${o.baseUrl.replace(/\/+$/, "")}/api${path}`, {
+    method: "DELETE",
+    headers: {
+      Authorization: `Bearer ${o.apiKey}`,
+      "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0"
+    }
+  });
+  if (!res.ok) throw new ConnectHttpError(res.status, path, res.statusText);
+}
+async function provisionReleaseLocks(o, locksModelId, route, repoNames) {
+  const scopes = [...new Set(repoNames)].sort().map((r) => releaseLockScope(route, r));
+  if (scopes.length === 0) return [];
+  const client2 = {
+    // The Locks table is a handful of rows, so read it whole and match in
+    // memory rather than depend on the HTTP filter syntax.
+    list: async (model, params) => {
+      const want = JSON.parse(params?.filters ?? "[]")[0]?.value;
+      const rows = await get(
+        o,
+        `/data-models/${model}/records?limit=500`
+      );
+      return rows.filter((r) => r.scope === want).slice(0, params?.limit ?? rows.length);
+    },
+    create: (model, body) => post2(o, `/data-models/${model}/records`, body),
+    remove: (model, id) => del(o, `/data-models/${model}/records/${id}`)
+  };
+  return ensureLockRows(client2, locksModelId, scopes);
+}
 var ISSUES_TEMPLATE_IDENTIFIER = "crew.issues";
 async function listLibraryTemplates(o) {
   return get(o, "/library-templates");
@@ -8325,11 +8432,11 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 // src/stream-sweep.ts
 import { existsSync as existsSync15, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync6 } from "fs";
 import { join as join14 } from "path";
-var DAY_MS = 24 * 60 * 60 * 1e3;
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
   const dir = join14(stateDir, "streams");
   if (!existsSync15(dir)) return [];
-  const cutoff = now - retentionDays * DAY_MS;
+  const cutoff = now - retentionDays * DAY_MS2;
   return readdirSync3(dir).map((name) => join14(dir, name)).filter((path) => {
     try {
       return statSync6(path).mtimeMs < cutoff;
@@ -10017,9 +10124,20 @@ ${changed2.map((c) => `  - ${c}
       shipName: cfg.ship.name
     });
   }
+  async function releaserLine(tracker, routeName, repo, release) {
+    const who2 = release.ship ? `released by ${release.ship}` : "any ship may release";
+    let lock2;
+    try {
+      const st = await tracker.lockState(releaseLockScope(routeName, repo));
+      lock2 = st === void 0 ? "no Locks table" : !st.exists ? "lock row MISSING (run crew connect)" : st.holder ? `lock held by ${st.holder}` : "lock row free";
+    } catch (e) {
+      lock2 = `lock unreadable (${e.message})`;
+    }
+    return `${who2}; ${lock2}`;
+  }
   const unplaceableReported = /* @__PURE__ */ new Set();
   async function releasePhase(c, target, opts = {}) {
-    const scope = `${c.route}/${target.name}`;
+    const scope = releaseLockScope(c.route, target.name);
     const remit = emit.forRoute(c.route);
     const relLock = dryRun ? void 0 : state.acquire(`release-${scope}`);
     if (relLock && !relLock.ok) {
@@ -10044,11 +10162,22 @@ ${changed2.map((c) => `  - ${c}
         remit.emit(`${scope}: skipping \u2014 ${detail}`, { step: "release" });
         return { scope, tests: "skipped", outcome: "skipped", detail };
       }
+      const who2 = releaserFor(repo.release, cfg.ship.name);
+      if (!who2.releases) {
+        const note = nonReleaserNote(target.name, who2.releaser);
+        remit.emit(note, { step: "release" });
+        return { scope, tests: "skipped", outcome: "skipped", detail: note };
+      }
       if (!dryRun && !c.enabled) return { scope, tests: "skipped", outcome: "skipped", detail: "route not enabled" };
       const tracker = new Tracker(c, cfg.ship);
       if (!dryRun) {
         const holderLabel = `${cfg.ship.name}:${process.pid}`;
         const got = await tracker.acquireBoardLock(scope, holderLabel, RELEASE_LOCK_TTL_MS);
+        if (!got.ok && got.reason === "missing") {
+          const detail = `no Locks row for ${scope} \u2014 run \`crew connect ${c.route}\` to provision it`;
+          remit.warn(`release for ${scope} refused: ${detail}`, { step: "release" });
+          return { scope, tests: "skipped", outcome: "skipped", detail };
+        }
         if (!got.ok) {
           const why = got.reason === "held" ? `held by ${got.heldBy ?? "another ship"}` : "claimed by another ship mid-check";
           remit.emit(`release for ${scope} is ${why} on the board \u2014 skipping`, { step: "release" });
@@ -11278,6 +11407,18 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         const route2 = `${found.workspaceSlug}/${found.projectSlug ?? found.projectId}`;
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, route2);
+        if (found.locksModelId && !dryRun) {
+          const configured = cfg.routes.find((r) => r.route === route2);
+          const repoNames = [...Object.values(found.repoNames ?? {}), ...configured ? reposOf(configured).map((t) => t.name) : []].filter((n) => !!n);
+          try {
+            const made = await provisionReleaseLocks(authOpts, found.locksModelId, route2, repoNames);
+            for (const sc of made) process.stderr.write(`created release lock row ${sc}
+`);
+          } catch (e) {
+            process.stderr.write(`(could not provision release lock rows \u2014 ${e.message})
+`);
+          }
+        }
         let operator = found.operator;
         if (!operator && found.holds.length > 0 && process.stdin.isTTY && process.stdout.isTTY) {
           operator = await pickOperator(found.holds);
@@ -11949,6 +12090,8 @@ watermark:  ${state.watermark()}
       for (const r of await resolvedRepos(route)) {
         const bh = baseHealth(r);
         if (bh.unsafe) process.stdout.write(`base:       ${r.name} \u2014 UNSAFE, no worktree cuts or releases: ${bh.detail}
+`);
+        process.stdout.write(`releaser:   ${r.name} \u2014 ${await releaserLine(statusTracker, route.route, r.name, r.config.release)}
 `);
       }
       if (waiting) {
@@ -12009,6 +12152,14 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 `);
           if (bh.unsafe) process.exitCode = 1;
         }
+        if (config.release.ship) {
+          process.stdout.write(`                   release.ship ${config.release.ship}${config.release.ship === cfg.ship.name ? " (this ship)" : ""}
+`);
+        } else {
+          const warn = missingReleaserWarning(r.name, config.release, await tracker.shipRows().catch(() => []));
+          if (warn) process.stdout.write(`                   WARNING ${warn}
+`);
+        }
       }
       const missingAuthorship = await tracker.missingAuthorshipColumns();
       process.stdout.write(

package/package.json

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