lunel-cli 0.1.93 → 0.1.95

package/dist/index.js

@@ -251,7 +251,7 @@ function parseExtraPortsFromArgs(args) {
 const EXTRA_PORTS = parseExtraPortsFromArgs(CLI_ARGS);
 const USE_APPLE_REVIEW_CODE = hasAnyFlag(CLI_ARGS, "--abcd-code");
 const FORCE_NEW_CODE = hasAnyFlag(CLI_ARGS, "--new", "-n");
-const SCAN_PORTS = Array.from(new Set([...DEV_PORTS, ...EXTRA_PORTS])).sort((a, b) => a - b);
+const trackedProxyPorts = new Set(EXTRA_PORTS);
 function samePortSet(a, b) {
     if (a.length !== b.length)
         return false;
@@ -1994,7 +1994,8 @@ async function handleHttpRequest(payload) {
 // ============================================================================
 async function scanDevPorts() {
     const openPorts = [];
-    const checks = SCAN_PORTS.map((port) => {
+    const scanPorts = Array.from(new Set([...DEV_PORTS, ...trackedProxyPorts])).sort((a, b) => a - b);
+    const checks = scanPorts.map((port) => {
         return new Promise((resolve) => {
             let finished = false;
             let pending = LOOPBACK_HOSTS.length;
@@ -2031,6 +2032,9 @@ async function scanDevPorts() {
     await Promise.all(checks);
     return openPorts.sort((a, b) => a - b);
 }
+function getTrackedProxyPorts() {
+    return Array.from(trackedProxyPorts).sort((a, b) => a - b);
+}
 async function publishDiscoveredPorts(force = false) {
     if (portScanInFlight)
         return;
@@ -2059,6 +2063,46 @@ async function publishDiscoveredPorts(force = false) {
         portScanInFlight = false;
     }
 }
+async function getProxyState() {
+    const openPorts = await scanDevPorts();
+    lastDiscoveredPorts = openPorts;
+    return {
+        trackedPorts: getTrackedProxyPorts(),
+        openPorts,
+    };
+}
+async function handleTrackProxyPort(payload) {
+    const port = Number(payload.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw Object.assign(new Error("port must be an integer between 1 and 65535"), { code: "EINVAL" });
+    }
+    trackedProxyPorts.add(port);
+    debugLog("[proxy] tracking custom port", {
+        port,
+        trackedPorts: getTrackedProxyPorts(),
+    });
+    await publishDiscoveredPorts(true);
+    return {
+        trackedPorts: getTrackedProxyPorts(),
+        openPorts: lastDiscoveredPorts,
+    };
+}
+async function handleUntrackProxyPort(payload) {
+    const port = Number(payload.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw Object.assign(new Error("port must be an integer between 1 and 65535"), { code: "EINVAL" });
+    }
+    trackedProxyPorts.delete(port);
+    debugLog("[proxy] removed custom port tracking", {
+        port,
+        trackedPorts: getTrackedProxyPorts(),
+    });
+    await publishDiscoveredPorts(true);
+    return {
+        trackedPorts: getTrackedProxyPorts(),
+        openPorts: lastDiscoveredPorts,
+    };
+}
 function stopPortSync() {
     if (portSyncTimer) {
         clearInterval(portSyncTimer);
@@ -2078,6 +2122,13 @@ async function handleProxyConnect(payload) {
     const port = payload.port;
     const setupStartedAt = Date.now();
     const getRemainingSetupMs = () => TUNNEL_SETUP_BUDGET_MS - (Date.now() - setupStartedAt);
+    debugLog("[proxy] handleProxyConnect received", {
+        tunnelId,
+        port,
+        hasSessionCode: Boolean(currentSessionCode),
+        hasSessionPassword: Boolean(currentSessionPassword),
+        activeGatewayUrl,
+    });
     if (!tunnelId)
         throw Object.assign(new Error("tunnelId is required"), { code: "EINVAL" });
     if (!port)
@@ -2126,8 +2177,14 @@ async function handleProxyConnect(payload) {
         }
     }
     if (!tcpSocket) {
+        debugLog("[proxy] local tcp connect failed", {
+            tunnelId,
+            port,
+            error: tcpConnectError?.message ?? null,
+        });
         throw tcpConnectError || Object.assign(new Error(`TCP connect failed to localhost:${port}`), { code: "ECONNREFUSED" });
     }
+    debugLog("[proxy] local tcp connected", { tunnelId, port });
     // 2. Open proxy WebSocket to gateway
     const wsBase = activeGatewayUrl.replace(/^https:/, "wss:");
     if (!wsBase.startsWith("wss://")) {
@@ -2137,6 +2194,12 @@ async function handleProxyConnect(payload) {
         ? `password=${encodeURIComponent(currentSessionPassword)}`
         : `code=${encodeURIComponent(currentSessionCode)}`;
     const proxyWsUrl = `${wsBase}/v1/ws/proxy?${authQuery}&tunnelId=${encodeURIComponent(tunnelId)}&role=cli`;
+    debugLog("[proxy] connecting cli proxy websocket", {
+        tunnelId,
+        port,
+        authMode: currentSessionPassword ? "password" : "code",
+        wsBase,
+    });
     let proxyWs = null;
     let lastProxyError = null;
     for (let attempt = 0; attempt <= PROXY_WS_CONNECT_RETRY_ATTEMPTS; attempt++) {
@@ -2191,8 +2254,14 @@ async function handleProxyConnect(payload) {
     if (!proxyWs) {
         tcpSocket.destroy();
         const err = lastProxyError || Object.assign(new Error("Proxy WS connect failed"), { code: "ECONNREFUSED" });
+        debugLog("[proxy] cli proxy websocket connect failed", {
+            tunnelId,
+            port,
+            error: err.message,
+        });
         throw err;
     }
+    debugLog("[proxy] cli proxy websocket connected", { tunnelId, port });
     // 3. Store the tunnel
     activeTunnels.set(tunnelId, {
         tunnelId,
@@ -2267,6 +2336,7 @@ async function handleProxyConnect(payload) {
         markLocalEnded();
     });
     tcpSocket.on("error", () => {
+        debugLog("[proxy] local tcp socket error", { tunnelId, port });
         const tunnel = activeTunnels.get(tunnelId);
         if (tunnel && !tunnel.finSent) {
             sendProxyControl(tunnel, "rst", "tcp_error");
@@ -2284,6 +2354,7 @@ async function handleProxyConnect(payload) {
     });
     // 7. Close cascade: WS closes -> close TCP
     proxyWs.on("close", () => {
+        debugLog("[proxy] cli proxy websocket closed", { tunnelId, port });
         const tunnel = activeTunnels.get(tunnelId);
         if (tunnel) {
             tunnel.closing = true;
@@ -2297,6 +2368,7 @@ async function handleProxyConnect(payload) {
         }
     });
     proxyWs.on("error", () => {
+        debugLog("[proxy] cli proxy websocket error", { tunnelId, port });
         const tunnel = activeTunnels.get(tunnelId);
         if (tunnel) {
             tunnel.closing = true;
@@ -2363,6 +2435,7 @@ async function processMessage(message) {
                 switch (action) {
                     case "capabilities":
                         result = handleSystemCapabilities();
+                        void publishDiscoveredPorts(true);
                         break;
                     case "ping":
                         result = handleSystemPing();
@@ -2626,6 +2699,15 @@ async function processMessage(message) {
                     case "connect":
                         result = await handleProxyConnect(payload);
                         break;
+                    case "getState":
+                        result = await getProxyState();
+                        break;
+                    case "trackPort":
+                        result = await handleTrackProxyPort(payload);
+                        break;
+                    case "untrackPort":
+                        result = await handleUntrackProxyPort(payload);
+                        break;
                     default:
                         throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
                 }
@@ -2836,15 +2918,12 @@ async function connectWebSocketV2() {
     if (!currentSessionPassword) {
         throw new Error("missing password for websocket connect");
     }
-    if (!currentSessionCode) {
-        throw new Error("missing session code for secure transport");
-    }
     console.log(`Connecting to gateway ${gatewayUrl}...`);
     activeGatewayUrl = gatewayUrl;
     const transport = new V2SessionTransport({
         gatewayUrl,
         password: currentSessionPassword,
-        sessionCode: currentSessionCode,
+        sessionSecret: currentSessionPassword,
         role: "cli",
         debugLog: DEBUG_MODE ? debugLog : undefined,
         handlers: {
@@ -2853,6 +2932,7 @@ async function connectWebSocketV2() {
                     return;
                 if (message.type === "peer_connected") {
                     console.log("App connected!\n");
+                    void publishDiscoveredPorts(true);
                     return;
                 }
                 if (message.type === "peer_disconnected") {

package/dist/transport/v2.d.ts

@@ -9,7 +9,7 @@ export interface V2TransportHandlers {
 export interface V2TransportOptions {
     gatewayUrl: string;
     password: string;
-    sessionCode: string;
+    sessionSecret: string;
     role: "cli" | "app";
     handlers: V2TransportHandlers;
     debugLog?: (message: string, ...args: unknown[]) => void;

package/dist/transport/v2.js

@@ -127,6 +127,9 @@ export class V2SessionTransport {
                     this.resetPeerSession();
                     await this.maybeStartHandshake();
                 }
+                else if (raw.type === "peer_disconnected" || raw.type === "app_disconnected") {
+                    this.resetPeerSession();
+                }
                 return;
             }
             if (isV2HandshakeFrame(raw)) {
@@ -302,7 +305,7 @@ export class V2SessionTransport {
         }
     }
     computeHandshakeAuth(phase, senderRole, peerPubkeyB64, nonce, boxed) {
-        const authKey = sodium.crypto_generichash(sodium.crypto_auth_KEYBYTES, encodeUtf8(this.options.sessionCode), undefined);
+        const authKey = sodium.crypto_generichash(sodium.crypto_auth_KEYBYTES, encodeUtf8(this.options.sessionSecret), undefined);
         const parts = [
             phase,
             senderRole,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.93",
+  "version": "0.1.95",
   "author": [
     {
       "name": "Soham Bharambe",