fix(notifier): migrate opencode notifier to v2 routes (v0.21.11)

CodeNomad's per-workspace instance proxy was upgraded and now only
serves opencode v2 /api/* routes; the v1 /session/... routes 403, which
broke all notifications.

- Discovery: GET {api}{proxyPath}/api/session (v2 {data,cursor} envelope)
  instead of GET {base}/session; sessions filtered by location.directory
  and the max time.updated entry is picked.
- Send: POST {api}{proxyPath}/api/session/{sid}/prompt with a {text}
  body instead of POST {base}/session/{id}/message with {parts:[...]}.
- v2 returns 2xx immediately, so the 15 s read-timeout-as-delivered
  branch is kept only as a harmless safety net.
- Updated the spec to the v2 routes/body/envelope (incl. a
  directory-filter assertion) and kept AGENTS.md in sync.

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v0.21.11 — 2026-10-05 14:47
+
+- Migrated the opencode notifier to the v2 API routes: discovery is now `GET {api}{proxyPath}/api/session` (a `{ data, cursor }` envelope; sessions filtered by `location.directory`, most-recent `time.updated` wins) and send is now `POST {api}{proxyPath}/api/session/{sid}/prompt` with a `{text}` body, instead of the v1 `GET /session` + `POST /session/{id}/message` (`{parts:[{type:"text",text}]}`) routes. CodeNomad's per-workspace instance proxy was upgraded and now only serves opencode v2 `/api/*` — every v1 `/session/…` call 403s, which was breaking all notifications. v2 returns 2xx immediately (no longer holds the response until the turn finishes), so the 15 s read-timeout-as-delivered branch is kept only as a harmless safety net.
+
 ## v0.21.10 — 2026-09-30 05:46
 
 - Container now runs with `TZ=Europe/Warsaw` (new line in the bot service's `environment:` block, hardcoded like MESH_HOST/MESH_PORT): scheduled jobs and log timestamps use local Polish time instead of UTC — the weather cron (`WEATHER_CRON=0 6,12,18 * * *`) previously fired at 06/12/18 UTC = 08/14/20 CEST. DST-aware via the IANA zone (CEST +2 / CET +1). Deployment-config only — no application code changed; takes effect on the next `docker compose up -d --build`.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "mesh-bot",
-  "version": "0.21.10",
+  "version": "0.21.11",
   "description": "",
   "author": "",
   "private": true,

src/opencode/opencode.service.spec.ts

@@ -72,7 +72,7 @@ describe('OpencodeService.notify', () => {
 
     expect(fetchMock).toHaveBeenCalledTimes(2);
     const [url, init] = fetchMock.mock.calls[1];
-    expect(url).toBe(`${API}/proxy/abc/session/ses_pinned/message`);
+    expect(url).toBe(`${API}/proxy/abc/api/session/ses_pinned/prompt`);
     const opts = init as {
       method?: string;
       headers?: Record<string, string>;
@@ -83,15 +83,10 @@ describe('OpencodeService.notify', () => {
     expect(opts.headers?.authorization).toBe(
       'Basic ' + Buffer.from('u:p').toString('base64'),
     );
-    // body is EXACTLY {"parts":[{"type":"text","text":msg}]} — em-dash, not a hyphen
+    // body is EXACTLY {"text": msg} — em-dash, not a hyphen — and a 2xx resolves notify as delivered
     expect(String(opts.body)).toBe(
       JSON.stringify({
-        parts: [
-          {
-            type: 'text',
-            text: 'New mesh message (id 7) from node 42: "hi" — please react to it.',
-          },
-        ],
+        text: 'New mesh message (id 7) from node 42: "hi" — please react to it.',
       }),
     );
   });
@@ -111,12 +106,7 @@ describe('OpencodeService.notify', () => {
     const [, init] = fetchMock.mock.calls[1];
     expect(String((init as { body?: string }).body)).toBe(
       JSON.stringify({
-        parts: [
-          {
-            type: 'text',
-            text: 'New mesh message (id 7): "hi" — please react to it.',
-          },
-        ],
+        text: 'New mesh message (id 7): "hi" — please react to it.',
       }),
     );
   });
@@ -149,7 +139,7 @@ describe('OpencodeService.notify', () => {
     await svc.notify(7, 'hi');
 
     expect(fetchMock.mock.calls[1][0]).toBe(
-      `${API}/proxy/abc/session/ses_pinned/message`,
+      `${API}/proxy/abc/api/session/ses_pinned/prompt`,
     );
   });
 
@@ -182,7 +172,7 @@ describe('OpencodeService.notify', () => {
     await svc.notify(7, 'hi');
 
     expect(fetchMock.mock.calls[1][0]).toBe(
-      `${API}/proxy/b/session/ses_pinned/message`,
+      `${API}/proxy/b/api/session/ses_pinned/prompt`,
     );
   });
 
@@ -191,18 +181,37 @@ describe('OpencodeService.notify', () => {
     fetchMock
       .mockResolvedValueOnce(json([WORKSPACE]))
       .mockResolvedValueOnce(
-        json([
-          { id: 'ses_old', time: { updated: 100 } },
-          { id: 'ses_new', time: { updated: 200 } },
-        ]),
+        // v2 envelope {data, cursor}; the /elsewhere session is more recent but a different
+        // directory, so the location.directory filter must exclude it
+        json({
+          data: [
+            {
+              id: 'ses_old',
+              location: { directory: WS_PATH },
+              time: { updated: 100 },
+            },
+            {
+              id: 'ses_other_ws',
+              location: { directory: '/elsewhere' },
+              time: { updated: 300 },
+            },
+            {
+              id: 'ses_new',
+              location: { directory: WS_PATH },
+              time: { updated: 200 },
+            },
+          ],
+          cursor: { previous: null, next: null },
+        }),
       )
       .mockResolvedValueOnce(json({}));
 
     await svc.notify(7, 'hi');
 
-    expect(fetchMock.mock.calls[1][0]).toBe(`${API}/proxy/abc/session`);
+    // discovery GET hits the v2 route; the prompt POST goes to the most recently updated session of THIS directory
+    expect(fetchMock.mock.calls[1][0]).toBe(`${API}/proxy/abc/api/session`);
     expect(fetchMock.mock.calls[2][0]).toBe(
-      `${API}/proxy/abc/session/ses_new/message`,
+      `${API}/proxy/abc/api/session/ses_new/prompt`,
     );
   });
 
@@ -210,13 +219,22 @@ describe('OpencodeService.notify', () => {
     const svc = makeService({ OPENCODE_USER: 'u', OPENCODE_PASS: 'p' });
     fetchMock
       .mockResolvedValueOnce(json([WORKSPACE]))
-      .mockResolvedValueOnce(json([{ id: 'ses_a' }, { id: 'ses_b', time: {} }]))
+      .mockResolvedValueOnce(
+        json({
+          data: [
+            { id: 'ses_a', location: { directory: WS_PATH } },
+            { id: 'ses_b', location: { directory: WS_PATH }, time: {} },
+          ],
+          cursor: { previous: null, next: null },
+        }),
+      )
       .mockResolvedValueOnce(json({}));
 
     await svc.notify(7, 'hi');
 
+    expect(fetchMock.mock.calls[1][0]).toBe(`${API}/proxy/abc/api/session`);
     expect(fetchMock.mock.calls[2][0]).toBe(
-      `${API}/proxy/abc/session/ses_a/message`,
+      `${API}/proxy/abc/api/session/ses_a/prompt`,
     );
   });
 
@@ -232,11 +250,11 @@ describe('OpencodeService.notify', () => {
 
     await svc.notify(7, 'hi');
 
-    // workspaces GET + message POST only — no /session discovery GET
+    // workspaces GET + prompt POST only — no /api/session discovery GET
     expect(fetchMock).toHaveBeenCalledTimes(2);
     expect(fetchMock.mock.calls[0][0]).toBe(`${API}/api/workspaces`);
     expect(fetchMock.mock.calls[1][0]).toBe(
-      `${API}/proxy/abc/session/ses_pinned/message`,
+      `${API}/proxy/abc/api/session/ses_pinned/prompt`,
     );
   });
 
@@ -248,7 +266,7 @@ describe('OpencodeService.notify', () => {
     });
     fetchMock
       .mockResolvedValueOnce(json([WORKSPACE]))
-      .mockRejectedValueOnce(timeoutError()); // the message POST times out — opencode holds the response until the turn finishes
+      .mockRejectedValueOnce(timeoutError()); // the prompt POST times out — a read timeout is still treated as delivered (safety net)
 
     const logSpy = vi.spyOn(Logger.prototype, 'log');
     await expect(svc.notify('hi')).resolves.toBeUndefined();

src/opencode/opencode.service.ts

@@ -2,7 +2,8 @@ import { Injectable, Logger } from '@nestjs/common';
 
 // ponytail: hardcoded backoff [2s, 10s, 30s] (~45 s window) — no env knob; tune here if outages run longer
 const RETRY_DELAYS_MS = [2_000, 10_000, 30_000];
-// opencode accepts a session message immediately but holds the HTTP response until the agent turn finishes
+// opencode v2 returns 2xx immediately (it no longer holds the response until the agent turn finishes);
+// the 15 s timeout only guards a stuck connection — a read timeout is still treated as delivered
 const TIMEOUT_MS = 15_000;
 
 /** Entry of GET {api}/api/workspaces (only the fields we use). */
@@ -14,9 +15,11 @@ interface WorkspaceEntry {
   proxyPath?: string;
 }
 
-/** Entry of GET {base}/session (only the fields we use). */
+/** Entry of GET {base}/api/session (v2; only the fields we use — directory lives under location, time is epoch ms). */
 interface SessionEntry {
   id: string;
+  title?: string;
+  location?: { directory?: string };
   time?: { updated?: number };
 }
 
@@ -43,11 +46,11 @@ export class OpencodeService {
   }
 
   /**
-   * Push an rx mesh message into the opencode session as a text part. Resolves when delivered —
-   * including on a final-POST read timeout, which means DELIVERED (opencode holds the response until
-   * the agent turn finishes) and is never retried. Workspace/session resolution failures are retried
-   * up to RETRY_DELAYS_MS.length + 1 attempts total; the last failure logs `opencode notify dropped
-   * after N attempts`. No-op when disabled (no credentials).
+   * Push an rx mesh message into the opencode session (v2: POST {base}/api/session/{id}/prompt with a
+   * `{text}` body). Resolves when delivered — including on a final-POST read timeout, which still means
+   * DELIVERED (kept as a harmless safety net; v2 normally returns 2xx immediately) and is never retried.
+   * Workspace/session resolution failures are retried up to RETRY_DELAYS_MS.length + 1 attempts total;
+   * the last failure logs `opencode notify dropped after N attempts`. No-op when disabled (no credentials).
    */
   async notify(id: number, text: string, from?: number): Promise<void> {
     if (!this.enabled) return;
@@ -112,12 +115,19 @@ export class OpencodeService {
     const base = this.api + (ws.proxyPath ?? '');
     let sid = this.sessionOverride;
     if (!sid) {
-      const sessions = await this.getJson<SessionEntry[]>(`${base}/session`);
+      // v2 discovery: GET {base}/api/session returns an envelope { data, cursor } — NOT a bare array
+      const envelope = await this.getJson<{ data?: SessionEntry[] }>(
+        `${base}/api/session`,
+      );
+      // only sessions of THIS workspace directory — the instance proxy may serve other sessions too
+      const sessions = (envelope.data ?? []).filter(
+        (s) => s.location?.directory === this.workspacePath,
+      );
       if (sessions.length === 0)
         throw new Error(
           `no sessions in workspace ${ws.id} (${this.workspacePath})`,
         );
-      // most recently updated session; first entry when none carry time.updated
+      // most recently updated session (epoch ms); first entry when none carry time.updated
       const updated = (s: SessionEntry): number => s.time?.updated ?? 0;
       sid = sessions.some((s) => updated(s))
         ? sessions.reduce((a, b) => (updated(b) > updated(a) ? b : a)).id
@@ -148,16 +158,17 @@ export class OpencodeService {
     msg: string,
   ): Promise<void> {
     try {
-      const res = await fetch(`${base}/session/${sid}/message`, {
+      const res = await fetch(`${base}/api/session/${sid}/prompt`, {
         method: 'POST',
         headers: { ...this.authHeaders(), 'content-type': 'application/json' },
-        body: JSON.stringify({ parts: [{ type: 'text', text: msg }] }),
+        body: JSON.stringify({ text: msg }),
         signal: AbortSignal.timeout(TIMEOUT_MS),
       });
       if (!res.ok) throw new Error(`HTTP ${res.status}`); // HTTP errors retry like network failures
     } catch (err) {
-      // a read timeout here means DELIVERED, not failed — opencode accepted the message and is holding
-      // the response until the agent turn finishes; never retried
+      // a read timeout here means DELIVERED, not failed — kept as a harmless safety net: v2 normally
+      // returns 2xx immediately, but if the response is still pending past the timeout we treat the
+      // message as accepted and never retry
       if ((err as Error).name === 'TimeoutError') {
         this.logger.log(
           `opencode notify accepted (response still pending after ${TIMEOUT_MS / 1000} s)`,