cyrus-edge-worker 0.0.40 → 0.2.0-rc

package/dist/SharedApplicationServer.js

@@ -1,33 +1,34 @@
-import { randomUUID } from "node:crypto";
-import { createServer, } from "node:http";
-import { URL } from "node:url";
-import { forward } from "@ngrok/ngrok";
-import { DEFAULT_PROXY_URL } from "cyrus-core";
+import { CloudflareTunnelClient } from "cyrus-cloudflare-tunnel-client";
+import Fastify from "fastify";
 /**
  * Shared application server that handles both webhooks and OAuth callbacks on a single port
  * Consolidates functionality from SharedWebhookServer and CLI OAuth server
  */
 export class SharedApplicationServer {
-    server = null;
+    app = null;
     webhookHandlers = new Map();
-    // Separate handlers for LinearWebhookClient that handle raw req/res
+    // Legacy handlers for direct Linear webhook registration (deprecated)
     linearWebhookHandlers = new Map();
     oauthCallbacks = new Map();
-    oauthCallbackHandler = null;
-    oauthStates = new Map();
     pendingApprovals = new Map();
     port;
     host;
     isListening = false;
-    ngrokListener = null;
-    ngrokAuthToken = null;
-    ngrokUrl = null;
-    proxyUrl;
-    constructor(port = 3456, host = "localhost", ngrokAuthToken, proxyUrl) {
+    tunnelClient = null;
+    constructor(port = 3456, host = "localhost") {
         this.port = port;
         this.host = host;
-        this.ngrokAuthToken = ngrokAuthToken || null;
-        this.proxyUrl = proxyUrl || process.env.PROXY_URL || DEFAULT_PROXY_URL;
+    }
+    /**
+     * Initialize the Fastify app instance (must be called before registering routes)
+     */
+    initializeFastify() {
+        if (this.app) {
+            return; // Already initialized
+        }
+        this.app = Fastify({
+            logger: false,
+        });
     }
     /**
      * Start the shared application server
@@ -36,30 +37,63 @@ export class SharedApplicationServer {
         if (this.isListening) {
             return; // Already listening
         }
-        return new Promise((resolve, reject) => {
-            this.server = createServer((req, res) => {
-                this.handleRequest(req, res);
+        // Initialize Fastify if not already done
+        this.initializeFastify();
+        try {
+            await this.app.listen({
+                port: this.port,
+                host: this.host,
             });
-            this.server.listen(this.port, this.host, async () => {
-                this.isListening = true;
-                console.log(`🔗 Shared application server listening on http://${this.host}:${this.port}`);
-                // Start ngrok tunnel if auth token is provided and not external host
-                const isExternalHost = process.env.CYRUS_HOST_EXTERNAL?.toLowerCase().trim() === "true";
-                if (this.ngrokAuthToken && !isExternalHost) {
-                    try {
-                        await this.startNgrokTunnel();
-                    }
-                    catch (error) {
-                        console.error("🔴 Failed to start ngrok tunnel:", error);
-                        // Don't reject here - server can still work without ngrok
-                    }
+            this.isListening = true;
+            console.log(`🔗 Shared application server listening on http://${this.host}:${this.port}`);
+            // Start Cloudflare tunnel if CLOUDFLARE_TOKEN is set
+            if (process.env.CLOUDFLARE_TOKEN) {
+                await this.startCloudflareTunnel(process.env.CLOUDFLARE_TOKEN);
+            }
+        }
+        catch (error) {
+            this.isListening = false;
+            throw error;
+        }
+    }
+    /**
+     * Start Cloudflare tunnel and wait for 4 'connected' events
+     */
+    async startCloudflareTunnel(cloudflareToken) {
+        return new Promise((resolve, reject) => {
+            let connectionCount = 0;
+            const requiredConnections = 4;
+            this.tunnelClient = new CloudflareTunnelClient(cloudflareToken, this.port);
+            // Listen for connection events (Cloudflare establishes 4 connections per tunnel)
+            this.tunnelClient.on("connected", () => {
+                connectionCount++;
+                console.log(`🔗 Cloudflare tunnel connection ${connectionCount}/${requiredConnections} established`);
+                if (connectionCount === requiredConnections) {
+                    console.log("✅ Cloudflare tunnel fully connected and ready");
+                    resolve();
                 }
-                resolve();
             });
-            this.server.on("error", (error) => {
-                this.isListening = false;
+            // Listen for ready event to get tunnel URL
+            this.tunnelClient.on("ready", (tunnelUrl) => {
+                console.log(`🔗 Cloudflare tunnel URL: ${tunnelUrl}`);
+            });
+            // Listen for error events
+            this.tunnelClient.on("error", (error) => {
+                console.error("❌ Cloudflare tunnel error:", error);
                 reject(error);
             });
+            // Listen for disconnect events
+            this.tunnelClient.on("disconnect", (reason) => {
+                console.log(`🔗 Cloudflare tunnel disconnected: ${reason}`);
+            });
+            // Start the tunnel
+            this.tunnelClient.startTunnel().catch(reject);
+            // Timeout after 30 seconds
+            setTimeout(() => {
+                if (connectionCount < requiredConnections) {
+                    reject(new Error(`Timeout waiting for Cloudflare tunnel (${connectionCount}/${requiredConnections} connections)`));
+                }
+            }, 30000);
         });
     }
     /**
@@ -72,26 +106,16 @@ export class SharedApplicationServer {
             console.log(`🔐 Rejected pending approval for session ${sessionId} due to shutdown`);
         }
         this.pendingApprovals.clear();
-        // Stop ngrok tunnel first
-        if (this.ngrokListener) {
-            try {
-                await this.ngrokListener.close();
-                this.ngrokListener = null;
-                this.ngrokUrl = null;
-                console.log("🔗 Ngrok tunnel stopped");
-            }
-            catch (error) {
-                console.error("🔴 Failed to stop ngrok tunnel:", error);
-            }
+        // Stop Cloudflare tunnel if running
+        if (this.tunnelClient) {
+            this.tunnelClient.disconnect();
+            this.tunnelClient = null;
+            console.log("🔗 Cloudflare tunnel stopped");
         }
-        if (this.server && this.isListening) {
-            return new Promise((resolve) => {
-                this.server.close(() => {
-                    this.isListening = false;
-                    console.log("🔗 Shared application server stopped");
-                    resolve();
-                });
-            });
+        if (this.app && this.isListening) {
+            await this.app.close();
+            this.isListening = false;
+            console.log("🔗 Shared application server stopped");
         }
     }
     /**
@@ -101,42 +125,20 @@ export class SharedApplicationServer {
         return this.port;
     }
     /**
-     * Get the base URL for the server (ngrok URL if available, otherwise local URL)
+     * Get the Fastify instance for registering routes
+     * Initializes Fastify if not already done
      */
-    getBaseUrl() {
-        if (this.ngrokUrl) {
-            return this.ngrokUrl;
-        }
-        return process.env.CYRUS_BASE_URL || `http://${this.host}:${this.port}`;
-    }
-    /**
-     * Start ngrok tunnel for the server
-     */
-    async startNgrokTunnel() {
-        if (!this.ngrokAuthToken) {
-            return;
-        }
-        try {
-            console.log("🔗 Starting ngrok tunnel...");
-            this.ngrokListener = await forward({
-                addr: this.port,
-                authtoken: this.ngrokAuthToken,
-            });
-            this.ngrokUrl = this.ngrokListener.url();
-            console.log(`🌐 Ngrok tunnel active: ${this.ngrokUrl}`);
-            // Override CYRUS_BASE_URL with ngrok URL
-            process.env.CYRUS_BASE_URL = this.ngrokUrl || undefined;
-        }
-        catch (error) {
-            console.error("🔴 Failed to start ngrok tunnel:", error);
-            throw error;
-        }
+    getFastifyInstance() {
+        this.initializeFastify();
+        return this.app;
     }
     /**
-     * Register a webhook handler for a specific token
+     * Register a webhook handler for a specific token (LEGACY - deprecated)
      * Supports two signatures:
      * 1. For ndjson-client: (token, secret, handler)
-     * 2. For linear-webhook-client: (token, handler) where handler takes (req, res)
+     * 2. For legacy direct registration: (token, handler) where handler takes (req, res)
+     *
+     * NOTE: New code should use LinearEventTransport which registers routes directly with Fastify
      */
     registerWebhookHandler(token, secretOrHandler, handler) {
         if (typeof secretOrHandler === "string" && handler) {
@@ -145,9 +147,9 @@ export class SharedApplicationServer {
             console.log(`🔗 Registered webhook handler (proxy-style) for token ending in ...${token.slice(-4)}`);
         }
         else if (typeof secretOrHandler === "function") {
-            // linear-webhook-client style registration
+            // Legacy direct registration
             this.linearWebhookHandlers.set(token, secretOrHandler);
-            console.log(`🔗 Registered webhook handler (direct-style) for token ending in ...${token.slice(-4)}`);
+            console.log(`🔗 Registered webhook handler (legacy direct-style) for token ending in ...${token.slice(-4)}`);
         }
         else {
             throw new Error("Invalid webhook handler registration parameters");
@@ -163,13 +165,6 @@ export class SharedApplicationServer {
             console.log(`🔗 Unregistered webhook handler for token ending in ...${token.slice(-4)}`);
         }
     }
-    /**
-     * Register an OAuth callback handler
-     */
-    registerOAuthCallbackHandler(handler) {
-        this.oauthCallbackHandler = handler;
-        console.log("🔐 Registered OAuth callback handler");
-    }
     /**
      * Start OAuth flow and return promise that resolves when callback is received
      */
@@ -182,7 +177,7 @@ export class SharedApplicationServer {
             // Check if we should use direct Linear OAuth (when self-hosting)
             const isExternalHost = process.env.CYRUS_HOST_EXTERNAL?.toLowerCase().trim() === "true";
             const useDirectOAuth = isExternalHost && process.env.LINEAR_CLIENT_ID;
-            const callbackBaseUrl = this.getBaseUrl();
+            const callbackBaseUrl = `http://${this.host}:${this.port}`;
             let authUrl;
             if (useDirectOAuth) {
                 // Use local OAuth authorize endpoint
@@ -205,25 +200,10 @@ export class SharedApplicationServer {
         });
     }
     /**
-     * Get the public URL (ngrok URL if available, otherwise base URL)
-     */
-    getPublicUrl() {
-        // Use ngrok URL if available
-        if (this.ngrokUrl) {
-            return this.ngrokUrl;
-        }
-        // If CYRUS_BASE_URL is set (could be from external proxy), use that
-        if (process.env.CYRUS_BASE_URL) {
-            return process.env.CYRUS_BASE_URL;
-        }
-        // Default to local URL
-        return `http://${this.host}:${this.port}`;
-    }
-    /**
-     * Get the webhook URL for registration with proxy
+     * Get the webhook URL
      */
     getWebhookUrl() {
-        return `${this.getPublicUrl()}/webhook`;
+        return `http://${this.host}:${this.port}/webhook`;
     }
     /**
      * Get the OAuth callback URL for registration with proxy
@@ -231,442 +211,6 @@ export class SharedApplicationServer {
     getOAuthCallbackUrl() {
         return `http://${this.host}:${this.port}/callback`;
     }
-    /**
-     * Handle incoming requests (both webhooks and OAuth callbacks)
-     */
-    async handleRequest(req, res) {
-        try {
-            const url = new URL(req.url, `http://${this.host}:${this.port}`);
-            if (url.pathname === "/webhook") {
-                await this.handleWebhookRequest(req, res);
-            }
-            else if (url.pathname === "/callback") {
-                await this.handleOAuthCallback(req, res, url);
-            }
-            else if (url.pathname === "/oauth/authorize") {
-                await this.handleOAuthAuthorize(req, res, url);
-            }
-            else if (url.pathname === "/approval") {
-                await this.handleApprovalRequest(req, res, url);
-            }
-            else {
-                res.writeHead(404, { "Content-Type": "text/plain" });
-                res.end("Not Found");
-            }
-        }
-        catch (error) {
-            console.error("🔗 Request handling error:", error);
-            res.writeHead(500, { "Content-Type": "text/plain" });
-            res.end("Internal Server Error");
-        }
-    }
-    /**
-     * Handle incoming webhook requests
-     */
-    async handleWebhookRequest(req, res) {
-        try {
-            console.log(`🔗 Incoming webhook request: ${req.method} ${req.url}`);
-            if (req.method !== "POST") {
-                console.log(`🔗 Rejected non-POST request: ${req.method}`);
-                res.writeHead(405, { "Content-Type": "text/plain" });
-                res.end("Method Not Allowed");
-                return;
-            }
-            // Check if this is a direct Linear webhook (has linear-signature header)
-            const linearSignature = req.headers["linear-signature"];
-            const isDirectWebhook = !!linearSignature;
-            if (isDirectWebhook && this.linearWebhookHandlers.size > 0) {
-                // For direct Linear webhooks, pass the raw request to the handler
-                // The LinearWebhookClient will handle its own signature verification
-                console.log(`🔗 Direct Linear webhook received, trying ${this.linearWebhookHandlers.size} direct handlers`);
-                // Try each direct handler
-                for (const [token, handler] of this.linearWebhookHandlers) {
-                    try {
-                        // The handler will manage the response
-                        await handler(req, res);
-                        console.log(`🔗 Direct webhook delivered to token ending in ...${token.slice(-4)}`);
-                        return;
-                    }
-                    catch (error) {
-                        console.error(`🔗 Error in direct webhook handler for token ...${token.slice(-4)}:`, error);
-                    }
-                }
-                // No direct handler could process it
-                console.error(`🔗 Direct webhook processing failed for all ${this.linearWebhookHandlers.size} handlers`);
-                res.writeHead(401, { "Content-Type": "text/plain" });
-                res.end("Unauthorized");
-                return;
-            }
-            // Otherwise, handle as proxy-style webhook
-            // Read request body
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", () => {
-                try {
-                    // For proxy-style webhooks, we need the signature header
-                    const signature = req.headers["x-webhook-signature"];
-                    const timestamp = req.headers["x-webhook-timestamp"];
-                    console.log(`🔗 Proxy webhook received with ${body.length} bytes, ${this.webhookHandlers.size} registered handlers`);
-                    if (!signature) {
-                        console.log("🔗 Webhook rejected: Missing signature header");
-                        res.writeHead(400, { "Content-Type": "text/plain" });
-                        res.end("Missing signature");
-                        return;
-                    }
-                    // Try each registered handler until one verifies the signature
-                    let handlerAttempts = 0;
-                    for (const [token, { handler }] of this.webhookHandlers) {
-                        handlerAttempts++;
-                        try {
-                            if (handler(body, signature, timestamp)) {
-                                // Handler verified signature and processed webhook
-                                res.writeHead(200, { "Content-Type": "text/plain" });
-                                res.end("OK");
-                                console.log(`🔗 Webhook delivered to token ending in ...${token.slice(-4)} (attempt ${handlerAttempts}/${this.webhookHandlers.size})`);
-                                return;
-                            }
-                        }
-                        catch (error) {
-                            console.error(`🔗 Error in webhook handler for token ...${token.slice(-4)}:`, error);
-                        }
-                    }
-                    // No handler could verify the signature
-                    console.error(`🔗 Webhook signature verification failed for all ${this.webhookHandlers.size} registered handlers`);
-                    res.writeHead(401, { "Content-Type": "text/plain" });
-                    res.end("Unauthorized");
-                }
-                catch (error) {
-                    console.error("🔗 Error processing webhook:", error);
-                    res.writeHead(400, { "Content-Type": "text/plain" });
-                    res.end("Bad Request");
-                }
-            });
-            req.on("error", (error) => {
-                console.error("🔗 Request error:", error);
-                res.writeHead(500, { "Content-Type": "text/plain" });
-                res.end("Internal Server Error");
-            });
-        }
-        catch (error) {
-            console.error("🔗 Webhook request error:", error);
-            res.writeHead(500, { "Content-Type": "text/plain" });
-            res.end("Internal Server Error");
-        }
-    }
-    /**
-     * Handle OAuth callback requests
-     */
-    async handleOAuthCallback(_req, res, url) {
-        try {
-            const code = url.searchParams.get("code");
-            const state = url.searchParams.get("state");
-            // Check if this is a direct Linear callback (has code and state)
-            const isExternalHost = process.env.CYRUS_HOST_EXTERNAL?.toLowerCase().trim() === "true";
-            const isDirectWebhooks = process.env.LINEAR_DIRECT_WEBHOOKS?.toLowerCase().trim() === "true";
-            // Handle direct callback if both external host and direct webhooks are enabled
-            if (code && state && isExternalHost && isDirectWebhooks) {
-                await this.handleDirectLinearCallback(_req, res, url);
-                return;
-            }
-            // Otherwise handle as proxy callback
-            const token = url.searchParams.get("token");
-            const workspaceId = url.searchParams.get("workspaceId");
-            const workspaceName = url.searchParams.get("workspaceName");
-            if (token && workspaceId && workspaceName) {
-                // Success! Return the Linear credentials
-                const linearCredentials = {
-                    linearToken: token,
-                    linearWorkspaceId: workspaceId,
-                    linearWorkspaceName: workspaceName,
-                };
-                // Send success response
-                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-                res.end(`
-          <!DOCTYPE html>
-          <html>
-            <head>
-              <meta charset="UTF-8">
-              <title>Authorization Successful</title>
-            </head>
-            <body style="font-family: system-ui; max-width: 600px; margin: 50px auto; padding: 20px;">
-              <h1>✅ Authorization Successful!</h1>
-              <p>You can close this window and return to the terminal.</p>
-              <p>Your Linear workspace <strong>${workspaceName}</strong> has been connected.</p>
-              <p style="margin-top: 30px;">
-                <a href="${this.proxyUrl}/oauth/authorize?callback=${process.env.CYRUS_BASE_URL || `http://${this.host}:${this.port}`}/callback" 
-                   style="padding: 10px 20px; background: #5E6AD2; color: white; text-decoration: none; border-radius: 5px;">
-                  Connect Another Workspace
-                </a>
-              </p>
-              <script>setTimeout(() => window.close(), 10000)</script>
-            </body>
-          </html>
-        `);
-                console.log(`🔐 OAuth callback received for workspace: ${workspaceName}`);
-                // Resolve any waiting promises
-                if (this.oauthCallbacks.size > 0) {
-                    const callback = this.oauthCallbacks.values().next().value;
-                    if (callback) {
-                        callback.resolve(linearCredentials);
-                        this.oauthCallbacks.delete(callback.id);
-                    }
-                }
-                // Call the registered OAuth callback handler
-                if (this.oauthCallbackHandler) {
-                    try {
-                        await this.oauthCallbackHandler(token, workspaceId, workspaceName);
-                    }
-                    catch (error) {
-                        console.error("🔐 Error in OAuth callback handler:", error);
-                    }
-                }
-            }
-            else {
-                res.writeHead(400, { "Content-Type": "text/html" });
-                res.end("<h1>Error: No token received</h1>");
-                // Reject any waiting promises
-                for (const [id, callback] of this.oauthCallbacks) {
-                    callback.reject(new Error("No token received"));
-                    this.oauthCallbacks.delete(id);
-                }
-            }
-        }
-        catch (error) {
-            console.error("🔐 OAuth callback error:", error);
-            res.writeHead(500, { "Content-Type": "text/plain" });
-            res.end("Internal Server Error");
-        }
-    }
-    /**
-     * Handle OAuth authorization requests for direct Linear OAuth
-     */
-    async handleOAuthAuthorize(_req, res, _url) {
-        try {
-            // Check if we're in external host mode with direct webhooks
-            const isExternalHost = process.env.CYRUS_HOST_EXTERNAL?.toLowerCase().trim() === "true";
-            const isDirectWebhooks = process.env.LINEAR_DIRECT_WEBHOOKS?.toLowerCase().trim() === "true";
-            // Only handle OAuth locally if both external host AND direct webhooks are enabled
-            if (!isExternalHost || !isDirectWebhooks) {
-                // Redirect to proxy OAuth endpoint
-                const callbackBaseUrl = this.getBaseUrl();
-                const proxyAuthUrl = `${this.proxyUrl}/oauth/authorize?callback=${callbackBaseUrl}/callback`;
-                res.writeHead(302, { Location: proxyAuthUrl });
-                res.end();
-                return;
-            }
-            // Check for LINEAR_CLIENT_ID
-            const clientId = process.env.LINEAR_CLIENT_ID;
-            if (!clientId) {
-                res.writeHead(400, { "Content-Type": "text/plain" });
-                res.end("LINEAR_CLIENT_ID environment variable is required for direct OAuth");
-                return;
-            }
-            // Generate state for CSRF protection
-            const state = randomUUID();
-            // Store state with expiration (10 minutes)
-            this.oauthStates.set(state, {
-                createdAt: Date.now(),
-                redirectUri: `${this.getBaseUrl()}/callback`,
-            });
-            // Clean up expired states (older than 10 minutes)
-            const now = Date.now();
-            for (const [stateKey, stateData] of this.oauthStates) {
-                if (now - stateData.createdAt > 10 * 60 * 1000) {
-                    this.oauthStates.delete(stateKey);
-                }
-            }
-            // Build Linear OAuth URL
-            const authUrl = new URL("https://linear.app/oauth/authorize");
-            authUrl.searchParams.set("client_id", clientId);
-            authUrl.searchParams.set("redirect_uri", `${this.getBaseUrl()}/callback`);
-            authUrl.searchParams.set("response_type", "code");
-            authUrl.searchParams.set("state", state);
-            authUrl.searchParams.set("scope", "read,write,app:assignable,app:mentionable");
-            authUrl.searchParams.set("actor", "app");
-            authUrl.searchParams.set("prompt", "consent");
-            console.log(`🔐 Redirecting to Linear OAuth: ${authUrl.toString()}`);
-            // Redirect to Linear OAuth
-            res.writeHead(302, { Location: authUrl.toString() });
-            res.end();
-        }
-        catch (error) {
-            console.error("🔐 OAuth authorize error:", error);
-            res.writeHead(500, { "Content-Type": "text/plain" });
-            res.end("Internal Server Error");
-        }
-    }
-    /**
-     * Handle direct Linear OAuth callback (exchange code for token)
-     */
-    async handleDirectLinearCallback(_req, res, url) {
-        try {
-            const code = url.searchParams.get("code");
-            const state = url.searchParams.get("state");
-            if (!code || !state) {
-                res.writeHead(400, { "Content-Type": "text/plain" });
-                res.end("Missing code or state parameter");
-                return;
-            }
-            // Validate state
-            const stateData = this.oauthStates.get(state);
-            if (!stateData) {
-                res.writeHead(400, { "Content-Type": "text/plain" });
-                res.end("Invalid or expired state");
-                return;
-            }
-            // Delete state after use
-            this.oauthStates.delete(state);
-            // Exchange code for token
-            const tokenResponse = await this.exchangeCodeForToken(code);
-            // Get workspace info using the token
-            const workspaceInfo = await this.getWorkspaceInfo(tokenResponse.access_token);
-            // Success! Return the Linear credentials
-            const linearCredentials = {
-                linearToken: tokenResponse.access_token,
-                linearWorkspaceId: workspaceInfo.organization.id,
-                linearWorkspaceName: workspaceInfo.organization.name,
-            };
-            // Send success response
-            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-            res.end(`
-        <!DOCTYPE html>
-        <html>
-          <head>
-            <meta charset="UTF-8">
-            <title>Authorization Successful</title>
-          </head>
-          <body style="font-family: system-ui; max-width: 600px; margin: 50px auto; padding: 20px;">
-            <h1>✅ Authorization Successful!</h1>
-            <p>You can close this window and return to the terminal.</p>
-            <p>Your Linear workspace <strong>${workspaceInfo.organization.name}</strong> has been connected.</p>
-            <p style="margin-top: 30px;">
-              <a href="${this.getBaseUrl()}/oauth/authorize" 
-                 style="padding: 10px 20px; background: #5E6AD2; color: white; text-decoration: none; border-radius: 5px;">
-                Connect Another Workspace
-              </a>
-            </p>
-            <script>setTimeout(() => window.close(), 10000)</script>
-          </body>
-        </html>
-      `);
-            console.log(`🔐 Direct OAuth callback received for workspace: ${workspaceInfo.organization.name}`);
-            // Resolve any waiting promises
-            if (this.oauthCallbacks.size > 0) {
-                const callback = this.oauthCallbacks.values().next().value;
-                if (callback) {
-                    callback.resolve(linearCredentials);
-                    this.oauthCallbacks.delete(callback.id);
-                }
-            }
-            // Call the registered OAuth callback handler
-            if (this.oauthCallbackHandler) {
-                try {
-                    await this.oauthCallbackHandler(tokenResponse.access_token, workspaceInfo.organization.id, workspaceInfo.organization.name);
-                }
-                catch (error) {
-                    console.error("🔐 Error in OAuth callback handler:", error);
-                }
-            }
-        }
-        catch (error) {
-            console.error("🔐 Direct Linear callback error:", error);
-            res.writeHead(500, { "Content-Type": "text/plain" });
-            res.end(`OAuth failed: ${error.message}`);
-            // Reject any waiting promises
-            for (const [id, callback] of this.oauthCallbacks) {
-                callback.reject(error);
-                this.oauthCallbacks.delete(id);
-            }
-        }
-    }
-    /**
-     * Exchange authorization code for access token
-     */
-    async exchangeCodeForToken(code) {
-        const clientId = process.env.LINEAR_CLIENT_ID;
-        const clientSecret = process.env.LINEAR_CLIENT_SECRET;
-        if (!clientId || !clientSecret) {
-            throw new Error("LINEAR_CLIENT_ID and LINEAR_CLIENT_SECRET are required");
-        }
-        const response = await fetch("https://api.linear.app/oauth/token", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded",
-            },
-            body: new URLSearchParams({
-                grant_type: "authorization_code",
-                client_id: clientId,
-                client_secret: clientSecret,
-                redirect_uri: `${this.getBaseUrl()}/callback`,
-                code: code,
-            }),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Token exchange failed: ${error}`);
-        }
-        return await response.json();
-    }
-    /**
-     * Get workspace information using access token
-     */
-    async getWorkspaceInfo(accessToken) {
-        const response = await fetch("https://api.linear.app/graphql", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${accessToken}`,
-            },
-            body: JSON.stringify({
-                query: `
-          query {
-            viewer {
-              id
-              name
-              email
-              organization {
-                id
-                name
-                urlKey
-                teams {
-                  nodes {
-                    id
-                    key
-                    name
-                  }
-                }
-              }
-            }
-          }
-        `,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error("Failed to get workspace info");
-        }
-        const data = (await response.json());
-        if (data.errors) {
-            throw new Error(`GraphQL errors: ${JSON.stringify(data.errors)}`);
-        }
-        return {
-            userId: data.data.viewer.id,
-            userEmail: data.data.viewer.email,
-            organization: data.data.viewer.organization,
-        };
-    }
-    /**
-     * Escape HTML special characters to prevent XSS attacks
-     */
-    escapeHtml(unsafe) {
-        return unsafe
-            .replace(/&/g, "&amp;")
-            .replace(/</g, "&lt;")
-            .replace(/>/g, "&gt;")
-            .replace(/"/g, "&quot;")
-            .replace(/'/g, "&#039;");
-    }
     /**
      * Register an approval request and get approval URL
      */
@@ -689,224 +233,9 @@ export class SharedApplicationServer {
             });
         });
         // Generate approval URL
-        const url = `${this.getBaseUrl()}/approval?session=${encodeURIComponent(sessionId)}`;
+        const url = `http://${this.host}:${this.port}/approval?session=${encodeURIComponent(sessionId)}`;
         console.log(`🔐 Registered approval request for session ${sessionId}: ${url}`);
         return { promise, url };
     }
-    /**
-     * Handle approval requests
-     */
-    async handleApprovalRequest(_req, res, url) {
-        try {
-            const sessionId = url.searchParams.get("session");
-            const action = url.searchParams.get("action"); // "approve" or "reject"
-            const feedback = url.searchParams.get("feedback");
-            if (!sessionId) {
-                res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
-                res.end(`
-          <!DOCTYPE html>
-          <html>
-            <head>
-              <meta charset="UTF-8">
-              <title>Invalid Request</title>
-            </head>
-            <body style="font-family: system-ui; max-width: 600px; margin: 50px auto; padding: 20px;">
-              <h1>❌ Invalid Request</h1>
-              <p>Missing session parameter.</p>
-            </body>
-          </html>
-        `);
-                return;
-            }
-            const approval = this.pendingApprovals.get(sessionId);
-            // If no action specified, show approval UI
-            if (!action) {
-                const approvalExists = !!approval;
-                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-                res.end(`
-          <!DOCTYPE html>
-          <html>
-            <head>
-              <meta charset="UTF-8">
-              <title>Approval Required</title>
-              <style>
-                body {
-                  font-family: system-ui, -apple-system, sans-serif;
-                  max-width: 700px;
-                  margin: 50px auto;
-                  padding: 20px;
-                  background: #f5f5f5;
-                }
-                .card {
-                  background: white;
-                  padding: 30px;
-                  border-radius: 8px;
-                  box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-                }
-                h1 {
-                  margin-top: 0;
-                  color: #333;
-                }
-                .status {
-                  padding: 15px;
-                  border-radius: 5px;
-                  margin: 20px 0;
-                }
-                .status.pending {
-                  background: #fff3cd;
-                  border-left: 4px solid #ffc107;
-                }
-                .status.resolved {
-                  background: #d4edda;
-                  border-left: 4px solid #28a745;
-                }
-                .buttons {
-                  display: flex;
-                  gap: 10px;
-                  margin-top: 20px;
-                }
-                button {
-                  padding: 12px 24px;
-                  font-size: 16px;
-                  border: none;
-                  border-radius: 5px;
-                  cursor: pointer;
-                  transition: opacity 0.2s;
-                }
-                button:hover:not(:disabled) {
-                  opacity: 0.9;
-                }
-                button:disabled {
-                  opacity: 0.5;
-                  cursor: not-allowed;
-                }
-                .approve-btn {
-                  background: #28a745;
-                  color: white;
-                  flex: 1;
-                }
-                .reject-btn {
-                  background: #dc3545;
-                  color: white;
-                  flex: 1;
-                }
-                textarea {
-                  width: 100%;
-                  padding: 10px;
-                  border: 1px solid #ddd;
-                  border-radius: 5px;
-                  font-family: inherit;
-                  margin-top: 10px;
-                  resize: vertical;
-                }
-                label {
-                  display: block;
-                  margin-top: 15px;
-                  color: #666;
-                  font-size: 14px;
-                }
-              </style>
-            </head>
-            <body>
-              <div class="card">
-                ${approvalExists
-                    ? `
-                  <h1>🔔 Approval Required</h1>
-                  <div class="status pending">
-                    <strong>Status:</strong> Waiting for your decision
-                  </div>
-                  <p>The agent is requesting your approval to proceed with the next step of the workflow.</p>
-
-                  <label for="feedback">Optional feedback or instructions:</label>
-                  <textarea id="feedback" rows="3" placeholder="Enter any feedback or additional instructions..."></textarea>
-
-                  <div class="buttons">
-                    <button class="approve-btn" onclick="handleAction('approve')">
-                      ✅ Approve
-                    </button>
-                    <button class="reject-btn" onclick="handleAction('reject')">
-                      ❌ Reject
-                    </button>
-                  </div>
-                `
-                    : `
-                  <h1>ℹ️ Approval Already Processed</h1>
-                  <div class="status resolved">
-                    This approval request has already been processed or has expired.
-                  </div>
-                  <p>You can close this window.</p>
-                `}
-              </div>
-
-              <script>
-                async function handleAction(action) {
-                  const feedback = document.getElementById('feedback')?.value || '';
-                  const url = new URL(window.location.href);
-                  url.searchParams.set('action', action);
-                  if (feedback) {
-                    url.searchParams.set('feedback', feedback);
-                  }
-
-                  // Disable buttons
-                  document.querySelectorAll('button').forEach(btn => btn.disabled = true);
-
-                  // Navigate to confirmation
-                  window.location.href = url.toString();
-                }
-              </script>
-            </body>
-          </html>
-        `);
-                return;
-            }
-            // Handle approval/rejection
-            if (!approval) {
-                res.writeHead(410, { "Content-Type": "text/html; charset=utf-8" });
-                res.end(`
-          <!DOCTYPE html>
-          <html>
-            <head>
-              <meta charset="UTF-8">
-              <title>Approval Expired</title>
-            </head>
-            <body style="font-family: system-ui; max-width: 600px; margin: 50px auto; padding: 20px;">
-              <h1>⏰ Approval Expired</h1>
-              <p>This approval request has already been processed or has expired.</p>
-              <p>You can close this window.</p>
-            </body>
-          </html>
-        `);
-                return;
-            }
-            // Process the approval/rejection
-            const approved = action === "approve";
-            approval.resolve(approved, feedback || undefined);
-            this.pendingApprovals.delete(sessionId);
-            console.log(`🔐 Approval ${approved ? "granted" : "rejected"} for session ${sessionId}${feedback ? ` with feedback: ${feedback}` : ""}`);
-            // Send success response
-            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-            res.end(`
-        <!DOCTYPE html>
-        <html>
-          <head>
-            <meta charset="UTF-8">
-            <title>Approval ${approved ? "Granted" : "Rejected"}</title>
-          </head>
-          <body style="font-family: system-ui; max-width: 600px; margin: 50px auto; padding: 20px;">
-            <h1>${approved ? "✅ Approval Granted" : "❌ Approval Rejected"}</h1>
-            <p>Your decision has been recorded. The agent will ${approved ? "proceed with the next step" : "stop the current workflow"}.</p>
-            ${feedback ? `<p><strong>Feedback provided:</strong> ${this.escapeHtml(feedback)}</p>` : ""}
-            <p style="margin-top: 30px; color: #666;">You can close this window and return to Linear.</p>
-            <script>setTimeout(() => window.close(), 5000)</script>
-          </body>
-        </html>
-      `);
-        }
-        catch (error) {
-            console.error("🔐 Approval request error:", error);
-            res.writeHead(500, { "Content-Type": "text/plain" });
-            res.end("Internal Server Error");
-        }
-    }
 }
 //# sourceMappingURL=SharedApplicationServer.js.map