mixdog 0.9.170 → 0.9.172

package/src/runtime/channels/lib/webhook/listener-lifecycle.mjs

@@ -0,0 +1,119 @@
+import * as http from 'node:http';
+import { logWebhook } from './log.mjs';
+import { resolveHookRelayUrl, startHookTunnel } from './relay-tunnel.mjs';
+
+const WEBHOOK_BIND_HOST = '127.0.0.1';
+
+function createWebhookListener({ getConfig, setConfig, handleRequest }) {
+  let server = null;
+  let boundPort = 0;
+  let listenInFlight = false;
+  let hookTunnel = null;
+
+  function start() {
+    if (server || listenInFlight) return;
+    server = http.createServer(handleRequest);
+    listenWithRetry();
+  }
+
+  function listenWithRetry() {
+    if (!server || listenInFlight) return;
+    listenInFlight = true;
+    const config = getConfig();
+    const basePort = config.port || 3333;
+    const maxPort = basePort + 7;
+    let currentPort = basePort;
+    const tryListen = () => {
+      server.listen(currentPort, WEBHOOK_BIND_HOST, () => {
+        listenInFlight = false;
+        boundPort = currentPort;
+        logWebhook(`listening on ${WEBHOOK_BIND_HOST}:${currentPort}`);
+        startRelayTunnel();
+      });
+    };
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE' && currentPort < maxPort) {
+        // The relay tunnel forwards to whatever port this process binds, so
+        // port identity no longer matters (the ngrok-era domain↔port coupling
+        // is gone) — walk up the range.
+        logWebhook(`port ${currentPort} already in use, trying ${currentPort + 1}`);
+        currentPort++;
+        tryListen();
+      } else if (err.code === 'EADDRINUSE') {
+        logWebhook(`all ports ${basePort}-${maxPort} in use — webhook server disabled`);
+        listenInFlight = false;
+        server = null;
+      } else {
+        // Non-EADDRINUSE listen error: null the server so a later start()
+        // can retry instead of holding a dead server reference.
+        logWebhook(`listen error: ${err?.code || ''} ${err?.message || err}`);
+        listenInFlight = false;
+        server = null;
+      }
+    });
+    tryListen();
+  }
+
+  function startRelayTunnel() {
+    if (hookTunnel) return;
+    const relayUrl = resolveHookRelayUrl();
+    if (!relayUrl) {
+      logWebhook('hook tunnel disabled (MIXDOG_RELAY_URL=off)');
+      return;
+    }
+    try {
+      hookTunnel = startHookTunnel({ relayUrl, getLocalPort: () => boundPort });
+      logWebhook(`public hook base: ${hookTunnel.publicBase}`);
+    } catch (err) {
+      logWebhook(`hook tunnel start failed: ${err?.message || err}`);
+    }
+  }
+
+  function stop() {
+    if (hookTunnel) {
+      try {
+        hookTunnel.close();
+      } catch {
+        /* already closed */
+      }
+      hookTunnel = null;
+    }
+    let closed = Promise.resolve();
+    if (server) {
+      const srv = server;
+      server = null;
+      listenInFlight = false;
+      closed = new Promise((resolve) => {
+        try {
+          srv.close(() => resolve());
+        } catch {
+          resolve();
+        }
+      });
+    }
+    logWebhook('stopped');
+    return closed;
+  }
+
+  async function reloadConfig(config, options = {}) {
+    // Await server.close() before re-listen: server.close() is async and
+    // releases the bound port only after the close callback fires. Calling
+    // start() before that drains races the port and surfaces EADDRINUSE
+    // through listenWithRetry's port-bump path even when no other process
+    // holds the port.
+    await stop();
+    setConfig(config);
+    if (options.autoStart !== false && config.enabled) start();
+  }
+
+  function getUrl(name) {
+    if (hookTunnel) {
+      return `${hookTunnel.publicBase}/webhook/${name}`;
+    }
+    return `http://localhost:${boundPort || getConfig().port}/webhook/${name}`;
+  }
+
+  return { start, stop, reloadConfig, getUrl };
+}
+
+export { WEBHOOK_BIND_HOST, createWebhookListener };

package/src/runtime/channels/lib/webhook/log.mjs

@@ -1,6 +1,6 @@
-import { join } from 'path';
-import { appendFileSync } from 'fs';
-import { appendFile } from 'fs/promises';
+import { join } from 'node:path';
+import { appendFileSync } from 'node:fs';
+import { appendFile } from 'node:fs/promises';
 import { DATA_DIR } from '../config.mjs';
 
 const WEBHOOK_LOG = join(DATA_DIR, 'webhook.log');

package/src/runtime/channels/lib/webhook/relay-tunnel/leg-heartbeat.mjs

@@ -0,0 +1,35 @@
+// NAT paths silently drop idle sockets; protocol pings keep the leg warm and
+// detect a half-dead link so the reconnect loop restores it.
+import WebSocket from 'ws';
+import { HEARTBEAT_MS } from './limits.mjs';
+
+export function armLegHeartbeat(ws) {
+  let alive = true;
+  ws.on('pong', () => {
+    alive = true;
+  });
+  const timer = setInterval(() => {
+    if (ws.readyState !== WebSocket.OPEN) return;
+    if (!alive) {
+      try {
+        ws.terminate();
+      } catch {
+        /* close reconnects */
+      }
+      return;
+    }
+    alive = false;
+    try {
+      ws.ping();
+    } catch {
+      /* close reconnects */
+    }
+  }, HEARTBEAT_MS);
+  timer.unref?.();
+  return {
+    markAlive: () => {
+      alive = true;
+    },
+    stop: () => clearInterval(timer),
+  };
+}

package/src/runtime/channels/lib/webhook/relay-tunnel/limits.mjs

@@ -0,0 +1,6 @@
+// Size and timing limits of the webhook relay leg.
+export const MAX_TUNNEL_BODY_BYTES = 1024 * 1024;
+export const MAX_HOOK_FRAME_BYTES = 2 * 1024 * 1024;
+export const MAX_HOOK_HEADER_BYTES = 32 * 1024;
+export const HEARTBEAT_MS = 25_000;
+export const LOCAL_TIMEOUT_MS = 25_000;

package/src/runtime/channels/lib/webhook/relay-tunnel/local-forward.mjs

@@ -0,0 +1,93 @@
+// Replaying one relayed request against the LOCAL webhook HTTP server and
+// answering the relay with the response (or the failure) over the leg.
+import * as http from 'node:http';
+import WebSocket from 'ws';
+import { LOCAL_TIMEOUT_MS, MAX_TUNNEL_BODY_BYTES } from './limits.mjs';
+
+export function respondOverLeg(ws, id, status, headers, bodyBuffer) {
+  if (ws.readyState !== WebSocket.OPEN) return;
+  try {
+    ws.send(
+      JSON.stringify({
+        type: 'http-response',
+        id,
+        status,
+        headers: headers || {},
+        body: bodyBuffer?.length ? bodyBuffer.toString('base64') : '',
+      })
+    );
+  } catch {
+    /* relay vanished; it times the request out */
+  }
+}
+
+export function respondJsonError(ws, id, status, error) {
+  respondOverLeg(
+    ws,
+    id,
+    status,
+    { 'content-type': 'application/json' },
+    Buffer.from(JSON.stringify({ error: String(error?.message || error) }))
+  );
+}
+
+function collectLocalResponse(ws, frame, response) {
+  const chunks = [];
+  let total = 0;
+  let overflow = false;
+  response.on('data', (chunk) => {
+    total += chunk.length;
+    if (total > MAX_TUNNEL_BODY_BYTES) {
+      overflow = true;
+      response.destroy(new Error('local webhook response exceeds limit'));
+      return;
+    }
+    chunks.push(chunk);
+  });
+  response.on('end', () => {
+    if (overflow) return;
+    respondOverLeg(
+      ws,
+      frame.id,
+      response.statusCode || 502,
+      { 'content-type': response.headers['content-type'] || 'application/json' },
+      Buffer.concat(chunks)
+    );
+  });
+  response.on('error', () => respondOverLeg(ws, frame.id, 502, {}, null));
+}
+
+export function forwardFrameToLocal(frame, ws, getLocalPort) {
+  const port = getLocalPort();
+  if (!port) {
+    respondOverLeg(
+      ws,
+      frame.id,
+      503,
+      { 'content-type': 'application/json' },
+      Buffer.from('{"error":"webhook server not listening"}')
+    );
+    return;
+  }
+  let request;
+  try {
+    request = http.request(
+      {
+        host: '127.0.0.1',
+        port,
+        method: frame.method,
+        path: frame.path,
+        headers: frame.headers,
+        timeout: LOCAL_TIMEOUT_MS,
+      },
+      (response) => collectLocalResponse(ws, frame, response)
+    );
+  } catch (err) {
+    respondJsonError(ws, frame.id, 400, err);
+    return;
+  }
+  request.on('timeout', () => request.destroy(new Error('local webhook timeout')));
+  request.on('error', (err) => respondJsonError(ws, frame.id, 502, err));
+  if (frame.body?.length) request.write(frame.body);
+  request.end();
+}

package/src/runtime/channels/lib/webhook/relay-tunnel.mjs

@@ -7,19 +7,20 @@
 // webhook HTTP server; the response returns verbatim. Endpoint HMAC
 // verification stays local — the relay never inspects payloads. Works out
 // of the box: no binary, no authtoken, no reserved domain.
-import * as http from 'http';
-import { randomBytes, randomUUID } from 'crypto';
-import { readFileSync, writeFileSync, mkdirSync, chmodSync } from 'fs';
-import { join } from 'path';
+import { randomBytes, randomUUID } from 'node:crypto';
+import { readFileSync, writeFileSync, mkdirSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
 import WebSocket from 'ws';
 import { DATA_DIR } from '../config.mjs';
 import { logWebhook } from './log.mjs';
+import { MAX_HOOK_FRAME_BYTES, MAX_HOOK_HEADER_BYTES, MAX_TUNNEL_BODY_BYTES } from './relay-tunnel/limits.mjs';
+import { forwardFrameToLocal, respondJsonError } from './relay-tunnel/local-forward.mjs';
+import { armLegHeartbeat } from './relay-tunnel/leg-heartbeat.mjs';
+
+export { MAX_TUNNEL_BODY_BYTES } from './relay-tunnel/limits.mjs';
 
 /** Packaged default mirrors the desktop pairing relay. */
 const DEFAULT_RELAY_URL = 'wss://192-255-139-161.sslip.io';
-export const MAX_TUNNEL_BODY_BYTES = 1024 * 1024;
-const MAX_HOOK_FRAME_BYTES = 2 * 1024 * 1024;
-const MAX_HOOK_HEADER_BYTES = 32 * 1024;
 const HOP_HEADERS = new Set([
   'host',
   'connection',
@@ -29,8 +30,6 @@ const HOP_HEADERS = new Set([
   'upgrade',
   'te',
 ]);
-const HEARTBEAT_MS = 25_000;
-const LOCAL_TIMEOUT_MS = 25_000;
 
 export function resolveHookRelayUrl(env = process.env) {
   const raw = String(env.MIXDOG_RELAY_URL || '').trim();
@@ -189,113 +188,40 @@ export function readHookPublicBase(env = process.env) {
   return null;
 }
 
+// One relayed frame: parse, validate, replay against the local server. An
+// invalid frame that still carries an id is answered 400 so the relay does
+// not wait for a timeout.
+function handleLegMessage(ws, raw, getLocalPort) {
+  let rawFrame;
+  try {
+    rawFrame = JSON.parse(String(raw));
+  } catch {
+    return;
+  }
+  let frame;
+  try {
+    frame = normalizeHookRequestFrame(rawFrame);
+  } catch (err) {
+    if (typeof rawFrame?.id === 'string') respondJsonError(ws, rawFrame.id, 400, err);
+    return;
+  }
+  forwardFrameToLocal(frame, ws, getLocalPort);
+}
+
 export function startHookTunnel({ relayUrl, getLocalPort }) {
   const { deviceId, deviceSecret } = loadOrCreateHookIdentity();
-  let socket = null;
-  let closed = false;
-  let retryMs = 1_000;
-  let reconnectTimer = null;
-  let announced = false;
+  // The reconnect loop's state: the live leg, exponential retry, one "up" announcement.
+  const leg = { socket: null, closed: false, retryMs: 1_000, reconnectTimer: null, announced: false };
 
   const scheduleReconnect = () => {
-    if (closed) return;
-    reconnectTimer = setTimeout(connect, retryMs);
-    reconnectTimer.unref?.();
-    retryMs = Math.min(30_000, retryMs * 2);
-  };
-
-  const respond = (ws, id, status, headers, bodyBuffer) => {
-    if (ws.readyState !== WebSocket.OPEN) return;
-    try {
-      ws.send(
-        JSON.stringify({
-          type: 'http-response',
-          id,
-          status,
-          headers: headers || {},
-          body: bodyBuffer && bodyBuffer.length ? bodyBuffer.toString('base64') : '',
-        })
-      );
-    } catch {
-      /* relay vanished; it times the request out */
-    }
-  };
-
-  const forwardToLocal = (frame, ws) => {
-    const port = getLocalPort();
-    if (!port) {
-      respond(
-        ws,
-        frame.id,
-        503,
-        { 'content-type': 'application/json' },
-        Buffer.from('{"error":"webhook server not listening"}')
-      );
-      return;
-    }
-    let request;
-    try {
-      request = http.request(
-        {
-          host: '127.0.0.1',
-          port,
-          method: frame.method,
-          path: frame.path,
-          headers: frame.headers,
-          timeout: LOCAL_TIMEOUT_MS,
-        },
-        (response) => {
-          const chunks = [];
-          let total = 0;
-          let overflow = false;
-          response.on('data', (chunk) => {
-            total += chunk.length;
-            if (total > MAX_TUNNEL_BODY_BYTES) {
-              overflow = true;
-              response.destroy(new Error('local webhook response exceeds limit'));
-              return;
-            }
-            chunks.push(chunk);
-          });
-          response.on('end', () => {
-            if (overflow) return;
-            respond(
-              ws,
-              frame.id,
-              response.statusCode || 502,
-              { 'content-type': response.headers['content-type'] || 'application/json' },
-              Buffer.concat(chunks)
-            );
-          });
-          response.on('error', () => respond(ws, frame.id, 502, {}, null));
-        }
-      );
-    } catch (err) {
-      respond(
-        ws,
-        frame.id,
-        400,
-        { 'content-type': 'application/json' },
-        Buffer.from(JSON.stringify({ error: String(err?.message || err) }))
-      );
-      return;
-    }
-    request.on('timeout', () => request.destroy(new Error('local webhook timeout')));
-    request.on('error', (err) =>
-      respond(
-        ws,
-        frame.id,
-        502,
-        { 'content-type': 'application/json' },
-        Buffer.from(JSON.stringify({ error: String(err?.message || err) }))
-      )
-    );
-    if (body && body.length) request.write(body);
-    request.end();
+    if (leg.closed) return;
+    leg.reconnectTimer = setTimeout(connect, leg.retryMs);
+    leg.reconnectTimer.unref?.();
+    leg.retryMs = Math.min(30_000, leg.retryMs * 2);
   };
 
   const connect = () => {
-    if (closed) return;
+    if (leg.closed) return;
     const connection = hookLegSocketOptions(relayUrl, { deviceId, deviceSecret });
     let ws;
     try {
@@ -308,69 +234,25 @@ export function startHookTunnel({ relayUrl, getLocalPort }) {
       scheduleReconnect();
       return;
     }
-    socket = ws;
-    // NAT paths silently drop idle sockets; protocol pings keep the leg warm
-    // and detect a half-dead link so the reconnect loop restores it.
-    let alive = true;
-    ws.on('pong', () => {
-      alive = true;
-    });
-    const heartbeat = setInterval(() => {
-      if (ws.readyState !== WebSocket.OPEN) return;
-      if (!alive) {
-        try {
-          ws.terminate();
-        } catch {
-          /* close reconnects */
-        }
-        return;
-      }
-      alive = false;
-      try {
-        ws.ping();
-      } catch {
-        /* close reconnects */
-      }
-    }, HEARTBEAT_MS);
-    heartbeat.unref?.();
+    leg.socket = ws;
+    const heartbeat = armLegHeartbeat(ws);
     ws.on('open', () => {
-      retryMs = 1_000;
-      if (!announced) {
-        announced = true;
+      leg.retryMs = 1_000;
+      if (!leg.announced) {
+        leg.announced = true;
         logWebhook(`hook tunnel up: ${hookPublicBase(relayUrl, deviceId)}`);
       }
     });
     ws.on('message', (raw) => {
-      alive = true;
-      let rawFrame;
-      try {
-        rawFrame = JSON.parse(String(raw));
-      } catch {
-        return;
-      }
-      let frame;
-      try {
-        frame = normalizeHookRequestFrame(rawFrame);
-      } catch (err) {
-        if (typeof rawFrame?.id === 'string') {
-          respond(
-            ws,
-            rawFrame.id,
-            400,
-            { 'content-type': 'application/json' },
-            Buffer.from(JSON.stringify({ error: String(err?.message || err) }))
-          );
-        }
-        return;
-      }
-      forwardToLocal(frame, ws);
+      heartbeat.markAlive();
+      handleLegMessage(ws, raw, getLocalPort);
     });
     ws.on('error', () => {
       /* surfaced as close */
     });
     ws.on('close', () => {
-      clearInterval(heartbeat);
-      if (socket === ws) socket = null;
+      heartbeat.stop();
+      if (leg.socket === ws) leg.socket = null;
       scheduleReconnect();
     });
   };
@@ -380,16 +262,16 @@ export function startHookTunnel({ relayUrl, getLocalPort }) {
     deviceId,
     publicBase: hookPublicBase(relayUrl, deviceId),
     close() {
-      if (closed) return;
-      closed = true;
-      if (reconnectTimer) clearTimeout(reconnectTimer);
-      if (socket) {
+      if (leg.closed) return;
+      leg.closed = true;
+      if (leg.reconnectTimer) clearTimeout(leg.reconnectTimer);
+      if (leg.socket) {
         try {
-          socket.terminate();
+          leg.socket.terminate();
         } catch {
           /* already gone */
         }
-        socket = null;
+        leg.socket = null;
       }
     },
   };