lampson 0.2.3 → 0.2.5

package/public/js/terminal.js

@@ -1,6 +1,20 @@
-// terminal.js — terminal real: xterm.js ↔ WebSocket /api/term ↔ pty en el servidor
-// Frames binarios = bytes del pty; texto JSON = control (hello / exit). Cerrar el panel cierra el socket y mata el shell.
-let term = null, termWs = null, termFit = null;
+// terminal.js — terminales reales: xterm.js ↔ WebSocket /api/term ↔ un pty por terminal en el servidor.
+// Frames de texto: "o" + salida del pty · "c" + JSON de control (hello / exit). Conviven varias como
+// pestañas (cada una con su shell); minimizar esconde el panel con todas vivas y el botón del encabezado
+// lo trae de vuelta; ✕ mata la shell de la activa (la última cierra el panel).
+// La shell NO vive en el socket sino en un agente del servidor (lib/term.syn): recargar la página no la
+// mata — al cargar pedimos /api/terms y nos reenganchamos por id, con replay de lo último que imprimió.
+const MAX_TERMS = 4;
+let terms = [];        // [{id, el, term, ws, fit, ro, box, meta, live}]
+let termAt = -1;       // índice de la activa en terms
+// qué estaba abierto antes del F5 (el panel y la pestaña activa; las shells las sabe el servidor)
+function saveTermUi() {
+  try {
+    localStorage.setItem('lampson.term.open', termShown() ? '1' : '0');
+    localStorage.setItem('lampson.term.at', String(termAt));
+    localStorage.setItem('lampson.term.max', $('#termpane').classList.contains('max') ? '1' : '0');
+  } catch (e) {}
+}
 function termTheme() {
   const s = getComputedStyle(document.documentElement); const v = n => s.getPropertyValue(n).trim();
   return { background: v('--paper'), foreground: v('--ink'), cursor: v('--accent'), cursorAccent: v('--paper'), selectionBackground: v('--sel'),
@@ -8,11 +22,56 @@ function termTheme() {
     yellow: v('--amber'), brightYellow: v('--amber'), blue: v('--term-blue'), brightBlue: v('--accent'), magenta: v('--rubric'), brightMagenta: v('--rubric'),
     cyan: v('--accent'), brightCyan: v('--accent'), white: v('--ink-2'), brightWhite: v('--ink') };
 }
-function openTerm() {
-  if (term) { showPane('term'); termFit.fit(); term.focus(); return; }
-  showPane('term'); procOpen = null; clearInterval(procTimer);
-  term = new Terminal({ cursorBlink: true, fontFamily: getComputedStyle(document.documentElement).getPropertyValue('--mono'), fontSize: 13, lineHeight: 1.25, theme: termTheme(), scrollback: 5000, allowProposedApi: true });
-  termFit = new FitAddon.FitAddon(); term.loadAddon(termFit); term.open($('#xterm')); termFit.fit();
+// ojo: el display inicial lo pone el CSS, no el style inline — mirando sólo el inline, «está abierto»
+// daba true antes del primer showPane() y la restauración se creía abierta
+const termShown = () => getComputedStyle($('#termpane')).display !== 'none';
+// Un solo lugar donde se ajusta el tamaño. fit() hace clear() + resize() del terminal y dispara un
+// resize del pty (el shell repinta entero), así que sólo se llama cuando la caja cambió DE VERDAD:
+// sin esa guarda, el ResizeObserver se realimenta con su propio ajuste y el terminal parpadea.
+function fitTerm(t) {
+  if (!t || !t.fit || !termShown()) return;
+  const box = t.el.clientWidth + 'x' + t.el.clientHeight;
+  if (!t.el.clientWidth || !t.el.clientHeight || box === t.box) return;
+  t.box = box;
+  requestAnimationFrame(() => { if (t.term && t.fit) try { t.fit.fit(); } catch (e) {} }); // fuera del callback del observer
+}
+// pestañas: una por terminal (siempre visibles, también con una sola: así se ve que hay numeración)
+function paintTabs() {
+  const tabs = $('#ttabs'); tabs.innerHTML = '';
+  terms.forEach((t, i) => {
+    const b = document.createElement('span');
+    b.className = 'ttab' + (i === termAt ? ' on' : '') + (t.live ? '' : ' dead');
+    b.textContent = String(i + 1);
+    b.title = 'terminal ' + (i + 1) + (t.meta ? ' · ' + t.meta : '') + (t.live ? '' : ' (shell terminada)');
+    b.onclick = () => activateTerm(i); tabs.appendChild(b);
+  });
+  const add = $('#tnew'); add.disabled = terms.length >= MAX_TERMS;
+  add.title = add.disabled ? 'máximo ' + MAX_TERMS + ' terminales abiertas' : 'abrir otra terminal: una shell nueva en el workspace';
+  const t = terms[termAt];
+  $('#tmeta').textContent = t ? t.meta : '';
+  $('#termpane').classList.toggle('live', !!(t && t.live));
+  $('#term').classList.toggle('live', terms.some(x => x.live));   // el botón del encabezado: hay shell viva
+}
+function activateTerm(i) {
+  termAt = i;
+  terms.forEach((t, k) => { t.el.style.display = k === i ? '' : 'none'; });
+  paintTabs(); saveTermUi();
+  const t = terms[i];
+  if (!t) return;
+  t.box = ''; fitTerm(t); t.term.refresh(0, t.term.rows - 1); t.term.focus();
+}
+// id = reengancharse a una shell que ya existe (tras un F5); show = false para reconstruir sin abrir el panel
+function newTerm(id, show) {
+  if (terms.length >= MAX_TERMS) return;
+  if (show !== false) { showPane('term'); procOpen = null; clearInterval(procTimer); }
+  const el = document.createElement('div'); el.className = 'xt'; $('#xterms').appendChild(el);
+  const term = new Terminal({ cursorBlink: true, fontFamily: getComputedStyle(document.documentElement).getPropertyValue('--mono'), fontSize: 13, lineHeight: 1.25, theme: termTheme(), scrollback: 5000, allowProposedApi: true });
+  const fit = new FitAddon.FitAddon(); term.loadAddon(fit);
+  const t = { id: id || '', el, term, fit, ws: null, ro: null, box: '', meta: 'conectando…', live: false };
+  terms.push(t);
+  if (show !== false) termAt = terms.length - 1;
+  terms.forEach((x, k) => { x.el.style.display = k === termAt ? '' : 'none'; });
+  term.open(el); fitTerm(t);
   // URLs clickeables (npm run dev imprime http://localhost:3000): link provider mínimo con la API nativa
   // de xterm v5 — el addon web-links no está vendorizado y no hace falta para http/https
   const TERM_URL_RE = /https?:\/\/[^\s"'`<>()\[\]{}]*[^\s"'`<>()\[\]{}.,;:!?]/g;
@@ -28,22 +87,98 @@ function openTerm() {
       cb(links.length ? links : undefined);
     }
   });
-  $('#tmeta').textContent = 'conectando…';
-  termWs = new WebSocket((location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host + BASE + '/api/term'); termWs.binaryType = 'arraybuffer';
-  const send = (o) => { if (termWs && termWs.readyState === 1) termWs.send(JSON.stringify(o)); };
-  termWs.onopen = () => { $('#termpane').classList.add('live'); send({ type: 'resize', cols: term.cols, rows: term.rows }); term.focus(); };
-  termWs.onmessage = (e) => { // "o" + salida del pty | "c" + JSON de control
+  const ws = new WebSocket((location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host + BASE + '/api/term' + (id ? '?id=' + encodeURIComponent(id) : ''));
+  ws.binaryType = 'arraybuffer'; t.ws = ws;
+  const send = (o) => { if (ws.readyState === 1) ws.send(JSON.stringify(o)); };
+  t.send = send;
+  ws.onopen = () => { t.live = true; paintTabs(); send({ type: 'resize', cols: term.cols, rows: term.rows }); if (termAt === terms.indexOf(t)) term.focus(); };
+  ws.onmessage = (e) => { // "o" + salida del pty | "c" + JSON de control
     const s = String(e.data);
     if (s[0] === 'o') { term.write(s.slice(1)); return; }
     let m; try { m = JSON.parse(s.slice(1)); } catch { return; }
-    if (m.type === 'hello') $('#tmeta').textContent = `${m.shell} · pid ${m.pid} · ${m.cwd || 'workspace'}`;
-    if (m.type === 'exit') { term.write(`\r\n\x1b[2m[shell terminado · código ${m.code}]\x1b[0m\r\n`); $('#termpane').classList.remove('live'); }
+    if (m.type === 'hello') { t.id = m.id || t.id; t.meta = `${m.shell} · pid ${m.pid} · ${m.cwd || 'workspace'}`; paintTabs(); }
+    if (m.type === 'exit') {
+      t.live = false; paintTabs();
+      if (m.error === 'too_many') { term.write(`\r\n\x1b[2m[ya hay ${MAX_TERMS} terminales abiertas — cerrá una para abrir otra]\x1b[0m\r\n`); return; }
+      term.write(`\r\n\x1b[2m[shell terminado · código ${m.code}]\x1b[0m\r\n`);
+    }
+  };
+  // el socket se corta pero la shell sigue viva en el servidor: se recupera recargando (o al volver a entrar)
+  ws.onclose = () => {
+    t.live = false;
+    if (t.meta === 'conectando…') t.meta = 'sin conexión';
+    else if (!t.killed) term.write('\r\n\x1b[2m[conexión perdida · la shell sigue viva: recargá la página para reengancharte]\x1b[0m\r\n');
+    paintTabs();
   };
-  termWs.onclose = () => { $('#termpane').classList.remove('live'); if ($('#tmeta').textContent === 'conectando…') $('#tmeta').textContent = 'sin conexión'; };
   term.onData(d => send({ type: 'in', data: d }));
   term.onResize(({ cols, rows }) => send({ type: 'resize', cols, rows }));
-  new ResizeObserver(() => { if ($('#termpane').style.display !== 'none') termFit.fit(); }).observe($('#xterm'));
+  t.ro = new ResizeObserver(() => fitTerm(t)); t.ro.observe(el);
+  paintTabs(); saveTermUi();
+}
+// el botón del encabezado: abre la primera, trae de vuelta el panel minimizado, o lo esconde si está a la vista.
+// Espera a saber qué shells sobrevivieron (termsReady): sin eso, un clic apurado abriría una shell de más.
+function openTerm() {
+  termsReady.then(() => {
+    if (!terms.length) { newTerm(); return; }
+    if (termShown()) { minTerm(); return; }
+    showPane('term'); procOpen = null; clearInterval(procTimer);
+    activateTerm(termAt < 0 || termAt >= terms.length ? terms.length - 1 : termAt);
+    saveTermUi();
+  });
+}
+// minimizar: el panel se esconde, las shells siguen vivas (el botón del encabezado queda verde y lo devuelve)
+function minTerm() { maxTerm(false); showPane('log'); saveTermUi(); }
+// pantalla completa: el panel tapa la ventana entera; se vuelve con el mismo botón (❐).
+function maxTerm(on) {
+  const pane = $('#termpane');
+  const max = on === undefined ? !pane.classList.contains('max') : on;
+  pane.classList.toggle('max', max);
+  $('#tmax').innerHTML = max ? '&#10064;' : '&#9633;';
+  $('#tmax').title = max ? 'volver al tamaño normal' : 'pantalla completa';
+  saveTermUi();
+  const t = terms[termAt];
+  if (t) { t.box = ''; fitTerm(t); t.term.focus(); }
+}
+// repintar las terminales abiertas al cambiar de tema (lo llama theme.js; ojo: «term» a secas es el BOTÓN
+// del encabezado — los id del HTML son globales — así que el repintado tiene que pasar por acá)
+function termsRetheme() { const th = termTheme(); terms.forEach(t => { t.term.options.theme = th; }); }
+// cerrar: sólo la terminal activa. Hay que PEDIR la muerte de la shell ({type:"kill"}): irse del socket
+// ya no la mata (ese es el precio, y la gracia, de que sobreviva a un F5). La última cierra el panel.
+function closeTerm() {
+  const t = terms[termAt];
+  if (!t) { showPane('log'); return; }
+  t.killed = true;
+  if (t.ro) t.ro.disconnect();
+  if (t.ws) try { t.send({ type: 'kill' }); t.ws.close(); } catch (e) {}
+  t.term.dispose(); t.el.remove();
+  terms.splice(termAt, 1);
+  if (!terms.length) { termAt = -1; paintTabs(); maxTerm(false); showPane('log'); saveTermUi(); return; }
+  activateTerm(Math.min(termAt, terms.length - 1));
+}
+// al cargar: las shells que sobrevivieron al F5 vuelven como pestañas (el panel sólo si estaba abierto)
+async function restoreTerms() {
+  let data; try { data = await (await fetch(BASE + '/api/terms')).json(); } catch (e) { return; }
+  const live = (data && data.terminals) || [];
+  if (!live.length) return;
+  // leer ANTES de crear nada: cada newTerm guarda el estado y pisaría lo que dejó la sesión anterior
+  let open = false, at = 0, max = false;
+  try {
+    open = localStorage.getItem('lampson.term.open') === '1';
+    at = +(localStorage.getItem('lampson.term.at') || 0);
+    max = localStorage.getItem('lampson.term.max') === '1';
+  } catch (e) {}
+  const yaAbrio = terms.length > 0;   // alguien abrió una mientras preguntábamos: no le movemos la vista
+  for (const info of live) newTerm(info.id, false);
+  if (yaAbrio) { paintTabs(); return; }
+  termAt = Math.max(0, Math.min(at, terms.length - 1));
+  if (open) { showPane('term'); procOpen = null; clearInterval(procTimer); if (max) maxTerm(true); activateTerm(termAt); }
+  else { terms.forEach((t, k) => { t.el.style.display = k === termAt ? '' : 'none'; }); paintTabs(); }
 }
-function closeTerm() { if (termWs) { try { termWs.close(); } catch (e) {} } if (term) term.dispose(); term = null; termWs = null; termFit = null; $('#xterm').innerHTML = ''; $('#termpane').classList.remove('live'); showPane('log'); }
+const termsReady = restoreTerms();   // se lanza al cargar; openTerm la espera
 $('#term').onclick = openTerm;
+$('#tnew').onclick = newTerm;
+$('#tmin').onclick = minTerm;
+$('#tmax').onclick = () => maxTerm();
 $('#tclose').onclick = closeTerm;
+// Sin atajo para salir de pantalla completa: Esc es del shell (vim, menús) y robársela rompería el terminal.
+// El botón ❐ queda a la vista en la cabecera, que es lo único que se dibuja fuera del área del terminal.

package/public/js/theme.js

@@ -2,5 +2,5 @@
 const SUN = '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><circle cx="12" cy="12" r="4"/><path d="M12 2.7v2.1M12 19.2v2.1M2.7 12h2.1M19.2 12h2.1M5.3 5.3l1.5 1.5M17.2 17.2l1.5 1.5M18.7 5.3l-1.5 1.5M6.8 17.2l-1.5 1.5"/></svg>';
 const MOON = '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M20.2 14.6A8.6 8.6 0 0 1 9.4 3.8a8.6 8.6 0 1 0 10.8 10.8z"/></svg>';
 function paintTheme() { const light = document.documentElement.getAttribute('data-theme') === 'light'; $('#theme').innerHTML = light ? MOON : SUN; $('#theme').title = light ? 'Cambiar a tema oscuro' : 'Cambiar a tema claro'; }
-$('#theme').onclick = () => { const r = document.documentElement; r.setAttribute('data-theme', r.getAttribute('data-theme') === 'light' ? 'dark' : 'light'); try { localStorage.setItem('lampson.theme', r.getAttribute('data-theme')); } catch (e) {} paintTheme(); if (typeof term !== 'undefined' && term) term.options.theme = termTheme(); };
+$('#theme').onclick = () => { const r = document.documentElement; r.setAttribute('data-theme', r.getAttribute('data-theme') === 'light' ? 'dark' : 'light'); try { localStorage.setItem('lampson.theme', r.getAttribute('data-theme')); } catch (e) {} paintTheme(); if (typeof termsRetheme === 'function') termsRetheme(); };
 paintTheme();

package/public/js/workspaces.js

@@ -4,8 +4,9 @@ let wsList = [], wsIdle = 4;
 // abierto por el puerto de un proceso (:808N) las URLs de otros workspaces tienen que ir al hub (:8080), no a este proceso
 const HUB_BASE = (location.port && location.port !== '8080') ? location.protocol + '//' + location.hostname + ':8080' : '';
 function wsUrl(w) { return HUB_BASE + w.url; }
-async function fetchWorkspaces() {
-  try { const r = await (await fetch('/api/workspaces')).json(); wsList = r.workspaces || []; wsIdle = r.idle_hours; return true; } catch (e) { wsList = []; return false; }
+// fresh=true: saltear la caché del hub (después de encender/apagar)
+async function fetchWorkspaces(fresh) {
+  try { const r = await (await fetch('/api/workspaces' + (fresh ? '?fresh=1' : ''))).json(); wsList = r.workspaces || []; wsIdle = r.idle_hours; return true; } catch (e) { wsList = []; return false; }
 }
 async function paintWorkspacePill() {
   const pill = $('#wsPill'); if (!pill) return;
@@ -22,12 +23,12 @@ function openWorkspaces(selectSlug) {
     browse: {
       placeholder: 'buscar workspace…', listWidth: '300px', key: w => w.slug,
       load: async (q) => { await fetchWorkspaces(); const list = wsList.filter(w => !q || (w.name + ' ' + w.path).toLowerCase().includes(q.toLowerCase())); return q ? list : [...list, WS_NEW]; },
-      render: (w) => w === WS_NEW ? `<span class="dot">+</span><div><div class="nm" style="color:var(--accent);font-weight:400">nuevo workspace…</div><div class="meta">elegí una carpeta</div></div>` : `<span class="dot">${w.alive ? '●' : '○'}</span><div><div class="nm">${esc(w.name)}${w.slug === WS_SLUG ? ' <span class="meta">(este)</span>' : ''}</div><div class="meta">${esc(w.path)}</div></div>`,
+      render: (w) => w === WS_NEW ? `<span class="dot">+</span><div><div class="nm" style="color:var(--accent);font-weight:400">nuevo workspace…</div><div class="meta">elegí una carpeta</div></div>` : `<span class="dot ${w.alive ? 'on' : 'off'}">${w.alive ? '●' : '○'}</span><div><div class="nm">${esc(w.name)}${w.slug === WS_SLUG ? ' <span class="meta">(este)</span>' : ''}</div><div class="meta">${esc(w.path)}</div></div>`,
       count: (rows) => { const n = rows.filter(r => r !== WS_NEW).length, a = rows.filter(r => r !== WS_NEW && r.alive).length; return `${n} workspace${n === 1 ? '' : 's'} · ${a} vivo${a === 1 ? '' : 's'}`; },
       emptyHtml: 'nada coincide', emptyDetail: 'Todavía no hay workspaces. Creá uno con «nuevo workspace…» o abrí <code>lampson</code> en la carpeta de un proyecto.',
-      detail: (w) => w === WS_NEW ? wsNewForm() : `<div class="dhead"><span class="nm">${esc(w.name)}</span><span class="meta">${w.alive ? '● vivo' : '○ apagado'} · ${esc(w.policy)}</span></div>
+      detail: (w) => w === WS_NEW ? wsNewForm() : `<div class="dhead"><span class="nm">${esc(w.name)}</span><span class="meta"><b class="st ${w.alive ? 'on' : 'off'}">${w.alive ? '● vivo' : (w.paused ? '○ apagado a mano' : '○ apagado')}</b> · ${esc(w.policy)}</span></div>
         <div class="dcap">${esc(w.path)}</div>
-        <div class="ddesc">${w.schedules_on ? `${w.schedules_on} tarea${w.schedules_on === 1 ? '' : 's'} programada${w.schedules_on === 1 ? '' : 's'} encendida${w.schedules_on === 1 ? '' : 's'} (lo mantienen vivo). ` : ''}Último uso: ${esc(fmtWhen(w.last_used))}.</div>
+        <div class="ddesc">${w.schedules_on ? `${w.schedules_on} tarea${w.schedules_on === 1 ? '' : 's'} programada${w.schedules_on === 1 ? '' : 's'} encendida${w.schedules_on === 1 ? '' : 's'} ${w.alive ? '(lo mantienen vivo)' : (w.paused ? '— en pausa hasta que lo enciendas' : '')}. ` : ''}${!w.alive && w.paused ? 'Lo apagaste a mano: no se enciende solo hasta ▶ encender o abrir <code>lampson</code> en la carpeta. ' : ''}Último uso: ${esc(fmtWhen(w.last_used))}.</div>
         <div class="dacts"><button class="primary" data-open>${w.slug === WS_SLUG ? 'Ya estás acá' : 'Abrir'}</button>${w.alive ? '<button data-stop>■ apagar</button>' : '<button data-start>▶ encender</button>'}</div>
         <div class="dform" style="margin-top:14px"><label>vida <select name="policy"><option value="auto" ${w.policy === 'auto' ? 'selected' : ''}>auto — vivo mientras se use (${wsIdle === 0 ? 'nunca se apaga' : 'se apaga tras ' + wsIdle + ' h sin uso'}) o tenga tareas</option><option value="always" ${w.policy === 'always' ? 'selected' : ''}>siempre vivo</option><option value="off" ${w.policy === 'off' ? 'selected' : ''}>apagado — solo cuando lo abrís</option></select></label><span class="ds">las horas de inactividad se cambian en ⚙ → General</span></div>
         <div class="dfoot"><span>/w/${esc(w.slug)} · :${w.port} (solo loopback)</span><span class="del">quitar del registro</span></div><div class="derr"></div>`,
@@ -35,8 +36,11 @@ function openWorkspaces(selectSlug) {
         const err = (m) => { const e = box.querySelector('.derr'); if (e) e.textContent = m || ''; };
         if (w === WS_NEW) { wsNewWire(box, err); return; }
         box.querySelector('[data-open]').onclick = () => { if (w.slug !== WS_SLUG) location.href = wsUrl(w); else Panel.close(); };
-        const st = box.querySelector('[data-start]'); if (st) st.onclick = async () => { err('arrancando…'); const r = await api('/api/workspaces/start', { slug: w.slug }); err(r.data.ok ? '' : 'no respondió a tiempo'); Panel.refresh(); };
-        const sp = box.querySelector('[data-stop]'); if (sp) sp.onclick = async () => { await api('/api/workspaces/stop', { slug: w.slug }); setTimeout(() => Panel.refresh(), 800); };
+        // esperar a que el hub vea el estado nuevo (matar/arrancar un proceso tarda unos segundos): sin esto el refresco
+        // a los 0,8 s todavía mostraba «vivo» y el botón parecía no hacer nada
+        const waitFor = async (alive, secs) => { const t0 = Date.now(); while (Date.now() - t0 < secs * 1000) { await fetchWorkspaces(true); const x = wsList.find(y => y.slug === w.slug); if (x && x.alive === alive) return true; await new Promise(r => setTimeout(r, 700)); } return false; };
+        const st = box.querySelector('[data-start]'); if (st) st.onclick = async () => { st.disabled = true; st.textContent = '⟳ encendiendo…'; err(''); const r = await api('/api/workspaces/start', { slug: w.slug }); const ok = r.data.ok || await waitFor(true, 6); err(ok ? '' : 'no respondió a tiempo · mirá .lampson/ws/' + w.slug + '/.lampson/web.log'); Panel.refresh(); };
+        const sp = box.querySelector('[data-stop]'); if (sp) sp.onclick = async () => { sp.disabled = true; sp.textContent = '⟳ apagando…'; err(''); await api('/api/workspaces/stop', { slug: w.slug }); const ok = await waitFor(false, 10); if (ok && w.slug === WS_SLUG) { location.href = HUB_BASE + '/'; return; } err(ok ? '' : 'sigue respondiendo · probá de nuevo'); Panel.refresh(); };
         box.querySelector('[name="policy"]').onchange = async (ev) => { const r = await api('/api/workspaces/policy', { slug: w.slug, policy: ev.target.value }); if (!r.ok) err(r.data.error || 'error'); };
         const del = box.querySelector('.dfoot .del');
         del.onclick = () => inlineConfirm(del, `¿quitar ${w.name} del registro?`, async () => { const r = await api('/api/workspaces/remove', { slug: w.slug }); if (!r.ok) { err(r.data.error || 'error'); return; } if (w.slug === WS_SLUG) location.href = HUB_BASE + '/'; else Panel.refresh(); });

package/skills/synsema/SKILL.md

@@ -3,7 +3,7 @@ name: synsema
 description: Writing, checking, running and testing Synsema (.syn) code — syntax reflexes, capabilities, live processes / pseudo-terminals, and the runtime traps that cost hours. Load before touching any .syn file.
 ---
 
-# Synsema quick reference (v0.6.12)
+# Synsema quick reference (v0.6.13)
 
 > Curated 10 KB summary for the agent (the full reference is ~450 KB and lives in the user's editor
 > skill). Kept in sync by hand with each `synsema update`; if `synsema --version` is newer than the
@@ -14,6 +14,13 @@ description: Writing, checking, running and testing Synsema (.syn) code — synt
   `synsema test file.syn` (runs `test "..."` blocks) · `synsema serve file.syn` (HTTP server) ·
   `synsema update` (self-update; then refresh the AI skill with the command it prints).
 - Errors carry `file:line` and a suggestion. Read them; they are usually right.
+- **Read the repo without opening files (v0.6.13+)**: `synsema code outline` (project map: intent,
+  symbols, imports per file), `routes [path]` (the table each `serve` publishes: method, path, auth,
+  stream/socket/proxy, response kind, capabilities), `refs <name>` (every use, through module aliases),
+  `symbol <name>`, `caps` (declared vs. effective vs. `missing`, with the `require` to add), `check`,
+  `search <text>`, `deps`. Add `--json` for scripts. Same eight tools over MCP: `synsema code --mcp`
+  (server `synsema-code`, static — it never talks to a running server). `outline` before opening a
+  `.syn`, `refs` before renaming, `check` after every edit.
 
 ## Syntax reflexes (Python → Synsema)
 - `let x be 5` / `set x to 6` (no `=`) · `-- comment` · `when / otherwise when / otherwise` (no colons)

package/web.syn

@@ -64,6 +64,7 @@ use "./lib/schedule.syn" as schedule
 use "./lib/sched_run.syn" as sched_run
 use "./lib/approvals.syn" as approvals
 use "./lib/permission.syn" as permission
+use "./lib/term.syn" as term
 
 let APPROVAL_TIMEOUT be 180
 
@@ -86,25 +87,10 @@ task as_text(x)
         give decode(x, "utf8_lossy")
     give x
 
--- shell para el terminal web: [cmd, args]. Windows: pwsh si está, si no PowerShell 5; unix: bash de login.
--- En pwsh, los directorios de `ls` salen sin fondo azul (el default de $PSStyle se lee mal en un tema oscuro).
-task term_shell()
-    when env("OS", "") == "Windows_NT"
-        try
-            run("pwsh", ["-NoLogo", "-Command", "exit"], 10)
-            give ["pwsh", ["-NoLogo", "-NoExit", "-Command", "$PSStyle.FileInfo.Directory = $PSStyle.Foreground.BrightBlue"]]
-        recover err
-            give ["powershell", ["-NoLogo"]]
-    give ["bash", ["-l"]]
-
--- cwd del terminal: la ruta REAL del proyecto (LAMPSON_WORKSPACE), no la junction ./workspace —
--- así el prompt muestra dónde estás de verdad y coincide con el header.
-task term_cwd()
-    give env("LAMPSON_WORKSPACE", "workspace")
-
 task boot(profile, mode, ask_fn, pname, model)
     let cfg be provider.config_for(pname, model)
-    let p be when contains(agents.PROFILES, profile) then profile otherwise "build"
+    -- worker es interno de delegate: por la API tampoco se elige como perfil de sesión
+    let p be when contains(agents.names(), profile) then profile otherwise "build"
     let opts be loop.default_opts(agents.registry_for(p), agents.catalog_for(p), ask_fn)
     set opts to loop.with_steps(opts, agents.steps_for(p))
     set opts to loop.with_inbox(opts, agents.parent_inbox, "")
@@ -209,39 +195,61 @@ serve on 8080
     route "GET /w/:slug/api/tree" requires auth
         give tree.tree(6)
 
-    -- Terminal real en el navegador: un shell dentro de un pseudo-terminal (pty) por conexión WebSocket.
-    -- Navegador → servidor: texto JSON {type: "in", data: teclas} | {type: "resize", cols, rows}.
-    -- Servidor → navegador: frames de texto con prefijo: "o" + salida cruda del pty (ANSI incluido, xterm.js
-    -- la dibuja) | "c" + JSON de control ({type: hello|exit}).
-    -- El shell vive lo que vive el socket: cerrar el panel lo mata (el runtime no deja huérfanos).
+    -- Terminales del navegador. El pty NO vive en este handler: vive en un agente supervisor
+    -- (lib/term.syn), y este socket es un puente por el bus. Así la shell sobrevive a un F5 —
+    -- la pestaña se reengancha con ?id=<id> y recibe el replay de lo último que imprimió.
+    -- Navegador → servidor: {type: "in", data} | {type: "resize", cols, rows} | {type: "kill"}.
+    -- Servidor → navegador: "o" + salida cruda del pty | "c" + JSON de control (hello | exit).
+    -- Sin ningún socket enganchado por 30 min, el supervisor recoge la shell; todo muere con lampson.
     route "GET /w/:slug/api/term" requires auth
         socket
             state_set("lampson:last_used", now())
-            let sh be term_shell()
-            let p be proc_spawn(sh[0], sh[1], {"cwd": term_cwd(), "pty": true, "cols": 120, "rows": 32})
-            ws_send(socket, "c" + json_encode({"type": "hello", "shell": sh[0], "pid": proc_stats(p)["pid"], "cwd": term_cwd()}))
-            let open be true
-            while open
-                let ev be select({"ui": socket, "sh": p}, 600)
-                when ev == nothing
-                    set open to proc_status(p) == "running"
-                otherwise when ev["name"] == "ui"
-                    when ev["type"] == "close"
-                        set open to false
-                    otherwise when ev["type"] == "binary"
-                        proc_send(p, ev["data"])
+            let id be when contains(query, "id") then text(query.id) otherwise ""
+            when id == "" or not term.alive(id)
+                set id to term.start(120, 32)          -- nothing = ya hay MAX_TERMS abiertas
+            when id == nothing
+                ws_send(socket, "c" + json_encode({"type": "exit", "code": -1, "error": "too_many"}))
+            otherwise
+                let st be term.state(id)
+                ws_send(socket, "c" + json_encode({"type": "hello", "id": id, "shell": st["shell"], "pid": st["pid"], "cwd": st["cwd"]}))
+                let sub be bus_subscribe("term.out." + id)
+                -- el replay vuelve marcado con este id de socket: otra pestaña abierta no lo repite
+                let me be text(floor(now() * 1000)) + "-" + text(floor(random() * 100000))
+                term.ctl(id, {"k": "replay", "to": me})
+                while true
+                    let ev be select({"ui": socket, "sh": sub}, 20)
+                    when ev == nothing
+                        when not term.alive(id)
+                            stop
+                        term.ctl(id, {"k": "ping"})           -- «sigo acá»: sin pings se recoge la shell
+                    otherwise when ev["name"] == "ui"
+                        when ev["type"] == "close"
+                            stop
+                        otherwise when ev["type"] == "binary"
+                            term.ctl(id, {"k": "in", "d": as_text(ev["data"])})
+                        otherwise
+                            let m be json_decode(ev["data"])
+                            when m["type"] == "in"
+                                term.ctl(id, {"k": "in", "d": m["data"]})
+                            otherwise when m["type"] == "resize"
+                                term.ctl(id, {"k": "resize", "cols": m["cols"], "rows": m["rows"]})
+                            otherwise when m["type"] == "kill"
+                                term.kill(id)                  -- cerrar la pestaña SÍ mata la shell, a pedido
                     otherwise
-                        let m be json_decode(ev["data"])
-                        when m["type"] == "in"
-                            proc_send(p, m["data"])
-                        otherwise when m["type"] == "resize"
-                            proc_resize(p, floor(m["cols"]), floor(m["rows"]))
-                otherwise when ev["type"] == "exit"
-                    ws_send(socket, "c" + json_encode({"type": "exit", "code": ev["data"]["exit_code"]}))
-                    set open to false
-                otherwise
-                    ws_send(socket, "o" + as_text(ev["data"]))
-            proc_close(p)
+                        let d be ev["data"]
+                        when d["k"] == "exit"
+                            ws_send(socket, "c" + json_encode({"type": "exit", "code": d["code"]}))
+                            stop
+                        otherwise when d["k"] == "replay"
+                            when d["to"] == me and d["d"] != ""
+                                ws_send(socket, "o" + d["d"])
+                        otherwise
+                            ws_send(socket, "o" + d["d"])
+                bus_unsubscribe(sub)
+
+    -- las terminales vivas: la UI las repinta como pestañas al cargar (después de un F5 siguen ahí)
+    route "GET /w/:slug/api/terms" requires auth
+        give {"terminals": term.list(), "max": term.MAX_TERMS}
 
     route "GET /w/:slug/api/update" requires auth
         give update.check()