@bongos/core 1.24.77 → 1.24.78

package/modules/autonomy/skills/autobongos-setup/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: autobongos-setup
+description: >-
+  Set up THIS device as an Autobongos runner, or fix one that is not working: one copied command, then one Run button. Metic+. Triggers: "/autobongos-setup", "set up Autobongos on this PC", "add this Mac as a runner", "my runner is not running".
+disable-model-invocation: true
+plain: >-
+  Turns the computer you are sitting at into one that builds the project's tasks by itself while you are away, and walks you through the two sign-ins it needs.
+reach-for: >-
+  When you want this computer to work on the project unattended, or its runner has stopped checking in.
+cost: >-
+  Setting it up is free and changes nothing in the project. Once you press Run, the runner spends your own Claude usage on the goals you chose, and each task it hands in runs a paid quality review charged to the project.
+---
+
+You are setting up the Autobongos runner on the device this session is running on, with the person beside you. The whole flow is **one copied command, then one button**. Your job is to get them through it in plain words and to read what the device says back — never to rebuild the flow by hand.
+
+Design of record: [ADR 0307](../../../../docs/adr/0307-autobongos-a-deterministic-supervisor-and-agentic-workers.md) §5. The guide a person can follow alone: [docs/recipes/autobongos-runner-setup.md](../../../../docs/recipes/autobongos-runner-setup.md).
+
+## What you must not do
+
+- **Never run the runner from this checkout.** `autobongos-host.js run` resets its checkout to the latest code every time it starts, and it refuses any copy that is not marked as the runner's own. Do not mark this one. The setup command makes the runner its own copy under `~/.cloudbongos-runner`.
+- **Never ask for the setup code in chat, and never type one yourself.** The person copies the whole command from the hall and pastes it into their own terminal. A code is a one-time login.
+- **Never turn on the project's runner switch or change which goals runners may work.** Those are the owner's, on Watch → Autobongos. If they are what is holding the runner, say so and stop.
+
+## 1. Is it already here?
+
+```bash
+node ~/.cloudbongos-runner/repo/scripts/bongos/autobongos-host.js status
+```
+
+- **The file does not exist** → the device has no runner yet. Go to step 2.
+- **`running : yes`** → it is set up and running. Skip to step 4 (is it *working*?).
+- **`running : no`, signed in** → start it: `node ~/.cloudbongos-runner/repo/scripts/bongos/autobongos-host.js start`, then step 4.
+- **No runner login** → its login was removed or never made. Go to step 2; the same command repairs it.
+
+On Windows the folder is `%USERPROFILE%\.cloudbongos-runner`.
+
+## 2. The one command
+
+Tell the person, in these words or close to them:
+
+> Open the hall, go to **Settings → Access & keys → Your Autobongos runner**, and press **Add a device**. Pick Windows or Mac. Copy the line it shows and paste it into a new **PowerShell** window (Windows, an ordinary one, not "as administrator") or **Terminal** (Mac). It works once and for 15 minutes, so paste it straight away.
+
+Then wait for them. What the command does, so you can answer questions without guessing:
+
+1. Finds git, Node and Claude Code, and installs whichever is missing. On Windows, Windows itself may ask "allow this app to make changes" while it installs; that is expected. On a Mac with no developer tools, macOS opens its own install window — they press Install, wait, and paste the command again.
+2. Makes the runner **its own copy** of the project. GitHub may ask them to sign in; it must be an account that can see the project.
+3. Signs the device in to the project with **a login of its own**. Their own command-line sign-in on this device is not touched.
+4. Checks Claude Code is signed in, and opens the Claude sign-in if it is not.
+5. Registers the runner to start whenever they sign in to the device, starts it, and waits for its first check-in.
+
+It ends with `Done. This device is connected…`. If it ends with `Autobongos setup stopped here: …`, read them the **What to do** line — it is written for them — and run the command again after they have done it. Running it twice is safe.
+
+## 3. Press Run
+
+A device added this way starts **stopped**, on purpose: the first press is theirs.
+
+> Back in Settings, your device now has a card. Tick the goals you want it to work under **What it works on**, press **Save**, then press **Run** on the card.
+
+The button then says what the device is doing: **Starting** (under a minute), **Running**, **Resting until** a time (their Claude usage is spent; it resumes by itself), or **Device is off or asleep**.
+
+Tell them the one rule of thumb: **keep the device on and plugged in while it runs.** If it sleeps, the runner pauses and picks up when it wakes. The runner keeps the device from idle-sleeping while it is allowed to work, but a closed laptop lid still sleeps.
+
+## 4. Is it working?
+
+The card in Settings is the answer; read it with them. If the button's second line says it is on **but** something holds it, that line names the cause:
+
+| The card says | Whose move |
+|---|---|
+| the project's runner switch is off | the owner's (Watch → Autobongos). Not yours to flip. |
+| the owner paused your runner | the owner's |
+| no goals are chosen for it yet | theirs: tick a goal under **What it works on**, Save |
+| the project has not allowed any goals for runners yet | the owner's |
+| idle because … | read them the rest of the line; it carries the fix |
+| Device is off or asleep | theirs: wake it and sign in |
+
+For anything the card does not explain, the device's own log is at `~/.cloudbongos-runner/logs/autobongos.log`. Read the last screen of it; do not paste it at the person.
+
+## 5. Stopping and removing
+
+- **Stop for now:** the **Stop** button on the card. It finishes the task in hand first.
+- **Stop it on the device itself** (maintenance): `node ~/.cloudbongos-runner/repo/scripts/bongos/autobongos-host.js stop`. It says `Stopped` only after it has watched the processes exit; if it says `NOT STOPPED`, read them the command it prints.
+- **Take the device out for good:** **Remove** on the card signs the device's login out at once. Then on the device: `…autobongos-host.js uninstall`, and delete the `.cloudbongos-runner` folder.
+
+## An always-on PC that must start with nobody signed in
+
+The setup above starts the runner when the person signs in, which is right for a laptop or a desktop. A Windows PC that must come back after a power cut with nobody at the keyboard uses the boot-time install instead, which needs an Administrator window once: [docs/recipes/autobongos-windows-host.md](../../../../docs/recipes/autobongos-windows-host.md). One runner per device: setup refuses to add a second beside it.

package/modules/hall-ui/public/commands-lib.js

@@ -46,7 +46,7 @@
     {
       key: 'setup', label: 'Your account and new projects',
       blurb: 'Signing in, keys, costs, and starting a project from scratch.',
-      names: ['builder-setup', 'builder-reauth', 'builder-key', 'builder-cost', 'new-project'],
+      names: ['builder-setup', 'builder-reauth', 'builder-key', 'builder-cost', 'autobongos-setup', 'new-project'],
     },
   ];
   const OTHER_GROUP = { key: 'other', label: 'Everything else', blurb: 'Skills this project has that no group above names yet.' };

package/modules/hall-ui/public/gate.js

@@ -96,8 +96,11 @@
   // only the order to pick the runner to describe in, and the colour of its dot.
   // idle_config (task 1004539): talking, but idle on a setting the owner can fix —
   // it carries the fix as `remedy`, and draws as a warning, never as "ok".
-  const HEALTH_RANK = { alive: 0, late: 1, idle_config: 2, restarting: 3, dead: 4, never_seen: 5 };
-  const HEALTH_DOT = { alive: 'ok', late: 'ok', idle_config: 'warn', restarting: 'info', dead: 'danger', never_seen: 'info' };
+  // stopped (task 1005094): checking in, and its builder pressed Stop on that
+  // device in Settings. Connected, not an alarm, and not the one to describe
+  // while another device is working.
+  const HEALTH_RANK = { alive: 0, late: 1, idle_config: 2, restarting: 3, stopped: 4, dead: 5, never_seen: 6 };
+  const HEALTH_DOT = { alive: 'ok', late: 'ok', idle_config: 'warn', restarting: 'info', stopped: 'info', dead: 'danger', never_seen: 'info' };
 
   // The panel is drawn from both reads at once; each is kept so a write that only
   // reloads one of them redraws with the other's last answer.
@@ -121,11 +124,13 @@
   // `project`, and then there is no second layer to check.
   function readiness(runner, fence, mine) {
     const h = (runner && runner.health) || {};
-    const connected = ['alive', 'late', 'restarting', 'idle_config'].includes(h.state);
+    const connected = ['alive', 'late', 'restarting', 'idle_config', 'stopped'].includes(h.state);
     const goals = (fence && fence.goals) || [];
     const items = [];
     if (!runner) {
-      items.push({ key: 'pc', state: 'todo', text: 'Connect a PC', hint: 'Install the runner on an always-on PC. It shows up here when it first checks in.' });
+      // The step that used to say nothing about HOW (task 1005097): it opens the
+      // Settings flow, where Add a device hands out the one setup command.
+      items.push({ key: 'pc', state: 'todo', text: 'Connect a PC', hint: 'Add a device in Settings: one copied command on any Windows PC or Mac. It shows up here when it first checks in.', action: 'add-device' });
     } else if (!connected) {
       items.push({ key: 'pc', state: 'todo', text: `${h.host || 'The PC'} has gone quiet`, hint: `No check-in for ${h.age || 'a while'}. Check the PC is on, then restart the runner.` });
     } else {
@@ -165,6 +170,7 @@
   function headline(runner) {
     const h = (runner && runner.health) || {};
     if (h.state === 'restarting') return 'Restarting to pick up new code';
+    if (h.state === 'stopped') return 'Stopped on its device';
     if (h.workingTaskId) return `Working on task ${h.workingTaskId}`;
     return 'Ready — waiting for a task';
   }
@@ -179,6 +185,7 @@
           ${i.hint && i.state !== 'ok' ? `<span class="rn-check__hint">${escapeHtml(i.hint)}</span>` : ''}</span>
         ${i.action === 'add-goal' ? '<button type="button" class="btn btn--sm" data-rn="add-goal">Choose goals</button>' : ''}
         ${i.action === 'settings' ? '<a class="btn btn--sm" href="/builders/settings#autobongos">Open Settings</a>' : ''}
+        ${i.action === 'add-device' ? '<a class="btn btn--sm" href="/builders/settings#autobongos">Add a device</a>' : ''}
       </li>`).join('')}</ul>`;
   }
 
@@ -381,7 +388,7 @@
       : 'has picked no goals, so their runner takes no work';
     const beats = (b.runners || []).map((r) => {
       const h = r.health || {};
-      const label = { dead: 'not checking in', late: 'quiet', alive: 'checking in', restarting: 'restarting', idle_config: `idle on a setting — ${h.remedy || 'see Settings'}` }[h.state] || 'unknown';
+      const label = { dead: 'not checking in', late: 'quiet', alive: 'checking in', restarting: 'restarting', stopped: 'stopped on that device', idle_config: `idle on a setting — ${h.remedy || 'see Settings'}` }[h.state] || 'unknown';
       return `<span class="ov-fact"><span class="rn-dot rn-dot--sm rn-dot--${HEALTH_DOT[h.state] || 'info'}" aria-hidden="true"></span> ${escapeHtml(h.host || r.host || '')} ${escapeHtml(label)}</span>`;
     }).join('');
     const paused = b.owner_paused === true;

package/modules/hall-ui/public/runner-button.css

@@ -0,0 +1,55 @@
+/* runner-button.css — a device's card and its one Run button on Settings >
+   Your Autobongos runner (task 1005094). Loaded by settings.html only.
+
+   The button's FACE is the device's state (Run, Starting, Running, Resting until
+   a time, Stopping, Device is off), so it is drawn larger than a form button and
+   carries a status word, an optional countdown and the action word side by side.
+   Tokens only: the pack's inks and grounds and the hall's status vocabulary
+   (--ok / --warn / --info), never a colour of its own. Both axes of every
+   target clear the 24px floor; the button itself is 52px tall. */
+
+.rb-h { margin: var(--space-4) 0 var(--space-2); font-size: var(--ds-text-sm); font-weight: 500; color: var(--ink-soft); }
+.rb-cards { list-style: none; margin: 0; padding: 0; display: grid; gap: var(--space-3); }
+.rb-card { display: grid; gap: var(--space-2); padding: var(--space-3); border: var(--line) solid var(--rule-soft); border-radius: var(--radius); background: var(--bg-card); min-width: 0; }
+.rb-card__head { display: flex; align-items: center; gap: var(--space-2); flex-wrap: wrap; min-width: 0; }
+.rb-card__name { font-size: var(--ds-text-lg); color: var(--ink); overflow-wrap: anywhere; }
+.rb-card__meta { font-size: var(--ds-text-sm); color: var(--ink-faint); overflow-wrap: anywhere; }
+.rb-card__sub { margin: 0; font-size: var(--ds-text-md); color: var(--ink); }
+/* Remove sits at the end of the card's first line: there, but not the thing the
+   eye lands on. The stay-on note is on the card of a device that is switched on. */
+.rb-card__remove { margin-left: auto; min-height: 32px; padding: 0 var(--space-3); font-size: var(--ds-text-sm); }
+.rb-card__note { margin: 0; font-size: var(--ds-text-sm); color: var(--ink-faint); max-width: var(--measure); }
+
+.rb-dot { width: 10px; height: 10px; border-radius: var(--radius-pill); flex: none; background: var(--rule); }
+.rb-dot--ok { background: var(--ok); }
+.rb-dot--warn { background: var(--warn); }
+.rb-dot--info { background: var(--info); }
+
+/* The button. It IS one of the hall's shared buttons (controls.css): the accent
+   door (.btn) when a press starts the runner, the quiet one (.settings-btn) when
+   the device is on and a press would stop it. This sheet only makes it larger and
+   lets its face hold a status word, a countdown and the action side by side. */
+.rb-button {
+  justify-self: start; gap: var(--space-2); flex-wrap: wrap;
+  min-height: 52px; min-width: 148px; max-width: 100%;
+  padding: var(--space-1) var(--space-4);
+  white-space: normal; text-align: center;
+}
+.rb-button--busy { border-style: dashed; cursor: default; }
+.rb-button__status { overflow-wrap: anywhere; }
+.rb-button__count { font-family: var(--font-mono); font-size: var(--ds-text-sm); }
+.rb-button__act { padding: 2px 10px; border: var(--line) solid var(--rule); border-radius: var(--radius-pill); font-size: var(--ds-text-sm); }
+
+/* Add a device. */
+.rb-addwrap { margin-top: var(--space-3); }
+.rb-add { display: grid; gap: var(--space-2); }
+.rb-add__tabs { display: flex; gap: var(--space-1); flex-wrap: wrap; }
+.rb-add__steps { margin: 0; padding-left: 20px; display: grid; gap: 4px; font-size: var(--ds-text-md); color: var(--ink); max-width: var(--measure); }
+.rb-add__wait { margin: 0; font-size: var(--ds-text-sm); color: var(--ink-faint); }
+.rb-add .quote__pre { white-space: pre-wrap; overflow-wrap: anywhere; }
+.rb-add__tabs [aria-pressed="true"] { color: var(--ink); border-color: var(--ink); }
+.rb-add > .settings-btn { justify-self: start; }
+/* On the accent Run button the action IS the face, so it is not drawn as a chip. */
+.btn .rb-button__act { border: 0; padding: 0; font-size: inherit; }
+/* The notices above the devices read as prose, so they keep to the measure. */
+#ab-notices .prow__hint { max-width: var(--measure); }

package/modules/hall-ui/public/runner-button.js

@@ -0,0 +1,187 @@
+// modules/hall-ui/public/runner-button.js — what a device's Run button says
+// (task 1005094, goal 1000139).
+//
+// WHY. Owner direction, 2026-11-09: running Autobongos on a device is ONE button,
+// and any cooldown is built into the button itself. So the button's face is the
+// device's state, not a label beside a status line someone has to find: Run,
+// Starting, Running, Resting until a time, Stopping, Device is off. This file
+// decides which, from facts the server already sent — the runner's check-in and
+// its health verdict (modules/autonomy/runner-health.js), the device's switch,
+// and the caller's fence — and builds the one setup command per platform.
+//
+// PURE, and that is the testability decision (the roadmap-timeline.js precedent):
+// no document, no fetch, no clock of its own (`nowMs` is an argument). The page
+// script (settings-autobongos.js) draws what this returns and nothing else, so a
+// test runs the real decision instead of agreeing with a copy of it. Assigned to
+// window only when one exists, so node can require it.
+
+(function (root) {
+  'use strict';
+
+  // How long a press of Run may read as "Starting". The runner notices a press on
+  // its next fence poll (every 60s while it waits) and then checks in, so two
+  // minutes is that plus slack. Past it the button says what is actually true —
+  // usually that the device is off — instead of promising a start forever.
+  const STARTING_MS = 2 * 60 * 1000;
+
+  const ms = (t) => { const n = Date.parse(t || ''); return Number.isFinite(n) ? n : null; };
+
+  // "in 42 min", "in 3 h 5 min" — the part of the cooldown that ticks.
+  function countdown(leftMs) {
+    if (!Number.isFinite(leftMs) || leftMs <= 0) return '';
+    const mins = Math.max(1, Math.round(leftMs / 60000));
+    if (mins < 60) return `${mins} min`;
+    const h = Math.floor(mins / 60);
+    const m = mins % 60;
+    return m ? `${h} h ${m} min` : `${h} h`;
+  }
+
+  // A clock time today, a weekday and time within the week, a date beyond that.
+  function clock(atMs, nowMs) {
+    const d = new Date(atMs);
+    const time = d.toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' });
+    const sameDay = new Date(nowMs).toDateString() === d.toDateString();
+    if (sameDay) return time;
+    if (atMs - nowMs < 6 * 24 * 3600 * 1000) return `${d.toLocaleDateString([], { weekday: 'short' })} ${time}`;
+    return d.toLocaleDateString([], { day: 'numeric', month: 'short', year: 'numeric' });
+  }
+
+  // Why a device that is switched on is not working, from the caller's own fence
+  // (GET /autonomy/fence with no device named), or null when nothing holds it.
+  function fenceHold(fence) {
+    if (!fence || typeof fence !== 'object') return null;
+    const scope = fence.scope || {};
+    const project = fence.project || {};
+    if (fence.enabled === false) {
+      if (fence.stop_code === 'builder_paused') return `the owner paused your runner${scope.owner_paused_reason ? ` (${scope.owner_paused_reason})` : ''}`;
+      if (fence.stop_code === 'not_permitted') return 'your rank cannot run a runner on this project';
+      return `the project’s runner switch is off${project.paused_reason ? ` (${project.paused_reason})` : ''}`;
+    }
+    if (Array.isArray(project.goals) && project.goals.length === 0) return 'the project has not allowed any goals for runners yet';
+    if (Array.isArray(scope.goals) && scope.goals.length === 0) return 'no goals are chosen for it yet — pick at least one below';
+    return null;
+  }
+
+  // buttonState — one device's button. Returns:
+  //   status   the words on the button's face that say what the device is doing
+  //            ('' when the face is just the action)
+  //   act      'run' | 'stop' | null — what a press does; null = it cannot be pressed
+  //   label    the action word shown on the button ('Run' | 'Stop' | '')
+  //   sub      the one line under the button
+  //   tone     'ok' | 'warn' | 'info' | 'neutral' — the dot's colour
+  //   busy     true while the face should show it is working on the press
+  //   alt      { act, label } | null — a second, small action (undo a Stop that
+  //            is still finishing a task)
+  //   stayOn   true when the card should carry the stay-on note: the device is
+  //            switched on, so whether it stays awake is what decides if it works
+  function buttonState(args = {}) {
+    const b = decideButton(args);
+    // Switched on (or about to stop after a task): the note is relevant. A
+    // device its builder stopped has nothing to stay awake for.
+    return { ...b, stayOn: ((args.runner || {}).run_requested !== false) || b.status === 'Stopping…' };
+  }
+
+  function decideButton({ runner, fence = null, nowMs = Date.now() } = {}) {
+    const r = runner || {};
+    const h = r.health || {};
+    const want = r.run_requested !== false;
+    const task = h.workingTaskId || null;
+    const quiet = h.state === 'dead' || h.state === 'never_seen' || (h.state === 'late' && !task);
+    const changed = ms(r.run_changed_at);
+    const seen = ms(r.last_seen_at);
+
+    if (!want) {
+      if (quiet) {
+        return { status: '', act: 'run', label: 'Run', tone: 'neutral', busy: false, alt: null,
+          sub: 'This device is off or asleep. Press Run and it starts when it is back on.' };
+      }
+      if (task) {
+        return { status: 'Stopping…', act: null, label: '', tone: 'info', busy: true, alt: { act: 'run', label: 'Keep it running' },
+          sub: `Finishing task ${task} first, then it stops.` };
+      }
+      return { status: '', act: 'run', label: 'Run', tone: 'neutral', busy: false, alt: null, sub: 'Stopped on this device.' };
+    }
+
+    // Switched on. Has the device picked the press up yet?
+    const pressedRecently = changed !== null && nowMs - changed < STARTING_MS;
+    if (pressedRecently && (seen === null || seen < changed)) {
+      return { status: 'Starting…', act: null, label: '', tone: 'info', busy: true, alt: null,
+        sub: 'The device picks this up in under a minute.' };
+    }
+
+    if (quiet) {
+      return { status: 'Device is off or asleep', act: 'stop', label: 'Stop', tone: 'warn', busy: false, alt: null,
+        sub: `No check-in for ${h.age || 'a while'}. Turn it on and sign in — it picks up by itself.` };
+    }
+
+    // A device that is building says so before anything else: whatever a setting
+    // now says, the task in its hands is the truth about this minute.
+    if (task) {
+      return { status: 'Running', act: 'stop', label: 'Stop', tone: 'ok', busy: false, alt: null, sub: `Working on task ${task}.` };
+    }
+
+    const hold = fenceHold(fence);
+    if (hold) {
+      return { status: 'Ready', act: 'stop', label: 'Stop', tone: 'warn', busy: false, alt: null,
+        sub: `It is on, but ${hold}.` };
+    }
+
+    if (h.state === 'idle_config') {
+      return { status: 'Ready', act: 'stop', label: 'Stop', tone: 'warn', busy: false, alt: null,
+        sub: `It is on, but idle because ${h.why || 'of a setting'}. ${h.remedy || ''}`.trim() };
+    }
+
+    // THE COOLDOWN, on the button. The runner said when it resumes (the reset of
+    // the Claude usage it is waiting on); the face carries that time and how
+    // long is left, and a press still stops it.
+    const until = ms(h.holdUntil);
+    if (until !== null && until > nowMs) {
+      const leftMs = until - nowMs;
+      return { status: `Resting until ${clock(until, nowMs)}`, act: 'stop', label: 'Stop', tone: 'info', busy: false, alt: null,
+        // A usage window is a week at most; a longer wait is not counted down.
+        countdown: leftMs < 8 * 24 * 3600 * 1000 ? countdown(leftMs) : '',
+        sub: 'Its Claude usage is spent for now. It starts again by itself at that time.' };
+    }
+
+    if (h.state === 'restarting') {
+      return { status: 'Updating…', act: 'stop', label: 'Stop', tone: 'info', busy: true, alt: null,
+        sub: 'Restarting to pick up new code. Back in a minute or two.' };
+    }
+
+    return { status: 'Running', act: 'stop', label: 'Stop', tone: 'ok', busy: false, alt: null, sub: 'On — waiting for work.' };
+  }
+
+  // The setup command for each platform. One line to copy: it fetches the first
+  // lines of setup from this project and runs them with the one-time code.
+  // Returns null when any part is missing or is not the shape it must be — a
+  // command with a hole in it is worse than no command, and these strings end up
+  // in a shell, so nothing outside the expected characters is ever placed in one.
+  //
+  // HTTPS ONLY. The line downloads a script from the project and runs it, so over
+  // plain http anyone on the network between the device and the project could
+  // swap that script for their own. The one exception is a project on this very
+  // machine (localhost, 127.0.0.1, a .localhost name), which is a developer's own
+  // instance and never leaves the device. scripts/bongos/autobongos-host.js
+  // cleanBase applies the same rule again when the code is traded.
+  const SECURE_BASE = /^https:\/\/[A-Za-z0-9.-]+(:\d+)?$/;
+  const LOCAL_BASE = /^http:\/\/(localhost|127\.0\.0\.1|[a-z0-9-]+\.localhost)(:\d+)?$/i;
+  function setupCommands({ apiBase, code, repoUrl } = {}) {
+    const base = String(apiBase || '').replace(/\/+$/, '');
+    if (!SECURE_BASE.test(base) && !LOCAL_BASE.test(base)) return null;
+    if (!/^abr_[0-9a-f]{16,128}$/.test(String(code || ''))) return null;
+    if (!/^https:\/\/[A-Za-z0-9.-]+\/[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(String(repoUrl || ''))) return null;
+    return {
+      windows: `& ([scriptblock]::Create((irm '${base}/api/bongos/autonomy/runner-setup.ps1'))) -Code '${code}' -ApiBase '${base}' -Repo '${repoUrl}'`,
+      mac: `curl -fsSL '${base}/api/bongos/autonomy/runner-setup.sh' | bash -s -- --code '${code}' --api-base '${base}' --repo '${repoUrl}'`,
+    };
+  }
+
+  // Which platform's command to show first, from the browser's own words.
+  function guessPlatform(userAgent) {
+    return /Mac OS X|Macintosh/i.test(String(userAgent || '')) ? 'mac' : 'windows';
+  }
+
+  const api = { STARTING_MS, buttonState, fenceHold, countdown, clock, setupCommands, guessPlatform };
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+  if (root) root.OTBRunnerButton = api;
+})(typeof window !== 'undefined' ? window : null);