@jpcasabiancai/cayenne 0.5.0 → 0.5.1

package/dist/cli.js

@@ -1507,10 +1507,10 @@ function assertClaudeDirExists(dir) {
   }
 }
 function claudeEnv(dir) {
-  return dir ? { CLAUDE_CONFIG_DIR: dir } : {};
+  return { CLAUDE_CONFIG_DIR: dir };
 }
 function sessionClaudeConfigDir(sessionEnv, daemonEnv = process.env, home = homedir()) {
-  return sessionEnv?.CLAUDE_CONFIG_DIR ?? daemonEnv.CLAUDE_CONFIG_DIR ?? join(home, ".claude");
+  return { ...daemonEnv, ...sessionEnv }.CLAUDE_CONFIG_DIR ?? join(home, ".claude");
 }
 function cliHash(text) {
   let hash = 0;
@@ -6847,6 +6847,31 @@ var init_handlers = __esm({
   }
 });
 
+// src/broadcast.ts
+import { REALTIME_CHANNEL_STATES } from "@supabase/supabase-js";
+function sendOnChannel(channel) {
+  return (message, timeoutMs) => canPush(channel) ? channel.send(message, { timeout: timeoutMs }) : sendOverRest(channel, message, timeoutMs);
+}
+async function sendOverRest(channel, message, timeoutMs) {
+  let sent;
+  try {
+    sent = await channel.httpSend(message.event, message.payload, { timeout: timeoutMs });
+  } catch (err) {
+    if (isAbort(err)) return "timed out";
+    throw err;
+  }
+  if (sent.success) return "ok";
+  throw new Error(`httpSend ${sent.status}: ${sent.error}`);
+}
+var isAbort, canPush;
+var init_broadcast = __esm({
+  "src/broadcast.ts"() {
+    "use strict";
+    isAbort = (err) => err?.name === "AbortError";
+    canPush = (channel) => channel.state === REALTIME_CHANNEL_STATES.joined && channel.socket.isConnected();
+  }
+});
+
 // src/documents/paths.ts
 import { realpathSync as realpathSync11 } from "fs";
 import { isAbsolute as isAbsolute12, join as join20, relative as relative6, sep as sep9 } from "path";
@@ -9760,6 +9785,7 @@ var init_manager = __esm({
   "src/sessions/manager.ts"() {
     "use strict";
     init_src();
+    init_broadcast();
     init_claude_dir();
     init_config();
     init_paths2();
@@ -11573,7 +11599,7 @@ var init_manager = __esm({
           channel,
           relay: new SessionRelay({
             sessionId,
-            send: (message, timeout) => channel.send(message, { timeout }),
+            send: sendOnChannel(channel),
             log: this.deps.log
           }),
           seq,
@@ -11944,10 +11970,10 @@ var init_manager = __esm({
       /**
        * Join `session:{id}` without waiting for it (chat latency follow-up, protocol §3).
        *
-       * The runner only sends on this channel, and realtime-js sends a channel that cannot push over
-       * its REST fallback, which the relay bounds. So a join that fails, or that nobody answers while
-       * the socket is down, costs relay subscribers the socket path and never the session: before
-       * this, it failed every `session.start` and every resume for as long as Realtime was down.
+       * The runner only sends on this channel, and the relay sends a channel that cannot push over
+       * REST (`sendOnChannel`), within the same bound. So a join that fails, or that nobody answers
+       * while the socket is down, costs relay subscribers the socket path and never the session:
+       * before this, it failed every `session.start` and every resume for as long as Realtime was down.
        *
        * A join that errors or times out is the client's to retry: it rejoins this instance on its own
        * timer while the socket is up, and as soon as the socket reopens. So the instance is kept, not
@@ -12492,7 +12518,21 @@ function createTerminalChannels({
     if (m.type === "output" && manager.relaySuppressed(terminalId)) return;
     const entry = joined.get(terminalId);
     if (!entry) return;
-    const sent = entry.channel.send({ type: "broadcast", event: TERMINAL_OUT_EVENT, payload: m }).then(
+    if (m.type !== "exit" && !canPush(entry.channel)) {
+      if (entry.skipped === 0) {
+        log.warn(
+          { terminalId, state: entry.channel.state },
+          "terminal channel cannot push; skipping output until it can"
+        );
+      }
+      entry.skipped += 1;
+      return;
+    }
+    if (entry.skipped > 0 && canPush(entry.channel)) {
+      log.info({ terminalId, skipped: entry.skipped }, "terminal channel pushing again");
+      entry.skipped = 0;
+    }
+    const sent = entry.send({ type: "broadcast", event: TERMINAL_OUT_EVENT, payload: m }, BROADCAST_SEND_TIMEOUT_MS).then(
       (result) => {
         if (result !== "ok")
           log.warn({ terminalId, type: m.type, result }, "terminal frame not sent");
@@ -12541,7 +12581,12 @@ function createTerminalChannels({
         log.warn({ terminalId, err: messageOf5(err) }, "terminal message refused");
       }
     });
-    joined.set(terminalId, { channel, pending: /* @__PURE__ */ new Set() });
+    joined.set(terminalId, {
+      channel,
+      send: sendOnChannel(channel),
+      pending: /* @__PURE__ */ new Set(),
+      skipped: 0
+    });
     try {
       await new Promise((resolve5, reject) => {
         let settled = false;
@@ -12574,6 +12619,7 @@ var init_channels = __esm({
   "src/terminal/channels.ts"() {
     "use strict";
     init_src();
+    init_broadcast();
     messageOf5 = (err) => err instanceof Error ? err.message : String(err);
   }
 });
@@ -12589,7 +12635,10 @@ function terminalEnv(base, { runnerOwner, claudeConfigDir }) {
     if (!runnerOwner && !MEMBER_ENV_KEYS.has(key) && !LOCALE_ENV.test(key)) continue;
     env[key] = value;
   }
-  if (runnerOwner && claudeConfigDir) env.CLAUDE_CONFIG_DIR = claudeConfigDir;
+  if (runnerOwner) {
+    if (claudeConfigDir) env.CLAUDE_CONFIG_DIR = claudeConfigDir;
+    else delete env.CLAUDE_CONFIG_DIR;
+  }
   return {
     ...env,
     TERM: "xterm-256color",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jpcasabiancai/cayenne",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "files": [
     "dist/cli.js"
   ],