@kivel.io/cli 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @kivel.io/cli
 
+## 0.10.0
+
+### Minor Changes
+
+- ad5805c: Add live event streams to the SDK and use them in the webhook listener.
+
+### Patch Changes
+
+- ad5805c: Reconnect webhook listeners after transient network failures with backoff and resume from the last processed event cursor.
+- Updated dependencies [ad5805c]
+    - @kivel.io/sdk@0.10.0
+
 ## 0.9.0
 
 ### Minor Changes

package/README.md

@@ -39,8 +39,8 @@ requests time out after 90 seconds. Mutations are never automatically retried.
 
 `job`, `status-page`, `smtp`, `phone` and `event wait` use the same owned APIs. Operator-dependent services stay disabled until configured; phone sending and calls are not implemented. Run `kivel --help` for their current commands.
 
-`listen` streams webhook events and can forward them to a local server. It runs on
-your machine, and stops on Ctrl+C. The optional server SSH gateway supports bounded
+`listen` streams webhook events and can forward them to a local server. On older
+servers, it uses the webhook wait endpoint. It runs on your machine and stops on Ctrl+C. The optional server SSH gateway supports bounded
 commands; it does not provide this continuous listener or a shell/SCP/SFTP service.
 
 [Command reference](https://kivel.io/docs/cli/) ·

package/dist/listen.js

@@ -1,4 +1,5 @@
 import { Buffer } from 'node:buffer';
+import { setTimeout as pause } from 'node:timers/promises';
 import { KivelError } from '@kivel.io/sdk';
 // Hop-by-hop and proxy headers describe the trip to Kivel, not the original sender.
 const dropped = /^(host|content-length|connection|keep-alive|transfer-encoding|upgrade|te|trailer|proxy-.*|x-forwarded-.*|x-real-ip|cf-.*|cdn-loop|true-client-ip|x-access-token|authorization)$/i;
@@ -24,27 +25,41 @@ export async function listen(client, inboxId, options, write, signal) {
     if (options.forward)
         new URL(options.forward);
     let after;
-    if (!options.all) {
-        const existing = (await client.inspectInbox(inboxId, options.token));
-        after = existing.requests.at(-1)?.id;
+    let delay = 200;
+    async function backoff(seconds = 0) {
+        await pause(Math.max(delay, seconds * 1000), undefined, { signal }).catch(() => { });
+        delay = Math.min(delay * 2, 10000);
     }
-    write({ event: 'listening', inboxId, forward: options.forward ?? null });
-    while (!signal?.aborted) {
-        let batch;
+    async function retry(error) {
+        if (signal?.aborted)
+            return;
+        if (error instanceof KivelError && error.status === 429) {
+            await backoff(error.retryAfter ?? 2);
+        }
+        else if (error instanceof TypeError ||
+            (error instanceof DOMException &&
+                ['AbortError', 'NetworkError', 'TimeoutError'].includes(error.name))) {
+            await backoff();
+        }
+        else {
+            throw error;
+        }
+    }
+    while (!options.all && !signal?.aborted) {
         try {
-            batch = await client.waitForRequests(inboxId, {
-                ...(options.token ? { token: options.token } : {}),
-                ...(after ? { after } : {}),
-            });
+            after = (await client.inspectInbox(inboxId, options.token)).requests.at(-1)?.id;
+            delay = 200;
+            break;
         }
         catch (error) {
-            if (error instanceof KivelError && error.status === 429) {
-                await new Promise((resolve) => setTimeout(resolve, (error.retryAfter ?? 2) * 1000));
-                continue;
-            }
-            throw error;
+            await retry(error);
         }
-        for (const request of batch.requests) {
+    }
+    if (signal?.aborted)
+        return;
+    write({ event: 'listening', inboxId, forward: options.forward ?? null });
+    async function report(requests) {
+        for (const request of requests) {
             after = request.id;
             write({ event: 'request', request });
             if (!options.forward)
@@ -78,4 +93,46 @@ export async function listen(client, inboxId, options, write, signal) {
             }
         }
     }
+    let cursor;
+    while (!signal?.aborted) {
+        try {
+            for await (const change of client.stream([`webhook:${inboxId}`], {
+                ...(options.token ? { token: options.token } : {}),
+                ...(cursor ? { lastEventId: cursor } : {}),
+                ...(signal ? { signal } : {}),
+            })) {
+                const { requests } = await client.waitForRequests(inboxId, {
+                    ...(options.token ? { token: options.token } : {}),
+                    ...(after ? { after } : {}),
+                    timeoutSeconds: 1,
+                });
+                await report(requests);
+                cursor = change.cursor;
+                delay = 200;
+            }
+            await backoff();
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return;
+            if (error instanceof KivelError && [404, 501, 503].includes(error.status))
+                break;
+            await retry(error);
+        }
+    }
+    while (!signal?.aborted) {
+        try {
+            const batch = await client.waitForRequests(inboxId, {
+                ...(options.token ? { token: options.token } : {}),
+                ...(after ? { after } : {}),
+            });
+            await report(batch.requests);
+            delay = 200;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return;
+            await retry(error);
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kivel.io/cli",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "bin": {
     "kivel": "./bin/kivel.mjs"
@@ -18,7 +18,7 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@kivel.io/sdk": "0.9.0"
+    "@kivel.io/sdk": "0.10.0"
   },
   "devDependencies": {
     "@types/node": "^26.6.5",