kantban-cli 0.1.18 → 0.1.20

package/dist/{cron-273WBN3N.js → cron-722GUOUP.js}

@@ -3,8 +3,8 @@ import {
   RalphLoop,
   cleanupMcpConfig,
   generateMcpConfig
-} from "./chunk-2EJEOAGB.js";
-import "./chunk-MN4H5NSU.js";
+} from "./chunk-D4T7ZUWI.js";
+import "./chunk-ZTQJMXJM.js";
 
 // src/commands/cron.ts
 import { readFileSync } from "fs";
@@ -101,4 +101,4 @@ async function runCron(client, args) {
 export {
   runCron
 };
-//# sourceMappingURL=cron-273WBN3N.js.map
+//# sourceMappingURL=cron-722GUOUP.js.map

package/dist/index.js

@@ -31,16 +31,16 @@ async function main() {
     }
     case "pipeline": {
       if (args[0] === "stop") {
-        const { stopPipeline } = await import("./pipeline-KAIEIIIC.js");
+        const { stopPipeline } = await import("./pipeline-FMDQGNHO.js");
         await stopPipeline(args.slice(1));
       } else {
-        const { runPipeline } = await import("./pipeline-KAIEIIIC.js");
+        const { runPipeline } = await import("./pipeline-FMDQGNHO.js");
         await runPipeline(client, args);
       }
       break;
     }
     case "cron": {
-      const { runCron } = await import("./cron-273WBN3N.js");
+      const { runCron } = await import("./cron-722GUOUP.js");
       await runCron(client, args);
       break;
     }

package/dist/lib/gate-proxy-server.js

@@ -5,12 +5,12 @@ import {
 import {
   formatGateErrors,
   runGates
-} from "../chunk-4IUZAIFL.js";
+} from "../chunk-APZG5K2J.js";
 import {
   parseGateConfig,
   parseTimeout,
   resolveGatesForColumn
-} from "../chunk-MN4H5NSU.js";
+} from "../chunk-ZTQJMXJM.js";
 
 // src/lib/gate-proxy-server.ts
 import { readFileSync } from "fs";

package/dist/{pipeline-KAIEIIIC.js → pipeline-FMDQGNHO.js}

@@ -1,6 +1,6 @@
 import {
   runGates
-} from "./chunk-4IUZAIFL.js";
+} from "./chunk-APZG5K2J.js";
 import {
   ClaudeProvider,
   RalphLoop,
@@ -12,14 +12,14 @@ import {
   generateMcpConfig,
   parseJsonFromLlmOutput,
   parseStuckDetectionResponse
-} from "./chunk-2EJEOAGB.js";
+} from "./chunk-D4T7ZUWI.js";
 import {
   LoopCheckpointSchema,
   VerdictSchema,
   parseGateConfig,
   parseTimeout,
   resolveGatesForColumn
-} from "./chunk-MN4H5NSU.js";
+} from "./chunk-ZTQJMXJM.js";
 
 // src/commands/pipeline.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync2, appendFileSync as appendFileSync2 } from "fs";
@@ -2214,12 +2214,28 @@ var EventQueue = class {
 
 // src/lib/ws-client.ts
 import WebSocket from "ws";
-var PipelineWsClient = class {
+var PipelineWsClient = class _PipelineWsClient {
   ws = null;
   client;
   options;
   pingTimer = null;
+  reconnectTimer = null;
+  reconnectAttempt = 0;
+  lastPong = 0;
   stopped = false;
+  sendBuffer = [];
+  static CRITICAL_TYPES = /* @__PURE__ */ new Set([
+    "pipeline:session-start",
+    "pipeline:session-end",
+    "pipeline:stopped",
+    "board:subscribe"
+  ]);
+  static BUFFER_MAX = 100;
+  static BUFFER_TTL_MS = 3e4;
+  // 30 seconds
+  static PING_INTERVAL_MS = 3e4;
+  static PONG_TIMEOUT_MS = 45e3;
+  // dead if no pong in 45s
   constructor(client, options) {
     this.client = client;
     this.options = options;
@@ -2237,22 +2253,35 @@ var PipelineWsClient = class {
       }
       this.ws = null;
     }
-    this.cleanupPing();
+    this.cleanupTimers();
     const { ticket } = await this.client.post("/ws-ticket");
-    const wsUrl = this.client.baseUrl.replace(/^http/, "ws") + `/ws?ticket=${ticket}`;
+    const wsUrl = this.client.baseUrl.replace(/^http/, "ws") + `/ws?ticket=${ticket}&clientType=cli`;
     return new Promise((resolve, reject) => {
       let resolved = false;
       this.ws = new WebSocket(wsUrl);
       let subscribed = false;
       this.ws.on("open", () => {
-        this.pingTimer = setInterval(() => this.send({ type: "ping", payload: {} }), 3e4);
+        this.lastPong = Date.now();
+        this.reconnectAttempt = 0;
+        this.pingTimer = setInterval(() => {
+          if (Date.now() - this.lastPong > _PipelineWsClient.PONG_TIMEOUT_MS) {
+            console.warn("[WS] No pong in 45s \u2014 connection dead, forcing reconnect");
+            this.ws?.close();
+            return;
+          }
+          this.send({ type: "ping", payload: {} });
+        }, _PipelineWsClient.PING_INTERVAL_MS);
       });
       this.ws.on("message", (data) => {
         try {
           const event = JSON.parse(data.toString());
+          if (event.type === "pong") {
+            this.lastPong = Date.now();
+          }
           if (!subscribed) {
             subscribed = true;
             this.send({ type: "board:subscribe", payload: { boardId: this.options.boardId, projectId: this.options.projectId } });
+            this.flushBuffer();
             this.options.onConnect();
             if (!resolved) {
               resolved = true;
@@ -2265,11 +2294,13 @@ var PipelineWsClient = class {
         }
       });
       this.ws.on("close", (code) => {
-        this.cleanupPing();
+        this.cleanupTimers();
         this.options.onDisconnect();
         if (!resolved) {
           resolved = true;
           reject(new Error(`WebSocket closed before handshake (code ${code})`));
+        } else {
+          this.scheduleReconnect();
         }
       });
       this.ws.on("error", (err) => {
@@ -2294,8 +2325,9 @@ var PipelineWsClient = class {
     }
   }
   stop() {
+    this.sendBuffer = [];
     this.stopped = true;
-    this.cleanupPing();
+    this.cleanupTimers();
     if (this.ws) {
       try {
         this.ws.removeAllListeners();
@@ -2308,13 +2340,57 @@ var PipelineWsClient = class {
   send(data) {
     if (this.ws?.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(data));
+      return;
+    }
+    const event = data;
+    const isCritical = _PipelineWsClient.CRITICAL_TYPES.has(event.type ?? "");
+    if (isCritical) {
+      if (this.sendBuffer.length < _PipelineWsClient.BUFFER_MAX) {
+        this.sendBuffer.push({ data, critical: true, timestamp: Date.now() });
+      }
+      console.warn(`[WS] Buffered critical event (WS not open): ${event.type}`);
+    } else if (event.type !== "ping") {
+      console.debug?.(`[WS] Dropped non-critical event (WS not open): ${event.type}`);
     }
   }
-  cleanupPing() {
+  flushBuffer() {
+    const now = Date.now();
+    const valid = this.sendBuffer.filter((e) => now - e.timestamp < _PipelineWsClient.BUFFER_TTL_MS);
+    this.sendBuffer = [];
+    for (const entry of valid) {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify(entry.data));
+        const event = entry.data;
+        console.log(`[WS] Replayed buffered event: ${event.type}`);
+      }
+    }
+  }
+  scheduleReconnect() {
+    if (this.stopped || this.reconnectTimer) return;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempt), 3e4);
+    this.reconnectAttempt++;
+    console.log(`[WS] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt})`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (this.stopped) return;
+      this.connect().then(() => {
+        console.log("[WS] Reconnected successfully");
+      }).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[WS] Reconnect failed: ${msg}`);
+        this.scheduleReconnect();
+      });
+    }, delay);
+  }
+  cleanupTimers() {
     if (this.pingTimer) {
       clearInterval(this.pingTimer);
       this.pingTimer = null;
     }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
   }
 };
 
@@ -4253,4 +4329,4 @@ export {
   runPipeline,
   stopPipeline
 };
-//# sourceMappingURL=pipeline-KAIEIIIC.js.map
+//# sourceMappingURL=pipeline-FMDQGNHO.js.map