zooid 0.12.0 → 0.13.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   buildAcpRegistry
-} from "./chunk-3Q4BPAZD.js";
+} from "./chunk-YZ4IO5MR.js";
 export {
   buildAcpRegistry
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zooid",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "An open-source, self-hostable chat app for collaborating with AI agents alongside your team. Any model, any CLI.",
   "type": "module",
   "license": "MIT",
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "zooid": {
-    "webVersion": "0.10.0"
+    "webVersion": "0.11.0"
   },
   "engines": {
     "node": ">=22"
@@ -40,19 +40,21 @@
     "marked": "^18.0.4",
     "sanitize-html": "^2.17.4",
     "tar": "^7.5.16",
+    "web-push": "^3.6.7",
     "yaml": "^2.5.0",
-    "@zooid/context-mcp": "^0.12.0",
-    "@zooid/acp-client": "^0.12.0",
-    "@zooid/core": "^0.12.0",
-    "@zooid/runtime-docker": "^0.12.0",
-    "@zooid/transport-http": "^0.12.0",
-    "@zooid/runtime-local": "^0.12.0",
-    "@zooid/transport-matrix": "^0.12.0"
+    "@zooid/acp-client": "^0.13.0",
+    "@zooid/transport-matrix": "^0.13.0",
+    "@zooid/context-mcp": "^0.13.0",
+    "@zooid/core": "^0.13.0",
+    "@zooid/runtime-local": "^0.13.0",
+    "@zooid/runtime-docker": "^0.13.0",
+    "@zooid/transport-http": "^0.13.0"
   },
   "devDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",
     "@playwright/test": "^1.49.0",
     "@types/node": "^22.0.0",
+    "@types/web-push": "^3.6.4",
     "release-it": "^19.2.4",
     "tsup": "^8.5.1",
     "tsx": "^4.19.0",

package/src/bin.test.ts

@@ -0,0 +1,63 @@
+import { spawnSync } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const TSX = join(HERE, '..', 'node_modules', '.bin', 'tsx')
+const BIN = join(HERE, 'bin.ts')
+
+function runCli(args: string[]) {
+  const result = spawnSync(TSX, [BIN, ...args], { encoding: 'utf8' })
+  return { stdout: result.stdout, stderr: result.stderr, status: result.status }
+}
+
+describe('zooid help', () => {
+  it('lists every registered command with no args', () => {
+    const { stdout, status } = runCli([])
+    expect(status).toBe(1)
+    for (const name of ['start', 'dev', 'logs', 'status', 'init', 'help']) {
+      expect(stdout).toContain(name)
+    }
+  })
+
+  it('--help prints the same command list and exits 0', () => {
+    const { stdout, status } = runCli(['--help'])
+    expect(status).toBe(0)
+    expect(stdout).toContain('Commands:')
+    expect(stdout).toContain('init [dir]')
+  })
+
+  it('`zooid help` mirrors `zooid --help`', () => {
+    const { stdout, status } = runCli(['help'])
+    expect(status).toBe(0)
+    expect(stdout).toContain('Commands:')
+  })
+
+  it('`zooid help <command>` shows that command\'s own help', () => {
+    const { stdout, status } = runCli(['help', 'init'])
+    expect(status).toBe(0)
+    expect(stdout).toContain('$ zooid init [dir]')
+    expect(stdout).toContain('--preset <name>')
+  })
+
+  it('`zooid <command> --help` still works directly', () => {
+    const { stdout, status } = runCli(['logs', '--help'])
+    expect(status).toBe(0)
+    expect(stdout).toContain('$ zooid logs [source]')
+  })
+
+  it('rejects an unknown subcommand of help', () => {
+    const { stdout, stderr, status } = runCli(['help', 'bogus'])
+    expect(status).toBe(1)
+    expect(stderr).toContain('Unknown command: bogus')
+    expect(stdout).toContain('Commands:')
+  })
+
+  it('rejects an unknown top-level command instead of exiting silently', () => {
+    const { stdout, stderr, status } = runCli(['frobnicate'])
+    expect(status).toBe(1)
+    expect(stderr).toContain('Unknown command: frobnicate')
+    expect(stdout).toContain('Commands:')
+  })
+})

package/src/bin.ts

@@ -6,6 +6,7 @@ import { resolveOptions } from './commands/init/prompts.js'
 import { runLogs } from './commands/logs.js'
 import { runStart } from './commands/start.js'
 import { runStatus } from './commands/status.js'
+import { CLI_VERSION } from './version.js'
 
 const cli = cac('zooid')
 
@@ -15,6 +16,8 @@ cli
   .option('--runtime <local|docker|podman>', 'Agent runtime')
   .option('--image <ref>', 'Agent container image')
   .option('--print-token', 'Print a 32-byte hex token and exit')
+  .example('$ zooid start --data ./data')
+  .example('$ zooid start --runtime docker --image ghcr.io/zooid-ai/agent:latest')
   .action(async (flags) => {
     await runStart({
       dataDir: flags.data,
@@ -35,6 +38,8 @@ cli
     '--watch-web [path]',
     'Run vite build --watch on @zooid/web. Path defaults to sibling ../zooid-clients/packages/web.',
   )
+  .example('$ zooid dev')
+  .example('$ zooid dev --engine podman --ui-port 5174')
   .action(async (flags) => {
     await runDev({
       dataDir: flags.data,
@@ -56,6 +61,9 @@ cli
   .option('--turn <id>', 'Filter ACP taps to a single turn id')
   .option('-f, --follow', 'Tail the file (not yet implemented)')
   .option('--keep <n>', 'For `logs prune`: days to retain', { default: 14 })
+  .example('$ zooid logs daemon')
+  .example('$ zooid logs agent-support.acp --turn 3f9c1a --day 2026-09-06')
+  .example('$ zooid logs prune --keep 7')
   .action(async (source, flags) => {
     if (source === 'prune') {
       await runLogs({
@@ -78,6 +86,7 @@ cli
   .command('status', 'Print Tuwunel + daemon health')
   .option('--data <dir>', 'Persistent data root dir', { default: './data' })
   .option('--port <n>', 'Tuwunel host port (defaults to zooid.yaml)')
+  .example('$ zooid status')
   .action(async (flags) => {
     await runStatus({
       dataDir: flags.data,
@@ -95,6 +104,9 @@ cli
   .option('--force', 'Allow scaffolding into a non-empty directory')
   .option('--overwrite', 'With --force, overwrite existing files')
   .option('--no-interactive', 'Disable prompts; require all flags up front')
+  .example('$ zooid init')
+  .example('$ zooid init my-workforce --preset opencode --provider anthropic')
+  .example('$ zooid init --preset claude --auth api-key --api-key sk-... --no-interactive')
   .action(async (dir: string | undefined, flags) => {
     const resolved = await resolveOptions({
       dir: dir ?? process.cwd(),
@@ -110,6 +122,43 @@ cli
     await runInit(resolved)
   })
 
-cli.help()
-cli.version('0.0.1')
-cli.parse()
+cli
+  .command('help [command]', 'Display help for zooid, or for a specific command')
+  .example('$ zooid help')
+  .example('$ zooid help init')
+  .action((commandName?: string) => {
+    if (!commandName) {
+      cli.globalCommand.outputHelp()
+      return
+    }
+    const target = cli.commands.find((c) => c.isMatched(commandName))
+    if (!target) {
+      console.error(`Unknown command: ${commandName}\n`)
+      cli.globalCommand.outputHelp()
+      process.exitCode = 1
+      return
+    }
+    target.outputHelp()
+  })
+
+cli.help((sections) => {
+  sections.push({
+    title: 'Docs',
+    body: '  https://zooid.dev/docs',
+  })
+  return sections
+})
+cli.version(CLI_VERSION)
+
+cli.on('command:*', () => {
+  console.error(`Unknown command: ${cli.args.join(' ')}\n`)
+  cli.outputHelp()
+  process.exitCode = 1
+})
+
+if (process.argv.slice(2).length === 0) {
+  cli.outputHelp()
+  process.exitCode = 1
+} else {
+  cli.parse()
+}

package/src/bootstrap/configs.test.ts

@@ -15,6 +15,13 @@ describe('renderTuwunelToml', () => {
     )
     expect(toml).toContain('allow_local_presence = true')
     expect(toml).toContain('port = [8448]')
+    // Presence-based push suppression stays OFF — sw.js suppresses per-room
+    // on visibility instead, and presence lingers long past a closed tab.
+    expect(toml).not.toContain('suppress_push_when_active')
+    // DEV ONLY: Tuwunel is in Podman, the push gateway runs on the host, and
+    // the default ip_range_denylist (127/8, 10/8, 172.16/12, 192.168/16, ::1)
+    // would silently drop every pusher delivery to it.
+    expect(toml).toContain('ip_range_denylist = []')
   })
 
   it('honors a non-default server_name', () => {

package/src/bootstrap/configs.ts

@@ -26,6 +26,20 @@ export function renderTuwunelToml(opts: TuwunelTomlOpts): string {
     'allow_local_presence = true',
     'address = ["0.0.0.0"]',
     `port = [${TUWUNEL_INTERNAL_PORT}]`,
+    // NOT `suppress_push_when_active` ([[ZNC025]]). It reads Matrix presence,
+    // which is both too coarse and too slow for this: coarse because it is
+    // per-user, so reading room A kills the push for room B; slow because
+    // `currently_active` lingers for minutes after the last sync, so closing
+    // the tab and waiting for an agent to finish still delivers nothing —
+    // exactly the case this feature exists for. `public/sw.js` already does
+    // the suppression we actually want, precisely: it drops a push only when
+    // a *visible* window is on *that* room.
+    // DEV ONLY — disables an SSRF guard. Tuwunel is in Podman and the push
+    // gateway runs on the host, so the default ip_range_denylist (127/8,
+    // 10/8, 172.16/12, 192.168/16, ::1) silently drops every pusher delivery.
+    // Never set on a box: there the gateway is reached at the public
+    // hostname through Caddy.
+    'ip_range_denylist = []',
     '',
   ].join('\n')
 }

package/src/commands/dev.ts

@@ -248,7 +248,22 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
                 t.output = msg
               },
             }))
-          const app = webStatic({ webRoot, homeserverUrl: homeserver })
+          const app = webStatic({
+            webRoot,
+            homeserverUrl: homeserver,
+            ...(ctx.daemon?.vapidPublicKey
+              ? {
+                  // Tuwunel runs in a container; `localhost` here would
+                  // resolve to the container, not the daemon. Same shorthand
+                  // as the AS registration url
+                  // (bootstrap/registration-url.ts). This URL is stored in
+                  // the pusher and fetched by the homeserver — the browser
+                  // never requests it.
+                  pushGatewayUrl: `http://host.docker.internal:${ctx.daemon.port}/_matrix/push/v1/notify`,
+                  vapidPublicKey: ctx.daemon.vapidPublicKey,
+                }
+              : {}),
+          })
           ctx.uiServer = serve({ fetch: app.fetch, port: flags.uiPort })
         },
       },
@@ -287,13 +302,28 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
   })
 
   if (flags.installSignalHandlers !== false) {
-    const handler = async (): Promise<void> => {
-      process.stdout.write(chalk.dim('\nStopping…\n'))
-      await shutdown()
-      process.exit(0)
+    // buildShutdown is idempotent, so a repeat Ctrl-C used to print again and
+    // await the same promise, with no way to give up on a step taking too
+    // long. Escalate on repeats instead.
+    let interrupts = 0
+    const onSignal = (): void => {
+      interrupts += 1
+      if (interrupts === 1) {
+        process.stdout.write(chalk.dim('\nStopping…\n'))
+        void shutdown().then(() => process.exit(0))
+        return
+      }
+      if (interrupts === 2) {
+        process.stdout.write(
+          chalk.dim('Still stopping — press Ctrl-C again to force quit.\n'),
+        )
+        return
+      }
+      process.stdout.write(chalk.dim('Forced.\n'))
+      process.exit(130)
     }
-    process.on('SIGINT', () => void handler())
-    process.on('SIGTERM', () => void handler())
+    process.on('SIGINT', onSignal)
+    process.on('SIGTERM', onSignal)
   }
 
   process.stdout.write(

package/src/commands/status.test.ts

@@ -54,6 +54,21 @@ describe('collectStatus', () => {
     ])
   })
 
+  it('reports the VAPID public key when vapid.json exists in the data dir', async () => {
+    writeFileSync(join(dir, 'zooid.yaml'), yaml)
+    writeFileSync(join(dir, 'vapid.json'), JSON.stringify({ publicKey: 'BPk', privateKey: 'priv' }))
+    vi.stubGlobal('fetch', vi.fn(async () => new Response('not found', { status: 404 })))
+    const s = await collectStatus({ cwd: dir, tuwunelUrl: 'http://localhost:8448', dataDir: dir })
+    expect(s.vapidPublicKey).toBe('BPk')
+  })
+
+  it('omits the VAPID key when no daemon has run yet', async () => {
+    writeFileSync(join(dir, 'zooid.yaml'), yaml)
+    vi.stubGlobal('fetch', vi.fn(async () => new Response('not found', { status: 404 })))
+    const s = await collectStatus({ cwd: dir, tuwunelUrl: 'http://localhost:8448', dataDir: dir })
+    expect(s.vapidPublicKey).toBeUndefined()
+  })
+
   it('reports daemon down when the AS callback port refuses the connection', async () => {
     writeFileSync(join(dir, 'zooid.yaml'), yaml)
     vi.stubGlobal(

package/src/commands/status.ts

@@ -1,8 +1,9 @@
 import { readFileSync } from 'node:fs'
-import { dirname } from 'node:path'
+import { dirname, join, resolve } from 'node:path'
 import chalk from 'chalk'
 import { findConfigFile, findMatrixTransport, loadZooidConfig } from '@zooid/core'
 import { deriveHomeserverShape } from '../bootstrap/derive.js'
+import { VAPID_FILENAME } from '../push-gateway/vapid.js'
 
 export interface StatusFlags {
   cwd?: string
@@ -15,6 +16,24 @@ export interface StatusReport {
   tuwunel: { status: 'up' | 'down'; url: string }
   daemon: { status: 'up' | 'down'; url: string } | { status: 'unknown'; reason: string }
   agents: { name: string; userId: string; trigger: string }[]
+  /** VAPID public key read from `<dataDir>/vapid.json`, when it exists. */
+  vapidPublicKey?: string
+}
+
+/**
+ * Read the daemon's VAPID public key straight off disk. Operators
+ * hand-editing a box's config.json need it and can't start a daemon just to
+ * ask, so this reads the persisted file rather than starting one.
+ */
+export function readVapidPublicKey(dataDir: string): string | undefined {
+  try {
+    const parsed = JSON.parse(readFileSync(join(dataDir, VAPID_FILENAME), 'utf8')) as {
+      publicKey?: string
+    }
+    return typeof parsed.publicKey === 'string' ? parsed.publicKey : undefined
+  } catch {
+    return undefined
+  }
 }
 
 async function probe(url: string, timeoutMs = 2_000): Promise<boolean> {
@@ -29,12 +48,14 @@ async function probe(url: string, timeoutMs = 2_000): Promise<boolean> {
 export async function collectStatus(opts: {
   cwd: string
   tuwunelUrl: string
+  dataDir?: string
 }): Promise<StatusReport> {
   const tuwunelUp = await probe(`${opts.tuwunelUrl}/_matrix/client/versions`)
   const tuwunel: StatusReport['tuwunel'] = {
     status: tuwunelUp ? 'up' : 'down',
     url: opts.tuwunelUrl,
   }
+  const vapidPublicKey = opts.dataDir ? readVapidPublicKey(opts.dataDir) : undefined
 
   const found = findConfigFile(opts.cwd)
   if (!found) {
@@ -42,6 +63,7 @@ export async function collectStatus(opts: {
       tuwunel,
       daemon: { status: 'unknown', reason: 'no zooid.yaml' },
       agents: [],
+      ...(vapidPublicKey ? { vapidPublicKey } : {}),
     }
   }
   const cfg = loadZooidConfig(readFileSync(found.path, 'utf8'), {
@@ -67,6 +89,7 @@ export async function collectStatus(opts: {
     tuwunel,
     daemon: { status: daemonUp ? 'up' : 'down', url: daemonUrl },
     agents,
+    ...(vapidPublicKey ? { vapidPublicKey } : {}),
   }
 }
 
@@ -89,7 +112,8 @@ export async function runStatus(flags: StatusFlags): Promise<void> {
     }
   }
   const tuwunelUrl = `http://localhost:${port ?? 8448}`
-  const s = await collectStatus({ cwd, tuwunelUrl })
+  const dataDir = resolve(cwd, flags.dataDir ?? './data')
+  const s = await collectStatus({ cwd, tuwunelUrl, dataDir })
   const fmt = (st: 'up' | 'down' | 'unknown'): string =>
     st === 'up' ? chalk.green('up') : st === 'down' ? chalk.red('down') : chalk.yellow('unknown')
   process.stdout.write(
@@ -99,6 +123,7 @@ export async function runStatus(flags: StatusFlags): Promise<void> {
       ...s.agents.map(
         (a) => `  agent: ${a.name} (${a.userId}, trigger: ${a.trigger})`,
       ),
+      ...(s.vapidPublicKey ? [`vapid public key: ${s.vapidPublicKey}`] : []),
       '',
     ].join('\n'),
   )

package/src/daemon/start-daemon.ts

@@ -33,6 +33,7 @@ import {
 } from '@zooid/context-mcp'
 import { buildAcpRegistry } from '../build-registry.js'
 import { prepullImages } from '../prepull-images.js'
+import { mountPushGateway } from '../push-gateway/index.js'
 import { makeSyncCursorStore } from './sync-cursors.js'
 import { shouldBindHttpListener } from './pull-wiring.js'
 
@@ -79,6 +80,8 @@ export interface StartDaemonOpts {
 export interface DaemonHandle {
   port: number
   agentNames: string[]
+  /** VAPID public key for web push, when the gateway bound (appservice mode with a data dir). */
+  vapidPublicKey?: string
   stop(): Promise<void>
   whenStopped: Promise<void>
 }
@@ -166,6 +169,7 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
 
   const matrix = findMatrixTransport(config)
   let port: number
+  let vapidPublicKey: string | undefined
 
   if (matrix) {
     const mode = matrix.transport.mode ?? 'appservice'
@@ -232,6 +236,16 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
     })
     if (shouldBindHttpListener(mode)) {
       const requestedPort = matrix.transport.port ?? 9000
+      // The gateway rides the appservice listener, not webStatic: webStatic
+      // exists only under `zooid dev`, and on a deployed box Caddy serves the
+      // dist directly with the daemon out of the serving path. This is the
+      // one HTTP surface bound in both modes.
+      if (dataDir) {
+        vapidPublicKey = mountPushGateway(transport.app, {
+          dataDir,
+          subject: `https://${serverName}`,
+        }).publicKey
+      }
       // Bind 0.0.0.0 explicitly — @hono/node-server defaults to IPv6-only on
       // macOS, which Docker's NAT bridge can't reach when Tuwunel pushes AS
       // events back to host.docker.internal:<port>.
@@ -347,5 +361,5 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
     process.on('SIGTERM', () => handler('SIGTERM'))
   }
 
-  return { port, agentNames, stop, whenStopped }
+  return { port, agentNames, vapidPublicKey, stop, whenStopped }
 }

package/src/push-gateway/gateway.test.ts

@@ -0,0 +1,150 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const sendNotification = vi.fn()
+class WebPushError extends Error {
+  constructor(
+    message: string,
+    public statusCode: number,
+  ) {
+    super(message)
+  }
+}
+vi.mock('web-push', () => ({
+  default: { sendNotification, WebPushError },
+  sendNotification,
+  WebPushError,
+}))
+
+const { pushGateway } = await import('./gateway.js')
+
+const KEYS = { publicKey: 'pub', privateKey: 'priv' }
+
+function device(over: Record<string, unknown> = {}) {
+  return {
+    app_id: 'dev.zooid.web',
+    pushkey: 'BPk_device_one',
+    data: { endpoint: 'https://fcm.example/one', auth: 'auth1' },
+    ...over,
+  }
+}
+
+function notification(devices: unknown[]) {
+  return {
+    notification: {
+      event_id: '$e:example.org',
+      room_id: '!r:example.org',
+      room_name: 'general',
+      sender_display_name: 'Alice',
+      type: 'm.room.message',
+      content: { msgtype: 'm.text', body: 'hello' },
+      counts: { unread: 1 },
+      devices,
+    },
+  }
+}
+
+async function notify(body: unknown) {
+  const app = pushGateway({ keys: KEYS, subject: 'mailto:ops@example.org' })
+  return app.request('/_matrix/push/v1/notify', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+}
+
+beforeEach(() => {
+  sendNotification.mockReset()
+  sendNotification.mockResolvedValue({ statusCode: 201 })
+})
+
+describe('pushGateway', () => {
+  it('encrypts to the device subscription reassembled from pushkey + data', async () => {
+    const res = await notify(notification([device()]))
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ rejected: [] })
+
+    const [subscription, payload, options] = sendNotification.mock.calls[0]!
+    expect(subscription).toEqual({
+      endpoint: 'https://fcm.example/one',
+      keys: { p256dh: 'BPk_device_one', auth: 'auth1' },
+    })
+    expect(JSON.parse(payload as string).room_name).toBe('general')
+    expect((options as { vapidDetails: unknown }).vapidDetails).toEqual({
+      subject: 'mailto:ops@example.org',
+      publicKey: 'pub',
+      privateKey: 'priv',
+    })
+  })
+
+  it('fans out to every matching device', async () => {
+    await notify(
+      notification([
+        device(),
+        device({ pushkey: 'BPk_two', data: { endpoint: 'https://fcm.example/two', auth: 'a2' } }),
+      ]),
+    )
+    expect(sendNotification).toHaveBeenCalledTimes(2)
+  })
+
+  it('skips a foreign app_id silently — never rejects it', async () => {
+    const res = await notify(notification([device({ app_id: 'im.vector.app.ios' })]))
+    expect(sendNotification).not.toHaveBeenCalled()
+    // Rejecting would make the homeserver permanently delete another client's pusher.
+    expect(await res.json()).toEqual({ rejected: [] })
+  })
+
+  it('rejects a pushkey on 410 Gone so the homeserver garbage-collects it', async () => {
+    sendNotification.mockRejectedValueOnce(new WebPushError('gone', 410))
+    const res = await notify(notification([device()]))
+    expect(await res.json()).toEqual({ rejected: ['BPk_device_one'] })
+  })
+
+  it('rejects a pushkey on 404 too', async () => {
+    sendNotification.mockRejectedValueOnce(new WebPushError('not found', 404))
+    expect(await (await notify(notification([device()]))).json()).toEqual({
+      rejected: ['BPk_device_one'],
+    })
+  })
+
+  it('does NOT reject on a transient 429 or 5xx', async () => {
+    sendNotification.mockRejectedValueOnce(new WebPushError('slow down', 429))
+    expect(await (await notify(notification([device()]))).json()).toEqual({ rejected: [] })
+
+    sendNotification.mockRejectedValueOnce(new WebPushError('bad gateway', 502))
+    expect(await (await notify(notification([device()]))).json()).toEqual({ rejected: [] })
+  })
+
+  it('does not let one dead device stop delivery to a live one', async () => {
+    sendNotification
+      .mockRejectedValueOnce(new WebPushError('gone', 410))
+      .mockResolvedValueOnce({ statusCode: 201 })
+    const res = await notify(
+      notification([
+        device(),
+        device({ pushkey: 'BPk_two', data: { endpoint: 'https://fcm.example/two', auth: 'a2' } }),
+      ]),
+    )
+    expect(sendNotification).toHaveBeenCalledTimes(2)
+    expect(await res.json()).toEqual({ rejected: ['BPk_device_one'] })
+  })
+
+  it('skips a device missing endpoint or auth without rejecting it', async () => {
+    const res = await notify(notification([device({ data: { endpoint: 'https://x' } })]))
+    expect(sendNotification).not.toHaveBeenCalled()
+    expect(await res.json()).toEqual({ rejected: [] })
+  })
+
+  it('400s on a malformed body instead of throwing', async () => {
+    expect((await notify({ nope: true })).status).toBe(400)
+  })
+
+  it('logs receipt and outcome — the only way to see a Tuwunel call in the daemon log', async () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {})
+    await notify(notification([device()]))
+    expect(log).toHaveBeenCalledWith(
+      expect.stringContaining('notify room=!r:example.org type=m.room.message devices=1'),
+    )
+    expect(log).toHaveBeenCalledWith(expect.stringContaining('delivered=1 rejected=0'))
+    log.mockRestore()
+  })
+})