pi-harness-runtime 1.1.375 → 1.1.377

package/scripts/unified-webhook-server.ts

@@ -1,26 +1,30 @@
 #!/usr/bin/env bun
 /**
- * Unified Webhook Server — Handles both Telegram and LINE on single domain
+ * 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
  *   /line     → LINE webhook handler
+ *   /ws       → WebSocket relay (port 8444)
  *
  * Usage:
  *   bun run scripts/unified-webhook-server.ts
- *
- * Environment variables (or keys/*.txt files):
- *   TELEGRAM_BOT_TOKEN, TELEGRAM_WEBHOOK_SECRET, TELEGRAM_ALLOWED_USERS
- *   LINE_CHANNEL_SECRET, LINE_ACCESS_TOKEN
- *
- * Webhook URLs to configure:
- *   Telegram: https://webhook.bunchee.online/telegram
- *   LINE:     https://webhook.bunchee.online/line
  */
 
-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 { 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 {
@@ -30,77 +34,58 @@ interface Config {
     allowedUsers: Set<number>;
   };
   line?: {
-    channelSecret: string;
     accessToken: string;
+    channelSecret: string;
   };
 }
 
-function getConfig(): Config {
-  const homedir = process.env.HOME || "/home/frappe";
-  const keysDir = join(homedir, ".pi-harness-runtime", "keys");
+const PORT = parseInt(process.env.PORT || "8443", 10);
+const WS_PORT = parseInt(process.env.WS_PORT || "8444", 10);
+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 {
+  const keysDir = join(homedir(), ".pi-harness-runtime", "keys");
   const config: Config = {};
 
-  // Telegram config
+  // Telegram
   const telegramTokenPath = join(keysDir, "telegram-bot-token.txt");
   const telegramSecretPath = join(keysDir, "telegram-webhook-secret.txt");
   const telegramUsersPath = join(keysDir, "telegram-allowed-users.txt");
 
   if (existsSync(telegramTokenPath)) {
-    const token = process.env.TELEGRAM_BOT_TOKEN || readFileSync(telegramTokenPath, "utf8").trim();
-    const secret = process.env.TELEGRAM_WEBHOOK_SECRET || (existsSync(telegramSecretPath) ? readFileSync(telegramSecretPath, "utf8").trim() : "");
+    const token = readFileSync(telegramTokenPath, "utf8").trim();
+    const secret = existsSync(telegramSecretPath)
+      ? readFileSync(telegramSecretPath, "utf8").trim()
+      : process.env.TELEGRAM_WEBHOOK_SECRET || "";
 
     const allowedUsers = new Set<number>();
-    const envUsers = process.env.TELEGRAM_ALLOWED_USERS;
-    if (envUsers) {
-      for (const part of envUsers.split(",")) {
-        const num = parseInt(part.trim(), 10);
-        if (!isNaN(num) && num > 0) allowedUsers.add(num);
-      }
-    }
     if (existsSync(telegramUsersPath)) {
-      const content = readFileSync(telegramUsersPath, "utf8").trim();
-      for (const part of content.split(",")) {
-        const num = parseInt(part.trim(), 10);
-        if (!isNaN(num) && num > 0) allowedUsers.add(num);
+      const users = readFileSync(telegramUsersPath, "utf8").trim();
+      for (const id of users.split(",").map((s) => parseInt(s.trim(), 10))) {
+        if (!isNaN(id) && id > 0) allowedUsers.add(id);
       }
     }
 
     config.telegram = { botToken: token, secret, allowedUsers };
   }
 
-  // LINE config
-  const lineSecretPath = join(keysDir, "line-channel-secret.txt");
+  // LINE
   const lineTokenPath = join(keysDir, "line-access-token.txt");
+  const lineSecretPath = join(keysDir, "line-channel-secret.txt");
 
-  if (existsSync(lineSecretPath) && existsSync(lineTokenPath)) {
-    const channelSecret = process.env.LINE_CHANNEL_SECRET || readFileSync(lineSecretPath, "utf8").trim();
-    const accessToken = process.env.LINE_ACCESS_TOKEN || readFileSync(lineTokenPath, "utf8").trim();
-    config.line = { channelSecret, accessToken };
+  if (existsSync(lineTokenPath) && existsSync(lineSecretPath)) {
+    config.line = {
+      accessToken: readFileSync(lineTokenPath, "utf8").trim(),
+      channelSecret: readFileSync(lineSecretPath, "utf8").trim(),
+    };
   }
 
   return config;
 }
 
-// --- Logging ---
-const LOG_FILE = "/tmp/unified-webhook.log";
-function log(prefix: string, ...args: unknown[]) {
-  const msg = args.map(a => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ");
-  const line = `[${new Date().toISOString()}] [${prefix}] ${msg}\n`;
-  appendFileSync(LOG_FILE, line);
-  console.log(line.trim());
-}
-
-// --- Crypto utilities ---
-async function verifyTelegram(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();
   const key = await crypto.subtle.importKey(
@@ -111,14 +96,49 @@ async function verifyLINE(body: string, channelSecret: string, xLineSignature: s
   return expected === xLineSignature;
 }
 
-// --- Callback queue ---
-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");
+// --- 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 { action: data, targetId: "" };
+}
+
+// --- 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) {
+// --- Telegram Handler ---
+async function handleTelegram(req: IncomingMessage, res: ServerResponse, config: Config, relayServer: ReturnType<typeof createRelayServer>) {
   if (!config.telegram) {
     res.writeHead(404);
     res.end("Telegram not configured");
@@ -128,7 +148,6 @@ async function handleTelegram(req: IncomingMessage, res: ServerResponse, config:
   // Verify secret token
   const secretToken = req.headers["x-telegram-bot-api-secret-token"];
   if (secretToken !== config.telegram.secret) {
-    log("Telegram", "Unauthorized - secret mismatch");
     res.writeHead(403);
     res.end("Forbidden");
     return;
@@ -149,37 +168,27 @@ async function handleTelegram(req: IncomingMessage, res: ServerResponse, config:
 
       // Check authorization
       if (config.telegram.allowedUsers.size > 0 && !config.telegram.allowedUsers.has(from.id)) {
-        log("Telegram", `Unauthorized user: ${from.id}`);
         res.writeHead(403);
         res.end("Forbidden");
         return;
       }
 
       // 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 || "");
 
-      // Queue the callback
-      queueCallback({
-        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,
-      });
+        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`, {
@@ -187,21 +196,19 @@ async function handleTelegram(req: IncomingMessage, res: ServerResponse, config:
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ callback_query_id: query.id }),
       });
-
-      log("Telegram", `Callback: ${action} ${targetId} from @${from.username || from.id}`);
     }
 
     res.writeHead(200);
     res.end("OK");
   } catch (err) {
-    log("Telegram", "Error:", err);
+    console.error("[Telegram] Error:", err);
     res.writeHead(500);
     res.end("Error");
   }
 }
 
-// --- LINE handler ---
-async function handleLINE(req: IncomingMessage, res: ServerResponse, config: Config) {
+// --- LINE Handler ---
+async function handleLINE(req: IncomingMessage, res: ServerResponse, config: Config, relayServer: ReturnType<typeof createRelayServer>) {
   if (!config.line) {
     res.writeHead(404);
     res.end("LINE not configured");
@@ -211,7 +218,6 @@ async function handleLINE(req: IncomingMessage, res: ServerResponse, config: Con
   // Verify signature
   const signature = req.headers["x-line-signature"] as string;
   if (!signature) {
-    log("LINE", "Missing signature");
     res.writeHead(400);
     res.end("Bad Request");
     return;
@@ -224,108 +230,117 @@ async function handleLINE(req: IncomingMessage, res: ServerResponse, config: Con
 
   // Verify
   if (!(await verifyLINE(body, config.line.channelSecret, signature))) {
-    log("LINE", "Invalid signature");
     res.writeHead(403);
     res.end("Forbidden");
     return;
   }
 
   try {
-    const events = JSON.parse(body).events || [];
+    const bodyJson = JSON.parse(body);
+    const events = bodyJson.events || [];
 
     for (const event of events) {
       if (event.type === "postback") {
-        // Parse postback data
         const data = event.postback?.data || "";
-        const colonIdx = data.indexOf(":");
-        let action: string, targetId: string;
-        if (colonIdx !== -1) {
-          action = data.slice(0, colonIdx);
-          targetId = data.slice(colonIdx + 1);
-        } else {
-          action = data;
-          targetId = "";
-        }
-
-        queueCallback({
-          type: "line_callback",
+        const { action, targetId } = parseCallbackData(data);
+
+        // Create typed callback payload
+        const callback = createCallbackPayload(
+          "line_callback",
           action,
           targetId,
-          userId: event.source?.userId,
-          replyToken: event.replyToken,
-        });
-
-        log("LINE", `Postback: ${action} ${targetId}`);
-      } else if (event.type === "message" && event.message?.type === "text") {
-        // Forward text messages to agent
-        queueCallback({
-          type: "line_message",
-          text: event.message.text,
-          userId: event.source?.userId,
-          replyToken: event.replyToken,
-        });
-
-        log("LINE", `Message: ${event.message.text}`);
+          event.source?.userId || "unknown"
+        );
+
+        // Broadcast via typed streaming relay
+        relayServer.broadcastCallback(callback);
+        console.log(`[LINE] Postback: ${action} ${targetId}`);
       }
     }
 
     res.writeHead(200);
-    res.end("OK");
+    res.end(JSON.stringify({ status: "ok" }));
   } catch (err) {
-    log("LINE", "Error:", err);
+    console.error("[LINE] Error:", err);
     res.writeHead(500);
     res.end("Error");
   }
 }
 
-// --- Main server ---
-const PORT = parseInt(process.env.PORT || "3000", 10);
-
+// --- Main ---
 async function main() {
-  const config = getConfig();
+  const config = loadConfig();
 
-  if (!config.telegram && !config.line) {
-    console.error("No webhooks configured. Set up Telegram and/or LINE keys.");
-    process.exit(1);
-  }
-
-  console.log("Unified Webhook Server");
-  console.log(`Listening on port ${PORT}`);
+  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}`);
+    },
+  };
+
+  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);
+        await handleTelegram(req, res, config, relayServer);
       } else if (url.pathname === "/line" && req.method === "POST") {
-        await handleLINE(req, res, config);
+        await handleLINE(req, res, config, relayServer);
       } else if (url.pathname === "/health") {
         res.writeHead(200);
-        res.end("OK");
+        res.end(JSON.stringify({
+          status: "ok",
+          clients: relayServer.getClientCount(),
+          running: relayServer.isRunning(),
+        }));
       } else {
         res.writeHead(404);
         res.end("Not Found");
       }
     } catch (err) {
-      log("Server", "Error:", 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(`Configure webhooks:`);
-    if (config.telegram) {
-      console.log(`  Telegram: https://webhook.bunchee.online/telegram`);
-    }
-    if (config.line) {
-      console.log(`  LINE:     https://webhook.bunchee.online/line`);
-    }
+    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`);
   });
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    console.log("\nShutting down...");
+    await relayServer.stop();
+    server.close();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
 }
 
-main();
+main().catch(console.error);

package/scripts/ws-server.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env bun
+/**
+ * WebSocket Relay Server - Two-way streaming callbacks
+ * 
+ * Uses the relay package's typed streaming protocol:
+ * - Snapshot + Live event pattern (t3code style)
+ * - Typed message protocol
+ * - Connection state machine
+ * - Stream coalescing for high-frequency events
+ * 
+ * Architecture:
+ *   Telegram/LINE → Webhook → This Server → WebSocket → Local Client
+ */
+
+import { createRelayServer, type RelayServerOptions } from "../packages/relay/src/server";
+
+// Configuration from environment
+const PORT = parseInt(process.env.WS_PORT || "8444", 10);
+const HOST = process.env.WS_HOST || "0.0.0.0";
+const AUTH_TOKEN = process.env.RELAY_AUTH_TOKEN || "change-me-in-production";
+const SERVER_VERSION = process.env.SERVER_VERSION || "1.0.0";
+
+// Create and start server
+const options: RelayServerOptions = {
+  port: PORT,
+  host: HOST,
+  authToken: AUTH_TOKEN,
+  serverVersion: SERVER_VERSION,
+  onTunnelConnect: (tunnel) => {
+    console.log(`[Main] Tunnel connected: ${tunnel.id}`);
+  },
+  onTunnelDisconnect: (tunnelId) => {
+    console.log(`[Main] Tunnel disconnected: ${tunnelId}`);
+  },
+  onStateChange: (change) => {
+    console.log(`[Main] State change: ${change.previous.state} → ${change.current.state}`);
+  },
+};
+
+const server = createRelayServer(options);
+
+async function main() {
+  console.log("===========================================");
+  console.log("WebSocket Relay Server - Streaming v2");
+  console.log("===========================================");
+  console.log(`  Host: ${HOST}`);
+  console.log(`  Port: ${PORT}`);
+  console.log(`  Auth: ${AUTH_TOKEN ? "enabled" : "disabled"}`);
+  console.log(`  Version: ${SERVER_VERSION}`);
+  console.log("===========================================");
+  
+  try {
+    await server.start();
+    console.log("Server started successfully!");
+    
+    // Log status periodically
+    setInterval(() => {
+      const clients = server.getClients();
+      console.log(`[Status] Clients: ${clients.length}, Running: ${server.isRunning()}`);
+    }, 30000);
+    
+  } catch (err) {
+    console.error("Failed to start server:", err);
+    process.exit(1);
+  }
+}
+
+// Graceful shutdown
+process.on("SIGINT", async () => {
+  console.log("\nShutting down...");
+  await server.stop();
+  process.exit(0);
+});
+
+process.on("SIGTERM", async () => {
+  console.log("\nShutting down...");
+  await server.stop();
+  process.exit(0);
+});
+
+main();