breakaway 1.0.2-main.6 → 1.0.2-main.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakaway",
-  "version": "1.0.2-main.6",
+  "version": "1.0.2-main.8",
   "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/cli.js

@@ -7,6 +7,7 @@ import { CLI_PACKAGE } from './init.js';
 /** The subcommands each command knows. Without one, each lists or shows (horizon needs close). */
 export const SUBCOMMANDS = {
   agents: ['next', 'start', 'refine'],
+  github: ['fix', 'review'],
   repos: ['add', 'init', 'modify', 'remove', 'setup'],
   routines: ['add', 'modify', 'run', 'trigger', 'revoke', 'pause', 'resume'],
   horizon: ['close'],
@@ -18,7 +19,6 @@ export const NO_ARGUMENTS = new Set([
   'list',
   'next',
   'activity',
-  'github',
   'health',
   'connections',
   'export',
@@ -74,6 +74,45 @@ export function githubRequest(repo, { sync = false } = {}) {
   return ['GET', repo ? `github?repo=${encodeURIComponent(repo)}` : 'github', undefined];
 }
 
+/** What `github fix` accepts for --problem: the same three the pull request page offers. */
+export const FIX_PROBLEMS = ['conflicts', 'failing', 'review'];
+
+/**
+ * The request behind `npx breakaway github fix <n>` and `github review <n>` (BRK-81): the pull request page's "Fix with an
+ * agent" and "Safe to merge?" buttons (`POST github/pulls/<n>/fix` and `/review`). It names the checkout's repository
+ * like `github` does. Returns an error message instead when the number or `problem` can't be right.
+ * @param {'fix' | 'review'} action
+ * @param {string | number | undefined} number
+ * @param {{ repo?: string | null, problem?: string, note?: string }} [options]
+ * @returns {{ error?: string, request?: [string, string, Record<string, string>] }}
+ */
+export function pullAgentRequest(action, number, { repo = null, problem, note } = {}) {
+  const n = String(number ?? '').replace(/^#/u, '');
+  if (!/^[1-9]\d{0,8}$/u.test(n)) return { error: `say which pull request: npx breakaway github ${action} <number>` };
+  if (problem !== undefined && action !== 'fix') return { error: '--problem is for github fix' };
+  if (problem !== undefined && !FIX_PROBLEMS.includes(problem))
+    return { error: `--problem is ${FIX_PROBLEMS.join(', ')}` };
+  const body = {
+    ...(repo ? { repo } : {}),
+    ...(problem ? { problem } : {}),
+    ...(typeof note === 'string' && note.trim() ? { note } : {}),
+  };
+  return { request: ['POST', `github/pulls/${n}/${action}`, body] };
+}
+
+/**
+ * What the CLI says about an answer to those requests: which task and agent took the pull request, or who already has it.
+ * @param {'fix' | 'review'} action
+ * @param {string | number} number
+ * @param {{ task: { wid?: string, short?: string }, run?: { url?: string, agent?: string } | null, already?: string | null }} answer
+ */
+export function pullAgentSummary(action, number, { task, run, already }) {
+  const id = task.wid ?? task.short;
+  if (!run) return `${id} already has it: ${already}.`;
+  const what = action === 'fix' ? `fixing #${number}` : `testing #${number}`;
+  return `Started ${run.agent ? `${run.agent}, ` : 'an agent '}${what} on ${id}${run.url ? `: ${run.url}` : ''}`;
+}
+
 /**
  * The task an idea becomes (`npx breakaway idea`): its first line, kept short, as the title, and the whole text as its
  * description. Like `add`, it lands in the repository of the checkout it was written in (BRK-71): without one, the

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,11 +40,18 @@ 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';
-import { githubRequest, ideaTask, staleCliWarning, unknownSubcommand } from './tasks/cli.js';
+import {
+  githubRequest,
+  ideaTask,
+  pullAgentRequest,
+  pullAgentSummary,
+  staleCliWarning,
+  unknownSubcommand,
+} from './tasks/cli.js';
 import { CLI_VERSION } from '../src/cli-version.js';
 import { LEGACY, parseInstall, secretName } from '../src/install.js';
 import {
@@ -143,6 +150,8 @@ Reading                (list, next, claim, and add work in this checkout's repos
   routines               saved prompts the owner runs with a button, and their caps
   routines run <slug>    run one now: makes a RUN task and starts an agent on it  [--note <text>]
   horizon close          close now: finished tasks go to the archive, next becomes now, later becomes next  [--dry-run]
+  github fix <n>         start an agent on a pull request's conflicts, failing checks, or review comments (owner)  [--problem conflicts|failing|review] [--note <text>] [--repo <slug>]
+  github review <n>      start an agent that tests a Dependabot pull request, as Safe to merge? does (owner)  [--note <text>] [--repo <slug>]
   github                 the checkout's repository on GitHub: open pull requests, checks, reviews, CI, deploys, alerts  [--sync] [--repo <slug>]
   hook session|wait      the Claude Code session hooks a repository's .claude/settings.json runs (npx breakaway hook session)
   health                 the server's state
@@ -517,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');
@@ -1188,6 +1211,18 @@ const commands = {
     );
   },
   async github() {
+    const action = args[0];
+    if (action === 'fix' || action === 'review') {
+      const built = pullAgentRequest(action, args[1], {
+        repo: (await checkoutRepo()).slug,
+        problem: opts.problem,
+        note: opts.note,
+      });
+      if (built.error || !built.request) fail(built.error ?? 'bad request');
+      const answer = await call(...built.request);
+      print(answer, (a) => pullAgentSummary(action, args[1].replace(/^#/u, ''), a));
+      return;
+    }
     const g = await call(...githubRequest((await checkoutRepo()).slug, { sync: Boolean(opts.sync) }));
     print(g, (d) => {
       if (!d.connected) return "GitHub isn't connected yet: open the GitHub view on the board (docs/tasks.md#github).";
@@ -1938,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 = 38;
-export const CLI_FINGERPRINT = 'e5cf577cb5354653';
+export const CLI_VERSION = 40;
+export const CLI_FINGERPRINT = '37624c98bbeb5108';