opencode-harness-kit 0.5.3 → 0.5.5

package/src/tasks.js

@@ -195,6 +195,12 @@ export const isBlocked = (t) => t.status === "blocked"
  * and its output became one string, and the driver handed that string to a
  * shell. A separate field cannot be mistaken for a command.
  *
+ * The writes happen in ONE order, and the order is part of the contract: the
+ * previous output is removed first, then the status is written, then the new
+ * output is written. A field line ends the output block, so a status line
+ * written before the old output was removed cut that block in half - and the
+ * half that survived was folded into the status by the parser.
+ *
  * @param {string} text
  * @param {Task} task
  * @param {{ status: string, verifyOutput?: string }} outcome
@@ -202,46 +208,100 @@ export const isBlocked = (t) => t.status === "blocked"
  */
 export function markTask(text, task, { status, verifyOutput }) {
   const lines = String(text).split("\n")
-  const boxLine = lines[task.start] ?? ""
+  // The lines of the task as they are RIGHT NOW.
+  //
+  // Every edit below moves the lines under it, so the range of the task is
+  // tracked here. The task the caller parsed was parsed before any of these
+  // edits, so its `end` goes stale as soon as one of them lands.
+  const range = { start: task.start, end: task.end }
+
+  const boxLine = lines[range.start] ?? ""
   // The indentation is part of the document: a task nested under a heading
   // keeps its nesting when it is marked.
-  lines[task.start] = boxLine.replace(
+  lines[range.start] = boxLine.replace(
     /^(\s*)-\s*\[[ xX]\]/,
     (_match, indent) => `${indent}- ${status === "done" ? "[x]" : "[ ]"}`,
   )
 
-  let statusLine = -1
-  for (let i = task.start; i <= task.end + 1 && i < lines.length; i++) {
-    const f = lines[i]?.match(fieldRe)
-    if (f && f[1] === "status") {
-      statusLine = i
-      break
+  // The PREVIOUS output is removed FIRST, before anything else is written
+  // into the task.
+  //
+  // A task that is marked twice keeps one output block, not two.
+  //
+  // It used to be removed after the status line had been written. The
+  // status line is a field line, and a field line ends the output block, so
+  // the removal took the FIRST line of the old output and left its wrapped
+  // lines behind. The parser folds a wrapped line back into the field above
+  // it, so those leftovers were folded into the status - and the status read
+  // back as "done old line 2 old line 3" instead of "done". The task was not
+  // done; it was done with a story attached.
+  if (verifyOutput) {
+    const previous = outputBlock(lines, range)
+    if (previous) {
+      const removed = previous.end - previous.start + 1
+      lines.splice(previous.start, removed)
+      if (previous.end <= range.end) range.end -= removed
     }
   }
-  if (statusLine >= 0) lines[statusLine] = lines[statusLine].replace(
-    /(\s-\s+status\s*:).*$/,
-    `$1 ${status}`,
-  )
 
-  if (verifyOutput) {
-    // A task that is marked twice keeps one output block, not two.
-    const previous = outputBlock(lines, task)
-    if (previous) lines.splice(previous.start, previous.end - previous.start + 1)
+  const statusLine = fieldLine(lines, range, "status")
+  if (statusLine >= 0) {
+    lines[statusLine] = lines[statusLine].replace(
+      /(\s-\s+status\s*:).*$/,
+      `$1 ${status}`,
+    )
+  } else {
+    // A task with no `status:` field had the status EVAPORATE.
+    //
+    // The status was only ever written into a status line that already
+    // existed, so a task marked blocked without one kept its unticked box
+    // and nothing else. The parser reads the status back from that box, so
+    // the block became "pending" - and `nextPending()` offered the blocked
+    // work again. The driver contract says blocked work is never retried.
+    //
+    // The status line is written where the other fields are, so the parser
+    // reads it back the way it reads them - and AFTER the whole block of
+    // the last field, not after the field line itself.
+    //
+    // Written after the field line, the status line landed INSIDE the block
+    // of a field that has wrapped lines under it: the output field, once the
+    // driver has run the task. The parser folded the wrapped lines into the
+    // status, so it read back as "blocked continued", the block was gone,
+    // and the blocked work was offered again.
+    const block = lastFieldBlock(lines, range)
+    const indent = fieldIndent(lines, range, block.field)
+    lines.splice(block.end + 1, 0, `${indent}- status: ${status}`)
+    range.end += 1
+  }
 
-    const verifyLine = fieldLine(lines, task, "verify")
-    const anchor = verifyLine >= 0 ? verifyLine : lastFieldLine(lines, task)
-    const source = lines[anchor] ?? lines[task.start] ?? ""
+  if (verifyOutput) {
+    // The output goes into its own `output:` field rather than under the
+    // `verify:` line. It used to be written as continuation lines under
+    // `verify:`, and the parser folded a continuation back into the field
+    // above it - so the command and its output became one string, and the
+    // driver handed that string to a shell. A separate field cannot be
+    // mistaken for a command.
+    //
+    // It is written after the whole block of the `verify:` field, so it
+    // cannot land inside that block either - a wrapped line under the
+    // verify field would be folded into the output above it.
+    const verifyAt = fieldLine(lines, range, "verify")
+    const block =
+      verifyAt >= 0
+        ? { field: verifyAt, end: fieldBlockEnd(lines, range, verifyAt) }
+        : lastFieldBlock(lines, range)
     // The field line sits at the same level as the field it belongs to; only
     // the continuation lines under it are indented deeper.
-    const fieldIndent = (source.match(/^\s*/) ?? [""])[0]
-    const contIndent = `${fieldIndent}  `
+    const indent = fieldIndent(lines, range, block.field)
+    const contIndent = `${indent}  `
     const quoted = String(verifyOutput)
       .trimEnd()
       .split("\n")
       .map((l) => `${contIndent}${l}`)
     // The first line rides on the field, the rest are continuations of it.
-    const block = [`${fieldIndent}- output: ${quoted[0].trim()}`, ...quoted.slice(1)]
-    lines.splice(anchor + 1, 0, ...block)
+    const written = [`${indent}- output: ${quoted[0].trim()}`, ...quoted.slice(1)]
+    lines.splice(block.end + 1, 0, ...written)
+    range.end += written.length
   }
 
   return lines.join("\n")
@@ -249,46 +309,139 @@ export function markTask(text, task, { status, verifyOutput }) {
 
 /**
  * The line a named field sits on, or -1.
+ *
+ * The scan stops at a task line or a heading: the fields under a nested
+ * task belong to that task, not to the one above it.
+ *
  * @param {string[]} lines
- * @param {Task} task
+ * @param {{ start: number, end: number }} range
  * @param {string} name
  * @returns {number}
  */
-function fieldLine(lines, task, name) {
-  for (let i = task.start; i <= task.end + 1 && i < lines.length; i++) {
-    const f = lines[i]?.match(fieldRe)
+function fieldLine(lines, range, name) {
+  // The scan starts below the task's own line: that line is the task, not
+  // one of its fields.
+  for (let i = range.start + 1; i <= range.end + 1 && i < lines.length; i++) {
+    const line = lines[i] ?? ""
+    if (taskRe.test(line) || headingRe.test(line)) break
+    const f = line.match(fieldRe)
     if (f && f[1] === name) return i
   }
   return -1
 }
 
 /**
- * The last field line of a task, or the task's own line when it has none.
+ * The last line of a field's block: the field line plus the lines wrapped
+ * under it.
+ *
+ * A field line is where a field is written, but it is not the end of the
+ * field: the parser folds a wrapped line back into the value above it, so
+ * the end of the block is the end of the value as the parser reads it. A
+ * field written inside that block takes the wrapped lines with it.
+ *
  * @param {string[]} lines
- * @param {Task} task
+ * @param {{ start: number, end: number }} range
+ * @param {number} fieldAt the line the field is written on
  * @returns {number}
  */
-function lastFieldLine(lines, task) {
-  let last = task.start
-  for (let i = task.start; i <= task.end + 1 && i < lines.length; i++) {
-    if (fieldRe.test(lines[i] ?? "")) last = i
+function fieldBlockEnd(lines, range, fieldAt) {
+  let end = fieldAt
+  for (let i = fieldAt + 1; i <= range.end + 1 && i < lines.length; i++) {
+    const line = lines[i] ?? ""
+    // A task, a heading or the next field ends the block.
+    if (taskRe.test(line) || headingRe.test(line)) break
+    if (fieldRe.test(line)) break
+    // A blank line is not part of the value, but it does not end the block
+    // either: the parser skips it and folds the wrapped line under it back
+    // into the field.
+    if (!line.trim()) continue
+    // A line that is not indented deeper is not a wrapped line.
+    if (!/^\s{4,}\S/.test(line)) break
+    end = i
+  }
+  return end
+}
+
+/**
+ * The last field of a task: the line it is written on, and the last line of
+ * its block.
+ *
+ * `field` is -1 when the task has no field of its own, and `end` is then
+ * the task's own line - the place a first field is written.
+ *
+ * @param {string[]} lines
+ * @param {{ start: number, end: number }} range
+ * @returns {{ field: number, end: number }}
+ */
+function lastFieldBlock(lines, range) {
+  let field = -1
+  // The scan starts below the task's own line: that line is the task, not
+  // one of its fields.
+  for (let i = range.start + 1; i <= range.end + 1 && i < lines.length; i++) {
+    const line = lines[i] ?? ""
+    if (taskRe.test(line) || headingRe.test(line)) break
+    if (fieldRe.test(line)) field = i
   }
-  return last
+  if (field < 0) return { field: -1, end: range.start }
+  return { field, end: fieldBlockEnd(lines, range, field) }
+}
+
+/**
+ * The indentation a field line of a task is written with.
+ *
+ * The fields of a task sit one level deeper than the task itself, so a
+ * field inserted into a task that has none yet follows that convention: a
+ * field at the task's own level reads as a task of its own, or as prose the
+ * parser skips.
+ *
+ * @param {string[]} lines
+ * @param {{ start: number, end: number }} range
+ * @param {number} fieldAt the line the field is written on, or -1 when the
+ *   task has no field of its own yet
+ * @returns {string}
+ */
+function fieldIndent(lines, range, fieldAt) {
+  const source = lines[fieldAt >= 0 ? fieldAt : range.start] ?? ""
+  const own = (source.match(/^\s*/) ?? [""])[0]
+  if (fieldAt < 0) return `${own}  `
+  return own
 }
 
 /**
  * The lines a task's `output:` field occupies, or null when it has none.
+ *
+ * The block ends at the first line that is NOT part of the output - and a
+ * task line or a heading is never part of it, however deeply it is indented.
+ *
+ * The indentation heuristic alone said otherwise: a nested task indented
+ * four spaces or more looked like a continuation of the output above it, so
+ * the block swallowed it and the rewrite DELETED it. The file's own header
+ * promises that every byte the loop does not own survives a rewrite, and a
+ * task the loop never owned was destroyed by marking the task above it.
+ *
+ * A blank line at the end of the block is not part of it: it belongs to the
+ * file, not to the output, and the rewrite must not swallow it.
+ *
  * @param {string[]} lines
- * @param {Task} task
+ * @param {{ start: number, end: number }} range
  * @returns {{ start: number, end: number } | null}
  */
-function outputBlock(lines, task) {
-  const start = fieldLine(lines, task, "output")
+function outputBlock(lines, range) {
+  const start = fieldLine(lines, range, "output")
   if (start < 0) return null
   let end = start
-  for (let i = start + 1; i <= task.end + 1 && i < lines.length; i++) {
-    if (fieldRe.test(lines[i] ?? "")) break
-    if (lines[i].trim() && !/^\s{4,}\S/.test(lines[i])) break
+  for (let i = start + 1; i <= range.end + 1 && i < lines.length; i++) {
+    const line = lines[i] ?? ""
+    // A task or a heading ends the block. This is checked BEFORE the
+    // indentation heuristic, because a nested task is indented deeper than
+    // the field it sits under - that is what nesting means here.
+    if (taskRe.test(line) || headingRe.test(line)) break
+    if (fieldRe.test(line)) break
+    // A blank line is not part of the output, but it does not end the block
+    // either: the parser skips it and folds the wrapped line under it back
+    // into the output.
+    if (!line.trim()) continue
+    if (!/^\s{4,}\S/.test(line)) break
     end = i
   }
   return { start, end }

package/src/telemetry-store.ts

@@ -11,7 +11,7 @@
 //
 // The file is a JSONL in the project, gitignored, and never a network call.
 
-import { appendFileSync, existsSync, mkdirSync, statSync, renameSync } from "node:fs"
+import { appendFileSync, existsSync, mkdirSync, rmSync, statSync, renameSync } from "node:fs"
 import { join } from "node:path"
 
 /** Rotate above this, so a long-running project cannot fill its disk. */
@@ -33,10 +33,33 @@ export function logFiles(dir: string): string[] {
   return out
 }
 
-/** Rotate by size so a long-running project cannot fill its disk. */
-function rotate(file: string) {
+/**
+ * Rotate by size so a long-running project cannot fill its disk.
+ *
+ * THREE generations are kept: the current file, `.1` and `.2`. The reader
+ * enumerates all three, so the writer has to produce all three.
+ *
+ * The rotation used to rename the current file straight to `.1`, and a
+ * rename REPLACES the destination on POSIX - so the previous generation was
+ * destroyed on every rotation and `.2` never came into existence. Two
+ * rotations after the fact, the oldest history was gone and the third
+ * generation the reader looks for was missing: the history a project lost
+ * was lost on a schedule nobody was watching.
+ *
+ * So the oldest is shifted out of the way first, and the oldest of the
+ * three is dropped - the disk use stays bounded at three files, and the
+ * generation that is dropped is the one that was already two rotations
+ * old.
+ *
+ * @param file the file to rotate
+ * @param maxBytes the size above which it is rotated
+ */
+export function rotate(file: string, maxBytes: number = MAX_BYTES) {
   try {
-    if (existsSync(file) && statSync(file).size > MAX_BYTES) {
+    if (existsSync(file) && statSync(file).size > maxBytes) {
+      const oldest = `${file}.2`
+      if (existsSync(oldest)) rmSync(oldest, { force: true })
+      if (existsSync(`${file}.1`)) renameSync(`${file}.1`, oldest)
       renameSync(file, `${file}.1`)
     }
   } catch {

package/src/trust.js

@@ -32,6 +32,12 @@ import { fileURLToPath } from "node:url"
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..")
 
+/** How long the two-factor wait polls for an answer. */
+const POLL_MS = 5000
+
+/** The window the two-factor wait is allowed to take, in seconds. */
+const DEFAULT_WAIT_SECONDS = 600
+
 /** @param {string} s */
 const bold = (s) => `\x1b[1m${s}\x1b[0m`
 /** @param {string} s */
@@ -52,12 +58,20 @@ const dim = (s) => `\x1b[2m${s}\x1b[0m`
  * that form - and getting it wrong is one of the ways a configuration ends up
  * not matching.
  *
+ * Every form git and npm both accept is read here: an https URL, an ssh URL,
+ * and the `github:owner/repo` shorthand npm itself understands. A trailing
+ * slash does not make a different repository either, and it used to throw on
+ * one - so a package whose `repository` field ended in a slash could not be
+ * set up at all, and the failure was a stack trace rather than a sentence.
+ *
  * @param {any} repository
  * @returns {string}
  */
 export function repoOf(repository) {
   const url = typeof repository === "string" ? repository : repository?.url ?? ""
-  const m = url.match(/github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?$/)
+  const m =
+    url.match(/github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?\/?$/) ??
+    url.match(/^github:([^/]+)\/([^/]+?)(?:\.git)?\/?$/)
   if (!m) throw new Error(`cannot read a GitHub repository out of ${JSON.stringify(repository)}`)
   return `${m[1]}/${m[2]}`
 }
@@ -163,8 +177,15 @@ async function npmWithOtp(args, state = {}) {
   // JSON body. Without this flag the create cannot be completed at all, and
   // the failure says nothing about why.
   const withJson = args.includes("--json") ? [] : ["--json"]
-  const userOtp = state.otp ? [`--otp=${state.otp}`] : []
-  let result = npmCaptured([...args, ...withJson], userOtp)
+  // The call is made WITHOUT a code first.
+  //
+  // npm sends a code with the request that was CHALLENGED, and the code used
+  // to be attached to every call in the chain instead. So a code was spent on
+  // a call that never needed it, and the call that DID need it got a fresh
+  // challenge - which the tool then answered with another browser flow. The
+  // chain was: challenge, spend the code, challenge again, spend it again,
+  // and one browser tab per challenge.
+  let result = npmCaptured([...args, ...withJson])
   if (result.code === 0) return result
 
   // The URLs come FROM the body, not from a guess. Guessing the done URL
@@ -172,51 +193,86 @@ async function npmWithOtp(args, state = {}) {
   // answers "forbidden" - which is not a token, so the wait runs its full
   // length and then reports that nobody answered.
   const done = /"doneUrl"\s*:\s*"([^"]+)"/.exec(result.out)
-  if (!done) return result
-  const doneUrl = done[1]
-  const auth = /"authUrl"\s*:\s*"([^"]+)"/.exec(result.out)
-  const authId = /authId=([a-f0-9-]+)/.exec(doneUrl)
-  const authUrl = auth ? auth[1] : `https://www.npmjs.com/auth/cli/${authId?.[1] ?? ""}`
+  if (done) {
+    const doneUrl = done[1]
+    const auth = /"authUrl"\s*:\s*"([^"]+)"/.exec(result.out)
+    const authId = /authId=([a-f0-9-]+)/.exec(doneUrl)
+    const authUrl = auth ? auth[1] : `https://www.npmjs.com/auth/cli/${authId?.[1] ?? ""}`
 
-  // Open it if this machine can. The URL is printed either way, because a
-  // browser that cannot be opened here can be opened anywhere.
-  //
-  // OC_TRUST_NO_BROWSER turns the opening off, which is what a test needs:
-  // a test that opens a browser on the machine it runs on is a test that
-  // breaks whatever the person at the keyboard was doing.
-  let opened = false
-  if (!process.env.OC_TRUST_NO_BROWSER) {
-    opened = openBrowser(authUrl)
-  }
-  console.error("")
-  console.error(bold("  npm needs to confirm it is you."))
-  console.error(`  ${authUrl}`)
-  console.error(dim("  Answer there however your npm account is set up - an authenticator"))
-  console.error(dim("  app, a security key, or a code sent to your email."))
-  // Saying the page is open when it is not sends the person looking for a
-  // browser window that was never opened.
-  console.error(
-    dim(
-      opened
-        ? "  This page is open in a browser, or copy the URL above."
-        : "  Open this page in a browser: the URL above is the way in.",
-    ),
-  )
-  console.error("")
+    // Open it if this machine can. The URL is printed either way, because a
+    // browser that cannot be opened here can be opened anywhere.
+    //
+    // OC_TRUST_NO_BROWSER turns the opening off, which is what a test needs:
+    // a test that opens a browser on the machine it runs on is a test that
+    // breaks whatever the person at the keyboard was doing.
+    let opened = false
+    if (!process.env.OC_TRUST_NO_BROWSER) {
+      opened = openBrowser(authUrl)
+    }
+    console.error("")
+    console.error(bold("  npm needs to confirm it is you."))
+    console.error(`  ${authUrl}`)
+    console.error(dim("  Answer there however your npm account is set up - an authenticator"))
+    console.error(dim("  app, a security key, or a code sent to your email."))
+    // Saying the page is open when it is not sends the person looking for a
+    // browser window that was never opened.
+    console.error(
+      dim(
+        opened
+          ? "  This page is open in a browser, or copy the URL above."
+          : "  Open this page in a browser: the URL above is the way in.",
+      ),
+    )
+    console.error("")
 
-  const token = await waitForToken(doneUrl)
-  if (!token) {
-    console.error(red("  no answer came back, so nothing was changed."))
+    const token = await waitForToken(doneUrl)
+    if (!token) {
+      console.error(
+        red(`  no answer came back within ${waitSeconds()}s, so nothing was changed.`),
+      )
+      return result
+    }
+    // The code is used for THIS call only.
+    result = npmCaptured([...args, ...withJson], [`--otp=${token}`])
     return result
   }
-  // The code is used for THIS call only.
-  result = npmCaptured([...args, ...withJson], [`--otp=${token}`])
+
+  // The registry wants an authenticator code rather than a browser, and the
+  // user gave one.
+  //
+  // The code answers THIS challenge and is spent by it, so it is not carried
+  // to the next call in the chain: a spent code is not accepted, and sending
+  // one produces a fresh challenge rather than the answer.
+  if (state.otp && /EOTP|one-time password|need otp/i.test(result.out)) {
+    const otp = state.otp
+    state.otp = undefined
+    result = npmCaptured([...args, ...withJson], [`--otp=${otp}`])
+  }
   return result
 }
 
+/**
+ * The window the two-factor wait is allowed to take.
+ *
+ * @returns {number} seconds
+ */
+function waitSeconds() {
+  const seconds = Number(process.env.OC_TRUST_WAIT_SECONDS ?? DEFAULT_WAIT_SECONDS)
+  return Number.isFinite(seconds) && seconds > 0 ? seconds : DEFAULT_WAIT_SECONDS
+}
+
 /**
  * Wait for the browser to answer.
  *
+ * The wait is BOUNDED by the configured window, and the bound covers the
+ * request as well as the number of attempts.
+ *
+ * The request had no timeout of its own, and undici's default body timeout
+ * is five minutes - so an endpoint that sent its headers and then never
+ * ended its body held the command open for minutes per attempt, and the
+ * loop's own attempt count did not bound it at all. At the default window
+ * the worst case was hours, with nothing said about the wait.
+ *
  * @param {string} doneUrl
  * @returns {Promise<string | null>}
  */
@@ -224,21 +280,80 @@ async function waitForToken(doneUrl) {
   // How long to wait for a human. The window is generous, because the person
   // may be answering an email, and it is configurable so a CI run does not
   // hang on it.
-  const seconds = Number(process.env.OC_TRUST_WAIT_SECONDS ?? 600)
-  const attempts = Math.max(1, Math.round(seconds / 5))
-  for (let i = 0; i < attempts; i++) {
+  const deadline = Date.now() + waitSeconds() * 1000
+  while (Date.now() < deadline) {
+    // The remaining budget bounds the request itself, so a server that sends
+    // its headers and never ends its body cannot hold the command open past
+    // the window.
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), Math.max(1, deadline - Date.now()))
     try {
-      const res = await fetch(doneUrl)
+      const res = await fetch(doneUrl, { signal: controller.signal })
       const body = /** @type {any} */ (await res.json())
       if (body && typeof body.token === "string" && body.token) return body.token
     } catch {
       // Not ready yet, or the network blipped. Try again.
+    } finally {
+      clearTimeout(timer)
     }
-    await new Promise((r) => setTimeout(r, 5000))
+    // Wait for the next attempt, but never past the deadline.
+    const wait = Math.min(POLL_MS, deadline - Date.now())
+    if (wait > 0) await new Promise((r) => setTimeout(r, wait))
   }
   return null
 }
 
+/**
+ * The configurations in npm's own answer.
+ *
+ * npm prints ONE JSON OBJECT PER CONFIGURATION - one object per line, not
+ * an array of objects. The answer was parsed as a single JSON document, so a
+ * package with two configurations could not be read at all, and the tool
+ * said "could not read the trusted publisher configuration" about a package
+ * that had one. That is the opposite of a diagnostic: it hides the
+ * configuration the tool exists to repair.
+ *
+ * Both shapes are read: the ndjson npm actually prints, and the single
+ * object or array that other versions print.
+ *
+ * @param {string} out npm's answer
+ * @returns {{ configs: any[], failed: boolean, detail?: string }}
+ */
+export function parseTrustList(out) {
+  const text = String(out ?? "").trim()
+  if (!text) return { configs: [], failed: false }
+
+  // One document first: a single object, or an array, on one line or
+  // pretty-printed over several.
+  let whole = null
+  try {
+    whole = JSON.parse(text)
+  } catch {
+    // Not one document. npm prints one object per line when a package has
+    // more than one configuration, and that is ndjson - not JSON.
+  }
+  const documents = whole === null ? text.split("\n").map((l) => l.trim()).filter(Boolean) : [text]
+
+  /** @type {any[]} */
+  const items = []
+  for (const doc of documents) {
+    let parsed
+    try {
+      parsed = JSON.parse(doc)
+    } catch {
+      // A line that is not JSON is npm's own noise, and an answer that
+      // cannot be read is a FAILURE - not an empty list. An empty list
+      // would say "no trusted publisher is configured", and the tool would
+      // then create one that already exists.
+      return { configs: [], failed: true, detail: out }
+    }
+    if (Array.isArray(parsed)) items.push(...parsed)
+    else if (parsed && Array.isArray(parsed.configs)) items.push(...parsed.configs)
+    else items.push(parsed)
+  }
+  return { configs: items.filter(Boolean), failed: false }
+}
+
 /**
  * The stored trusted publisher configurations for this package.
  *
@@ -259,14 +374,7 @@ async function listConfigs(name, state = {}) {
     return { configs: [], failed: true, detail: out }
   }
   if (!out.trim()) return { configs: [], failed: false }
-  let parsed
-  try {
-    parsed = JSON.parse(out)
-  } catch {
-    return { configs: [], failed: true, detail: out }
-  }
-  const items = Array.isArray(parsed) ? parsed : parsed.configs ?? [parsed]
-  return { configs: items.filter(Boolean), failed: false }
+  return parseTrustList(out)
 }
 
 /**
@@ -289,11 +397,31 @@ function describe(config) {
 export async function main(argv = []) {
   const pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf8"))
   const name = pkg.name
-  const repo = repoOf(pkg.repository)
+  let repo
+  try {
+    repo = repoOf(pkg.repository)
+  } catch (err) {
+    // A diagnostic, not a stack trace.
+    //
+    // The throw used to escape the command and kill it with a JavaScript
+    // stack trace, which says nothing about the package.json field that
+    // was wrong - and the person reading it had to work out that the
+    // release tool was the thing that died.
+    console.error(red(`cannot work out the GitHub repository of ${name}.`))
+    console.error(dim(`  ${err instanceof Error ? err.message : String(err)}`))
+    console.error(dim("  the `repository` field of package.json has to point at a GitHub repository."))
+    return 1
+  }
   const file = process.env.TRUSTED_PUBLISHER_FILE ?? "ci.yml"
   const checkOnly = argv.includes("--check")
-  // A code given on the command line is used as-is. A code given at the
-  // prompt is remembered for the rest of the run, so the user types it once.
+  // A code given on the command line is used as-is, and only for the call
+  // that was challenged.
+  //
+  // There is no prompt for a code. The challenge is answered in a browser,
+  // and npm's own helper only offers that when stdin AND stdout are both
+  // terminals - which a piped command is not. A code typed at a prompt would
+  // never arrive, so the comment about remembering it described a prompt
+  // that no longer existed.
   const state = { otp: argv.find((a) => a.startsWith("--otp="))?.slice("--otp=".length) }
 
   console.log(`\n${bold("npm trusted publishing")}  ${dim(`${name} · ${repo} · ${file}`)}\n`)