ai-or-die 0.1.88 → 0.1.90

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.90",
   "description": "Universal AI coding terminal — Claude, Copilot, Gemini & more in your browser",
   "main": "src/server.js",
   "bin": {

package/src/artifact-review.js

@@ -9,6 +9,9 @@ const { EventEmitter } = require('events');
 const DEFAULT_POLL_HOLD_MS = 25000;
 const DEFAULT_POLL_HEARTBEAT_MS = 5000;
 const DEFAULT_SSE_HEARTBEAT_MS = 15000;
+// Bound the artifact-push await so a stalled PTY write can't hold the /prompts
+// HTTP response open. On timeout we treat the push as failed and re-queue.
+const PUSH_TIMEOUT_MS = 4000;
 
 function realpathOrResolve(file) {
   let resolved = path.resolve(file);
@@ -81,6 +84,65 @@ function feedbackHasData(snapshot) {
   );
 }
 
+// Render queued human prompts into a single message suitable for injecting into
+// the CLI as a new user turn (the artifact-push path). Pure + exported so the
+// gate decision and wording are unit-testable without a live PTY. Accepts both
+// the panel's prompt objects ({prompt, text, sourceLine}) and bare-string prompts
+// (curl/legacy). Returns '' when there is nothing actionable to push (caller
+// skips injection on empty).
+function normalizeFeedbackPrompt(p) {
+  if (typeof p === 'string') {
+    return p.trim() ? { prompt: p.trim() } : null;
+  }
+  if (p && typeof p.prompt === 'string' && p.prompt.trim()) {
+    return {
+      prompt: p.prompt.trim(),
+      text: typeof p.text === 'string' ? p.text : '',
+      sourceLine: typeof p.sourceLine === 'number' ? p.sourceLine : undefined,
+    };
+  }
+  return null;
+}
+function formatFeedbackForAgent(prompts) {
+  const items = (Array.isArray(prompts) ? prompts : [])
+    .map(normalizeFeedbackPrompt)
+    .filter(Boolean);
+  if (items.length === 0) return '';
+  const lines = items.map((p, i) => {
+    const quoted = p.text && p.text.trim()
+      ? ' (re: "' + p.text.trim().slice(0, 160) + '")'
+      : '';
+    const where = typeof p.sourceLine === 'number' ? ' [line ' + p.sourceLine + ']' : '';
+    return (i + 1) + '.' + where + quoted + ' ' + p.prompt;
+  });
+  return (
+    'Human review feedback from the artifact panel (you were idle, so this was '
+    + 'delivered as a new turn instead of through artifact_poll). Address these in '
+    + 'the open artifact, then reply with the artifact_reply tool:\n'
+    + lines.join('\n')
+  );
+}
+
+// Build the raw bytes to inject into the CLI PTY for an artifact push. Pure +
+// exported so the security-sensitive sanitization is unit-testable. Strips ALL
+// C0 control bytes and DEL except TAB and LF (this removes ESC, so the bracketed-
+// paste markers and any other escape/CSI sequence in the human text cannot
+// survive), which also drops CR so the only submit is the trailing CR we add.
+// Wraps in a bracketed paste so multi-line feedback enters the composer
+// atomically; size-capped to bound a single injection.
+function buildArtifactPushPayload(text) {
+  if (!text || typeof text !== 'string') return '';
+  const safe = text.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, ' ').slice(0, 4000);
+  return '\x1b[200~' + safe + '\x1b[201~\r';
+}
+
+// Whether the artifact-push feature is enabled from its env var. Default ON:
+// only an explicit falsy value (0 / false / off / no) disables it. Pure +
+// exported so the default-on / opt-out contract is unit-tested.
+function artifactPushEnabledFromEnv(raw) {
+  return !/^(0|false|off|no)$/i.test(String(raw == null ? '' : raw).trim());
+}
+
 class ArtifactReviewStore extends EventEmitter {
   constructor() {
     super();
@@ -214,6 +276,25 @@ class ArtifactReviewStore extends EventEmitter {
     return review;
   }
 
+  // Restore prompts that were claimed (acked) for a push that then failed, back to
+  // the FRONT of the queue so order is preserved (FIFO) ahead of any prompts that
+  // arrived during the push window. Re-emits 'feedback' so an in-flight poll picks
+  // them up. Used only by the artifact-push re-queue path.
+  restoreClaimedFeedback(aiSessionId, snapshot) {
+    const review = this._reviews.get(aiSessionId);
+    if (!review || !snapshot) return null;
+    const prompts = cloneArray(snapshot.prompts);
+    if (prompts.length > 0) {
+      review.queuedPrompts.unshift(...prompts);
+      if (snapshot.dom_snapshot !== undefined && review.domSnapshot == null) {
+        review.domSnapshot = snapshot.dom_snapshot;
+      }
+      review.updatedAt = nowIso();
+      this.emit('feedback', { aiSessionId, kind: 'prompts', review });
+    }
+    return review;
+  }
+
   addAgentReply(aiSessionId, text) {
     const review = this._reviews.get(aiSessionId);
     if (!review) return null;
@@ -567,6 +648,27 @@ function createArtifactReviewRouter(options) {
   const sseHeartbeatMs = typeof options.sseHeartbeatMs === 'number'
     ? options.sseHeartbeatMs
     : DEFAULT_SSE_HEARTBEAT_MS;
+  // Optional artifact-push hook (default off). When provided, panel feedback that
+  // arrives while NO agent poll is in flight is pushed into the CLI as a new turn
+  // (so an idle agent reacts without the human switching to the terminal). The
+  // server supplies this only when AIORDIE_ARTIFACT_PUSH is enabled; it returns a
+  // truthy value when it actually injected, so we can consume the queued prompts.
+  const pushToAgent = typeof options.pushToAgent === 'function'
+    ? options.pushToAgent
+    : null;
+  const pushTimeoutMs = typeof options.pushTimeoutMs === 'number' && options.pushTimeoutMs > 0
+    ? options.pushTimeoutMs
+    : PUSH_TIMEOUT_MS;
+
+  // Count of in-flight long-poll requests per session. Non-zero means the agent
+  // is actively waiting on artifact_poll, so a queued prompt is delivered by that
+  // poll and must NOT be injected (injecting mid-turn would race the CLI's TUI).
+  const activePolls = new Map();
+  function pollDelta(sessionId, delta) {
+    const next = (activePolls.get(sessionId) || 0) + delta;
+    if (next > 0) activePolls.set(sessionId, next);
+    else activePolls.delete(sessionId);
+  }
 
   if (!store) throw new TypeError('Artifact review store is required');
   if (typeof validatePath !== 'function') throw new TypeError('validatePath is required');
@@ -731,15 +833,60 @@ function createArtifactReviewRouter(options) {
     res.sendFile(resolved.path);
   });
 
-  router.post('/:sessionId/prompts', (req, res) => {
+  router.post('/:sessionId/prompts', async (req, res) => {
     const sessionId = req.params.sessionId;
     if (!store.get(sessionId)) return res.status(404).json({ error: 'artifact review not found' });
 
     const prompts = req.body && req.body.prompts;
     if (!Array.isArray(prompts)) return res.status(400).json({ error: 'prompts must be an array' });
 
+    // Snapshot whether a poll is in flight BEFORE queuing: queuePrompts emits
+    // 'feedback' synchronously, which makes an in-flight poll deliver + tear down
+    // (decrementing the count to 0) before we could observe it. Reading the count
+    // first is the correct "was the agent waiting when this arrived?" signal.
+    const hadActivePoll = (activePolls.get(sessionId) || 0) > 0;
+
     const review = store.queuePrompts(sessionId, prompts, req.body ? req.body.domSnapshot : undefined);
-    res.json({ ok: true, queued: review ? review.queuedPrompts.length : 0 });
+
+    // Artifact push (default off; pushToAgent is null unless enabled). If the
+    // agent was NOT waiting on a poll, the queued feedback would otherwise sit
+    // until the agent next polls. Push it into the CLI as a new turn so an idle
+    // agent reacts. When a poll WAS in flight the queue path already delivers it,
+    // so we never inject then (injecting mid-turn would race the TUI).
+    //
+    // We CLAIM the feedback (ackFeedback) synchronously BEFORE the await, so a
+    // poll that arrives during the push window sees an empty queue and cannot
+    // also deliver the same feedback (no double-delivery). If the push then fails
+    // or times out we re-queue exactly what we claimed, so feedback is never lost
+    // and the poll path still works. The server hook applies its own PTY-quiet
+    // idle check and may decline.
+    let pushed = false;
+    if (pushToAgent && !hadActivePoll) {
+      const snapshot = store.peekFeedback(sessionId);
+      const text = feedbackHasData(snapshot) ? formatFeedbackForAgent(snapshot.prompts) : '';
+      if (text) {
+        store.ackFeedback(sessionId, snapshot); // claim before await
+        try {
+          pushed = !!(await Promise.race([
+            Promise.resolve(pushToAgent(sessionId, text)),
+            new Promise((resolve) => setTimeout(() => resolve(false), pushTimeoutMs)),
+          ]));
+        } catch (_) {
+          pushed = false;
+        }
+        if (!pushed) {
+          // Re-queue what we claimed (to the FRONT, preserving order) so the poll
+          // path still delivers it.
+          store.restoreClaimedFeedback(sessionId, snapshot);
+        }
+      }
+    }
+
+    res.json({
+      ok: true,
+      pushed,
+      queued: pushed ? 0 : (review ? review.queuedPrompts.length : 0),
+    });
   });
 
   router.post('/:sessionId/layout-warnings', (req, res) => {
@@ -849,11 +996,18 @@ function createArtifactReviewRouter(options) {
     res.setHeader('X-Accel-Buffering', 'no');
     if (typeof res.flushHeaders === 'function') res.flushHeaders();
 
+    // This request is now an in-flight poll; mark the agent as actively waiting
+    // so concurrent /prompts feedback is delivered HERE (not injected into the
+    // PTY). Decremented exactly once on teardown.
+    let pollCounted = true;
+    pollDelta(sessionId, 1);
+
     let done = false;
     let snapshotToAck = null;
     let timeout = null;
     let heartbeat = null;
     function cleanup() {
+      if (pollCounted) { pollCounted = false; pollDelta(sessionId, -1); }
       if (timeout) clearTimeout(timeout);
       if (heartbeat) clearInterval(heartbeat);
       store.removeListener('feedback', onFeedback);
@@ -924,6 +1078,9 @@ module.exports = {
   createAssetTokenSigner,
   createArtifactReviewRouter,
   feedbackHasData,
+  formatFeedbackForAgent,
+  buildArtifactPushPayload,
+  artifactPushEnabledFromEnv,
   injectLavishSdk,
   isMarkdownFile,
   markdownArtifactShell,

package/src/base-bridge.js

@@ -320,6 +320,10 @@ class BaseBridge {
         workingDir,
         created: new Date(),
         active: true,
+        // Epoch ms of the most recent PTY output, updated in the onData handler.
+        // Used by the artifact-push idle gate (msSinceLastOutput) to avoid
+        // injecting input while the CLI is actively rendering. Seeded at spawn.
+        lastOutputAt: Date.now(),
         killTimeout: null,
         writeQueue: Promise.resolve(),
         // PTY listener handles registered against ptyProcess.{onData,onExit,on('error')}.
@@ -382,6 +386,7 @@ class BaseBridge {
           receivedLifeSign = true;
           clearTimeout(spawnWatchdog);
         }
+        session.lastOutputAt = Date.now();
 
         if (process.env.DEBUG) {
           console.log(`${this.toolName} session ${sessionId} output:`, data);
@@ -558,6 +563,19 @@ class BaseBridge {
     return session.writeQueue;
   }
 
+  /**
+   * Milliseconds since this session's PTY last emitted output, or null if there
+   * is no active session. Used by the artifact-push idle gate to skip injecting
+   * input while the CLI is actively rendering (a proxy for "not mid-turn").
+   * @param {string} sessionId
+   * @returns {number|null}
+   */
+  msSinceLastOutput(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session || !session.active) return null;
+    return Date.now() - (session.lastOutputAt || 0);
+  }
+
   /**
    * Write data to the PTY in chunks to prevent kernel buffer overflow.
    * @private

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/public/components/artifact-panel.css

@@ -212,3 +212,60 @@
     linear-gradient(135deg, transparent 0 50%, var(--border-hover, #484f58) 50% 60%, transparent 60% 70%, var(--border-hover, #484f58) 70% 80%, transparent 80%);
 }
 .artifact-panel__resize[hidden] { display: none; }
+
+/* Maximized layout: horizontal split. Artifact content is the large flexible
+   pane; chat is a fixed 360px right rail (the lavish-axi / mainstream artifact-UI
+   model). Maximizing is a request for content WIDTH, so spend the reclaimed
+   space on the artifact, not on a wide chat. CSS grid (not a JS reparent) places
+   pillbar / chat / chatbar into the rail in source order: pills at the rail top,
+   chat filling the middle, the composer at the bottom. Reverts to the default
+   vertical stack under 1024px, where a narrow window reads better stacked. */
+.artifact-panel--maximized .artifact-panel__body {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 360px;
+  grid-template-rows: auto minmax(0, 1fr) auto;
+}
+.artifact-panel--maximized .artifact-panel__frame {
+  grid-column: 1;
+  grid-row: 1 / 4; /* content spans the full height on the left */
+  /* The frame is an <iframe> (a replaced element): it uses its intrinsic size and
+     does NOT stretch to fill a grid cell like a normal block, so it needs explicit
+     100% dimensions (the old flex layout filled it via `flex: 1`). */
+  width: 100%;
+  height: 100%;
+}
+.artifact-panel--maximized .artifact-panel__pillbar {
+  grid-column: 2;
+  grid-row: 1;
+  border-left: 1px solid var(--panel-border, #33363f);
+}
+.artifact-panel--maximized .artifact-panel__chat {
+  grid-column: 2;
+  grid-row: 2;
+  max-height: none; /* fill the rail middle row instead of the 30% cap */
+  border-left: 1px solid var(--panel-border, #33363f);
+}
+.artifact-panel--maximized .artifact-panel__chatbar {
+  grid-column: 2;
+  grid-row: 3;
+  border-left: 1px solid var(--panel-border, #33363f);
+}
+
+/* Narrow viewport: revert the maximized panel to the vertical stack so the
+   content is not squeezed into a sliver beside a 360px rail. */
+@media (max-width: 1024px) {
+  .artifact-panel--maximized .artifact-panel__body {
+    display: flex;
+    flex-direction: column;
+  }
+  .artifact-panel--maximized .artifact-panel__frame,
+  .artifact-panel--maximized .artifact-panel__pillbar,
+  .artifact-panel--maximized .artifact-panel__chat,
+  .artifact-panel--maximized .artifact-panel__chatbar {
+    grid-column: auto;
+    grid-row: auto;
+    border-left: none;
+  }
+  .artifact-panel--maximized .artifact-panel__frame { width: 100%; }
+  .artifact-panel--maximized .artifact-panel__chat { max-height: 30%; }
+}

package/src/server.js

@@ -37,7 +37,7 @@ const KeepaliveManager = require('./keepalive-manager');
 const { ControlEventBus, EVENT_KINDS: CONTROL_EVENT_KINDS } = require('./control/event-bus');
 const TranscriptBuffer = require('./sticky-note-transcript');
 const { createControlRouter } = require('./control/routes');
-const { ArtifactReviewStore, createArtifactReviewRouter, createAssetTokenSigner } = require('./artifact-review');
+const { ArtifactReviewStore, createArtifactReviewRouter, createAssetTokenSigner, buildArtifactPushPayload, artifactPushEnabledFromEnv } = require('./artifact-review');
 const { deriveStatus, awaitingKindForPendingTool, awaitingFromScreen, TRUST_PROMPT_REGEX, DEFAULT_UNBOUND_QUIET_MS } = require('./control/session-status');
 const { detectAwaiting } = require('./control/jsonl-awaiting');
 
@@ -166,6 +166,14 @@ class ClaudeCodeWebServer {
     this.artifactPollHoldMs = options.artifactPollHoldMs || 25000;
     this.artifactPollHeartbeatMs = options.artifactPollHeartbeatMs || 5000;
     this.artifactSseHeartbeatMs = options.artifactSseHeartbeatMs || 15000;
+    // Artifact push (default ON): panel feedback that arrives while the agent is
+    // idle (no in-flight poll + PTY quiet) is injected into the CLI as a new turn,
+    // so the composer works without the human switching to the terminal or the
+    // agent having to poll. Opt OUT with AIORDIE_ARTIFACT_PUSH=0 (or false/off/no).
+    // The idle-gate + residual TUI-timing risk are recorded in docs/adrs/0035.
+    this._artifactPushEnabled = artifactPushEnabledFromEnv(process.env.AIORDIE_ARTIFACT_PUSH);
+    const quietRaw = Number(process.env.AIORDIE_ARTIFACT_PUSH_QUIET_MS);
+    this._artifactPushQuietMs = Number.isFinite(quietRaw) && quietRaw > 0 ? quietRaw : 1500;
     // PROC-04: min-heap of {id, lastActivity} pairs keyed by lastActivity.
     // Used by _evictStaleSessions to find the oldest session in O(log n)
     // rather than scanning the full Map every 5 min. Lazy-tombstone protocol
@@ -1270,6 +1278,9 @@ class ClaudeCodeWebServer {
       pollHoldMs: this.artifactPollHoldMs,
       pollHeartbeatMs: this.artifactPollHeartbeatMs,
       sseHeartbeatMs: this.artifactSseHeartbeatMs,
+      pushToAgent: this._artifactPushEnabled
+        ? (sessionId, text) => this._pushArtifactFeedbackToAgent(sessionId, text)
+        : null,
     }));
 
     // Commands API removed
@@ -4101,10 +4112,53 @@ class ClaudeCodeWebServer {
     return bridges[agentType] || null;
   }
 
+  // Return the bridge that currently owns a live PTY for `sessionId`, or null.
+  // Uses msSinceLastOutput (null when the session is absent/inactive) so we
+  // don't reach into a bridge's private session map.
+  _bridgeForSession(sessionId) {
+    const bridges = [
+      this.claudeBridge, this.terminalBridge,
+      this.codexBridge, this.copilotBridge, this.geminiBridge,
+    ];
+    for (const bridge of bridges) {
+      if (bridge && typeof bridge.msSinceLastOutput === 'function'
+          && bridge.msSinceLastOutput(sessionId) !== null) {
+        return bridge;
+      }
+    }
+    return null;
+  }
+
+  // Artifact-push hook (wired only when AIORDIE_ARTIFACT_PUSH is enabled). Inject
+  // panel feedback into the idle CLI as a NEW turn. Returns true only if it
+  // actually wrote to the PTY (the caller then consumes the queued prompts).
+  // Idle gate: decline when the session's PTY emitted output within the quiet
+  // window (likely mid-render / mid-turn), a heuristic, hence opt-in. Bracketed
+  // paste keeps multi-line feedback atomic; a trailing CR submits the turn.
+  async _pushArtifactFeedbackToAgent(sessionId, text) {
+    if (!text || typeof text !== 'string') return false;
+    const bridge = this._bridgeForSession(sessionId);
+    if (!bridge) return false;
+    const quietMs = bridge.msSinceLastOutput(sessionId);
+    if (quietMs === null || quietMs < this._artifactPushQuietMs) return false;
+    // Sanitize + bracketed-paste-wrap the human text (pure helper, unit-tested in
+    // artifact-review): strips ESC/control bytes so nothing can break out of the
+    // paste envelope, and a trailing CR submits the turn.
+    const payload = buildArtifactPushPayload(text);
+    if (!payload) return false;
+    try {
+      await bridge.sendInput(sessionId, payload);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+
   _buildControlDeps() {
     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),