opencode-courier 0.13.8 → 0.14.0

package/dist/tree/wake.js

@@ -1,31 +1,21 @@
 import { millis } from "../platform/json.js";
 import { busy, endsIdle } from "./domain.js";
 import { wakeStore } from "./store.js";
-/** How long a courier message may wait in an idle session's inbox before its wake counts as missed. */
 export const WAKE_MS = 30_000;
-/**
- * Watches a courier message enqueued for a session until it is delivered, noting whether the session runs.
- * Returns whether it is watched, which one sent with `resume: false` is not.
- */
 export async function watchWake(ports, event) {
     const { sessionID, inboxID, item } = event.data;
     const payload = item.payload;
     if (item.type !== "synthetic" || payload?.metadata?.source !== "courier" || typeof payload.text !== "string")
         return false;
-    // Sent without a wake: it waits for the next turn, which nothing owes it.
+    // resume: false starts no turn: the item waits for the next (api-notes)
     if (payload.metadata.resume === false)
         return false;
     const at = event.created ?? ports.now();
-    // A row `noteSent` wrote already is kept: it may have moved on since, and is no later than this one.
     if ((await wakeStore(ports.storage).of(sessionID)).some((wake) => wake.inboxID === inboxID))
         return true;
     await watch(ports, { sessionID, inboxID, at, text: payload.text, ...(typeof payload.description === "string" ? { description: payload.description } : {}) });
     return true;
 }
-/**
- * Watches a message `courier_send` has just had enqueued, without waiting for its enqueued event, so the limits see a reported child woken
- * for it at once; the event leaves this row be. Dropped again if the message is already stored, delivered before it was written.
- */
 export async function noteSent(ports, sent) {
     const store = wakeStore(ports.storage);
     if ((await store.of(sent.sessionID)).some((wake) => wake.inboxID === sent.inboxID))
@@ -36,24 +26,17 @@ export async function noteSent(ports, sent) {
         await store.remove(sent.sessionID, sent.inboxID);
 }
 async function watch(ports, wake) {
-    // Read after the enqueue: a turn it started has stored messages since, and an unknown session is taken to run.
     const idle = await ports.session.context({ sessionID: wake.sessionID }).then(endsIdle, () => false);
     await wakeStore(ports.storage).put({ ...wake, running: !idle, ...(idle ? { idleAt: wake.at } : {}) });
 }
-/** Stops watching a message once it is delivered or cancelled. */
 export async function settleWake(ports, event) {
     await wakeStore(ports.storage).remove(event.data.sessionID, event.data.inboxID);
 }
-/** A turn started in a session: the messages waiting there are its to take. */
 export async function wakeStarted(ports, event) {
     const store = wakeStore(ports.storage);
     const waiting = await store.of(event.data.sessionID);
     await Promise.all(waiting.filter((wake) => !wake.running).map(({ idleAt: _, ...wake }) => store.put({ ...wake, running: true })));
 }
-/**
- * A session's turn ended: a message it took is no longer watched, as its delivery may have been missed by this
- * subscription; one still waiting is watched as waiting in an idle session from now.
- */
 export async function wakeEnded(ports, event) {
     const { sessionID } = event.data;
     const store = wakeStore(ports.storage);
@@ -62,22 +45,16 @@ export async function wakeEnded(ports, event) {
         return;
     const at = event.created ?? ports.now();
     const messages = await ports.session.context({ sessionID }).catch(() => []);
-    // A plain decline reports a shutdown after the aborted step that ends its turn; a real one between steps ends none. One during a
-    // step reads as ended too, until the turn the next boot resumes is seen to start or `wakeAgain` finds it running.
+    // a plain decline reports a shutdown after its aborted step (api-notes)
     if (event.data.reason === "shutdown" && !endsIdle(messages))
         return;
     const stored = new Set(messages.map((message) => message.id));
     await Promise.all(waiting.map((wake) => (stored.has(wake.inboxID) ? store.remove(sessionID, wake.inboxID) : store.put({ ...wake, running: false, idleAt: at }))));
 }
-/** Forgets the messages watched in a session's inbox: it was deleted, or stopped, which nothing is to wake again. */
 export async function forgetWakes(ports, sessionID) {
     const store = wakeStore(ports.storage);
     await Promise.all((await store.of(sessionID)).map((wake) => store.remove(sessionID, wake.inboxID)));
 }
-/**
- * Sends once more, under its inbox id, each courier message an idle session has left waiting for `WAKE_MS`, flags stalled one still
- * waiting `WAKE_MS` later, and marks running one a turn it shows will take; run by the scheduler's owner, `claimed` keeping a tick alongside off it.
- */
 export async function wakeMissed(ports, claimed) {
     const store = wakeStore(ports.storage);
     const now = ports.now();
@@ -87,9 +64,7 @@ export async function wakeMissed(ports, claimed) {
     await Promise.all(due.map((wake) => wakeAgain(ports, store, wake, now).finally(() => claimed.delete(claimOf(wake)))));
 }
 const claimOf = (wake) => `wake ${wake.sessionID} ${wake.inboxID}`;
-/** Since when a message has waited in an idle session: it was enqueued, seen waiting as the turn ended, or sent again, whichever is last. */
 const waitingSince = (wake) => Math.max(wake.idleAt ?? wake.at, wake.rewoken ?? 0);
-/** Whether a message has waited in an idle session past `WAKE_MS`, and since a wake again, if one was sent; a stalled one is done. */
 export function missed(wake, now) {
     if (wake.running || wake.stalled !== undefined)
         return false;
@@ -97,11 +72,9 @@ export function missed(wake, now) {
 }
 async function wakeAgain(ports, store, wake, now) {
     try {
-        // Re-read: the message may have been delivered, or the session woken, since the scan.
         const current = (await store.of(wake.sessionID)).find((one) => one.inboxID === wake.inboxID);
         if (!current || !missed(current, now))
             return;
-        // A shutdown during a step reads as an end, and the turn the next boot resumes may start unseen: that turn takes the message.
         if (await runsNow(ports, current)) {
             const { idleAt: _, ...running } = current;
             return await store.put({ ...running, running: true });
@@ -110,8 +83,9 @@ async function wakeAgain(ports, store, wake, now) {
             ports.log(`courier wake: ${wake.sessionID} has not taken message ${wake.inboxID} since it was woken again; flagged stalled`);
             return await store.put({ ...current, stalled: now });
         }
-        // Noted before the send: the turn it starts may take the message, and drop the watch, before the send returns.
+        // the woken turn may take the message before synthetic returns
         await store.put({ ...current, rewoken: now });
+        // synthetic with a waiting item's id wakes again, adds no message (api-notes)
         await ports.session.synthetic({
             sessionID: wake.sessionID,
             id: wake.inboxID,
@@ -129,15 +103,12 @@ async function wakeAgain(ports, store, wake, now) {
         ports.log(`courier wake: could not wake ${wake.sessionID} again for ${wake.inboxID}: ${String(error)}`);
     }
 }
-/**
- * Whether a session shows a turn running that takes the message: by `time.busy` (2.2.2), an execution started since the message was
- * last left waiting and not ended; without it, by its times and its transcript read now. One that cannot be read does not, and is woken again.
- */
 async function runsNow(ports, wake) {
     const { sessionID } = wake;
     const info = await ports.session.get({ sessionID }).catch(() => undefined);
     if (!info)
         return false;
+    // time.busy, since 2.2.2, records a start whose event was missed (api-notes)
     if (info.time.busy !== undefined)
         return busy(info.time) && millis(info.time.busy) >= waitingSince(wake);
     if (!busy(info.time))
@@ -145,14 +116,9 @@ async function runsNow(ports, wake) {
     const messages = await ports.session.context({ sessionID }).catch(() => []);
     return messages.length > 0 && !endsIdle(messages);
 }
-/**
- * Whether a courier message sent with a wake waits undelivered in the session's inbox while it is idle, waiting or, unless
- * `stalled` is false, stalled; one a running turn is to take is not counted, as `runs` says that turn runs.
- */
 export async function waitsInInbox(ports, sessionID, { stalled = true } = {}) {
     return (await wakeStore(ports.storage).of(sessionID)).some((wake) => !wake.running && (stalled || wake.stalled === undefined));
 }
-/** The sessions among `sessionIDs` flagged stalled, each with when its oldest stalled message was enqueued. */
 export async function stalledAmong(ports, sessionIDs) {
     const wanted = new Set(sessionIDs);
     const stalled = new Map();

package/dist/tui.js

@@ -12,6 +12,7 @@ var Part = Schema.Struct({
   title: Schema.String,
   depth: Count,
   isolated: Schema.Boolean,
+  subagent: Schema.optionalKey(Schema.Boolean),
   group: Schema.optionalKey(Schema.String),
   status: Schema.Literals(PART_STATUSES),
   duration: Schema.optionalKey(Schema.Number),
@@ -110,14 +111,14 @@ var count = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
 var times = (n) => n === 1 ? "once" : `${n} times`;
 var money = (cost) => `$${cost.toFixed(2)}`;
 var nameOf = (record) => clip(oneLine2(record.title) || record.sessionID, 60);
-function partsCounted(parts) {
-  if (!parts.length)
-    return "no parts";
+function partsCounted(all) {
+  const parts = all.filter((part) => !part.subagent);
+  const subagents = all.length - parts.length;
   const statuses = PART_STATUSES.flatMap((status) => {
     const n = parts.filter((part) => part.status === status).length;
     return n ? [`${n} ${status}`] : [];
   }).join(", ");
-  return `${count(parts.length, "part")}: ${statuses}`;
+  return [parts.length ? `${count(parts.length, "part")}: ${statuses}` : "no parts", ...subagents ? [count(subagents, "subagent")] : []].join(", ");
 }
 function costOf(record) {
   return record.parts.some((part) => part.cost !== undefined) ? record.parts.reduce((sum, part) => sum + (part.cost ?? 0), 0) : undefined;
@@ -146,7 +147,7 @@ function recordDetails(record) {
   return record.lesson ? [clip(`${lessonHeading(record.lesson)}: "${oneLine2(record.lesson.text)}"`, LESSON_LINE_MAX)] : [];
 }
 function partLine(part) {
-  return [part.status, `depth ${part.depth}`, part.isolated ? "isolated" : "", part.group ? `group ${part.group}` : "", part.duration === undefined ? "" : duration(part.duration), part.cost === undefined ? "" : money(part.cost), part.context === undefined ? "" : `ctx ${Math.round(part.context * 100)}%`, part.refused ? `${count(part.refused, "spawn")} refused` : ""].filter(Boolean).join(" \xB7 ");
+  return [part.status, `depth ${part.depth}`, part.isolated ? "isolated" : "", part.subagent ? "subagent" : "", part.group ? `group ${part.group}` : "", part.duration === undefined ? "" : duration(part.duration), part.cost === undefined ? "" : money(part.cost), part.context === undefined ? "" : `ctx ${Math.round(part.context * 100)}%`, part.refused ? `${count(part.refused, "spawn")} refused` : ""].filter(Boolean).join(" \xB7 ");
 }
 function wrap(text, width) {
   const rows = [];
@@ -1470,6 +1471,7 @@ var Row = Schema3.Struct({
   group: Schema3.optionalKey(Schema3.Struct({ name: Schema3.String, standing: Schema3.String })),
   isolated: Schema3.Boolean,
   native: Schema3.optionalKey(Schema3.Boolean),
+  subagent: Schema3.optionalKey(Schema3.Boolean),
   model: Schema3.optionalKey(Schema3.String),
   created: Schema3.Number,
   idle: Schema3.optionalKey(Schema3.Number),
@@ -1720,7 +1722,7 @@ function duration2(ms) {
   return `${Math.floor(seconds / 3600)}h ${pad(Math.floor(seconds / 60) % 60)}m`;
 }
 function parts(rows, parentID) {
-  const children = rows.filter((row) => row.parentID === parentID);
+  const children = rows.filter((row) => row.parentID === parentID && !row.subagent);
   return {
     reported: children.filter((row) => row.report?.state === "reported").length,
     started: children.length
@@ -1760,6 +1762,9 @@ function statusParts(row, now = Date.now()) {
   }, {
     text: row.native ? "native" : "",
     kind: "plain"
+  }, {
+    text: row.subagent ? "subagent" : "",
+    kind: "plain"
   }, {
     text: row.model ?? "",
     kind: "plain"
@@ -2211,6 +2216,14 @@ function TreePanel(props) {
     openRow(row);
   };
   const ownRow = (row, key) => {
+    if (row.subagent) {
+      ctx.ui.toast.show({
+        title: "courier",
+        message: `${key} acts on a session started with courier_spawn; "${oneLine3(row.title)}" is a subagent, stopped with the one above it.`,
+        variant: "warning"
+      });
+      return true;
+    }
     if (row.sessionID !== view.root)
       return false;
     ctx.ui.toast.show({
@@ -2842,13 +2855,14 @@ function addTreePanel(ctx, verbs = {}) {
       error
     }));
     const rows = read.rows;
+    const spawned = rows.filter((row) => !row.subagent);
     if (!target && "error" in read)
       return ctx.ui.toast.show({
         title: "courier stop",
         message: reason(read.error),
         variant: "error"
       });
-    if (!target && !rows.length)
+    if (!target && !spawned.length)
       return ctx.ui.toast.show({
         title: "courier stop",
         message: "No session started with courier_spawn under this one.",
@@ -2856,7 +2870,7 @@ function addTreePanel(ctx, verbs = {}) {
       });
     const sessionID = target || await ctx.ui.dialog.select({
       title: "Stop which session?",
-      options: rows.map((row) => ({
+      options: spawned.map((row) => ({
         title: row.title,
         value: row.sessionID,
         description: `${row.sessionID} \xB7 ${statusLine(row)}`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-courier",
-  "version": "0.13.8",
+  "version": "0.14.0",
   "description": "Multi-session orchestration for OpenCode V2: spawn child sessions, be woken by them. No polling.",
   "license": "MIT",
   "author": "Ivo Pogace <71701666+ivopogace@users.noreply.github.com>",
@@ -45,7 +45,6 @@
     "background-agents",
     "parallel",
     "worktree",
-    "webhook",
     "scheduler",
     "ai-agents"
   ],
@@ -56,17 +55,17 @@
     "test:e2e": "e2e/run.sh"
   },
   "peerDependencies": {
-    "@opencode/plugin": "2.2.5",
-    "effect": "4.0.6"
+    "@opencode/plugin": "2.2.6",
+    "effect": "4.1.0"
   },
   "devDependencies": {
-    "@opencode/plugin": "2.2.5",
-    "@opencode/theme": "2.2.5",
-    "@opentui/core": "0.8.0",
-    "@opentui/solid": "0.8.0",
+    "@opencode/plugin": "2.2.6",
+    "@opencode/theme": "2.2.6",
+    "@opentui/core": "0.8.1",
+    "@opentui/solid": "0.8.1",
     "@types/bun": "1.4.2",
     "@types/node": "26.6.4",
-    "effect": "4.0.6",
+    "effect": "4.1.0",
     "solid-js": "1.9.17",
     "typescript": "5.9.3"
   }

package/dist/webhook/index.d.ts

@@ -1,5 +0,0 @@
-export { joinReceiver, listen, readConfig, receiving } from "./receiver.js";
-export type { WebhookConfig } from "./receiver.js";
-export { subscribedSince } from "./subscriptions.js";
-export type { WebhookPorts } from "./subscriptions.js";
-export { addWebhookTools } from "./tools.js";

package/dist/webhook/index.js

@@ -1,3 +0,0 @@
-export { joinReceiver, listen, readConfig, receiving } from "./receiver.js";
-export { subscribedSince } from "./subscriptions.js";
-export { addWebhookTools } from "./tools.js";

package/dist/webhook/receiver.d.ts

@@ -1,80 +0,0 @@
-import { type IncomingMessage, type Server } from "node:http";
-import { type WebhookPorts } from "./subscriptions.js";
-/** Bodies above this are refused; GitHub's own deliveries are capped at 25 MB, real ones are far smaller. */
-export declare const DEFAULT_MAX_BYTES: number;
-/**
- * The webhook receiver, one per process: every instance configured with a `webhook` option joins
- * `instances`, the first one starts the server, and the last one to unload stops it.
- */
-export interface Receiver {
-    readonly config: WebhookConfig;
-    readonly instances: Set<WebhookPorts>;
-    readonly server: Promise<Server | undefined>;
-}
-/** The current receiver, if any, and the previous one while it closes, which a new one waits for. */
-export interface Receivers {
-    current?: Receiver;
-    closing?: Promise<void>;
-}
-/** The receiver's settings, from the plugin's `webhook` option. */
-export interface WebhookConfig {
-    readonly port: number;
-    readonly host: string;
-    readonly secret: string;
-    readonly maxBytes: number;
-}
-/**
- * Checks an `X-Hub-Signature-256` header (`sha256=` + 64 hex digits) in constant time, returning the
- * digest in lowercase hex, or undefined; replays are keyed by that digest, never by the header text.
- */
-export declare function checkSignature(secret: string, body: Uint8Array, header: string | undefined, name?: string): string | undefined;
-/** The `X-Hub-Signature-256` value for a body; give the topic name for `/hook/<name>`. */
-export declare function sign(secret: string, body: string | Uint8Array, name?: string): string;
-/** What an event means for subscribers: the topics it belongs to and a short summary. */
-export interface Event {
-    readonly source: string;
-    readonly name: string;
-    readonly topics: readonly string[];
-    readonly summary: string;
-}
-/**
- * Maps a GitHub delivery to its topics (`github:owner/repo`, plus `github:owner/repo#N` for PRs and
- * issues) and a summary; undefined for pings, unfinished CI events and actions outside `ITEM_ACTIONS`.
- */
-export declare function githubEvent(name: string, payload: unknown): Event | undefined;
-/** A delivery to `/hook/<topic>`: a JSON body's `text`, `summary` or `message` field, else the body itself. */
-export declare function genericEvent(topic: string, body: string): Event;
-/**
- * Delivers an event to every session subscribed to one of its topics, once per session. A session
- * OpenCode no longer knows loses its subscriptions.
- */
-export declare function dispatch(ports: WebhookPorts, event: Event, delivery?: string): Promise<{
-    delivered: number;
-    failed: number;
-}>;
-export interface Request {
-    readonly method: string;
-    readonly path: string;
-    readonly headers: Readonly<Record<string, string | string[] | undefined>>;
-    readonly body: Buffer;
-}
-export interface Response {
-    readonly status: number;
-    readonly body: string;
-}
-/**
- * Handles one request: `POST /github` with GitHub's headers, or `POST /hook/<name>` signed over name
- * and body; anything unsigned is refused before parsing, and a signature already accepted is ignored.
- */
-export declare function receive(ports: WebhookPorts, secret: string, request: Request, seen?: Set<string>): Promise<Response>;
-/** Starts the HTTP receiver; `ports()` picks a live plugin instance for each request. */
-export declare function listen(config: WebhookConfig, ports: () => WebhookPorts | undefined): Promise<Server<typeof IncomingMessage, typeof import("node:http").ServerResponse>>;
-/**
- * Reads the `webhook` option, undefined when the receiver is not configured; the secret comes from
- * `secretFile` or the env var `secretEnv` (default `COURIER_WEBHOOK_SECRET`), never from the option.
- */
-export declare function readConfig(options: unknown, env?: Record<string, string | undefined>): WebhookConfig | undefined;
-/** Joins this instance to the process's receiver, starting it if there is none; returns the leave. */
-export declare function joinReceiver(config: WebhookConfig, ports: WebhookPorts): () => Promise<void>;
-/** Whether a webhook receiver runs in this server. */
-export declare const receiving: () => Promise<boolean>;