@tablation/crew 0.82.1 → 0.84.0

package/dist/cli.js

@@ -34,6 +34,29 @@ function doctorBaseReport(r, base, health) {
   }
 }
 
+// src/periscopes.ts
+import { lookup } from "dns/promises";
+function periscopeRoutes(cfg) {
+  return cfg.routes.filter((r) => r.enabled && r.hostPeriscopes).map((r) => r.route);
+}
+function periscopeSummary(cfg) {
+  const routes = periscopeRoutes(cfg);
+  const limits = `max ${cfg.ship.maxPeriscopes}, idle ${cfg.ship.periscopeIdleMinutes} min`;
+  if (routes.length === 0) return `off (no enabled route sets hostPeriscopes: true; ${limits})`;
+  return `ON for ${routes.join(", ")} (host ${cfg.ship.previewHost ?? "NOT SET (ship.previewHost)"}, ${limits})`;
+}
+async function previewHostProblem(cfg, resolve6 = (h) => lookup(h)) {
+  if (periscopeRoutes(cfg).length === 0) return void 0;
+  const host = cfg.ship.previewHost;
+  if (!host) return "ship.previewHost is not set \u2014 a route hosts periscopes, so Passengers have no host to be sent to";
+  try {
+    await resolve6(host);
+  } catch {
+    return `ship.previewHost "${host}" does not resolve from this machine`;
+  }
+  return void 0;
+}
+
 // src/config.ts
 import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
 import { resolve, dirname as dirname3, isAbsolute, join as join9, basename as basename3 } from "path";
@@ -1448,6 +1471,7 @@ var HOOK_NAMES = [
   "ports",
   "isolate",
   "handoff",
+  "preview",
   "ci_status",
   "version",
   "bump",
@@ -2033,6 +2057,8 @@ var ROLE_LABEL = {
 };
 var ConfigError = class extends Error {
 };
+var DEFAULT_MAX_PERISCOPES = 3;
+var DEFAULT_PERISCOPE_IDLE_MINUTES = 120;
 function parseCloneScheme(v) {
   if (v === void 0 || v === null || v === "") return void 0;
   if (v === "ssh" || v === "https") return v;
@@ -2064,7 +2090,10 @@ var SHIP_KEYS = /* @__PURE__ */ new Set([
   "relayHttpPort",
   "relayPublicDomain",
   "passengerImage",
-  "cloneScheme"
+  "cloneScheme",
+  "previewHost",
+  "maxPeriscopes",
+  "periscopeIdleMinutes"
 ]);
 var ROUTE_KEYS = /* @__PURE__ */ new Set([
   "route",
@@ -2087,6 +2116,7 @@ var ROUTE_KEYS = /* @__PURE__ */ new Set([
   "resolved",
   "promptSet",
   "hostPassengers",
+  "hostPeriscopes",
   "toolchain"
 ]);
 function parseWorktreeName(v, where, file) {
@@ -2316,6 +2346,7 @@ function parseResolved(raw, m, where) {
     areaId: raw.areaId,
     shipsModelId: raw.shipsModelId,
     epicsModelId: raw.epicsModelId,
+    periscopesModelId: raw.periscopesModelId,
     locksModelId: raw.locksModelId,
     recordLinkViewId: raw.recordLinkViewId,
     reposModelId: raw.reposModelId,
@@ -2397,6 +2428,14 @@ Create the first of those:
   if (!Number.isInteger(streamRetentionDays) || streamRetentionDays < 1) {
     missing.add(`ship.streamRetentionDays must be a positive integer (got "${shipRaw.streamRetentionDays}")`);
   }
+  const maxPeriscopes = shipRaw.maxPeriscopes === void 0 ? DEFAULT_MAX_PERISCOPES : Number(shipRaw.maxPeriscopes);
+  if (!Number.isInteger(maxPeriscopes) || maxPeriscopes < 1) {
+    missing.add(`ship.maxPeriscopes must be a positive integer (got "${shipRaw.maxPeriscopes}")`);
+  }
+  const periscopeIdleMinutes = shipRaw.periscopeIdleMinutes === void 0 ? DEFAULT_PERISCOPE_IDLE_MINUTES : Number(shipRaw.periscopeIdleMinutes);
+  if (!Number.isInteger(periscopeIdleMinutes) || periscopeIdleMinutes < 1) {
+    missing.add(`ship.periscopeIdleMinutes must be a positive integer (got "${shipRaw.periscopeIdleMinutes}")`);
+  }
   const eventsRotateBytes = shipRaw.eventsRotateBytes === void 0 ? DEFAULT_EVENTS_ROTATE_BYTES : Number(shipRaw.eventsRotateBytes);
   if (!Number.isInteger(eventsRotateBytes) || eventsRotateBytes < 1) {
     missing.add(`ship.eventsRotateBytes must be a positive integer (got "${shipRaw.eventsRotateBytes}")`);
@@ -2466,7 +2505,10 @@ Create the first of those:
       relayHttpPort: shipRaw.relayHttpPort !== void 0 ? Number(shipRaw.relayHttpPort) : 443,
       relayPublicDomain: shipRaw.relayPublicDomain ? String(shipRaw.relayPublicDomain) : void 0,
       passengerImage: shipRaw.passengerImage ? String(shipRaw.passengerImage) : void 0,
-      cloneScheme: parseCloneScheme(shipRaw.cloneScheme)
+      cloneScheme: parseCloneScheme(shipRaw.cloneScheme),
+      previewHost: shipRaw.previewHost ? String(shipRaw.previewHost).trim() || void 0 : void 0,
+      maxPeriscopes,
+      periscopeIdleMinutes
     },
     routes,
     crewHome,
@@ -2567,6 +2609,9 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
     missing.add(`${where}.toolchain "${toolchain}" is not defined in ship.toolchains (have: ${[...toolchainNames].join(", ")})`);
   }
   const route = missing.req(c?.route, `${where}.route`);
+  if (c?.hostPeriscopes === true && c?.hostPassengers !== true) {
+    missing.add(`${where} (route "${route}") sets hostPeriscopes: true without hostPassengers: true \u2014 a Passenger must be able to board before they can open a periscope`);
+  }
   const routeParts = route ? route.split("/") : [];
   const routeWellFormed = routeParts.length === 2 && routeParts.every(Boolean);
   if (route && !routeWellFormed) {
@@ -2641,7 +2686,8 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
     },
     release: parseReleaseOverride(c?.release, where, file),
     branch: parseBranchOverride(c?.branch, where, file),
-    hostPassengers: c?.hostPassengers === true
+    hostPassengers: c?.hostPassengers === true,
+    hostPeriscopes: c?.hostPeriscopes === true
   };
   const resolvedFile = routeWellFormed ? readResolvedFile(stateDir, route) : void 0;
   result.resolved = parseResolved(resolvedFile ?? c?.resolved, missing, where);
@@ -5114,6 +5160,7 @@ var HOOK_PURPOSE = [
   ["isolate", "point this worktree at state of its own; prints KEY=value overrides to export"],
   ["ports", "this worktree's port assignments; prints KEY=value overrides to export"],
   ["handoff", "leave the operator able to open what you built; put its output in your progress comment"],
+  ["preview", "start this worktree's dev server for a viewer, bound to CREW_PREVIEW_HOST, detached; its last stdout line is the URL"],
   ["test", "run the suite"],
   ["build", "build it"],
   ["ci_status", "after you push and before you hand off: exit 0 means CI is green for your branch; on failure fix and push again, and say in your progress comment if it is still pending"]
@@ -5558,6 +5605,19 @@ function validateContract(c) {
   return problems;
 }
 var EVENT_LOG_MISSING = "the Issues table has no event log \u2014 crew writes its audit trail there (CREW-1574). In the app, open the Issues table's Data & lifecycle tab and turn on Event log, then rerun.";
+var PERISCOPE_COLUMNS = [
+  "ticket_id",
+  "ship_id",
+  "url",
+  "host",
+  "worktree",
+  "branch",
+  "state",
+  "isolated",
+  "started_at",
+  "last_activity_at",
+  "expires_at"
+];
 
 // src/agent-log.ts
 import { existsSync as existsSync12, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync12, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "fs";
@@ -6806,6 +6866,19 @@ var Tracker = class {
   async hasPublicReplyColumn() {
     return (await this.authorshipProbe()).commentPublicReply;
   }
+  /**
+   * Whether this workspace has the optional Periscopes table (EPIC-077), and
+   * which of the columns the crew writes (`PERISCOPE_COLUMNS`) it lacks.
+   * `present: false` is a legitimate shape, never a fault. A table whose
+   * metadata cannot be read reports every column missing, as the authorship
+   * probe reads an unreadable table as "column absent".
+   */
+  async periscopesStatus() {
+    const modelId = this.route.resolved?.periscopesModelId;
+    if (!modelId) return { present: false, missing: [] };
+    const have = await this.columnNames(modelId);
+    return { present: true, modelId, missing: PERISCOPE_COLUMNS.filter((c) => !have.has(c)) };
+  }
   /**
    * The authorship columns this workspace is missing, as `table.column` names
    * for `crew doctor` to report (CREW-1371). Empty on a fully updated install.
@@ -7733,7 +7806,7 @@ function skillMarkerNames(text) {
   }
   return names;
 }
-function expandSkillMarkers(text, lookup, opts = {}) {
+function expandSkillMarkers(text, lookup2, opts = {}) {
   const maxDepth = opts.maxDepth ?? MAX_INCLUDE_DEPTH;
   const maxBytes = opts.maxBytes ?? MAX_INCLUDED_BYTES;
   const warnings = [];
@@ -7749,7 +7822,7 @@ function expandSkillMarkers(text, lookup, opts = {}) {
       warnings.push(`skill include "${name}" left literal: nested deeper than ${maxDepth} levels`);
       return literal;
     }
-    const body = lookup(name);
+    const body = lookup2(name);
     if (body === void 0) throw new SkillIncludeError(`no skill named "${name}" for the include ${literal}`);
     const trimmed = body.replace(/^\n+/, "").replace(/\n+$/, "");
     const bytes = Buffer.byteLength(trimmed, "utf8");
@@ -13719,6 +13792,7 @@ function forbiddenDetail(e, route) {
     [r?.shipsModelId, "Ships"],
     [r?.locksModelId, "Locks"],
     [r?.epicsModelId, "Epics"],
+    [r?.periscopesModelId, "Periscopes"],
     [r?.reposModelId, "Repos"]
   ];
   const table2 = modelId ? known.find(([id]) => id && id === modelId)?.[1] ?? `table ${modelId}` : void 0;
@@ -14563,6 +14637,7 @@ async function discover(o) {
   out.reposModelId = find("Repos");
   out.shipsModelId = find("Ships");
   out.epicsModelId = find("Epics");
+  out.periscopesModelId = find("Periscopes");
   out.locksModelId = find("Locks");
   try {
     const views = await get(o, `/views?workspaceId=${ws.id}`);
@@ -14614,6 +14689,7 @@ async function discover(o) {
       shipColumns = new Set((shipsModel.fields ?? []).map((f) => f.columnName));
     } catch {
     }
+    const hostPeriscopes = shipColumns.has("host_periscopes") ? o.ship.hostPeriscopes : void 0;
     let ownerId;
     if (out.meId) {
       if (shipColumns.has("owner_id")) ownerId = out.meId;
@@ -14656,6 +14732,7 @@ async function discover(o) {
       }
       if (writeMachineId) patchBody.machine_id = machineId;
       if ((mine[0].host_passengers ?? false) !== hostPassengers) patchBody.host_passengers = hostPassengers;
+      if (hostPeriscopes !== void 0 && (mine[0].host_periscopes ?? false) !== hostPeriscopes) patchBody.host_periscopes = hostPeriscopes;
       if (sshPublicKey !== void 0 && (mine[0].ssh_public_key ?? "") !== sshPublicKey) {
         patchBody.ssh_public_key = sshPublicKey;
       }
@@ -14663,6 +14740,7 @@ async function discover(o) {
       if (Object.keys(patchBody).length > 0) {
         await patch(o, `/data-models/${out.shipsModelId}/records/${shipRowId}`, patchBody);
         if ("host_passengers" in patchBody) provisioning.push(`synced host_passengers=${hostPassengers} onto Ships row "${o.ship.name}"`);
+        if ("host_periscopes" in patchBody) provisioning.push(`synced host_periscopes=${hostPeriscopes} onto Ships row "${o.ship.name}"`);
         if ("ssh_public_key" in patchBody) provisioning.push(`synced ssh_public_key onto Ships row "${o.ship.name}"`);
         if ("owner_id" in patchBody) provisioning.push(`recorded owner on Ships row "${o.ship.name}"`);
       }
@@ -14671,6 +14749,7 @@ async function discover(o) {
         name: o.ship.name,
         ...o.ship.platform ? { platform: o.ship.platform } : {},
         host_passengers: hostPassengers,
+        ...hostPeriscopes !== void 0 ? { host_periscopes: hostPeriscopes } : {},
         ...sshPublicKey !== void 0 ? { ssh_public_key: sshPublicKey } : {},
         ...ownerId !== void 0 ? { owner_id: ownerId } : {},
         ...writeMachineId ? { machine_id: machineId } : {}
@@ -20350,6 +20429,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         platform: cfg.ship.platform,
         machineId,
         hostPassengers: firstRun?.answers.hostPassengers ?? existingRoute?.hostPassengers === true,
+        hostPeriscopes: existingRoute?.hostPeriscopes === true,
         sshPublicKey,
         lastSyncedName: (r) => readSyncedName(resolvedPathFor(cfg.ship.stateDir, r))
       };
@@ -20561,6 +20641,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           areaId: found.areaId,
           shipsModelId: found.shipsModelId,
           epicsModelId: found.epicsModelId,
+          periscopesModelId: found.periscopesModelId,
           locksModelId: found.locksModelId,
           recordLinkViewId: found.recordLinkViewId,
           reposModelId: found.reposModelId,
@@ -21812,6 +21893,7 @@ ${owed.map((l) => `  ${l}
         `ship:       ${cfg.ship.name} (${cfg.ship.platform})
 route:      ${route.route} -> ${route.dir}
 enabled:    ${route.enabled}
+periscopes: ${periscopeSummary(cfg)}
 crew:       ${state.isPaused() ? "paused" : "active"}
 release:    ${state.releaseSkipReason() ? "paused" : "active"}
 watermark:  ${state.watermark()}
@@ -21929,6 +22011,8 @@ watermark:  ${state.watermark()}
           }
         }
         for (const message of roleCapWarnings(cfg.ship)) problems.push({ severity: "note", kind: "role_cap_above_ship_cap", message });
+        const previewProblem2 = await previewHostProblem(cfg);
+        if (previewProblem2) problems.push({ severity: "blocker", kind: "preview_host", message: previewProblem2 });
         problems.push(...attentionProblems(openShipAttention(state), problems));
         if (problems.some((p) => p.severity === "blocker")) process.exitCode = 1;
         process.stdout.write(`${JSON.stringify({ offline: flag("offline"), pushAuth, tools: toolRows, problems, passed }, null, 2)}
@@ -21942,6 +22026,14 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       );
       for (const w of roleCapWarnings(cfg.ship)) process.stdout.write(`role concurrency: WARN ${w}
 `);
+      process.stdout.write(`periscopes:        ${periscopeSummary(cfg)}
+`);
+      const previewProblem = await previewHostProblem(cfg);
+      if (previewProblem) {
+        process.stdout.write(`                   BLOCKER ${previewProblem}
+`);
+        process.exitCode = 1;
+      }
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
         const evSize = existsSync35(evFile) ? statSync10(evFile).size : 0;
@@ -22043,6 +22135,12 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       process.stdout.write(
         await tracker.hasPublicReplyColumn() ? `public replies:  Comments.${tracker.contract.comments.publicReply} present \u2014 public reporters are labelled in the digest
 ` : `public replies:  Comments.${tracker.contract.comments.publicReply} absent \u2014 no public intake form, nothing to guard
+`
+      );
+      const periscopes = await tracker.periscopesStatus();
+      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})
+` : `periscopes:      Periscopes table present (${periscopes.modelId}) but missing ${periscopes.missing.join(", ")} \u2014 update the Issues template
 `
       );
       process.stdout.write(

package/package.json

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