siltrun 0.1.1 → 0.2.0

package/README.md

@@ -42,12 +42,25 @@ restart (250ms → 5s cap), clearly logged, so a transient failure never ends yo
 
 ```
 siltrun dev <contract.ts> [options]
-  --wt-port <n>     WebTransport port      (default 4433, env SILT_WT_PORT)
-  --info-port <n>   room-info port         (default 4000, env SILT_INFO_PORT)
-  --wt-host <host>  WebTransport bind host (default 127.0.0.1)
+  --wt-port <n>     WebTransport port          (default 4433, env SILT_WT_PORT)
+  --info-port <n>   room-info port             (default 4000, env SILT_INFO_PORT)
+  --wt-host <host>  advertised WebTransport host (default 127.0.0.1, env SILT_WT_HOST)
+  --wt-bind <addr>  WebTransport bind address  (default: --wt-host, env SILT_WT_BIND)
   --no-doctor       skip the determinism check on (re)load
 ```
 
+`--wt-host` is what the room *advertises*; `--wt-bind` is the address it *listens* on.
+They are the same by default. To reach the room from a second device, bind wide and let
+discovery answer for itself:
+
+```bash
+npx siltrun dev room.ts --wt-bind 0.0.0.0
+```
+
+room-info binds wherever WebTransport binds — a device that can reach the room can also
+discover it — and the advertised `wtEndpoint` follows the host each request arrived on, so
+a loopback fetch learns a loopback endpoint and a LAN or tailnet fetch learns that one.
+
 Path overrides (mainly for tests and for running against a local checkout):
 `SILT_ROOM_SERVER_DIR`, `SILT_ROOM_HOST_ENTRY`, `SILT_DOCTOR_ENTRY`.
 

package/package.json

@@ -1,8 +1,29 @@
 {
   "name": "siltrun",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "license": "MIT",
   "description": "The Silt CLI — run an authoritative multiplayer room locally with `siltrun dev`.",
+  "keywords": [
+    "multiplayer",
+    "webtransport",
+    "realtime",
+    "game-server",
+    "silt",
+    "cli",
+    "dev-server",
+    "netcode",
+    "gamedev",
+    "authoritative-server"
+  ],
+  "homepage": "https://silt.run",
+  "bugs": {
+    "url": "https://github.com/siltrun/silt/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/siltrun/silt.git",
+    "directory": "packages/cli"
+  },
   "type": "module",
   "bin": {
     "siltrun": "bin/silt.mjs"
@@ -16,14 +37,14 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@siltrun/room-host": "0.1.0",
+    "@siltrun/room-host": "0.2.0",
     "bun": "^1.3.0"
   },
   "optionalDependencies": {
-    "@siltrun/room-server-darwin-arm64": "0.1.0",
-    "@siltrun/room-server-darwin-x64": "0.1.0",
-    "@siltrun/room-server-linux-arm64": "0.1.0",
-    "@siltrun/room-server-linux-x64": "0.1.0"
+    "@siltrun/room-server-darwin-arm64": "0.2.0",
+    "@siltrun/room-server-darwin-x64": "0.2.0",
+    "@siltrun/room-server-linux-arm64": "0.2.0",
+    "@siltrun/room-server-linux-x64": "0.2.0"
   },
   "engines": {
     "node": ">=18"
@@ -31,6 +52,5 @@
   "devDependencies": {
     "@types/bun": "^1.2.0",
     "typescript": "^5.6.0"
-  },
-  "homepage": "https://silt.run"
+  }
 }

package/src/args.test.ts

@@ -91,3 +91,21 @@ describe("deriveRoomName", () => {
     expect(deriveRoomName("examples/„…“/⚡.ts")).toBe("room");
   });
 });
+
+describe("wt-bind", () => {
+  const noEnv = {};
+  test("defaults to wtHost", () => {
+    const o = parseDevArgs(["room.ts", "--wt-host", "100.64.0.5"], noEnv);
+    expect(o.wtBind).toBe("100.64.0.5");
+  });
+  test("splits bind from advertised host", () => {
+    const o = parseDevArgs(["room.ts", "--wt-host", "100.64.0.5", "--wt-bind", "0.0.0.0"], noEnv);
+    expect(o.wtBind).toBe("0.0.0.0");
+    expect(o.wtHost).toBe("100.64.0.5");
+  });
+  test("reads SILT_WT_BIND from env", () => {
+    const o = parseDevArgs(["room.ts"], { SILT_WT_BIND: "0.0.0.0" });
+    expect(o.wtBind).toBe("0.0.0.0");
+    expect(o.wtHost).toBe("127.0.0.1");
+  });
+});

package/src/args.ts

@@ -9,6 +9,9 @@ export interface DevOptions {
   wtPort: number;
   infoPort: number;
   wtHost: string;
+  /** WT bind address; defaults to wtHost. Split so a host can bind 0.0.0.0 (serve
+   *  loopback AND a LAN/tailnet interface) while advertising one reachable host. */
+  wtBind: string;
   doctor: boolean;
 }
 
@@ -105,6 +108,7 @@ export function parseDevArgs(argv: string[], env: Record<string, string | undefi
   }
 
   const wtHost = (flags.get("wt-host") as string) || env.SILT_WT_HOST || "127.0.0.1";
+  const wtBind = (flags.get("wt-bind") as string) || env.SILT_WT_BIND || wtHost;
   const wtPort = intOpt((flags.get("wt-port") as string) ?? env.SILT_WT_PORT, "--wt-port", 4433);
   const infoPort = intOpt(
     (flags.get("info-port") as string) ?? env.SILT_INFO_PORT,
@@ -113,5 +117,5 @@ export function parseDevArgs(argv: string[], env: Record<string, string | undefi
   );
   const doctor = flags.get("no-doctor") !== true;
 
-  return { contract, room, wtPort, infoPort, wtHost, doctor };
+  return { contract, room, wtPort, infoPort, wtHost, wtBind, doctor };
 }

package/src/cli.ts

@@ -26,7 +26,9 @@ ${paint.bold("dev options")}
                        generic like room.ts/index.ts; env SILT_ROOM)
   --wt-port <n>        WebTransport port (default: 4433, env SILT_WT_PORT)
   --info-port <n>      room-info port (default: 4000, env SILT_INFO_PORT)
-  --wt-host <host>     WebTransport bind host (default: 127.0.0.1)
+  --wt-host <host>     advertised WebTransport + room-info host (default: 127.0.0.1)
+  --wt-bind <addr>     WT bind address (default: --wt-host; use 0.0.0.0 to serve
+                       loopback and a LAN/tailnet interface at once)
   --no-doctor          skip the determinism check on (re)load
 
 ${paint.bold("deploy options")}

package/src/dev.ts

@@ -93,9 +93,16 @@ export async function dev(opts: DevOptions): Promise<void> {
   // room-info state — cert refreshes on each (re)boot. The room name (SEAM §4:
   // /room/<name>) comes from --room, or is derived from the contract path (args.ts);
   // the server serves exactly this path and loudly rejects anything else.
-  const wtEndpoint = `https://${opts.wtHost}:${opts.wtPort}/room/${opts.room}`;
+  // The advertised WT host follows the host the info request arrived on (a loopback
+  // fetch gets a loopback endpoint, a tailnet fetch the tailnet one — cert pinning
+  // makes the hostname interchangeable); --wt-host is the fallback for callers with
+  // no request in hand (boot banner).
   let certHash: string | null = null;
-  const getInfo = (): RoomInfo => ({ wtEndpoint, certHash, mode });
+  const getInfo = (requestHost?: string): RoomInfo => ({
+    wtEndpoint: `https://${requestHost ?? opts.wtHost}:${opts.wtPort}/room/${opts.room}`,
+    certHash,
+    mode,
+  });
 
   // 4. supervise the room-server.
   // The server treats a non-empty --contract as "enable compute mode"; empty = relay.
@@ -107,7 +114,7 @@ export async function dev(opts: DevOptions): Promise<void> {
     cwd: existsSync(paths.roomServerDir) ? paths.roomServerDir : undefined,
     // SILT_BUN: the server spawns the Bun room-host itself (compute.go) — hand it the
     // exact runtime running this CLI so it never depends on `bun` being on PATH.
-    env: { WT_BIND: `${opts.wtHost}:${opts.wtPort}`, SILT_BUN: bunBin() },
+    env: { WT_BIND: `${opts.wtBind}:${opts.wtPort}`, SILT_BUN: bunBin() },
     onCert: (h) => {
       certHash = h;
     },
@@ -134,7 +141,11 @@ export async function dev(opts: DevOptions): Promise<void> {
   // 5. room-info endpoint
   let roomInfo: RoomInfoServer;
   try {
-    roomInfo = startRoomInfoServer({ port: opts.infoPort, hostname: "127.0.0.1", getInfo });
+    // Bind room-info wherever WebTransport binds: a device that can reach the room
+    // must also be able to discover it (the /.well-known/silt fetch carries the cert
+    // hash), and with --wt-bind 0.0.0.0 that includes loopback AND the external
+    // interface. Default flags keep this loopback-only, exactly as before.
+    roomInfo = startRoomInfoServer({ port: opts.infoPort, hostname: opts.wtBind, getInfo });
   } catch (e) {
     log.error(`could not bind room-info on :${opts.infoPort}: ${String(e)}`);
     log.plain(

package/src/room-info.test.ts

@@ -78,3 +78,24 @@ describe("room-info endpoint (SEAM §4)", () => {
     expect(res.status).toBe(404);
   });
 });
+
+describe("request-host advertisement", () => {
+  test("getInfo receives the hostname the request arrived on", async () => {
+    let seen: string | undefined = "unset" as string | undefined;
+    const s = startRoomInfoServer({
+      port: 0,
+      getInfo: (requestHost) => {
+        seen = requestHost;
+        return { wtEndpoint: `https://${requestHost}:4433/room/x`, certHash: null, mode: "compute" };
+      },
+    });
+    try {
+      const res = await fetch(`http://127.0.0.1:${s.port}${WELL_KNOWN_PATH}`);
+      const body = (await res.json()) as { wtEndpoint: string };
+      expect(seen).toBe("127.0.0.1");
+      expect(body.wtEndpoint).toBe("https://127.0.0.1:4433/room/x");
+    } finally {
+      s.stop();
+    }
+  });
+});

package/src/room-info.ts

@@ -31,12 +31,15 @@ export interface RoomInfoServer {
 
 /**
  * Serve room-info on `port`. `getInfo` is called per request so the served cert hash
- * tracks the live room-server across restarts (the cert changes each boot).
+ * tracks the live room-server across restarts (the cert changes each boot). It receives
+ * the hostname the request arrived on, so a multi-homed dev server (--wt-bind 0.0.0.0)
+ * can advertise a WT endpoint the asking client can actually reach — a loopback fetch
+ * learns a loopback endpoint, a tailnet fetch learns the tailnet one.
  */
 export function startRoomInfoServer(opts: {
   port: number;
   hostname?: string;
-  getInfo: () => RoomInfo;
+  getInfo: (requestHost?: string) => RoomInfo;
 }): RoomInfoServer {
   const hostname = opts.hostname ?? "127.0.0.1";
   const server = Bun.serve({
@@ -53,7 +56,8 @@ export function startRoomInfoServer(opts: {
         if (req.method !== "GET") {
           return new Response("method not allowed", { status: 405, headers: CORS });
         }
-        return Response.json(opts.getInfo(), { headers: CORS });
+        const requestHost = new URL(req.url).hostname || undefined;
+        return Response.json(opts.getInfo(requestHost), { headers: CORS });
       }
 
       return new Response("not found", { status: 404, headers: CORS });