create-pmos 0.520.0 → 0.522.0

package/workspace/public/pm/term-view.js

@@ -4,13 +4,28 @@
  *   to the session over the page's WebSocket, as the sign-in terminal does (cozy-claude-setup.js signInTerminal), so keys typed in it reach the
  *   session — a first-run prompt, a pasted sign-in code, an answer to Claude. Before, it was read only, and a new user whose Claude stopped at its
  *   theme or trust-this-folder screen could not answer it.
+ *   It fills the whole card and fits its grid to it, again whenever the card or the window changes size (batch 27 item 6), and only the keys
+ *   the PM types reach the session: xterm.js's own answers to the queries in the replayed screen do not (chat-term.js typedOnly, item 5).
  *   An ENDED session, or a page where the socket cannot attach, keeps the read-only view: GET /api/sessions/transcript?id=<sid>&raw=1 every 2 s,
  *   drawn in xterm.js the size of the session's own, after the first read only what was printed since (since + gen). When xterm.js cannot load,
  *   it falls back to the plain text (GET …&max=12000, ANSI taken out). */
 import { open, current, setKind } from './cozy-viewer.js';
 import { pmGet, pageNonce } from './http.js';
+import { typedOnly } from './chat-term.js';
 
-let xtermP = null;
+let xtermP = null, fitP = null;
+/** window.FitAddon from /vendor/addon-fit.js, loaded once. Resolves null when it cannot load: the live terminal then keeps the session's grid. */
+function loadFit() {
+  if (window.FitAddon) return Promise.resolve(window.FitAddon);
+  if (fitP) return fitP;
+  fitP = new Promise((done) => {
+    const s = document.createElement('script'); s.src = '/vendor/addon-fit.js';
+    s.onload = () => done(window.FitAddon || null);
+    s.onerror = () => { fitP = null; done(null); };
+    document.head.appendChild(s);
+  });
+  return fitP;
+}
 /** window.Terminal from /vendor/xterm.js, loaded once with its stylesheet. Resolves null when it cannot load. */
 function loadXterm() {
   if (window.Terminal) return Promise.resolve(window.Terminal);
@@ -39,14 +54,15 @@ function look(el) {
 
 /** The live terminal: attach over the WebSocket and send what the PM types. Resolves true when it attached to a running session,
  * false when the session has ended or the socket did not answer (the caller then shows the read-only view). */
-function attachLive(Terminal, body, sid, live, keep) {
+function attachLive(Terminal, Fit, body, sid, live, keep) {
   return new Promise((done) => {
+    let ro = null;
     let sock;
     try { sock = new WebSocket((location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host + '/?pmos-nonce=' + encodeURIComponent(pageNonce())); } catch { done(false); return; }
     const send = (d) => { if (sock.readyState === WebSocket.OPEN) sock.send(JSON.stringify(d)); };
     let term = null, settled = false;
     const settle = (v) => { if (!settled) { settled = true; clearTimeout(t); done(v); } };
-    const close = () => { try { send({ t: 'detach', id: sid }); sock.close(); } catch { /* gone */ } if (term) { try { term.dispose(); } catch { /* gone */ } term = null; } };
+    const close = () => { if (ro) { ro.disconnect(); ro = null; } try { send({ t: 'detach', id: sid }); sock.close(); } catch { /* gone */ } if (term) { try { term.dispose(); } catch { /* gone */ } term = null; } };
     const t = setTimeout(() => { close(); settle(false); }, 1500);   // a session the server does not know never answers
     sock.addEventListener('open', () => send({ t: 'attach', id: sid }));
     sock.addEventListener('error', () => { close(); settle(false); });
@@ -60,14 +76,29 @@ function attachLive(Terminal, body, sid, live, keep) {
         term = new Terminal({ cols: m.cols || 80, rows: m.rows || 24, cursorBlink: true, scrollback: 5000, fontFamily: L.fontFamily, lineHeight: 1.25, theme: { ...L.theme, cursor: L.theme.foreground } });
         term.open(host);
         if (m.buf) term.write(m.buf, () => term && term.scrollToBottom());
-        term.onData((d) => send({ t: 'input', id: sid, data: d }));
-        // drawn at the session's own grid (as the read-only view is), so opening the card never reflows a running agent
+        // only the keys the PM types reach the session: the terminal's own answers to the queries in the replayed screen stay here (chat-term.js typedOnly)
+        term.onData((d) => { const k = typedOnly(d); if (k) send({ t: 'input', id: sid, data: k }); });
+        // the terminal fills the whole card and fits its lines to it, again on every resize (batch 27 item 6, Wawan 2026-11-04: "Terminal
+        // should occupy the whole width and height"). The session has one grid, so the agent redraws at the card's size.
+        if (Fit) {
+          const fit = new Fit.FitAddon(); term.loadAddon(fit);
+          let t0 = null, sent = { cols: term.cols, rows: term.rows };
+          const refit = () => {
+            if (!term || !host.isConnected) return;
+            try { fit.fit(); } catch { return; }
+            if (term.cols !== sent.cols || term.rows !== sent.rows) { sent = { cols: term.cols, rows: term.rows }; send({ t: 'resize', id: sid, cols: term.cols, rows: term.rows }); }
+          };
+          refit();
+          ro = new ResizeObserver(() => { clearTimeout(t0); t0 = setTimeout(refit, 80); });
+          ro.observe(host);
+        }
         keep(close);
         term.focus();
         settle(true);
       }
       if (m.t === 'data' && m.id === sid && term) { const b = term.buffer.active, atEnd = b.viewportY >= b.baseY; term.write(m.data, () => { if (atEnd && term) term.scrollToBottom(); }); }
-      if (m.t === 'size' && m.id === sid && term) { try { term.resize(m.cols, m.rows); } catch { /* keep */ } }
+      // another screen resized the session: this card takes the size back at its next fit (a resize of the card or the window)
+      if (m.t === 'size' && m.id === sid && term && !ro) { try { term.resize(m.cols, m.rows); } catch { /* keep */ } }
       if (m.t === 'error' && !term) { close(); settle(false); }
     });
   });
@@ -117,9 +148,9 @@ export function openTermView(sid, o = {}) {
   };
 
   (async () => {
-    const Terminal = await loadXterm();
+    const [Terminal, Fit] = await Promise.all([loadXterm(), loadFit()]);
     if (!Terminal) plain = true;
-    else if (await attachLive(Terminal, body, sid, live, (c) => { closeLive = c; })) return;   // a running session: the real terminal
+    else if (await attachLive(Terminal, Fit, body, sid, live, (c) => { closeLive = c; })) return;   // a running session: the real terminal
     if (!live()) return;
     // an ended session (or no socket): the read-only view, and the card says so
     setKind(id, 'Terminal · read only');