pi-harness-runtime 1.1.376 → 1.1.377

package/scripts/relay-client.ts

@@ -1,9 +1,11 @@
 #!/usr/bin/env bun
 /**
- * Real-time Callback Relay Client
+ * Real-time Callback Relay Client - Two-way streaming
  * 
- * Connects to WebSocket server on VPS to receive callbacks instantly.
- * No file queue sync needed!
+ * Uses the relay package's typed streaming protocol:
+ * - Snapshot + Live event pattern (t3code style)
+ * - Connection state machine with automatic reconnection
+ * - Typed message handling
  * 
  * Usage:
  *   RELAY_WS_URL=wss://webhook.bunchee.online:8444 \
@@ -11,35 +13,20 @@
  *   bun run scripts/relay-client.ts
  */
 
-import { WebSocket } from "ws";
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import { RelayClient } from "../packages/relay/src/client";
+import type { CallbackPayload, SnapshotMessage } from "../packages/relay/src/types";
 
 // Configuration
 const RELAY_WS_URL = process.env.RELAY_WS_URL || "wss://webhook.bunchee.online:8444";
 const RELAY_AUTH_TOKEN = process.env.RELAY_AUTH_TOKEN || "change-me-in-production";
-const CALLBACK_QUEUE_FILE = join(homedir(), ".pi-harness-runtime", "callback-queue.jsonl");
 const JOB_PIPE_FILE = join(homedir(), ".pi-harness-runtime", "job-commands.jsonl");
 
-interface RelayMessage {
-  type: string;
-  payload: unknown;
-}
-
-interface CallbackPayload {
-  type: "telegram_callback" | "line_callback";
-  action: string;
-  targetId: string;
-  userId: number;
-  username?: string;
-  messageId?: number;
-  timestamp: string;
-}
-
-let ws: WebSocket | null = null;
-let reconnectDelay = 1000;
-let authenticated = false;
+// ============================================================================
+// Telegram Integration
+// ============================================================================
 
 function loadKeys() {
   const keysDir = join(homedir(), ".pi-harness-runtime", "keys");
@@ -52,7 +39,7 @@ function loadKeys() {
 function writeToJobPipe(command: { command: string; jobId: string; userId: number; timestamp: string }): void {
   const line = JSON.stringify(command) + "\n";
   writeFileSync(JOB_PIPE_FILE, line, { flag: "a" });
-  console.log(`[RelayClient] Wrote to job pipe: ${command.command} ${command.jobId}`);
+  console.log(`[Client] Wrote to job pipe: ${command.command} ${command.jobId}`);
 }
 
 async function sendTelegramMessage(chatId: number, text: string): Promise<void> {
@@ -64,8 +51,12 @@ async function sendTelegramMessage(chatId: number, text: string): Promise<void>
   });
 }
 
+// ============================================================================
+// Callback Processing
+// ============================================================================
+
 async function processCallback(callback: CallbackPayload): Promise<void> {
-  console.log(`[RelayClient] Processing: ${callback.type} - ${callback.action} ${callback.targetId}`);
+  console.log(`[Client] Processing: ${callback.type} - ${callback.action} ${callback.targetId}`);
 
   switch (callback.action) {
     case "approve":
@@ -75,7 +66,7 @@ async function processCallback(callback: CallbackPayload): Promise<void> {
         userId: callback.userId,
         timestamp: new Date().toISOString(),
       });
-      await sendTelegramMessage(callback.userId, `✅ Approved! Job ${callback.targetId} will resume.`);
+      await sendTelegramMessage(callback.userId, `Approved! Job ${callback.targetId} will resume.`);
       break;
 
     case "reject":
@@ -85,91 +76,109 @@ async function processCallback(callback: CallbackPayload): Promise<void> {
         userId: callback.userId,
         timestamp: new Date().toISOString(),
       });
-      await sendTelegramMessage(callback.userId, `❌ Rejected. Job ${callback.targetId} cancelled.`);
+      await sendTelegramMessage(callback.userId, `Rejected. Job ${callback.targetId} cancelled.`);
       break;
 
     case "sayhi":
       await sendTelegramMessage(
         callback.userId,
-        "👋 Hi! Two-way communication working! (Real-time via WebSocket)"
+        "Hi! Two-way streaming communication working!"
       );
       break;
 
     default:
-      console.log(`[RelayClient] Unknown action: ${callback.action}`);
+      console.log(`[Client] Unknown action: ${callback.action}`);
   }
 }
 
-function connect(): void {
-  console.log(`[RelayClient] Connecting to ${RELAY_WS_URL}...`);
-  
-  ws = new WebSocket(RELAY_WS_URL);
-
-  ws.on("open", () => {
-    console.log("[RelayClient] Connected!");
-    reconnectDelay = 1000;
-    
-    // Authenticate
-    ws!.send(JSON.stringify({ type: "auth", payload: RELAY_AUTH_TOKEN }));
-  });
-
-  ws.on("message", async (data) => {
-    try {
-      const msg = JSON.parse(data.toString()) as RelayMessage;
-      
-      switch (msg.type) {
-        case "connected":
-          console.log("[RelayClient] Server acknowledged connection");
-          break;
-
-        case "auth":
-          const authResult = msg.payload as { success: boolean; error?: string };
-          if (authResult.success) {
-            authenticated = true;
-            console.log("[RelayClient] Authenticated!");
-          } else {
-            console.error("[RelayClient] Auth failed:", authResult.error);
-            ws?.close();
-          }
-          break;
-
-        case "callback":
-          if (!authenticated) break;
-          await processCallback(msg.payload as CallbackPayload);
-          break;
-
-        case "pong":
-          // Heartbeat response
-          break;
-      }
-    } catch (err) {
-      console.error("[RelayClient] Parse error:", err);
+// ============================================================================
+// Main
+// ============================================================================
+
+async function main() {
+  console.log("===========================================");
+  console.log("Real-time Callback Relay Client - Streaming v2");
+  console.log("===========================================");
+  console.log(`Server: ${RELAY_WS_URL}`);
+  console.log("===========================================");
+
+  // Create client with typed callbacks
+  const client = new RelayClient(
+    {
+      serverUrl: RELAY_WS_URL,
+      token: RELAY_AUTH_TOKEN,
+      keepAlive: 30000,
+    },
+    {
+      onConnected: (sessionId) => {
+        console.log(`[Client] Connected! Session: ${sessionId}`);
+      },
+
+      onDisconnected: () => {
+        console.log("[Client] Disconnected");
+      },
+
+      onSnapshot: (snapshot: SnapshotMessage["payload"]) => {
+        console.log(`[Client] Snapshot received:`);
+        console.log(`  - Session: ${snapshot.sessionId}`);
+        console.log(`  - Version: ${snapshot.serverVersion}`);
+        console.log(`  - Connected clients: ${snapshot.connectedClients}`);
+        console.log(`  - Recent callbacks: ${snapshot.recentCallbacks.length}`);
+        
+        // Process any recent callbacks from snapshot
+        for (const callback of snapshot.recentCallbacks) {
+          processCallback(callback).catch(console.error);
+        }
+      },
+
+      onSynchronized: () => {
+        console.log("[Client] Synchronized - receiving live events");
+      },
+
+      onCallback: (callback: CallbackPayload) => {
+        console.log(`[Client] Live callback: ${callback.action} ${callback.targetId}`);
+        processCallback(callback).catch(console.error);
+      },
+
+      onStatus: (status) => {
+        console.log(`[Client] Status [${status.kind}]: ${status.code} - ${status.message}`);
+      },
+
+      onError: (error) => {
+        console.error("[Client] Error:", error.message);
+      },
+
+      onStateChange: (change) => {
+        const prev = change.previous.state;
+        const curr = change.current.state;
+        if (prev !== curr) {
+          console.log(`[Client] State: ${prev} → ${curr}`);
+        }
+      },
     }
-  });
+  );
 
-  ws.on("close", () => {
-    authenticated = false;
-    console.log(`[RelayClient] Disconnected. Reconnecting in ${reconnectDelay}ms...`);
-    setTimeout(connect, reconnectDelay);
-    reconnectDelay = Math.min(reconnectDelay * 2, 30000); // Max 30s
-  });
+  // Handle graceful shutdown
+  const shutdown = () => {
+    console.log("\nShutting down...");
+    client.disconnect();
+    process.exit(0);
+  };
 
-  ws.on("error", (err) => {
-    console.error("[RelayClient] Error:", err.message);
-  });
-}
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
 
-// Send ping every 30s to keep alive
-setInterval(() => {
-  if (ws?.readyState === WebSocket.OPEN) {
-    ws.send(JSON.stringify({ type: "ping", payload: {} }));
+  // Connect
+  try {
+    await client.connect();
+    console.log("[Client] Connection established!");
+    
+    // Keep running
+    await new Promise(() => {});
+  } catch (err) {
+    console.error("[Client] Failed to connect:", err);
+    process.exit(1);
   }
-}, 30000);
-
-console.log("===========================================");
-console.log("Real-time Callback Relay Client");
-console.log("===========================================");
-console.log(`Server: ${RELAY_WS_URL}`);
-console.log("===========================================");
+}
 
-connect();
+main();

package/scripts/unified-webhook-server.ts

@@ -1,6 +1,12 @@
 #!/usr/bin/env bun
 /**
  * Unified Webhook Server — Handles Telegram, LINE, and WebSocket relay
+ * 
+ * Two-way streaming implementation using relay package:
+ * - Snapshot + Live event pattern (t3code style)
+ * - Typed message protocol
+ * - Connection state machine
+ * - Stream coalescing for high-frequency events
  *
  * Routes:
  *   /telegram → Telegram webhook handler
@@ -11,12 +17,14 @@
  *   bun run scripts/unified-webhook-server.ts
  */
 
-import { existsSync, readFileSync, appendFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "os";
 import { createServer, IncomingMessage, ServerResponse } from "node:http";
-import { WebSocketServer, WebSocket } from "ws";
-import { randomUUID } from "node:crypto";
+import { createRelayServer } from "../packages/relay/src/server";
+import { generateMessageId } from "../packages/relay/src/types";
+import type { CallbackPayload } from "../packages/relay/src/types";
+import type { RelayServerOptions } from "../packages/relay/src/server";
 
 // --- Configuration ---
 interface Config {
@@ -33,7 +41,8 @@ interface Config {
 
 const PORT = parseInt(process.env.PORT || "8443", 10);
 const WS_PORT = parseInt(process.env.WS_PORT || "8444", 10);
-const RELAY_AUTH_TOKEN = process.env.RELAY_AUTH_TOKEN || "b61940936a2625036d6faf7fe32c52b3"; // Same as webhook secret
+const AUTH_TOKEN = process.env.RELAY_AUTH_TOKEN || "change-me-in-production";
+const SERVER_VERSION = process.env.SERVER_VERSION || "1.0.0";
 
 // --- Keys Loader ---
 function loadConfig(): Config {
@@ -76,17 +85,6 @@ function loadConfig(): Config {
   return config;
 }
 
-// --- Telegram HMAC Verification (for future use with secret hash) ---
-async function _verifyTelegramHmac(data: string, secret: string, hash: string): Promise<boolean> {
-  const encoder = new TextEncoder();
-  const key = await crypto.subtle.importKey(
-    "raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]
-  );
-  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(data));
-  const expected = Array.from(new Uint8Array(signature)).map(b => b.toString(16).padStart(2, "0")).join("");
-  return expected === hash;
-}
-
 // --- LINE Verification ---
 async function verifyLINE(body: string, channelSecret: string, xLineSignature: string): Promise<boolean> {
   const encoder = new TextEncoder();
@@ -98,58 +96,49 @@ async function verifyLINE(body: string, channelSecret: string, xLineSignature: s
   return expected === xLineSignature;
 }
 
-// --- Callback Queue (file-based fallback) ---
-const QUEUE_FILE = join(process.env.HOME || "/tmp", ".pi-harness-runtime", "callback-queue.jsonl");
-function queueCallback(callback: Record<string, unknown>) {
-  appendFileSync(QUEUE_FILE, JSON.stringify({ ...callback, timestamp: new Date().toISOString() }) + "\n");
-}
-
-// --- WebSocket Relay ---
-const wsClients = new Map<string, WebSocket>();
-
-function broadcastCallback(callback: Record<string, unknown>) {
-  const msg = JSON.stringify({ type: "callback", payload: callback });
-  let count = 0;
-  for (const ws of wsClients.values()) {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(msg);
-      count++;
-    }
+// --- Parse Callback Data ---
+function parseCallbackData(data: string): { action: string; targetId: string } {
+  const colonIdx = data.indexOf(":");
+  const underscoreIdx = data.indexOf("_");
+  
+  if (colonIdx !== -1) {
+    return {
+      action: data.slice(0, colonIdx),
+      targetId: data.slice(colonIdx + 1).replace(/_+$/, ""),
+    };
+  } else if (underscoreIdx !== -1) {
+    return {
+      action: data.slice(0, underscoreIdx),
+      targetId: data.slice(underscoreIdx + 1).replace(/_+$/, ""),
+    };
   }
-  return count;
-}
-
-function startWebSocketServer() {
-  const wss = new WebSocketServer({ port: WS_PORT });
   
-  wss.on("connection", (ws: WebSocket) => {
-    const clientId = randomUUID();
-    wsClients.set(clientId, ws);
-    console.log(`[WS] Client connected: ${clientId}`);
-
-    ws.on("message", (data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        if (msg.type === "auth" && msg.payload === RELAY_AUTH_TOKEN) {
-          ws.send(JSON.stringify({ type: "auth", payload: { success: true } }));
-          console.log(`[WS] Client authenticated: ${clientId}`);
-        }
-      } catch (err) {
-        console.error(`[WS] Invalid message from ${clientId}:`, err);
-      }
-    });
-
-    ws.on("close", () => {
-      wsClients.delete(clientId);
-      console.log(`[WS] Client disconnected: ${clientId}`);
-    });
-  });
+  return { action: data, targetId: "" };
+}
 
-  console.log(`[WS] WebSocket server started on port ${WS_PORT}`);
+// --- Create Callback Payload ---
+function createCallbackPayload(
+  type: "telegram_callback" | "line_callback",
+  action: string,
+  targetId: string,
+  userId: number | string,
+  username?: string,
+  messageId?: number
+): CallbackPayload {
+  return {
+    id: generateMessageId(),
+    type,
+    action,
+    targetId,
+    userId: typeof userId === "string" ? parseInt(userId, 10) || 0 : userId,
+    username,
+    messageId,
+    timestamp: new Date().toISOString(),
+  };
 }
 
 // --- Telegram Handler ---
-async function handleTelegram(req: IncomingMessage, res: ServerResponse, config: Config) {
+async function handleTelegram(req: IncomingMessage, res: ServerResponse, config: Config, relayServer: ReturnType<typeof createRelayServer>) {
   if (!config.telegram) {
     res.writeHead(404);
     res.end("Telegram not configured");
@@ -185,37 +174,21 @@ async function handleTelegram(req: IncomingMessage, res: ServerResponse, config:
       }
 
       // Parse callback data
-      const data = query.data || "";
-      const colonIdx = data.indexOf(":");
-      const underscoreIdx = data.indexOf("_");
-      let action: string, targetId: string;
-      if (colonIdx !== -1) {
-        action = data.slice(0, colonIdx);
-        targetId = data.slice(colonIdx + 1).replace(/_+$/, "");
-      } else if (underscoreIdx !== -1) {
-        action = data.slice(0, underscoreIdx);
-        targetId = data.slice(underscoreIdx + 1).replace(/_+$/, "");
-      } else {
-        action = data;
-        targetId = "";
-      }
+      const { action, targetId } = parseCallbackData(query.data || "");
 
-      const callback = {
-        type: "telegram_callback",
+      // Create typed callback payload
+      const callback = createCallbackPayload(
+        "telegram_callback",
         action,
         targetId,
-        userId: from.id,
-        username: from.username,
-        messageId: query.message?.message_id,
-      };
-
-      // Broadcast via WebSocket
-      const wsCount = broadcastCallback(callback);
-      if (wsCount === 0) {
-        // Fallback to file queue
-        queueCallback(callback);
-      }
-      console.log(`[Telegram] Callback: ${action} ${targetId} from @${from.username || from.id} (WS clients: ${wsCount})`);
+        from.id,
+        from.username,
+        query.message?.message_id
+      );
+
+      // Broadcast via typed streaming relay
+      relayServer.broadcastCallback(callback);
+      console.log(`[Telegram] Callback: ${action} ${targetId} from @${from.username || from.id}`);
 
       // Acknowledge immediately
       await fetch(`https://api.telegram.org/bot${config.telegram.botToken}/answerCallbackQuery`, {
@@ -235,7 +208,7 @@ async function handleTelegram(req: IncomingMessage, res: ServerResponse, config:
 }
 
 // --- LINE Handler ---
-async function handleLINE(req: IncomingMessage, res: ServerResponse, config: Config) {
+async function handleLINE(req: IncomingMessage, res: ServerResponse, config: Config, relayServer: ReturnType<typeof createRelayServer>) {
   if (!config.line) {
     res.writeHead(404);
     res.end("LINE not configured");
@@ -269,24 +242,19 @@ async function handleLINE(req: IncomingMessage, res: ServerResponse, config: Con
     for (const event of events) {
       if (event.type === "postback") {
         const data = event.postback?.data || "";
-        const colonIdx = data.indexOf(":");
-        let action = data.slice(0, colonIdx !== -1 ? colonIdx : undefined);
-        let targetId = colonIdx !== -1 ? data.slice(colonIdx + 1) : "";
+        const { action, targetId } = parseCallbackData(data);
 
-        const callback = {
-          type: "line_callback",
+        // Create typed callback payload
+        const callback = createCallbackPayload(
+          "line_callback",
           action,
           targetId,
-          userId: event.source?.userId,
-          timestamp: new Date().toISOString(),
-        };
-
-        // Broadcast via WebSocket
-        const wsCount = broadcastCallback(callback);
-        if (wsCount === 0) {
-          queueCallback(callback);
-        }
-        console.log(`[LINE] Postback: ${action} ${targetId} (WS clients: ${wsCount})`);
+          event.source?.userId || "unknown"
+        );
+
+        // Broadcast via typed streaming relay
+        relayServer.broadcastCallback(callback);
+        console.log(`[LINE] Postback: ${action} ${targetId}`);
       }
     }
 
@@ -300,45 +268,79 @@ async function handleLINE(req: IncomingMessage, res: ServerResponse, config: Con
 }
 
 // --- Main ---
-const config = loadConfig();
+async function main() {
+  const config = loadConfig();
+
+  console.log("===========================================");
+  console.log("Unified Webhook Server - Streaming v2");
+  console.log("===========================================");
+  if (config.telegram) console.log("  /telegram - Telegram webhook");
+  if (config.line) console.log("  /line     - LINE webhook");
+  console.log(`  HTTP:      http://0.0.0.0:${PORT}`);
+  console.log(`  WebSocket: ws://0.0.0.0:${WS_PORT}`);
+  console.log("===========================================");
+
+  // Create relay server with typed streaming
+  const relayOptions: RelayServerOptions = {
+    port: WS_PORT,
+    host: "0.0.0.0",
+    authToken: AUTH_TOKEN,
+    serverVersion: SERVER_VERSION,
+    onStateChange: (change: { previous: { state: string }; current: { state: string }; timestamp: string }) => {
+      console.log(`[Relay] State: ${change.previous.state} → ${change.current.state}`);
+    },
+  };
 
-console.log("===========================================");
-console.log("Unified Webhook Server");
-console.log("===========================================");
-if (config.telegram) console.log("  /telegram - Telegram webhook");
-if (config.line) console.log("  /line     - LINE webhook");
-console.log("===========================================");
+  const relayServer = createRelayServer(relayOptions);
+
+  // Start WebSocket relay
+  await relayServer.start();
+  console.log("[Relay] WebSocket server started on port", WS_PORT);
+
+  // HTTP webhook server
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url || "/", `http://localhost:${PORT}`);
+
+    try {
+      if (url.pathname === "/telegram" && req.method === "POST") {
+        await handleTelegram(req, res, config, relayServer);
+      } else if (url.pathname === "/line" && req.method === "POST") {
+        await handleLINE(req, res, config, relayServer);
+      } else if (url.pathname === "/health") {
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          status: "ok",
+          clients: relayServer.getClientCount(),
+          running: relayServer.isRunning(),
+        }));
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    } catch (err) {
+      console.error("[Server] Error:", err);
+      res.writeHead(500);
+      res.end("Error");
+    }
+  });
 
-// Start WebSocket relay
-startWebSocketServer();
+  server.listen(PORT, () => {
+    console.log(`HTTP server running on http://0.0.0.0:${PORT}`);
+    console.log("Configure webhooks:");
+    if (config.telegram) console.log(`  Telegram: https://webhook.bunchee.online/telegram`);
+    if (config.line) console.log(`  LINE:     https://webhook.bunchee.online/line`);
+  });
 
-// HTTP webhook server
-const server = createServer(async (req, res) => {
-  const url = new URL(req.url || "/", `http://localhost:${PORT}`);
+  // Graceful shutdown
+  const shutdown = async () => {
+    console.log("\nShutting down...");
+    await relayServer.stop();
+    server.close();
+    process.exit(0);
+  };
 
-  try {
-    if (url.pathname === "/telegram" && req.method === "POST") {
-      await handleTelegram(req, res, config);
-    } else if (url.pathname === "/line" && req.method === "POST") {
-      await handleLINE(req, res, config);
-    } else if (url.pathname === "/health") {
-      res.writeHead(200);
-      res.end("OK");
-    } else {
-      res.writeHead(404);
-      res.end("Not Found");
-    }
-  } catch (err) {
-    console.error("[Server] Error:", err);
-    res.writeHead(500);
-    res.end("Error");
-  }
-});
-
-server.listen(PORT, () => {
-  console.log(`Server running on http://0.0.0.0:${PORT}`);
-  console.log(`WebSocket relay on ws://0.0.0.0:${WS_PORT}`);
-  console.log("Configure webhooks:");
-  if (config.telegram) console.log(`  Telegram: https://webhook.bunchee.online/telegram`);
-  if (config.line) console.log(`  LINE:     https://webhook.bunchee.online/line`);
-});
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+main().catch(console.error);