@sinch/functions-runtime 0.1.0-beta.28 → 0.2.1-beta

package/dist/bin/sinch-runtime.js

@@ -6,6 +6,12 @@ import { createRequire as createRequire3 } from "module";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import fs3 from "fs";
 
+// ../runtime-shared/dist/ai/connect-agent.js
+var AgentProvider;
+(function(AgentProvider2) {
+  AgentProvider2["ElevenLabs"] = "elevenlabs";
+})(AgentProvider || (AgentProvider = {}));
+
 // ../runtime-shared/dist/host/middleware.js
 import { createRequire } from "module";
 var requireCjs = createRequire(import.meta.url);
@@ -522,6 +528,65 @@ function setupRequestHandler(app, options = {}) {
   });
 }
 
+// ../runtime-shared/dist/sinch/index.js
+import { SinchClient, validateAuthenticationHeader } from "@sinch/sdk-core";
+
+// ../runtime-shared/dist/ai/elevenlabs/state.js
+var ElevenLabsStateManager = class {
+  state = {
+    isConfigured: false
+  };
+  /**
+   * Get the current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Check if ElevenLabs is configured
+   */
+  isConfigured() {
+    return this.state.isConfigured;
+  }
+  /**
+   * Update state with auto-configuration results
+   */
+  setConfigured(data) {
+    this.state = {
+      ...data,
+      isConfigured: true,
+      configuredAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Clear the configuration state
+   */
+  clear() {
+    this.state = {
+      isConfigured: false
+    };
+  }
+  /**
+   * Get the phone number ID for making calls
+   */
+  getPhoneNumberId() {
+    return this.state.phoneNumberId;
+  }
+  /**
+   * Get the SIP address for connecting to the agent
+   */
+  getSipAddress() {
+    return this.state.sipAddress;
+  }
+  /**
+   * Get the configured agent ID
+   */
+  getAgentId() {
+    return this.state.agentId;
+  }
+};
+var ElevenLabsState = new ElevenLabsStateManager();
+
 // ../runtime-shared/dist/utils/templateRender.js
 import fs from "fs";
 import path from "path";
@@ -611,6 +676,382 @@ function createCacheClient(_projectId, _functionName) {
   return new LocalCache();
 }
 
+// src/tunnel/index.ts
+import WebSocket from "ws";
+import axios from "axios";
+
+// src/tunnel/webhook-config.ts
+import { SinchClient as SinchClient2 } from "@sinch/sdk-core";
+async function configureConversationWebhooks(tunnelUrl, config) {
+  try {
+    const conversationAppId = process.env.CONVERSATION_APP_ID;
+    const projectId = process.env.PROJECT_ID;
+    const keyId = process.env.KEY_ID;
+    const keySecret = process.env.KEY_SECRET;
+    if (!conversationAppId || !projectId || !keyId || !keySecret) {
+      console.log("\u{1F4A1} Conversation API not fully configured - skipping webhook setup");
+      return;
+    }
+    const webhookUrl = `${tunnelUrl}/conversation`;
+    console.log(`\u{1F4AC} Conversation webhook URL: ${webhookUrl}`);
+    const sinchClient = new SinchClient2({
+      projectId,
+      keyId,
+      keySecret
+    });
+    const webhooksResult = await sinchClient.conversation.webhooks.list({ app_id: conversationAppId });
+    const existingWebhooks = webhooksResult.webhooks || [];
+    const tunnelWebhooks = existingWebhooks.filter(
+      (w) => w.target?.includes("/api/ingress/")
+    );
+    for (const staleWebhook of tunnelWebhooks) {
+      try {
+        await sinchClient.conversation.webhooks.delete({ webhook_id: staleWebhook.id });
+        console.log(`\u{1F9F9} Cleaned up stale tunnel webhook: ${staleWebhook.id}`);
+      } catch (err) {
+      }
+    }
+    const createResult = await sinchClient.conversation.webhooks.create({
+      webhookCreateRequestBody: {
+        app_id: conversationAppId,
+        target: webhookUrl,
+        target_type: "HTTP",
+        triggers: ["MESSAGE_INBOUND"]
+      }
+    });
+    config.conversationWebhookId = createResult.id;
+    console.log(`\u2705 Created Conversation webhook: ${webhookUrl}`);
+    console.log("\u{1F4AC} Send a message to your Conversation app to test!");
+  } catch (error) {
+    console.log("\u26A0\uFE0F Could not configure Conversation webhooks:", error.message);
+  }
+}
+async function cleanupConversationWebhook(config) {
+  if (!config.conversationWebhookId) return;
+  try {
+    const conversationAppId = process.env.CONVERSATION_APP_ID;
+    const projectId = process.env.PROJECT_ID;
+    const keyId = process.env.KEY_ID;
+    const keySecret = process.env.KEY_SECRET;
+    if (!conversationAppId || !projectId || !keyId || !keySecret) return;
+    const sinchClient = new SinchClient2({
+      projectId,
+      keyId,
+      keySecret
+    });
+    await sinchClient.conversation.webhooks.delete({ webhook_id: config.conversationWebhookId });
+    console.log("\u{1F9F9} Cleaned up tunnel webhook");
+    config.conversationWebhookId = void 0;
+  } catch (error) {
+  }
+}
+async function configureElevenLabs() {
+  try {
+    const agentId = process.env.ELEVENLABS_AGENT_ID;
+    const apiKey = process.env.ELEVENLABS_API_KEY;
+    if (!agentId || !apiKey) {
+      console.log("\u{1F4A1} ElevenLabs not fully configured - skipping auto-configuration");
+      return;
+    }
+    void apiKey;
+    console.log("\u{1F916} ElevenLabs auto-configuration enabled");
+    console.log(`   Agent ID: ${agentId}`);
+  } catch (error) {
+    console.log("\u26A0\uFE0F Could not configure ElevenLabs:", error.message);
+  }
+}
+
+// src/tunnel/index.ts
+var TUNNEL_GATEWAY_DEFAULT = "https://tunnel.fn.sinch.com";
+var TunnelClient = class {
+  ws = null;
+  tunnelUrl = null;
+  tunnelId = null;
+  isConnected = false;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 10;
+  reconnectDelay = 5e3;
+  heartbeatInterval = null;
+  localPort;
+  webhookConfig = {};
+  welcomeResolver = null;
+  constructor(localPort = 3e3) {
+    this.localPort = localPort;
+  }
+  getTunnelGatewayUrl() {
+    const explicitUrl = process.env.TUNNEL_GATEWAY_URL;
+    if (explicitUrl) {
+      return explicitUrl;
+    }
+    return TUNNEL_GATEWAY_DEFAULT;
+  }
+  generateTunnelId() {
+    const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    const timestamp = Date.now();
+    let timestampPart = "";
+    let t = timestamp;
+    for (let i = 0; i < 10; i++) {
+      timestampPart = ENCODING[t % 32] + timestampPart;
+      t = Math.floor(t / 32);
+    }
+    const randomBytes = new Uint8Array(10);
+    crypto.getRandomValues(randomBytes);
+    let randomPart = "";
+    for (let i = 0; i < 10; i++) {
+      const byte = randomBytes[i];
+      randomPart += ENCODING[byte >> 3];
+      if (randomPart.length < 16) {
+        randomPart += ENCODING[(byte & 7) << 2 | (i + 1 < 10 ? randomBytes[i + 1] >> 6 : 0)];
+      }
+    }
+    randomPart = randomPart.substring(0, 16);
+    return timestampPart + randomPart;
+  }
+  async connect() {
+    if (process.env.SINCH_TUNNEL !== "true") {
+      console.log("Tunnel is disabled (set SINCH_TUNNEL=true to enable)");
+      return;
+    }
+    const gatewayUrl = this.getTunnelGatewayUrl();
+    this.tunnelId = this.generateTunnelId();
+    const gatewayUri = new URL(gatewayUrl);
+    const wsUrl = new URL(gatewayUrl);
+    wsUrl.protocol = gatewayUri.protocol === "https:" ? "wss:" : "ws:";
+    wsUrl.pathname = "/ws";
+    wsUrl.searchParams.set("tunnel", this.tunnelId);
+    const tunnelEndpoint = wsUrl.toString();
+    console.log(`Connecting to tunnel gateway at ${tunnelEndpoint}...`);
+    try {
+      this.ws = new WebSocket(tunnelEndpoint);
+      const welcomePromise = new Promise((resolve, reject) => {
+        this.welcomeResolver = resolve;
+        setTimeout(() => reject(new Error("Timed out waiting for welcome message")), 1e4);
+      });
+      this.ws.on("open", () => {
+        this.isConnected = true;
+        this.reconnectAttempts = 0;
+        console.log("WebSocket connected, waiting for welcome message...");
+      });
+      this.ws.on("message", async (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          await this.handleMessage(message);
+        } catch (error) {
+          console.error("Error processing tunnel message:", error);
+        }
+      });
+      this.ws.on("close", async () => {
+        this.isConnected = false;
+        console.log("Tunnel connection closed");
+        this.stopHeartbeat();
+        this.scheduleReconnect();
+      });
+      this.ws.on("error", (error) => {
+        console.error("Tunnel connection error:", error.message);
+      });
+      await welcomePromise;
+      if (!this.tunnelUrl) {
+        throw new Error("Did not receive tunnel URL from gateway");
+      }
+      console.log("Tunnel connected successfully!");
+      this.startHeartbeat();
+      await this.configureWebhooks();
+    } catch (error) {
+      console.error("Failed to establish tunnel connection:", error.message);
+      this.scheduleReconnect();
+    }
+  }
+  async handleMessage(message) {
+    switch (message.type) {
+      case "welcome":
+        this.handleWelcomeMessage(message);
+        break;
+      case "request":
+        await this.handleRequest(message);
+        break;
+      case "ping":
+        this.sendPong();
+        break;
+    }
+  }
+  handleWelcomeMessage(message) {
+    this.tunnelId = message.tunnelId || null;
+    this.tunnelUrl = message.publicUrl || null;
+    console.log(`Received welcome: tunnelId=${this.tunnelId}`);
+    if (this.welcomeResolver) {
+      this.welcomeResolver(true);
+      this.welcomeResolver = null;
+    }
+  }
+  async handleRequest(message) {
+    console.log(`Forwarding ${message.method} request to ${message.path}`);
+    try {
+      const localUrl = `http://localhost:${this.localPort}${message.path}${message.query || ""}`;
+      const axiosConfig = {
+        method: message.method,
+        url: localUrl,
+        headers: {}
+      };
+      if (message.headers) {
+        axiosConfig.headers = { ...message.headers };
+      }
+      if (message.body) {
+        axiosConfig.data = message.body;
+      }
+      const response = await axios(axiosConfig);
+      const headers = {};
+      for (const [key, value] of Object.entries(response.headers)) {
+        if (value) {
+          const normalizedKey = key.toLowerCase() === "content-type" ? "Content-Type" : key.toLowerCase() === "content-length" ? "Content-Length" : key;
+          headers[normalizedKey] = String(value);
+        }
+      }
+      if (!headers["Content-Type"] && response.data) {
+        headers["Content-Type"] = "application/json";
+      }
+      const body = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+      const responseMessage = {
+        type: "response",
+        id: message.id,
+        statusCode: response.status,
+        headers,
+        body
+      };
+      this.ws?.send(JSON.stringify(responseMessage));
+    } catch (error) {
+      console.error("Error forwarding request:", error.message);
+      const errorResponse = {
+        type: "response",
+        id: message.id,
+        statusCode: error.response?.status || 502,
+        headers: { "Content-Type": "text/plain" },
+        body: "Error forwarding request to local server"
+      };
+      this.ws?.send(JSON.stringify(errorResponse));
+    }
+  }
+  sendPong() {
+    const pongMessage = { type: "pong" };
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(pongMessage));
+    }
+  }
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        const pingMessage = { type: "ping" };
+        this.ws.send(JSON.stringify(pingMessage));
+      }
+    }, 3e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  /**
+   * Configure all webhooks (Voice, Conversation, ElevenLabs)
+   */
+  async configureWebhooks() {
+    const autoConfigVoice = process.env.AUTO_CONFIGURE_VOICE !== "false";
+    const autoConfigConversation = process.env.AUTO_CONFIGURE_CONVERSATION !== "false";
+    if (autoConfigVoice && process.env.VOICE_APPLICATION_KEY) {
+      await this.configureVoiceWebhooks();
+    }
+    if (autoConfigConversation && process.env.CONVERSATION_APP_ID) {
+      await configureConversationWebhooks(this.tunnelUrl, this.webhookConfig);
+    }
+    if (process.env.ELEVENLABS_AUTO_CONFIGURE === "true") {
+      await configureElevenLabs();
+    }
+  }
+  /**
+   * Cleanup webhooks on disconnect
+   */
+  async cleanupWebhooks() {
+    await cleanupConversationWebhook(this.webhookConfig);
+  }
+  async configureVoiceWebhooks() {
+    try {
+      const appKey = process.env.VOICE_APPLICATION_KEY;
+      const appSecret = process.env.VOICE_APPLICATION_SECRET;
+      if (!appKey || !appSecret) {
+        console.log("\u{1F4A1} Voice API not configured - skipping phone number display");
+        return;
+      }
+      try {
+        const updateUrl = `https://callingapi.sinch.com/v1/configuration/callbacks/applications/${appKey}/`;
+        const auth = Buffer.from(`${appKey}:${appSecret}`).toString("base64");
+        await axios.post(updateUrl, {
+          url: {
+            primary: this.tunnelUrl,
+            fallback: null
+          }
+        }, {
+          headers: {
+            "Authorization": `Basic ${auth}`,
+            "Content-Type": "application/json"
+          }
+        });
+        console.log("\u2705 Updated voice webhook URL");
+      } catch (error) {
+        console.log("\u26A0\uFE0F Could not update webhook URL:", error.message);
+      }
+      try {
+        const listUrl = `https://callingapi.sinch.com/v1/configuration/numbers/`;
+        const auth = Buffer.from(`${appKey}:${appSecret}`).toString("base64");
+        const response = await axios.get(listUrl, {
+          headers: {
+            "Authorization": `Basic ${auth}`
+          }
+        });
+        const numbers = response.data?.numbers || [];
+        const appNumbers = numbers.filter((n) => n.applicationkey === appKey);
+        if (appNumbers.length > 0) {
+          console.log("\u{1F4F1} Test Phone Numbers:");
+          appNumbers.forEach((num) => {
+            console.log(`   \u260E\uFE0F  ${num.number}`);
+          });
+          console.log("\u{1F4A1} Call any of these numbers to test your voice function!");
+        } else {
+          console.log("\u26A0\uFE0F No phone numbers assigned to this application yet");
+          console.log("\u{1F4A1} Add numbers at https://dashboard.sinch.com/voice/apps");
+        }
+      } catch (error) {
+        console.log("\u{1F4A1} Could not fetch phone numbers:", error.message);
+      }
+    } catch (error) {
+      console.log("\u{1F4A1} Could not fetch phone numbers (Voice API may not be configured)");
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("Max reconnection attempts reached. Giving up.");
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), 3e4);
+    console.log(`Attempting to reconnect in ${delay / 1e3} seconds...`);
+    setTimeout(() => this.connect(), delay);
+  }
+  async disconnect() {
+    this.stopHeartbeat();
+    await this.cleanupWebhooks();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.isConnected = false;
+  }
+  getTunnelUrl() {
+    return this.tunnelUrl;
+  }
+  getIsConnected() {
+    return this.isConnected;
+  }
+};
+
 // src/bin/sinch-runtime.ts
 var requireCjs3 = createRequire3(import.meta.url);
 function findFunctionPath3() {
@@ -783,18 +1224,25 @@ async function main() {
     });
   });
   displayStartupInfo(config, verbose, port);
-  app.listen(port, () => {
+  app.listen(port, async () => {
     console.log(`Function server running on http://localhost:${port}`);
     console.log("\nTest endpoints:");
     console.log(`   ICE: POST http://localhost:${port}/ice`);
     console.log(`   PIE: POST http://localhost:${port}/pie`);
     console.log(`   ACE: POST http://localhost:${port}/ace`);
     console.log(`   DICE: POST http://localhost:${port}/dice`);
-    void displayDetectedFunctions().then(() => {
-      if (!verbose) {
-        console.log("\nTip: Set VERBOSE=true or use --verbose for detailed output");
-      }
-    });
+    await displayDetectedFunctions();
+    if (!verbose) {
+      console.log("\nTip: Set VERBOSE=true or use --verbose for detailed output");
+    }
+    if (process.env.SINCH_TUNNEL === "true") {
+      console.log("\nStarting tunnel...");
+      const tunnelClient = new TunnelClient(port);
+      await tunnelClient.connect();
+      process.on("beforeExit", async () => {
+        await tunnelClient.disconnect();
+      });
+    }
   });
 }
 main().catch((error) => {