breakaway 1.0.2-main.7 → 1.0.2-main.9

package/README.md

@@ -171,7 +171,7 @@ pnpm interop    # checks sync against real Taskwarrior 3
 
 breakaway publishes releases and never deploys an install. Every install, the owner's included, deploys a release from its own repository, and this repository holds no Cloudflare credentials. Its website follows the latest stable release: the release moves the `site` branch, and Cloudflare deploys it ([`site/README.md`](https://github.com/TheAnarchoX/breakaway/blob/main/site/README.md#deploy-it)).
 
-- **Every merge to `main`**, once CI passes, publishes a GitHub pre-release `vX.Y.Z-main.N` on the `main` channel. It carries the bundle (`breakaway-bundle.tar.gz`: the Worker's files and the web app's `dist`), a `manifest.json` (version, channel, commit, `manual`, and the lowest version it updates from), and `SHA256SUMS`. The notes list the merged pull requests by title.
+- **Every merge to `main`**, once CI passes, publishes a GitHub pre-release `vX.Y.Z-main.N` on the `main` channel. It carries the bundle (`breakaway-bundle.tar.gz`: the Worker's files and the web app's `dist`), a `manifest.json` (version, channel, commit, `manual`, and the lowest version it updates from), its signature `manifest.json.sig` (Ed25519, made with a key only the release workflow holds; the public key is `src/release-key.js`), and `SHA256SUMS`. The notes list the merged pull requests by title.
 - **A stable release** `vX.Y.Z` is the owner's: they run the **Release** workflow with the pre-release to promote. The bundle is that pre-release's, unchanged, and the notes cover everything since the last stable.
 - **The CLI** is on npm as [`breakaway`](https://www.npmjs.com/package/breakaway), staged on npm by the same workflow, with provenance, and live once the owner approves it there with 2FA. npm's trusted publishing can't yet read the OIDC identity of a repository as new as this one ([npm/cli#9969](https://github.com/npm/cli/issues/9969)), so until it can, a token that can stage but never publish by itself stands in, in an environment only `main` can use. Every pre-release goes out under the `next` dist-tag, and a stable release as `latest`. `npx breakaway <command>` is `node scripts/tasks.mjs <command>`.
 - **A major release** is one where an install has to do something by hand: a config or binding change, a Durable Object class or migration, a route or cron. Its notes have a **Manual steps** section and its manifest says `manual: true`, which an install's deploy stops on. A change that needs it sets `manual` and `manualSteps` in `release.json`, and the pull request that ships the steps clears them. Data the Durable Object stores changes forward-only and additively, so an install can always go back one release.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakaway",
-  "version": "1.0.2-main.7",
+  "version": "1.0.2-main.9",
   "description": "The task board for you and your coding agents: a Cloudflare Worker, its web app, Taskwarrior sync, and the CLI (npx breakaway).",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/scripts/tasks/message-wait.mjs

@@ -17,7 +17,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { boardConfig, claimedTask, projectRoot } from './hook-config.js';
-import { routeThroughSessionProxy } from './proxy.js';
+import { sessionRequest } from './proxy.js';
 import { waitForMessages } from './session-messages.js';
 
 async function main() {
@@ -43,9 +43,9 @@ async function main() {
   const { base, headers } = boardConfig(root);
   if (!base) return;
   const url = `${base}/api/tasks/${encodeURIComponent(claim.uuid)}/messages/waiting?agent=${encodeURIComponent(claim.agent)}`;
-  routeThroughSessionProxy();
+  // Through curl in a cloud session, so it works on whichever Node runs hooks there (BRK-86).
   const ask = async () => {
-    const res = await fetch(url, { headers, signal: AbortSignal.timeout(10_000) });
+    const res = await sessionRequest(url, { headers, timeoutMs: 10_000 });
     return res.ok ? res.json() : null;
   };
 

package/scripts/tasks/proxy.js

@@ -7,7 +7,11 @@
  * routeThroughSessionProxy() sends fetch through the proxy and trusts the system's CA store too, which
  * holds the proxy's certificate. Without a proxy in the environment it does nothing.
  */
+import { spawn } from 'node:child_process';
+import { readFileSync, rmSync, writeFileSync } from 'node:fs';
 import http from 'node:http';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import tls from 'node:tls';
 
 export function sessionProxy(env = process.env) {
@@ -25,3 +29,89 @@ export function routeThroughSessionProxy(env = process.env) {
   }
   return true;
 }
+
+/** Runs `command` with `args`, `input` on stdin, and resolves with stdout; rejects with stderr when it fails. */
+function runWithInput(command, args, input) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+    let out = '';
+    let err = '';
+    child.stdout.on('data', (d) => {
+      out += d;
+    });
+    child.stderr.on('data', (d) => {
+      err += d;
+    });
+    child.on('error', reject);
+    child.on('close', (code) =>
+      code === 0 ? resolve(out) : reject(Object.assign(new Error(err.trim() || `${command} exited ${code}`), { code })),
+    );
+    child.stdin.end(input ?? '');
+  });
+}
+
+/**
+ * A hook's request to the board (BRK-86). Claude Code runs hooks with the image's default Node, which in a cloud session
+ * can be too old to send fetch through the session proxy (Node 20 has neither http.setGlobalProxyFromEnv nor the CA
+ * calls above), and the sandbox refuses a request that goes around it. So with a proxy the request goes through curl,
+ * which reads HTTPS_PROXY and the system's certificates on any Node; without curl, or without a proxy, through fetch.
+ * Answers like fetch's response: { ok, status, json() }.
+ * @param {string} url
+ * @param {{ method?: string, headers?: Record<string, string>, body?: string, timeoutMs?: number }} [request]
+ */
+export async function sessionRequest(
+  url,
+  { method = 'GET', headers = {}, body, timeoutMs = 4000 } = {},
+  { env = process.env, run = runWithInput, fetch = globalThis.fetch } = {},
+) {
+  if (sessionProxy(env)) {
+    const args = ['-sS', '--max-time', String(Math.max(1, Math.ceil(timeoutMs / 1000))), '-X', method];
+    for (const [name, value] of Object.entries(headers)) args.push('-H', `${name}: ${value}`);
+    if (body !== undefined) args.push('--data-binary', '@-');
+    args.push('-w', '\n%{http_code}', url);
+    try {
+      const out = await run('curl', args, body);
+      const at = out.lastIndexOf('\n');
+      const status = Number(out.slice(at + 1));
+      const text = out.slice(0, Math.max(0, at));
+      return { ok: status >= 200 && status < 300, status, json: async () => (text.trim() ? JSON.parse(text) : null) };
+    } catch (error) {
+      if (/** @type {any} */ (error)?.code !== 'ENOENT') throw error;
+      // No curl here: fetch, through the proxy if this Node can.
+    }
+  }
+  routeThroughSessionProxy(env);
+  return fetch(url, { method, headers, body, signal: AbortSignal.timeout(timeoutMs) });
+}
+
+/**
+ * Where a hook notes why it couldn't post for a task (BRK-86): the system's temp folder, never the repository, where a
+ * cloud session's Stop check would take a new file as work to commit. The CLI shows it on its next command here.
+ */
+const failurePath = (uuid, dir) => join(dir, `breakaway-hook-${String(uuid).replace(/[^\w-]/gu, '')}.json`);
+
+/** Records that the hook couldn't post for task `uuid`, and why. */
+export function noteHookFailure(uuid, reason, dir = tmpdir(), at = new Date()) {
+  try {
+    writeFileSync(
+      failurePath(uuid, dir),
+      `${JSON.stringify({ at: at.toISOString(), reason: String(reason).slice(0, 300) })}\n`,
+    );
+  } catch {
+    /* nowhere to note it */
+  }
+}
+
+/** Clears that note, after a post that went through. */
+export function clearHookFailure(uuid, dir = tmpdir()) {
+  rmSync(failurePath(uuid, dir), { force: true });
+}
+
+/** The hook's last failure for task `uuid`, or null. */
+export function hookFailure(uuid, dir = tmpdir()) {
+  try {
+    return JSON.parse(readFileSync(failurePath(uuid, dir), 'utf8'));
+  } catch {
+    return null;
+  }
+}

package/scripts/tasks/session-hook.mjs

@@ -7,10 +7,11 @@
  * additionalContext so Claude gets them on its next turn (docs/specs/IDEA-15-message-a-running-agent.md).
  *
  * Quiet by design: without a claimed task (.task-session, written by `tasks claim`), with
- * BREAKAWAY_SESSION_LOG=off (or SAMEWAVE_TASKS_SESSION_LOG=off), or on any error, it does nothing and exits 0.
+ * BREAKAWAY_SESSION_LOG=off (or SAMEWAVE_TASKS_SESSION_LOG=off), or on any error, it does nothing and exits 0. A post
+ * that fails leaves its reason in the temp folder, which the CLI's next command here shows (BRK-86).
  */
 import { boardConfig, claimedTask, projectRoot } from './hook-config.js';
-import { routeThroughSessionProxy } from './proxy.js';
+import { clearHookFailure, noteHookFailure, sessionRequest } from './proxy.js';
 import { entryFor } from './session-log.js';
 import { CONTEXT_EVENTS, messageOutput } from './session-messages.js';
 
@@ -26,22 +27,28 @@ async function main() {
   if (!entry) return;
 
   const { base, headers } = boardConfig(root);
-  if (!base) return;
-  routeThroughSessionProxy();
-  const res = await fetch(`${base}/api/tasks/${encodeURIComponent(claim.uuid)}/session`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...headers },
-    body: JSON.stringify({
-      agent: claim.agent,
-      session: hook.session_id ?? null,
-      remote: process.env.CLAUDE_CODE_REMOTE === 'true',
-      entries: [entry],
-      // A Stop hook's output can't reach Claude, so it leaves the messages for the next event.
-      messages: CONTEXT_EVENTS.has(hook.hook_event_name),
-    }),
-    signal: AbortSignal.timeout(4000),
-  });
-  if (!res.ok) return;
+  if (!base) return noteHookFailure(claim.uuid, 'no board address: set BREAKAWAY_URL');
+  let res;
+  try {
+    // Through curl in a cloud session, so it works on whichever Node runs hooks there (BRK-86).
+    res = await sessionRequest(`${base}/api/tasks/${encodeURIComponent(claim.uuid)}/session`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...headers },
+      body: JSON.stringify({
+        agent: claim.agent,
+        session: hook.session_id ?? null,
+        remote: process.env.CLAUDE_CODE_REMOTE === 'true',
+        entries: [entry],
+        // A Stop hook's output can't reach Claude, so it leaves the messages for the next event.
+        messages: CONTEXT_EVENTS.has(hook.hook_event_name),
+      }),
+      timeoutMs: 4000,
+    });
+  } catch (error) {
+    return noteHookFailure(claim.uuid, /** @type {Error} */ (error)?.message ?? String(error));
+  }
+  if (!res.ok) return noteHookFailure(claim.uuid, `HTTP ${res.status}`);
+  clearHookFailure(claim.uuid);
   const output = messageOutput(await res.json(), hook.hook_event_name);
   if (output) process.stdout.write(`${JSON.stringify(output)}\n`);
 }

package/scripts/tasks.mjs

@@ -40,7 +40,7 @@ import {
 } from './tasks/structure.js';
 import { looksLikeSecret } from '../src/ping.js';
 import { promptPathOf } from '../src/repos.js';
-import { sessionProxy, routeThroughSessionProxy } from './tasks/proxy.js';
+import { hookFailure, sessionProxy, routeThroughSessionProxy } from './tasks/proxy.js';
 import { githubFromRemote, inRepo, pickRepo } from './tasks/repo.js';
 import { NO_TERMINAL, ask as askIn } from './tasks/ask.js';
 import { CLI_PACKAGE, PROMPT_SECTIONS, initPlan, machineTaskrc, promptSections } from './tasks/init.js';
@@ -526,6 +526,20 @@ async function startSessionLog(t) {
     );
 }
 
+/** The session hook couldn't post this checkout's live output: say so where the agent and the owner see it (BRK-86). */
+function warnHookFailure() {
+  try {
+    const claim = JSON.parse(readFileSync(join(REPO, '.task-session'), 'utf8'));
+    const failed = claim?.uuid && hookFailure(claim.uuid);
+    if (failed)
+      console.error(
+        `tasks: the session hook couldn't post ${claim.wid ?? 'this task'}'s live output (${failed.reason}, ${failed.at.slice(0, 16).replace('T', ' ')} UTC), so the board shows none. docs/tasks.md#cloud-agents says what to check.`,
+      );
+  } catch {
+    /* no claim here */
+  }
+}
+
 function unmarkSession(t) {
   try {
     const path = join(REPO, '.task-session');
@@ -1959,5 +1973,6 @@ if (opts.help || command === 'help') {
 } else if (unknownSubcommand(command, args[0])) {
   fail(unknownSubcommand(command, args[0]));
 } else {
+  if (command !== 'hook') warnHookFailure();
   await commands[command]();
 }

package/src/cli-version.js

@@ -5,5 +5,5 @@
  * bump CLI_VERSION and set CLI_FINGERPRINT to the value it prints. Constants only: the board's Worker imports it,
  * so it lives in the board's package (CLD-135) and the CLI imports it from here.
  */
-export const CLI_VERSION = 39;
-export const CLI_FINGERPRINT = '15250a95aca206af';
+export const CLI_VERSION = 40;
+export const CLI_FINGERPRINT = '37624c98bbeb5108';