@bongos/core 1.18.0 → 1.18.18

package/modules/dev-box/app/src/task-picker.js

@@ -0,0 +1,70 @@
+// devbox-app/src/task-picker.js — BV1.R100 (goal 1000051): the "What are you
+// working on?" pick + confirm logic, kept PURE so test/unit.mjs can pin it
+// without Electron (the same pattern as box-controller's decision helpers).
+//
+// The flow this backs: the panel lists the builder's claimable tasks, the builder
+// picks one, the app claims it over the GDS API (server-mediated — no SSH), then
+// reads the resulting box scope (GET /box/scope, credential-free) to CONFIRM, in
+// plain words, exactly what code the box will now hold. The re-scope itself is
+// R94 + R96 machinery (the claim re-points /box/source-access; /builder-sync on the
+// box pulls it) — this module only shapes the list and writes the confirmation.
+
+// shapeClaimableTasks — normalize the GET /tasks/claimable payload into the small
+// row shape the panel renders. Caps the list (the panel is a menu-bar popover, not
+// a full queue — "show all" lives in the hall). Tolerant of a missing/using body.
+function shapeClaimableTasks(payload, { limit = 6 } = {}) {
+  const rows = payload && Array.isArray(payload.claimable) ? payload.claimable : [];
+  const capped = limit > 0 ? rows.slice(0, limit) : rows;
+  return capped.map((t) => ({
+    id: String(t.id),
+    title: t.title || `Task ${t.id}`,
+    kind: t.kind || 'task',
+    estMinutes: Number.isFinite(t.est_minutes) ? t.est_minutes : null,
+  }));
+}
+
+// boxScopeMessage — the confirmation shown after a successful pick+claim. `task`
+// is { id }; `scope` is the GET /box/scope body ({ scope, modules, task_scope }) or
+// null when that read failed (best-effort — the claim still succeeded). The three
+// shapes mirror decideSourceAccess / scopeMetadata on the server:
+//   - modules non-empty  → TASK scope: name exactly the modules the box will hold.
+//   - modules === []      → BASE-only: the task needs nothing beyond the base box.
+//   - modules === null    → rank fallback (no task→module mapping): generic refresh.
+//   - scope === null      → the scope read failed: claim landed, still direct to sync.
+const SYNC_HINT = 'On the box, run /builder-sync to pull it now — or it auto-syncs within ~10 minutes.';
+
+function boxScopeMessage({ task, scope } = {}) {
+  const n = task && task.id ? `task ${task.id}` : 'your task';
+  if (!scope) {
+    return `Claimed ${n}. Your box will re-scope to it. ${SYNC_HINT}`;
+  }
+  const mods = Array.isArray(scope.modules) ? scope.modules : null;
+  if (mods && mods.length) {
+    return `Claimed ${n}. Your box is now scoped to: ${mods.join(', ')} — and nothing else. ${SYNC_HINT}`;
+  }
+  if (mods && mods.length === 0) {
+    return `Claimed ${n}. It needs only the base instance already on your box — nothing extra to pull.`;
+  }
+  // modules === null → the rank fallback (no lifecycle port / no per-module scope).
+  return `Claimed ${n}. Your box keeps its ${scope.scope || 'rank'} scope. ${SYNC_HINT}`;
+}
+
+// claimErrorMessage — map a GdsError from POST /claims to plain, actionable copy.
+// The common refusals (deps, one-claim-per-session, not-ready, touches conflict)
+// each get a specific line; anything else falls back to the server message/code.
+function claimErrorMessage(err) {
+  const body = (err && err.body) || {};
+  const code = body.error || body.code || (err && err.message) || 'claim_failed';
+  const known = {
+    DEPS_NOT_SHIPPED: 'That task is waiting on other work to ship first. Pick another one.',
+    session_already_has_active_claim: 'You already have a task in flight — ship or release it first.',
+    task_not_ready: 'That task isn’t ready to claim yet. Pick another.',
+    not_ready: 'That task isn’t ready to claim yet. Pick another.',
+    touches_conflict: 'Another builder is touching the same files right now. Pick a different task.',
+    already_claimed: 'Someone just claimed that one. Refresh and pick another.',
+    newcomer_claim_forbidden: 'That task is above your current rank. Pick a newcomer-friendly one.',
+  };
+  return known[code] || body.message || `Couldn’t claim it (${code}).`;
+}
+
+module.exports = { shapeClaimableTasks, boxScopeMessage, claimErrorMessage, SYNC_HINT };

package/modules/dev-box/app/src/tray.js

@@ -0,0 +1,99 @@
+// devbox-app/src/tray.js — the menu-bar (mac) / system-tray (Windows) face.
+//
+// macOS gets monochrome TEMPLATE images (the OS recolors them for light/dark
+// menu bars; the shape carries the state). Windows gets colored PNGs. Four
+// states: off (outline), on (filled), busy (half), alert (bang).
+
+const path = require('node:path');
+const { Tray, Menu, nativeImage } = require('electron');
+
+const ASSETS = path.join(__dirname, '..', 'assets', 'tray');
+const IS_MAC = process.platform === 'darwin';
+
+// status (box-controller vocabulary) → icon variant
+function iconVariant(status) {
+  switch (status) {
+    case 'active': return 'on';
+    case 'provisioning':
+    case 'closing': return 'busy';
+    case 'error': return 'alert';
+    default: return 'off'; // none / signed_out / loading
+  }
+}
+
+function loadIcon(variant) {
+  const file = IS_MAC ? `mac-${variant}Template.png` : `win-${variant}.png`;
+  const img = nativeImage.createFromPath(path.join(ASSETS, file));
+  if (IS_MAC) img.setTemplateImage(true);
+  return img;
+}
+
+function statusLine(snapshot) {
+  switch (snapshot.status) {
+    case 'signed_out': return 'Not signed in';
+    case 'loading': return 'Checking…';
+    case 'none': return 'Box: off';
+    case 'provisioning': return 'Box: starting up…';
+    case 'active': return `Box: ON${snapshot.box && snapshot.box.hostname ? ` — ${snapshot.box.hostname}` : ''}`;
+    case 'closing': return 'Box: shutting down…';
+    case 'error': return 'Box: error — open the panel';
+    default: return 'Dev Box';
+  }
+}
+
+// createTray({ onOpen, onToggle, onOpenTerminal, onOpenHall, onQuit,
+//              getLoginItem, setLoginItem }) → { update(snapshot), destroy() }
+function createTray(handlers) {
+  const tray = new Tray(loadIcon('off'));
+  let current = { status: 'loading' };
+
+  function buildMenu() {
+    const s = current;
+    const onOrOff = s.status === 'active' || s.status === 'closing';
+    return Menu.buildFromTemplate([
+      { label: statusLine(s), enabled: false },
+      { type: 'separator' },
+      { label: 'Open Dev Box panel', click: handlers.onOpen },
+      {
+        label: onOrOff ? 'Turn box off' : 'Turn box on',
+        enabled: s.status !== 'signed_out' && s.status !== 'loading' && !s.busy
+          && s.status !== 'provisioning' && s.status !== 'closing',
+        click: handlers.onToggle,
+      },
+      {
+        label: 'Open browser terminal',
+        enabled: Boolean(s.terminal && s.terminal.url),
+        click: handlers.onOpenTerminal,
+      },
+      { label: 'Open the builders’ hall', click: handlers.onOpenHall },
+      { type: 'separator' },
+      {
+        label: 'Start at login',
+        type: 'checkbox',
+        checked: handlers.getLoginItem(),
+        click: (item) => handlers.setLoginItem(item.checked),
+      },
+      { type: 'separator' },
+      { label: 'Quit', click: handlers.onQuit },
+    ]);
+  }
+
+  // Left-click opens the panel; right-click (and mac ctrl-click) the menu.
+  tray.on('click', handlers.onOpen);
+  tray.on('right-click', () => tray.popUpContextMenu(buildMenu()));
+
+  return {
+    update(snapshot) {
+      current = snapshot;
+      tray.setImage(loadIcon(iconVariant(snapshot.status)));
+      tray.setToolTip(statusLine(snapshot));
+      // Keep a context menu reachable on platforms that route both buttons to
+      // 'click' — popUpContextMenu handles the rest.
+      if (!IS_MAC) tray.setContextMenu(buildMenu());
+    },
+    bounds() { return tray.getBounds(); },
+    destroy() { tray.destroy(); },
+  };
+}
+
+module.exports = { createTray, iconVariant, statusLine };

package/modules/dev-box/app/src/updater.js

@@ -0,0 +1,55 @@
+// devbox-app/src/updater.js — pure update-check logic (#924). No Electron, no
+// network: deciding "is a newer release available?" and "which installer target
+// do I need?" are pure functions so test/unit.mjs proves them without a GUI. The
+// Electron wiring (poll the endpoint, download, launch the installer) is in main.js.
+
+// Parse "X.Y.Z" → [X, Y, Z] numbers, or null for anything that isn't a clean
+// three-part numeric version (the same shape devbox-downloads.js enforces on the
+// server), so a malformed value can never be mistaken for an upgrade.
+function parseVersion(v) {
+  if (typeof v !== 'string') return null;
+  const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(v.trim());
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+
+// -1 if a<b, 0 if equal, 1 if a>b. An unparseable side sorts BELOW a parseable
+// one (and two bad ones are equal), so a malformed version never reads as newer.
+function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) {
+    if (!pa && !pb) return 0;
+    return pa ? 1 : -1;
+  }
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
+  }
+  return 0;
+}
+
+// The load-bearing decision: the "update available" banner shows ONLY when the
+// published release is STRICTLY newer than what's running. This replaces the
+// naive `latest !== current` check, which would advertise a DOWNGRADE whenever
+// the published config trails the installed app (the live state today: app 1.0.6
+// vs config 1.0.5). Returns false on any unparseable version — never a
+// false-positive.
+function isUpdateAvailable(currentVersion, latestVersion) {
+  if (!parseVersion(currentVersion) || !parseVersion(latestVersion)) return false;
+  return compareVersions(latestVersion, currentVersion) > 0;
+}
+
+// Map the running (platform, arch) to a config/devbox-app.json asset target key.
+// Mirrors the four built targets. Anything else (e.g. linux) → null = no
+// in-app installer for this platform (the banner simply won't offer one).
+function resolveTarget(platform, arch) {
+  if (platform === 'darwin') return arch === 'arm64' ? 'mac-arm64' : 'mac-x64';
+  if (platform === 'win32') return arch === 'arm64' ? 'win-arm64' : 'win-x64';
+  return null;
+}
+
+// The exact banner copy the task specifies: "Update available — v1.0.6".
+function updateBannerText(latestVersion) {
+  return `Update available — v${latestVersion}`;
+}
+
+module.exports = { parseVersion, compareVersions, isUpdateAvailable, resolveTarget, updateBannerText };