@ai-ecoverse/slicc-kernel 1.59.0 → 1.59.1

package/dist/node.js

@@ -1323,6 +1323,11 @@ function blockedReason(url, e) {
   }
   return `${url}: ${e instanceof Error ? e.message : String(e)}`;
 }
+function unopened(url, code) {
+  return Object.assign(new Error(`${url}: the WebSocket closed (${code}) before it opened`), {
+    status: 502
+  });
+}
 function openWebSocket(Socket, request, withHeaders) {
   const { url, protocols, signal } = request;
   signal.throwIfAborted();
@@ -1336,13 +1341,22 @@ function openWebSocket(Socket, request, withHeaders) {
   const queue = new MessageQueue(() => socket.close(1e3, "too many waiting messages"));
   return new Promise((resolve, reject) => {
     let open = false;
+    let settled = false;
+    const fail3 = (error) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", abort);
+      reject(error);
+    };
     const abort = () => {
       socket.close(1e3, "aborted");
-      reject(signal.reason);
+      fail3(signal.reason);
     };
     signal.addEventListener("abort", abort, { once: true });
     socket.addEventListener("open", () => {
+      if (settled) return;
       open = true;
+      settled = true;
       signal.removeEventListener("abort", abort);
       resolve({
         protocol: socket.protocol,
@@ -1358,15 +1372,19 @@ function openWebSocket(Socket, request, withHeaders) {
     socket.addEventListener("message", (event) => {
       queue.push(typeof event.data === "string" ? event.data : new Uint8Array(event.data));
     });
+    socket.addEventListener("error", () => {
+      if (open || settled) return;
+      try {
+        socket.close();
+      } catch {
+      }
+      queue.end({ code: 1006, reason: "" });
+      fail3(unopened(url, 1006));
+    });
     socket.addEventListener("close", (event) => {
       queue.end({ code: event.code, reason: event.reason });
       if (open) return;
-      signal.removeEventListener("abort", abort);
-      reject(
-        Object.assign(new Error(`${url}: the WebSocket closed (${event.code}) before it opened`), {
-          status: 502
-        })
-      );
+      fail3(unopened(url, event.code));
     });
   });
 }
@@ -8399,7 +8417,7 @@ function enableNetwork(net, options) {
   let proxy;
   const transport = options.transport ?? missingTransport();
   net.activate({ family: "inet", host: "127.0.0.1", port: REALM_PROXY_PORT }, () => {
-    const tls = new TlsTerminator({
+    const tls2 = new TlsTerminator({
       ca: options.ca,
       engine: options.engine,
       ...options.now ? { now: options.now } : {}
@@ -8407,7 +8425,7 @@ function enableNetwork(net, options) {
     const started = new RealmProxy({
       net,
       transport,
-      tunnel: tls.handler,
+      tunnel: tls2.handler,
       tunnelReady: async () => {
         await options.engine();
       }
@@ -8415,7 +8433,7 @@ function enableNetwork(net, options) {
     proxy = started;
     void started.closed.then(async () => {
       if (proxy === started) proxy = void 0;
-      await tls.close();
+      await tls2.close();
     });
   });
   return () => proxy;
@@ -8434,6 +8452,11 @@ var TOKEN3 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
 function message(e) {
   return e instanceof Error ? e.message : String(e);
 }
+var ERRNO = /^E[A-Z]+$|^EAI_[A-Z]+$/;
+function errnoOf(e) {
+  const code = e?.code;
+  return typeof code === "string" && ERRNO.test(code) ? code : "ECONNREFUSED";
+}
 function fail(errno, text) {
   return { ok: false, errno, message: text };
 }
@@ -8477,13 +8500,13 @@ var WsHandles = class {
     let socket;
     try {
       socket = await transport.websocket({
-        url: req.url,
+        url: toHostLoopback(req.url),
         protocols: req.protocols,
         headers: req.headers,
         signal: entry.abort.signal
       });
     } catch (e) {
-      return fail("ECONNREFUSED", message(e));
+      return fail(errnoOf(e), message(e));
     }
     if (!this.open.has(handle)) {
       socket.close(1001, "the program went away");
@@ -8838,14 +8861,14 @@ var Resolver = class {
     if (hit && hit.expires > this.now()) return hit.addresses;
     const signal = blocking?.();
     if (signal?.aborted) throw new KernelError("EINTR");
-    let lookup = this.pending.get(id2);
-    if (!lookup) {
+    let lookup2 = this.pending.get(id2);
+    if (!lookup2) {
       const abort = new AbortController();
-      lookup = { work: this.lookup(key, asked, id2, abort.signal), abort, waiters: 0 };
-      this.pending.set(id2, lookup);
-      void lookup.work.then(() => this.pending.delete(id2));
+      lookup2 = { work: this.lookup(key, asked, id2, abort.signal), abort, waiters: 0 };
+      this.pending.set(id2, lookup2);
+      void lookup2.work.then(() => this.pending.delete(id2));
     }
-    return waitFor(lookup, signal);
+    return waitFor(lookup2, signal);
   }
   async lookup(name2, family, id2, abandoned) {
     const uplink = this.uplink;
@@ -8886,17 +8909,17 @@ var Resolver = class {
     }
   }
 };
-function waitFor(lookup, signal) {
-  lookup.waiters++;
+function waitFor(lookup2, signal) {
+  lookup2.waiters++;
   return new Promise((resolve, reject) => {
     const abort = () => {
-      if (--lookup.waiters === 0) lookup.abort.abort(new KernelError("EINTR"));
+      if (--lookup2.waiters === 0) lookup2.abort.abort(new KernelError("EINTR"));
       reject(new KernelError("EINTR"));
     };
     signal?.addEventListener("abort", abort, { once: true });
-    void lookup.work.then((value) => {
+    void lookup2.work.then((value) => {
       if (signal?.aborted) return;
-      lookup.waiters--;
+      lookup2.waiters--;
       signal?.removeEventListener("abort", abort);
       resolve(value);
     });
@@ -14490,6 +14513,62 @@ function isMemoryRoot(handle) {
   return handle instanceof MemoryDirectory;
 }
 
+// src/node/ws-diagnose.ts
+import { lookup } from "node:dns/promises";
+import { isIP, connect as tcp } from "node:net";
+import { connect as tls } from "node:tls";
+var PROBE_MS = 3e3;
+var PASSED = /* @__PURE__ */ new Set(["ECONNREFUSED", "EHOSTUNREACH", "ENETUNREACH", "ETIMEDOUT", "ECONNRESET"]);
+var NO_NAME = /* @__PURE__ */ new Set(["ENOTFOUND", "EAI_AGAIN", "EAI_NONAME", "EAI_FAIL", "ENODATA"]);
+function codeOf5(e) {
+  const code = e?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function probe(secure, host, port, ms) {
+  return new Promise((resolve) => {
+    const socket = secure ? tls({ host, port, ...isIP(host) ? {} : { servername: host } }) : tcp({ host, port });
+    const done4 = (code) => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(code);
+    };
+    const timer = setTimeout(() => done4("ETIMEDOUT"), ms);
+    socket.once(secure ? "secureConnect" : "connect", () => done4("EPROTO"));
+    socket.once("error", (e) => {
+      const code = codeOf5(e) ?? "";
+      done4(PASSED.has(code) ? code : "EPROTO");
+    });
+  });
+}
+async function diagnose(url, ms = PROBE_MS) {
+  const at = new URL(url);
+  const host = at.hostname.replace(/^\[(.*)\]$/, "$1");
+  const secure = at.protocol === "wss:";
+  const port = Number(at.port) || (secure ? 443 : 80);
+  try {
+    await lookup(host);
+  } catch (e) {
+    return NO_NAME.has(codeOf5(e) ?? "") ? "EAI_NONAME" : void 0;
+  }
+  return probe(secure, host, port, ms);
+}
+function diagnosing(transport, check = diagnose) {
+  const open = transport.websocket;
+  if (!open) return transport;
+  return {
+    ...transport,
+    websocket: async (request) => {
+      try {
+        return await open(request);
+      } catch (e) {
+        if (request.signal.aborted || !(e instanceof Error) || codeOf5(e)) throw e;
+        const code = await check(request.url).catch(() => void 0);
+        throw code ? Object.assign(e, { code }) : e;
+      }
+    }
+  };
+}
+
 // src/kernel/net/remote-transport.ts
 var TransportError = class extends Error {
   status;
@@ -15284,7 +15363,7 @@ function hostfsFetchOf(options) {
 }
 function nodeTransport() {
   const transport = fetchTransport({ webSocket: true, webSocketHeaders: true, redirect: "manual" });
-  return { ...transport, traits: { ...transport.traits, crossOrigin: "any" } };
+  return diagnosing({ ...transport, traits: { ...transport.traits, crossOrigin: "any" } });
 }
 var TERMINATED = "the kernel is terminated";
 var EXIT_GRACE_MS = 50;