@jpcasabiancai/cayenne 0.3.4 → 0.3.5

package/dist/cli.js

@@ -27,11 +27,11 @@ var CLOUD_SUPABASE_URL, CLOUD_SUPABASE_ANON_KEY, CLOUD_APP_ORIGIN;
 var init_cloud = __esm({
   "src/cloud.ts"() {
     "use strict";
-    CLOUD_SUPABASE_URL = "";
+    CLOUD_SUPABASE_URL = "https://ndqrkqxwkzxgnhkvcunr.supabase.co";
     CLOUD_SUPABASE_ANON_KEY = assertPublishable(
-      ""
+      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im5kcXJrcXh3a3p4Z25oa3ZjdW5yIiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODg3MTMyNzYsImV4cCI6MjEwNDI4OTI3Nn0.Dlsxw91E1QYZ4eoRDjP80Rf4feY77Z-T-fiIwUDY2k0"
     );
-    CLOUD_APP_ORIGIN = "";
+    CLOUD_APP_ORIGIN = "https://cayenne-pink.vercel.app";
   }
 });
 
@@ -1646,11 +1646,13 @@ var init_lock = __esm({
 });
 
 // ../../packages/db/src/client.ts
-import { createClient } from "@supabase/supabase-js";
-function createRunnerClient(url, anonKey, storage) {
+import {
+  createClient
+} from "@supabase/supabase-js";
+function createRunnerClient(url, anonKey, storage, transport) {
   return createClient(url, anonKey, {
     auth: { storage, persistSession: true, autoRefreshToken: true, detectSessionInUrl: false },
-    realtime: { params: { eventsPerSecond: 50 } }
+    realtime: { params: { eventsPerSecond: 50 }, transport }
   });
 }
 var init_client = __esm({
@@ -1667,17 +1669,38 @@ var init_src2 = __esm({
   }
 });
 
+// src/realtime-transport.ts
+import { WebSocket } from "ws";
+function realtimeTransport(handshakeTimeoutMs = REALTIME_HANDSHAKE_TIMEOUT_MS) {
+  return class RealtimeTransport2 extends WebSocket {
+    static handshakeTimeoutMs = handshakeTimeoutMs;
+    constructor(address, protocols) {
+      super(address, protocols, { handshakeTimeout: RealtimeTransport2.handshakeTimeoutMs });
+    }
+  };
+}
+var REALTIME_HANDSHAKE_TIMEOUT_MS, RealtimeTransport;
+var init_realtime_transport = __esm({
+  "src/realtime-transport.ts"() {
+    "use strict";
+    REALTIME_HANDSHAKE_TIMEOUT_MS = 1e4;
+    RealtimeTransport = realtimeTransport();
+  }
+});
+
 // src/supabase.ts
 import { join as join7 } from "path";
 function makeClient(cfg, dir = cayenneDir()) {
   const storage = new FileSessionStorage(join7(dir, "credentials.json"));
-  return createRunnerClient(cfg.supabaseUrl, cfg.supabaseAnonKey, storage);
+  const transport = RealtimeTransport;
+  return createRunnerClient(cfg.supabaseUrl, cfg.supabaseAnonKey, storage, transport);
 }
 var init_supabase = __esm({
   "src/supabase.ts"() {
     "use strict";
     init_src2();
     init_config();
+    init_realtime_transport();
   }
 });
 
@@ -1978,12 +2001,17 @@ var init_dispatcher = __esm({
 
 // src/commands/source.ts
 import { LRUCache } from "lru-cache";
-var STOPPING, byCreatedAt, GIT_READ_KINDS, GIT_WORKTREE_KINDS, laneOf, CommandSource;
+var STOPPING, REJOIN_MIN_MS, REJOIN_MAX_MS, SOCKET_RESET_MS, LOST, messageOf, byCreatedAt, GIT_READ_KINDS, GIT_WORKTREE_KINDS, laneOf, CommandSource;
 var init_source = __esm({
   "src/commands/source.ts"() {
     "use strict";
     init_src();
     STOPPING = "runner stopping";
+    REJOIN_MIN_MS = 1e3;
+    REJOIN_MAX_MS = 3e4;
+    SOCKET_RESET_MS = 6e4;
+    LOST = /* @__PURE__ */ new Set(["CHANNEL_ERROR", "TIMED_OUT", "CLOSED"]);
+    messageOf = (err) => err instanceof Error ? err.message : String(err);
     byCreatedAt = (a, b) => Date.parse(a.created_at) - Date.parse(b.created_at) || a.id.localeCompare(b.id);
     GIT_READ_KINDS = /* @__PURE__ */ new Set(["git.status", "git.diff", "git.branches"]);
     GIT_WORKTREE_KINDS = /* @__PURE__ */ new Set([
@@ -2018,32 +2046,175 @@ var init_source = __esm({
       /** Rows between `enqueue` and their settlement: an `offer` for one of these registers hooks only. */
       inflight = /* @__PURE__ */ new Set();
       queues = /* @__PURE__ */ new Map();
+      /** The live `runner:{id}` instance; only its statuses count (see `onStatus`). */
       channel = null;
+      /** Every instance this source gave up on: the client can hand one back if its removal did not take. */
+      abandoned = /* @__PURE__ */ new WeakSet();
+      /** Removals of abandoned instances; never rejects. A rejoin waits for it before reusing the topic. */
+      removal = Promise.resolve();
+      rejoinTimer = null;
+      /** Rejoin attempts scheduled since the last `SUBSCRIBED`: the backoff step. */
+      attempts = 0;
+      /** `now()` at the first attempt that found the socket down, or at its last reset; null while up. */
+      socketDownSince = null;
       staleMs;
       now;
       stopped = false;
       /** The in-flight `drain()`, so `stop()` can wait for work it never started itself. */
       draining = null;
+      /** A `drain()` arrived while one was in flight: that one reads once more before it ends. */
+      again = false;
       /** Broadcasts held back while a drain is in flight; see `drain()` for why. */
       pending = [];
+      /** Join `runner:{id}` at once; no connectedness check, since `subscribe` connects the socket. */
       async start() {
-        this.channel = this.db.channel(runnerTopic(this.runnerId), { config: { private: true } }).on("broadcast", { event: "command" }, ({ payload }) => {
-          const record = payload?.record;
-          const parsed = CommandRow.safeParse(record);
-          if (!parsed.success) {
-            this.log.warn({ issues: parsed.error.issues }, "ignoring malformed command broadcast");
+        this.join(this.runnerChannel());
+      }
+      /**
+       * The one place a `runner:{id}` instance is asked for, first join and rejoins alike. Private:
+       * Realtime authorises the join against RLS, which is what keeps this topic this runner's.
+       */
+      runnerChannel() {
+        return this.db.channel(runnerTopic(this.runnerId), { config: { private: true } });
+      }
+      /** Make `ch` the live instance, then give it the one broadcast and status handler every instance gets. */
+      join(ch) {
+        this.channel = ch;
+        ch.on("broadcast", { event: "command" }, ({ payload }) => this.onBroadcast(payload)).subscribe(
+          (status, err) => this.onStatus(ch, status, err)
+        );
+      }
+      onBroadcast(payload) {
+        const record = payload?.record;
+        const parsed = CommandRow.safeParse(record);
+        if (!parsed.success) {
+          this.log.warn({ issues: parsed.error.issues }, "ignoring malformed command broadcast");
+          return;
+        }
+        if (parsed.data.runner_id !== this.runnerId) {
+          this.log.warn({ id: parsed.data.id }, "ignoring command for another runner");
+          return;
+        }
+        if (this.draining) this.pending.push(parsed.data);
+        else this.enqueue(parsed.data);
+      }
+      /**
+       * The subscribe callback of every instance this source joined (BACKLOG P-29, protocol §8 step
+       * 5). Nothing else rejoins a lost channel: after a three-hour outage the client's own rejoin never
+       * ran, because its socket never reopened. So a lost instance is abandoned and a fresh one joined
+       * after a backoff; every `SUBSCRIBED` drains, since broadcasts sent while the channel was down
+       * are gone and their rows sit `queued`.
+       *
+       * Only the live instance counts. An abandoned one still reports: its own removal fires `CLOSED`
+       * in-line, and handling that as a loss would remove the instance again, whose leave fires
+       * `CLOSED` again, and so on: removals nested inside removals.
+       */
+      onStatus(ch, status, err) {
+        if (ch !== this.channel) {
+          this.log.debug({ status }, "ignoring the status of a runner channel no longer in use");
+          return;
+        }
+        this.log.info({ status, err: err?.message }, "runner channel status");
+        if (status === "SUBSCRIBED") {
+          this.attempts = 0;
+          this.socketDownSince = null;
+          void this.drain();
+        } else if (LOST.has(status)) {
+          this.abandon(ch);
+          this.scheduleRejoin(status);
+        }
+      }
+      /** Stop listening to `ch` (null first, so its removal's `CLOSED` is ignored), then remove it. */
+      abandon(ch) {
+        if (this.channel === ch) this.channel = null;
+        this.abandoned.add(ch);
+        const left = (async () => this.db.removeChannel(ch))().then(
+          (result) => {
+            if (result === "ok" || result === "timed out") return true;
+            this.log.warn({ result }, "leaving the runner channel failed");
+            return false;
+          },
+          (err) => {
+            this.log.warn({ err: messageOf(err) }, "leaving the runner channel failed");
+            return false;
+          }
+        );
+        this.removal = Promise.all([this.removal, left]).then(() => {
+        });
+        return left;
+      }
+      /**
+       * At most one pending attempt, `min(1 s * 2^n, 30 s)` away, n = attempts since the last
+       * `SUBSCRIBED`. `reason` says why: the lost channel's status, or `SOCKET_DOWN`, `NOT_REMOVED`,
+       * `JOIN_FAILED` for an attempt that could not join. It is logged as `reason`, not `status`, so
+       * a search for the client's statuses never meets one of these.
+       */
+      scheduleRejoin(reason) {
+        if (this.stopped || this.rejoinTimer) return;
+        const delayMs = Math.min(REJOIN_MIN_MS * 2 ** this.attempts, REJOIN_MAX_MS);
+        this.attempts += 1;
+        this.log.warn({ reason, attempt: this.attempts, delayMs }, "runner channel lost; rejoining");
+        this.rejoinTimer = setTimeout(() => {
+          this.rejoinTimer = null;
+          void this.rejoin();
+        }, delayMs);
+      }
+      /**
+       * One attempt. The client hands back the instance it holds for a topic and drops a topic's
+       * entry when any instance of it closes, so the old removal must have finished before a fresh
+       * instance is created. A socket that is down gets a `connect()` and no join: it buffers every
+       * push while down and flushes them all on reopen, so a join per attempt through a long outage
+       * would arrive as a burst of joins and leaves.
+       */
+      async rejoin() {
+        await this.removal;
+        if (this.stopped) return;
+        try {
+          if (!this.db.realtime.isConnected()) {
+            await this.reconnectSocket();
+            this.scheduleRejoin("SOCKET_DOWN");
             return;
           }
-          if (parsed.data.runner_id !== this.runnerId) {
-            this.log.warn({ id: parsed.data.id }, "ignoring command for another runner");
+          this.socketDownSince = null;
+          const ch = this.runnerChannel();
+          if (this.abandoned.has(ch)) {
+            this.log.warn({ attempt: this.attempts }, "runner channel still held after leaving it");
+            this.abandon(ch);
+            this.scheduleRejoin("NOT_REMOVED");
             return;
           }
-          if (this.draining) this.pending.push(parsed.data);
-          else this.enqueue(parsed.data);
-        }).subscribe((status, err) => {
-          this.log.info({ status, err: err?.message }, "runner channel status");
-          if (status === "SUBSCRIBED") void this.drain();
-        });
+          this.join(ch);
+        } catch (err) {
+          this.log.warn(
+            { attempt: this.attempts, err: messageOf(err) },
+            "runner channel rejoin failed"
+          );
+          if (this.channel) this.abandon(this.channel);
+          this.scheduleRejoin("JOIN_FAILED");
+        }
+      }
+      /**
+       * Ask a down socket to connect. Once attempts have found it down for `SOCKET_RESET_MS`, tear it
+       * down first: `connect()` returns early while the client still holds a conn, and a conn whose
+       * handshake failed without a close (Node's own WebSocket, BACKLOG P-29) is held forever. The
+       * `ws` transport should never leave one; this clears it whatever the transport. In an ordinary
+       * outage it costs nothing, since phoenix's reconnect loop carries on from this `connect()`.
+       */
+      async reconnectSocket() {
+        const now = this.now();
+        this.socketDownSince ??= now;
+        const downMs = now - this.socketDownSince;
+        if (downMs >= SOCKET_RESET_MS) {
+          this.log.warn({ downMs }, "realtime socket still down; resetting it");
+          this.socketDownSince = now;
+          try {
+            await this.db.realtime.disconnect();
+          } catch (err) {
+            this.log.warn({ err: messageOf(err) }, "realtime socket reset failed");
+          }
+          if (this.stopped) return;
+        }
+        this.db.realtime.connect();
       }
       /**
        * Pick up rows queued while the runner was offline, oldest first.
@@ -2051,15 +2222,37 @@ var init_source = __esm({
        * Broadcasts that land while the select is in flight are buffered and merged in here rather
        * than enqueued as they arrive: every drained row predates them, and protocol §2.1 requires
        * one session's commands to execute in `created_at` order.
+       *
+       * One drain at a time: a call while one is in flight (a rejoin's `SUBSCRIBED`) asks it for one
+       * more read and waits for it. A second, overlapping select would release the buffer while the
+       * first was still reading older rows. Rows and buffered broadcasts of every read are merged once,
+       * at the end, because a row only the later read finds can predate a broadcast held earlier.
        */
-      async drain() {
-        if (this.stopped) return;
-        let release = () => {
-        };
-        this.draining = new Promise((res) => {
-          release = res;
-        });
+      drain() {
+        if (this.stopped) return Promise.resolve();
+        if (this.draining) {
+          this.again = true;
+          return this.draining;
+        }
+        this.draining = this.drainAll();
+        return this.draining;
+      }
+      async drainAll() {
         const rows = [];
+        try {
+          do {
+            this.again = false;
+            await this.readQueued(rows);
+          } while (this.again && !this.stopped);
+        } finally {
+          const merged = [...rows, ...this.pending].sort(byCreatedAt);
+          this.pending = [];
+          this.draining = null;
+          for (const row of merged) this.enqueue(row);
+        }
+      }
+      /** One read of this runner's `queued` rows, appended to `rows`. Never rejects. */
+      async readQueued(rows) {
         try {
           const { data, error } = await this.db.from("runner_commands").select("*").eq("runner_id", this.runnerId).eq("status", "queued").order("created_at", { ascending: true });
           if (error) this.log.error({ err: error.message }, "drain failed");
@@ -2069,17 +2262,16 @@ var init_source = __esm({
           }
         } catch (err) {
           this.log.error({ err }, "drain failed");
-        } finally {
-          const merged = [...rows, ...this.pending].sort(byCreatedAt);
-          this.pending = [];
-          this.draining = null;
-          for (const row of merged) this.enqueue(row);
-          release();
         }
       }
       async stop() {
         this.stopped = true;
-        if (this.channel) await this.db.removeChannel(this.channel);
+        if (this.rejoinTimer) clearTimeout(this.rejoinTimer);
+        this.rejoinTimer = null;
+        const live = this.channel;
+        const left = live ? this.abandon(live) : null;
+        await this.removal;
+        if (left && await left) this.log.info({ status: "CLOSED" }, "runner channel status");
         this.pending = [];
         await this.draining;
         while (this.queues.size > 0) await Promise.allSettled([...this.queues.values()]);
@@ -8733,7 +8925,7 @@ function createTerminalChannels({
           log.warn({ terminalId, type: m.type, result }, "terminal frame not sent");
       },
       (err) => {
-        log.warn({ terminalId, type: m.type, err: messageOf(err) }, "terminal frame not sent");
+        log.warn({ terminalId, type: m.type, err: messageOf2(err) }, "terminal frame not sent");
       }
     ).finally(() => {
       entry.pending.delete(sent);
@@ -8773,7 +8965,7 @@ function createTerminalChannels({
       try {
         manager.receive(terminalId, payload, "relay");
       } catch (err) {
-        log.warn({ terminalId, err: messageOf(err) }, "terminal message refused");
+        log.warn({ terminalId, err: messageOf2(err) }, "terminal message refused");
       }
     });
     joined.set(terminalId, { channel, pending: /* @__PURE__ */ new Set() });
@@ -8804,12 +8996,12 @@ function createTerminalChannels({
     }
   }
 }
-var messageOf;
+var messageOf2;
 var init_channels = __esm({
   "src/terminal/channels.ts"() {
     "use strict";
     init_src();
-    messageOf = (err) => err instanceof Error ? err.message : String(err);
+    messageOf2 = (err) => err instanceof Error ? err.message : String(err);
   }
 });
 
@@ -9746,7 +9938,7 @@ function createTerminalService({
       await closeRow(terminalId);
       await channels.detach(terminalId);
     })().catch((err) => {
-      log.warn({ terminalId, err: messageOf2(err) }, "terminal exit cleanup failed");
+      log.warn({ terminalId, err: messageOf3(err) }, "terminal exit cleanup failed");
     }).finally(() => {
       exiting.delete(done);
     });
@@ -9777,7 +9969,7 @@ function createTerminalService({
         if (!manager.has(terminalId) && !cleanedWhileOpening.has(terminalId)) {
           live.delete(terminalId);
           await channels.detach(terminalId).catch((detachErr) => {
-            log.warn({ terminalId, err: messageOf2(detachErr) }, "terminal channel detach failed");
+            log.warn({ terminalId, err: messageOf3(detachErr) }, "terminal channel detach failed");
           });
           await closeRow(terminalId);
         }
@@ -9838,13 +10030,13 @@ function createTerminalService({
     }
   };
 }
-var messageOf2;
+var messageOf3;
 var init_service3 = __esm({
   "src/terminal/service.ts"() {
     "use strict";
     init_manager2();
     init_refusals();
-    messageOf2 = (err) => err instanceof Error ? err.message : String(err);
+    messageOf3 = (err) => err instanceof Error ? err.message : String(err);
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jpcasabiancai/cayenne",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "files": [
     "dist/cli.js"
   ],
@@ -24,7 +24,11 @@
     "dev": "tsx src/cli.ts start",
     "build": "tsup",
     "postbuild": "node dist/cli.js --version",
-    "prepublishOnly": "pnpm build",
+    "release:guard:pre": "tsx src/release/cli.ts --pre",
+    "release:guard:post": "tsx src/release/cli.ts --post",
+    "release:build": "pnpm release:guard:pre && CAYENNE_REQUIRE_CLOUD=1 pnpm build && pnpm release:guard:post",
+    "release:pack": "pnpm release:build && npm pack",
+    "prepublishOnly": "pnpm release:build",
     "typecheck": "tsc -p tsconfig.json",
     "test": "vitest run"
   },