ai-or-die 0.1.88 → 0.1.89

package/bin/ai-or-die.js

@@ -216,6 +216,7 @@ async function main() {
       const mesh = new MeshManager({
         port,
         dev: options.dev,
+        authToken,
         onUrl: (meshUrl) => {
           const t = authToken ? `${meshUrl}?token=${authToken}` : meshUrl;
           console.log(`\n  \x1b[1m\x1b[32mMesh ready:\x1b[0m \x1b[1m\x1b[4m${t}\x1b[0m\n`);

package/mesh/main.go

@@ -17,6 +17,7 @@
 //   MESH-URL https://<name>      node is up, serving real TLS at the edge
 //   MESH-URL http://<name>       node is up, but TLS certs unavailable (degraded)
 //   MESH-NOCERT                  hint: enable HTTPS Certificates in the tailnet
+//   MESH-PEERS {"self":...,"peers":[...]} tagged fleet peers snapshot
 //   MESH-NEEDLOGIN <url>         no/!valid key — operator must enroll
 //   MESH-ERR <msg>               fatal
 package main
@@ -24,6 +25,7 @@ package main
 import (
 	"context"
 	"crypto/tls"
+	"encoding/json"
 	"flag"
 	"fmt"
 	"net"
@@ -31,16 +33,23 @@ import (
 	"net/http/httputil"
 	"net/url"
 	"os"
+	"sort"
 	"strings"
 	"time"
 
+	"tailscale.com/ipn/ipnstate"
 	"tailscale.com/tsnet"
 )
 
 // version is stamped at build time via -ldflags "-X main.version=<contentHash>".
 var version = "dev"
 
-const certWaitTimeout = 20 * time.Second
+const (
+	certWaitTimeout   = 20 * time.Second
+	meshPeersInterval = 20 * time.Second
+	meshPeersMaxPeers = 512
+	meshPeerTag       = "tag:aiordie"
+)
 
 func main() {
 	port := flag.String("port", "7777", "local ai-or-die port to expose (loopback)")
@@ -55,6 +64,8 @@ func main() {
 		return
 	}
 
+	proxyBearer := os.Getenv("AIORDIE_PROXY_BEARER")
+
 	// Resolve + validate the backend target. It MUST be loopback: the sidecar is
 	// a tailnet-facing reverse proxy, and pointing it off-host would expose an
 	// arbitrary origin to the whole tailnet.
@@ -80,6 +91,10 @@ func main() {
 		os.Exit(1)
 	}
 
+	if lc, err := s.LocalClient(); err == nil {
+		go emitMeshPeersLoop(context.Background(), lc)
+	}
+
 	name := *host
 	if st != nil && st.Self != nil && st.Self.DNSName != "" {
 		name = strings.TrimSuffix(st.Self.DNSName, ".")
@@ -91,7 +106,7 @@ func main() {
 	// so wss works regardless; this header is hygiene for any absolute-URL or
 	// redirect the app generates (no mixed content).
 	edgeProto := "http"
-	rp := newEdgeProxy(target, name, &edgeProto)
+	rp := newEdgeProxy(target, name, &edgeProto, proxyBearer)
 
 	// Decide the scheme BEFORE advertising. tsnet's ListenTLS returns a listener
 	// without provisioning the cert; the ACME work (and any failure) happens
@@ -163,6 +178,94 @@ func isLoopbackHost(h string) bool {
 	return ip != nil && ip.IsLoopback()
 }
 
+type statusClient interface {
+	Status(context.Context) (*ipnstate.Status, error)
+}
+
+type meshPeersSnapshot struct {
+	Self  meshPeerSelf `json:"self"`
+	Peers []meshPeer   `json:"peers"`
+}
+
+type meshPeerSelf struct {
+	Hostname string `json:"hostname"`
+	DNSName  string `json:"dnsName"`
+}
+
+type meshPeer struct {
+	Hostname string `json:"hostname"`
+	DNSName  string `json:"dnsName"`
+	Online   bool   `json:"online"`
+}
+
+func emitMeshPeersLoop(ctx context.Context, lc statusClient) {
+	emitMeshPeers(ctx, lc)
+	ticker := time.NewTicker(meshPeersInterval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			emitMeshPeers(ctx, lc)
+		}
+	}
+}
+
+func emitMeshPeers(ctx context.Context, lc statusClient) {
+	status, err := lc.Status(ctx)
+	if err != nil || status == nil {
+		return
+	}
+	line := meshPeersFromStatus(status)
+	b, err := json.Marshal(line)
+	if err != nil {
+		return
+	}
+	fmt.Printf("MESH-PEERS %s\n", b)
+}
+
+func meshPeersFromStatus(status *ipnstate.Status) meshPeersSnapshot {
+	var self meshPeerSelf
+	if status.Self != nil {
+		self = meshPeerSelf{Hostname: status.Self.HostName, DNSName: normalizeDNSName(status.Self.DNSName)}
+	}
+
+	peers := make([]meshPeer, 0)
+	for _, ps := range status.Peer {
+		if ps == nil || !peerHasTag(ps, meshPeerTag) {
+			continue
+		}
+		peers = append(peers, meshPeer{Hostname: ps.HostName, DNSName: normalizeDNSName(ps.DNSName), Online: ps.Online})
+	}
+	sort.Slice(peers, func(i, j int) bool {
+		if peers[i].DNSName != peers[j].DNSName {
+			return peers[i].DNSName < peers[j].DNSName
+		}
+		return peers[i].Hostname < peers[j].Hostname
+	})
+	if len(peers) > meshPeersMaxPeers {
+		peers = peers[:meshPeersMaxPeers]
+	}
+	return meshPeersSnapshot{Self: self, Peers: peers}
+}
+
+func peerHasTag(ps *ipnstate.PeerStatus, tag string) bool {
+	if ps.Tags == nil {
+		return false
+	}
+	for i := 0; i < ps.Tags.Len(); i++ {
+		if ps.Tags.At(i) == tag {
+			return true
+		}
+	}
+	return false
+}
+
+func normalizeDNSName(s string) string {
+	return strings.ToLower(strings.TrimSuffix(s, "."))
+}
+
 // tryListenTLS returns a TLS listener on :443 only when a cert for `name` looks
 // obtainable; otherwise nil. It first checks the tailnet's advertised cert
 // domains, then proactively warms the cert with a bounded timeout so a failure
@@ -214,13 +317,22 @@ func redirectToHTTPS(name string) http.HandlerFunc {
 // X-Forwarded-Host so the app never emits mixed-content links. For an https
 // loopback backend (a future self-signed local listener) it skips verification —
 // the host is already validated as loopback, so this is not a trust boundary.
-func newEdgeProxy(target *url.URL, name string, proto *string) *httputil.ReverseProxy {
+func newEdgeProxy(target *url.URL, name string, proto *string, proxyBearer string) *httputil.ReverseProxy {
 	rp := httputil.NewSingleHostReverseProxy(target)
 	orig := rp.Director
 	rp.Director = func(r *http.Request) {
 		orig(r)
 		r.Header.Set("X-Forwarded-Proto", *proto)
 		r.Header.Set("X-Forwarded-Host", name)
+		// Authenticate tailnet->loopback traffic to the app's bearer middleware.
+		// Set REPLACES any client-supplied Authorization (no spoofing). When no
+		// token is configured, DELETE a client-supplied Authorization so a tailnet
+		// caller can never smuggle one through to the loopback app.
+		if proxyBearer != "" {
+			r.Header.Set("Authorization", "Bearer "+proxyBearer)
+		} else {
+			r.Header.Del("Authorization")
+		}
 	}
 	if target.Scheme == "https" {
 		rp.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}

package/mesh/main_test.go

@@ -67,20 +67,21 @@ func TestIsLoopbackHost(t *testing.T) {
 }
 
 // End-to-end through the actual reverse proxy (no tailnet): a real loopback
-// backend must receive the X-Forwarded-Proto/Host the edge stamps, and the
-// pointer-captured proto must reflect the post-TLS decision.
-func TestEdgeProxyForwardsProtoAndHost(t *testing.T) {
-	var gotProto, gotHost, gotBody string
+// backend must receive the X-Forwarded-Proto/Host the edge stamps, the app
+// bearer, and the pointer-captured proto must reflect the post-TLS decision.
+func TestEdgeProxyForwardsProtoHostAndAuth(t *testing.T) {
+	var gotProto, gotHost, gotAuth, gotBody string
 	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		gotProto = r.Header.Get("X-Forwarded-Proto")
 		gotHost = r.Header.Get("X-Forwarded-Host")
+		gotAuth = r.Header.Get("Authorization")
 		io.WriteString(w, "backend-ok")
 	}))
 	defer backend.Close()
 
 	target, _ := url.Parse(backend.URL) // 127.0.0.1 loopback
 	proto := "http"                      // default before the TLS decision
-	rp := newEdgeProxy(target, "node.tailnet.ts.net", &proto)
+	rp := newEdgeProxy(target, "node.tailnet.ts.net", &proto, "app-token")
 	proto = "https" // edge decided real TLS AFTER constructing the proxy
 
 	front := httptest.NewServer(rp)
@@ -100,6 +101,9 @@ func TestEdgeProxyForwardsProtoAndHost(t *testing.T) {
 	if gotHost != "node.tailnet.ts.net" {
 		t.Errorf("backend saw X-Forwarded-Host=%q, want node.tailnet.ts.net", gotHost)
 	}
+	if gotAuth != "Bearer app-token" {
+		t.Errorf("backend saw Authorization=%q, want Bearer app-token", gotAuth)
+	}
 	if gotBody != "backend-ok" {
 		t.Errorf("proxy body=%q, want backend-ok", gotBody)
 	}

package/mesh-sidecar.lock.json

@@ -1,12 +1,12 @@
 {
   "version": "1.0.0",
-  "contentHash": "fb010e2cd6a930ef7eeac0de0adaf903cdb7252815650c38eac2d72f15da6e3d",
+  "contentHash": "dbf60b5215ebb0b0947edf8fa47906280dd1fea12ef7e1181918fecfe7d9bcc0",
   "assets": {
-    "aiordie-mesh-windows-amd64.exe": "7a30a635b726e5cae694e3f48b37b329d470e8cf493ac5f025b99ea4a0fbded0",
-    "aiordie-mesh-windows-arm64.exe": "6d056c561538a40991a975e410b61b7ba4e076c456ee280744ae9ade65202dda",
-    "aiordie-mesh-linux-amd64": "2e5fd52842b67ec56647efb59ce8944bb211055b7630a19206a67b2c80b328fd",
-    "aiordie-mesh-linux-arm64": "7508a98a2762feb3405df54150a34c53028b5588b44eac504835c56a5df82822",
-    "aiordie-mesh-darwin-amd64": "d095c85d01036f3a9a529179c9ef5ca67231150bd49fc5adf1c4fb4e0d0da11b",
-    "aiordie-mesh-darwin-arm64": "8d115b8233697995dc0d7bab8f45f881bba2d37896c86cd70ea626965b1e4cb0"
+    "aiordie-mesh-windows-amd64.exe": "3be314f27ddf69560cb34b40b70302609f28fe6feba7600580e68ce04a811a71",
+    "aiordie-mesh-windows-arm64.exe": "3169f41dc835522c42dc4766dcd9a608a65430fb3797120bcd1ae9e58014942c",
+    "aiordie-mesh-linux-amd64": "7fb0d9c624c85759fb20e789886d1f4e0e2b5621f8ee6105634c7e73fd44d049",
+    "aiordie-mesh-linux-arm64": "7d23eb2d8c4c9632f37ad8f11f8c8523ce7d6ce58d0607b4c73fb9ccbc261239",
+    "aiordie-mesh-darwin-amd64": "69336be9137a98d8a3409ea87702502fa82d573875041111ea46f65b2fd22442",
+    "aiordie-mesh-darwin-arm64": "f73bcb5a6107ac3c0da8a39f06af6620e2db6e66b4e3c135740d9081703fd938"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-or-die",
-  "version": "0.1.88",
+  "version": "0.1.89",
   "description": "Universal AI coding terminal — Claude, Copilot, Gemini & more in your browser",
   "main": "src/server.js",
   "bin": {

package/src/control/routes.js

@@ -187,6 +187,10 @@ function createControlRouter(deps) {
     }
   });
 
+  router.get('/mesh/peers', (req, res) => {
+    res.json({ peers: deps.getMeshPeers ? deps.getMeshPeers() : [] });
+  });
+
   // GET /snapshot — F15 atomic batch resync. Returns every session's derived
   // status PLUS the event cursor, captured atomically (cursor first, then
   // statuses), so after a gap/overflow the controller resyncs in ONE call and

package/src/mesh-manager.js

@@ -17,28 +17,32 @@ const STABILITY_THRESHOLD_MS = 60000;  // 60s up = reset retry budget
 const MIN_RESTART_DELAY_MS = 1000;
 const MAX_RESTART_DELAY_MS = 30000;
 const MAX_RETRIES = 10;
+const MESH_PEERS_JSON_MAX = 256 * 1024;
 
 class MeshManager {
   constructor(options = {}) {
     this.port = options.port || 7777;          // the ai-or-die port to expose
     this.dev = options.dev || false;
     this.onUrl = options.onUrl || (() => {});
-    // Consume the key once and scrub it everywhere it could leak.
+    this._proxyBearer = options.authToken || null;
+    // Consume the key once and scrub secrets everywhere they could leak.
     this._authKey = options.authKey || process.env.AIORDIE_TS_AUTHKEY || null;
     delete process.env.AIORDIE_TS_AUTHKEY;
+    delete process.env.AIORDIE_PROXY_BEARER;
     this._childEnv = { ...process.env };
     delete this._childEnv.AIORDIE_TS_AUTHKEY;
+    delete this._childEnv.AIORDIE_PROXY_BEARER;
 
     const localApp = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
-    const base = process.platform === 'win32'
+    this._appBase = process.platform === 'win32'
       ? path.join(localApp, 'ai-or-die')
       : path.join(os.homedir(), '.ai-or-die');
-    this.stateDir = options.stateDir || path.join(base, 'ts-state');
+    this.stateDir = options.stateDir || path.join(this._appBase, 'ts-state');
     // The sidecar binary is content-addressed: its path embeds the lock's
     // contentHash so a new build installs alongside the old one (no overwrite of
     // a running .exe). Derived from the installer's lock + path helpers.
     this._installer = options._installer || require('./utils/sidecar-installer');
-    this.sidecar = options.sidecar || this._sidecarPathFromLock(base);
+    this.sidecar = options.sidecar || this._sidecarPathFromLock(this._appBase);
     this.hostname = (options.hostname || `aiordie-${os.hostname()}`).toLowerCase().replace(/[^a-z0-9-]/g, '');
 
     this.proc = null;
@@ -53,6 +57,8 @@ class MeshManager {
     this._restartDelayTimer = null;
     this._restartDelayResolve = null;
     this._stabilityThresholdMs = options._stabilityThresholdMs || STABILITY_THRESHOLD_MS;
+    this._stdoutBuffer = '';
+    this.peers = null;
   }
 
   /** Never throws — degrades to localhost/devtunnel on any failure. */
@@ -93,11 +99,20 @@ class MeshManager {
   }
 
   getStatus() {
-    return { running: this.proc !== null && !this.stopping && !!this.dnsName, publicUrl: this.dnsName ? `${this.scheme || 'https'}://${this.dnsName}` : null };
+    return {
+      running: this.proc !== null && !this.stopping && !!this.dnsName,
+      publicUrl: this.dnsName ? `${this.scheme || 'https'}://${this.dnsName}` : null,
+      peers: this.peers ? this.peers.peers : [],
+    };
+  }
+
+  peersFilePath() {
+    return path.join(this._appBase, 'mesh', 'peers.json');
   }
 
   async stop() {
     this.stopping = true;
+    this._deletePeersFile();
     this._clearStabilityTimer();
     clearTimeout(this._restartDelayTimer);
     if (this._restartDelayResolve) { this._restartDelayResolve(); this._restartDelayResolve = null; }
@@ -117,36 +132,123 @@ class MeshManager {
   _spawn() {
     return new Promise((resolve) => {
       const args = ['--port', String(this.port), '--backend', this.backend, '--hostname', this.hostname, '--statedir', this.stateDir];
-      // Pass the key to the sidecar via TS_AUTHKEY (enroll only); it's already
-      // stripped from this process + base child env, so it reaches only this child.
-      const env = this._authKey ? { ...this._childEnv, TS_AUTHKEY: this._authKey } : this._childEnv;
+      // Pass secrets only to the sidecar child; both are stripped from this
+      // process + base child env before spawning.
+      const env = { ...this._childEnv };
+      if (this._authKey) env.TS_AUTHKEY = this._authKey;
+      if (this._proxyBearer) env.AIORDIE_PROXY_BEARER = this._proxyBearer;
+      this._stdoutBuffer = '';
       this.proc = spawn(this.sidecar, args, { stdio: ['ignore', 'pipe', 'pipe'], env });
       let done = false;
       const timer = setTimeout(() => { if (!done) { done = true; console.warn('  \x1b[33mMesh: no URL within 60s — check key/connectivity.\x1b[0m'); resolve(); } }, URL_TIMEOUT_MS);
       this.proc.stdout.on('data', (d) => {
-        const out = d.toString();
-        if (this.dev) process.stdout.write(`  [mesh] ${out}`);
-        if (/MESH-NOCERT/.test(out)) this._printNoCert();
-        const url = out.match(/MESH-URL (https?):\/\/(\S+)/);
-        if (url && !this.dnsName) {
-          this.scheme = url[1];
-          this.dnsName = url[2];
-          this._authKey = null;
-          this._startStabilityTimer();
-          this.onUrl(`${this.scheme}://${this.dnsName}`);
-          if (!done) { done = true; clearTimeout(timer); resolve(); }
-        }
-        if (/MESH-NEEDLOGIN/.test(out)) { this._printNotEnrolled(); if (!done) { done = true; clearTimeout(timer); resolve(); } }
+        if (this.dev) process.stdout.write(`  [mesh] ${d}`);
+        this._handleStdoutData(d, (line) => {
+          if (/^MESH-NOCERT\b/.test(line)) this._printNoCert();
+          const url = line.match(/^MESH-URL (https?):\/\/(\S+)/);
+          if (url && !this.dnsName) {
+            this.scheme = url[1];
+            this.dnsName = url[2];
+            this._authKey = null;
+            this._startStabilityTimer();
+            this.onUrl(`${this.scheme}://${this.dnsName}`);
+            if (!done) { done = true; clearTimeout(timer); resolve(); }
+          }
+          if (/^MESH-NEEDLOGIN\b/.test(line)) {
+            this._deletePeersFile();
+            this._printNotEnrolled();
+            if (!done) { done = true; clearTimeout(timer); resolve(); }
+          }
+        });
       });
       this.proc.stderr.on('data', (d) => { if (this.dev) process.stderr.write(`  [mesh] ${d}`); });
       this.proc.on('error', (e) => { console.error(`  \x1b[31mmesh sidecar failed: ${e.message}\x1b[0m`); this.proc = null; if (!done) { done = true; clearTimeout(timer); resolve(); } });
       this.proc.on('exit', (code) => {
-        this._clearStabilityTimer(); this.proc = null; this.dnsName = null;
+        this._clearStabilityTimer(); this.proc = null; this.dnsName = null; this._deletePeersFile();
         if (!this.stopping && code !== 0) this._restart();
       });
     });
   }
 
+  _handleStdoutData(chunk, onLine) {
+    try {
+      this._stdoutBuffer += chunk.toString();
+      const lines = this._stdoutBuffer.split('\n');
+      this._stdoutBuffer = lines.pop() || '';
+      // Bound the carry-over: a newline-less run longer than any legitimate line
+      // (MESH-PEERS is capped well under this) is junk/log-spam — drop it so a
+      // misbehaving child can't grow the buffer without limit.
+      if (this._stdoutBuffer.length > MESH_PEERS_JSON_MAX) this._stdoutBuffer = '';
+      for (const rawLine of lines) {
+        const line = rawLine.replace(/\r$/, '');
+        this._handleStdoutLine(line);
+        if (onLine) onLine(line);
+      }
+    } catch (_) {}
+  }
+
+  _handleStdoutLine(line) {
+    try {
+      if (/^MESH-NEEDLOGIN\b/.test(line)) this._deletePeersFile();
+      const match = /^MESH-PEERS\s+(.+)$/.exec(line);
+      if (!match) return;
+      const raw = match[1];
+      if (Buffer.byteLength(raw, 'utf8') > MESH_PEERS_JSON_MAX) {
+        if (this.dev) console.debug('  [mesh] ignoring oversized MESH-PEERS payload');
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (_) {
+        return;
+      }
+      const normalized = this._validatePeersPayload(parsed);
+      if (!normalized) return;
+      this.peers = normalized;
+      this._writePeersFile(normalized);
+    } catch (_) {}
+  }
+
+  _validatePeersPayload(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return null;
+    const self = payload.self;
+    if (!self || typeof self !== 'object' || Array.isArray(self)) return null;
+    if (typeof self.hostname !== 'string' || typeof self.dnsName !== 'string') return null;
+    if (!Array.isArray(payload.peers)) return null;
+    const peers = [];
+    for (const p of payload.peers) {
+      if (!p || typeof p !== 'object' || Array.isArray(p)) continue;
+      if (typeof p.hostname !== 'string' || typeof p.dnsName !== 'string' || typeof p.online !== 'boolean') continue;
+      peers.push({ hostname: p.hostname, dnsName: p.dnsName, online: p.online });
+    }
+    return { self: { hostname: self.hostname, dnsName: self.dnsName }, peers };
+  }
+
+  _writePeersFile(snapshot) {
+    const file = this.peersFilePath();
+    const dir = path.dirname(file);
+    const tmp = path.join(dir, `peers.json.${process.pid}.tmp`);
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(tmp, JSON.stringify({
+        version: 1,
+        updatedAt: Date.now(),
+        self: snapshot.self,
+        peers: snapshot.peers,
+      }), { mode: 0o600 });
+      fs.chmodSync(tmp, 0o600);
+      fs.renameSync(tmp, file);
+    } catch (_) {
+      try { fs.rmSync(tmp, { force: true }); } catch (_) {}
+    }
+  }
+
+  _deletePeersFile() {
+    this.peers = null;
+    try { fs.rmSync(this.peersFilePath(), { force: true }); } catch (_) {}
+  }
+
   _printMissing(err) {
     const code = err && err.code;
     const map = {

package/src/server.js

@@ -4105,6 +4105,7 @@ class ClaudeCodeWebServer {
     return {
       sessions: this.claudeSessions,
       eventBus: this.controlEventBus,
+      getMeshPeers: () => this.meshManager ? this.meshManager.getStatus().peers : [],
       getStatusSignal: (id) => this._controlStatusSignal(id),
       readTail: async (id, lines) => this._controlReadTail(id, lines),
       createSession: async (opts) => this._controlCreateSession(opts),