pal-code 0.1.0__py3-none-any.whl

pal/web/app.py

@@ -0,0 +1,276 @@
+"""HTTP layer: a thin Flask app around ChatService. No business logic lives here.
+
+- create_app() is a factory, so tests and servers build their own app around their own service.
+- Errors: PalError subclasses map to their HTTP status with a safe message; anything else is
+  logged with a traceback and answered with a generic 500 (no traceback ever reaches the client).
+- API keys arrive per request and are passed straight through; they are never logged or stored.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import uuid
+from dataclasses import asdict
+from typing import Any, Optional
+
+from flask import Flask, Response, jsonify, render_template, request
+from werkzeug.exceptions import HTTPException
+
+from pal.chat import API_PROVIDERS, ChatService
+from pal.chat.demo import Demo
+from pal.chat.sessions import validate_session_id
+from pal.chat.uploads import (  # noqa: F401  (read_upload is part of this module's API)
+    MEDIA_TYPES,
+    _clean_filename,
+    _is_text,
+    read_upload,
+)
+from pal.config import Settings
+from pal.errors import NotFoundError, PalError, UserInputError
+from pal.input_savers.components.methods import METHODS
+from pal.llm_wrapper.modes import default_mode, describe_modes
+from pal.sdk.agent import list_agents
+
+log = logging.getLogger(__name__)
+
+_SECURITY_HEADERS = {
+    "X-Content-Type-Options": "nosniff",
+    "X-Frame-Options": "DENY",
+    "Referrer-Policy": "no-referrer",
+    "Cache-Control": "no-store",
+}
+
+
+def _saver_json(res) -> Optional[dict]:
+    if res is None:  # turn handled without an API call: no input saver ran
+        return None
+    return {
+        "original": res.original, "reduced": res.reduced,
+        "tokens_original": res.tokens_original, "tokens_reduced": res.tokens_reduced,
+        "tokens_saved": res.tokens_saved,
+        "steps": [asdict(s) for s in res.steps],
+    }
+
+
+def _flag(v: Any) -> bool:
+    return v is True or str(v).lower() in ("1", "true", "on", "yes")
+
+
+def _pasted(v: Any) -> list:
+    """Pasted spans the client tracked; the LLM never sees or edits them."""
+    if isinstance(v, list):
+        return [x for x in v if isinstance(x, str)]
+    try:
+        out = json.loads(v or "[]")
+    except ValueError:
+        return []
+    return [x for x in out if isinstance(x, str)] if isinstance(out, list) else []
+
+
+def create_app(service: Optional[ChatService] = None, settings: Optional[Settings] = None, studio: Optional[dict] = None) -> Flask:
+    """`studio` passes options to the Studio (its planner model, builder model and model discovery); tests use it to plug in fakes."""
+    service = service or ChatService(settings)
+    cfg = service.settings
+    app = Flask(__name__)
+    app.config["MAX_CONTENT_LENGTH"] = cfg.server.max_upload_mb * 1024 * 1024
+    app.extensions["pal_service"] = service
+    demo = Demo(service)
+
+    @app.after_request
+    def _headers(resp: Response) -> Response:
+        for k, v in _SECURITY_HEADERS.items():
+            resp.headers.setdefault(k, v)
+        return resp
+
+    @app.errorhandler(PalError)
+    def _pal_error(e: PalError):
+        if e.http_status >= 500:
+            log.error("request failed: %s: %s", type(e).__name__, e)
+        msg = str(e) if e.public else "internal error"
+        return jsonify({"error": msg, "code": type(e).__name__}), e.http_status
+
+    @app.errorhandler(HTTPException)
+    def _http_error(e: HTTPException):
+        msg = "upload too large" if e.code == 413 else (e.description or e.name)
+        return jsonify({"error": msg, "code": e.name.replace(" ", "")}), e.code or 500
+
+    @app.errorhandler(Exception)
+    def _unexpected(e: Exception):
+        log.exception("unhandled error")
+        return jsonify({"error": "internal error", "code": "InternalError"}), 500
+
+    @app.get("/")
+    def index():
+        return render_template("index.html")
+
+    @app.get("/healthz")
+    def healthz():
+        return jsonify({"ok": True})
+
+    @app.get("/api/config")
+    def config():
+        return jsonify({
+            "providers": {p: bool(os.environ.get(env)) for p, env in API_PROVIDERS.items()},
+            "llm_modes": describe_modes(), "llm_mode": default_mode(),
+            "methods": [{"id": m, "name": METHODS[m].name} for m in cfg.input_methods],
+            "local_llm": {k: v for k, v in cfg.local_llm.items() if k != "api_key"},
+            "mode": cfg.input_mode,
+            "routing": {"enabled": cfg.task_routing.enabled, "default": cfg.task_routing.default},
+            "graph": {"enabled": service.graph.enabled, "available": service.graph.available()},
+            "memory": {"enabled": cfg.memory.enabled},
+            "agents": list_agents(service.agents) if cfg.agents.enabled else [],
+            "metrics": {"enabled": cfg.metrics.enabled},
+        })
+
+    @app.get("/api/llm/modes")
+    def llm_modes():
+        return jsonify({"default": default_mode(), "modes": describe_modes()})
+
+    @app.get("/api/llm/models")
+    def llm_models():
+        """OpenRouter's models for the Explore mode: ?q=words&free=1&limit=50."""
+        try:
+            limit = max(1, min(int(request.args.get("limit", "50")), 500))
+        except ValueError:
+            raise UserInputError("limit must be a number") from None
+        free = request.args.get("free", "").lower() in ("1", "true", "yes")
+        return jsonify({"models": service.model_catalogue(request.args.get("q", ""), free, limit)})
+
+    @app.get("/api/voice")
+    def voice_status():
+        """Which speech-to-text engines this server has: the page records and sends the audio here when there is one."""
+        from pal.terminal import voice
+        return jsonify({"engines": voice.engines()})
+
+    @app.post("/api/transcribe")
+    def transcribe():
+        """The recorded audio (the request body, as the browser's MediaRecorder made it) -> text. Nothing is kept."""
+        from pal.terminal import voice
+        audio = request.get_data(cache=False)
+        if not audio:
+            raise UserInputError("no audio received")
+        kind = (request.content_type or "").split(";")[0]
+        suffix = {"audio/webm": ".webm", "audio/ogg": ".ogg", "audio/mp4": ".m4a", "audio/mpeg": ".mp3", "audio/wav": ".wav", "audio/x-wav": ".wav"}.get(kind, ".webm")
+        try:
+            heard = voice.transcribe(audio, suffix)
+        except voice.VoiceUnavailable as e:
+            raise UserInputError(str(e)) from None
+        return jsonify({"text": heard.text, "engine": heard.engine})
+
+    @app.get("/api/local_status")
+    def local_status():
+        return jsonify(service.local_status())
+
+    @app.post("/api/chat")
+    def chat():
+        d: dict[str, Any]
+        if request.is_json:
+            d, files = request.get_json(silent=True) or {}, []
+        else:
+            d = dict(request.form.to_dict())
+            if "methods" in request.form:
+                d["methods"] = request.form.getlist("methods")
+            files = request.files.getlist("files")
+        sid = d.get("session_id") or uuid.uuid4().hex
+        attachments, errors = [], []
+        for f in files:
+            try:
+                attachments.append(read_upload(service, f, sid))
+            except UserInputError as e:
+                errors.append(str(e))
+        message = d.get("message") or ""
+        if errors and not (message.strip() or attachments):
+            return jsonify({"error": "; ".join(errors)}), 400
+        res = service.send(
+            sid, d.get("provider", ""), d.get("model", ""), d.get("api_key") or None, message, attachments,
+            d.get("methods"), d.get("mode") or None, _pasted(d.get("pasted")), d.get("route") or None,
+            agent=d.get("agent") or None)
+        return jsonify({
+            "reply": res.reply, "sent": res.sent,
+            "input_tokens": res.input_tokens, "output_tokens": res.output_tokens,
+            "saver": _saver_json(res.saver), "file_errors": errors,
+            "handled_by": res.handled_by, "route_reason": res.route_reason,
+            "graph": res.graph, "documents": res.documents, "memory": res.memory,
+            "context": res.context, "tools": res.tools, "latency": res.latency, "fallback": res.fallback,
+            "cost_usd": res.cost_usd, "files": res.files,
+        })
+
+    @app.post("/api/experiment")
+    def experiment():
+        d = request.get_json(silent=True) or {}
+        if not (d.get("text") or "").strip():
+            raise UserInputError("enter some text")
+        out = service.experiment(
+            d["text"], d.get("methods"), d.get("provider", ""), d.get("model", ""), d.get("api_key") or None,
+            _flag(d.get("call_api")), d.get("mode") or None, _pasted(d.get("pasted")))
+        return jsonify({"saver": _saver_json(out["saver"]), "counter": out["counter"], "api": out["api"]})
+
+    @app.post("/api/reset")
+    def reset():
+        service.reset((request.get_json(silent=True) or {}).get("session_id", ""))
+        return jsonify({"ok": True})
+
+    @app.get("/api/workspace")
+    def workspace_list():
+        """Files an agent saved for this session (its workspace in the OS kernel interface)."""
+        sess = _session_or_404(request.args.get("session_id", ""))
+        return jsonify({"files": service.os_kernel.workspace(sess.agent_id).list()})
+
+    @app.get("/api/workspace/file")
+    def workspace_file():
+        sess = _session_or_404(request.args.get("session_id", ""))
+        path = request.args.get("path", "")
+        data = service.os_kernel.workspace(sess.agent_id).read_bytes(path)   # validated: inside this session's workspace only
+        ext = "." + path.rsplit(".", 1)[1].lower() if "." in path else ""
+        mime = MEDIA_TYPES.get(ext, "text/plain" if _is_text(data) else "application/octet-stream")
+        name = re.sub(r"[^A-Za-z0-9._-]", "_", path.rsplit("/", 1)[-1]) or "file.txt"
+        return Response(data, mimetype=mime, headers={"Content-Disposition": f'attachment; filename="{name}"'})
+
+    def _session_or_404(session_id: str):
+        validate_session_id(session_id)                                     # a malformed id is a 400
+        sess = service.sessions.get(session_id)
+        if sess is None:
+            raise NotFoundError("no such session")
+        return sess
+
+    @app.get("/api/metrics")
+    def metrics():
+        sid = request.args.get("session") or None
+        return jsonify({"summary": service.metrics.chat_summary(sid), "recent": service.metrics.turns()[-30:],
+                        "scheduler": service.scheduler.snapshot(), "memory": service.metrics.memory.snapshot()})
+
+    @app.post("/api/metrics/reset")
+    def metrics_reset():
+        service.metrics.reset()
+        return jsonify({"ok": True})
+
+    @app.post("/api/demo/start")
+    def demo_start():
+        d = request.get_json(silent=True) or {}
+        return jsonify(demo.start(d.get("provider", ""), d.get("model", ""), d.get("api_key") or None))
+
+    @app.post("/api/demo/step")
+    def demo_step():
+        d = request.get_json(silent=True) or {}
+        return jsonify(demo.step(d.get("run_id", ""), d.get("api_key") or None))
+
+    @app.post("/api/demo/cancel")
+    def demo_cancel():
+        demo.cancel((request.get_json(silent=True) or {}).get("run_id", ""))
+        return jsonify({"ok": True})
+
+    from pal.studio.routes import register_studio
+    register_studio(app, service, **(studio or {}))         # the Studio: describe a product, review the plan, watch it being built
+
+    @app.get("/api/memory")
+    def memory_status():
+        return jsonify({"enabled": cfg.memory.enabled, "notes": service.memory_count() if cfg.memory.enabled else 0,
+                        "stats": service.notes.stats() if cfg.memory.enabled else None})
+
+    @app.delete("/api/memory")
+    def memory_clear():
+        return jsonify({"cleared": service.clear_memory() if cfg.memory.enabled else 0})
+
+    return app

pal/web/static/editor.js

@@ -0,0 +1,219 @@
+/* Pal editor: open a finished build as a project. File list, tabs, a code pane with line numbers, and "Ask Pal" on the right: Pal proposes a change as a diff,
+   you accept or reject it. Every request goes through the token-saving client on the server, and the panel shows what it cost.
+   Everything a model or a file contains is shown with textContent (or as a textarea's value), never as HTML. */
+(() => {
+'use strict';
+const $ = (id) => document.getElementById(id);
+const wait = () => new Promise((r) => { const t = setInterval(() => { if (window.studio && window.studio.util) { clearInterval(t); r(window.studio); } }, 20); });
+
+wait().then((studio) => {
+const { h, api, post, n } = studio.util;
+const E = { run: null, arm: '', files: [], tabs: [], cur: '', buf: {}, proposal: null, busy: false, ctl: null, seq: 0 };
+
+const has = () => !!E.run;
+const dirty = (p) => E.buf[p] && E.buf[p].text !== E.buf[p].orig;
+const say = (text, cls = '') => { const m = h('div', { class: 'edmsg ' + cls, text }); $('edmsgs').append(m); $('edmsgs').scrollTop = $('edmsgs').scrollHeight; return m; };
+const status = (t, bad = false) => { const s = $('edstatus'); s.textContent = t; s.classList.toggle('bad', bad); };
+const armQ = () => `arm=${encodeURIComponent(E.arm)}`;
+
+function renderFiles() {
+  $('edfiles').replaceChildren(...E.files.map((f) => h('li', {}, h('button', { type: 'button', class: f.path === E.cur ? 'active' : '', 'data-file': f.path },
+    h('span', { class: 'fname', text: f.path }), dirty(f.path) ? h('span', { class: 'dotmark', text: '●', title: 'Unsaved changes' }) : null))));
+}
+function renderTabs() {
+  $('edtabs').replaceChildren(...E.tabs.map((p) => h('div', { class: 'edtab' + (p === E.cur ? ' active' : '') },
+    h('button', { type: 'button', class: 'edtabname', 'data-tab': p, text: p.split('/').pop() + (dirty(p) ? ' ●' : ''), title: p }),
+    h('button', { type: 'button', class: 'edtabx', 'data-close': p, 'aria-label': 'Close ' + p, text: '×' }))));
+}
+function gutter() {
+  const code = $('edcode'), lines = code.value.split('\n').length;
+  $('edgutter').textContent = Array.from({ length: lines }, (_, i) => i + 1).join('\n');
+  $('edgutter').scrollTop = code.scrollTop;
+}
+function caret() {
+  const code = $('edcode'), before = code.value.slice(0, code.selectionStart).split('\n');
+  $('edpos').textContent = `Ln ${before.length}, Col ${before[before.length - 1].length + 1}`;
+}
+function show() {
+  const p = E.cur, b = E.buf[p];
+  $('edcode').hidden = !p; $('edgutter').hidden = !p; $('edempty').hidden = !!p;
+  if (!p) { $('edpath').textContent = ''; $('edsave').disabled = true; renderFiles(); renderTabs(); return; }
+  $('edcode').value = b.text;
+  $('edcode').readOnly = !!b.readonly || E.busy;
+  $('edpath').textContent = p + (b.readonly ? ' (too large to edit here)' : '');
+  $('edsave').disabled = !dirty(p) || !!b.readonly;
+  gutter(); caret(); renderFiles(); renderTabs();
+  status(dirty(p) ? 'Unsaved changes' : 'Saved');
+}
+async function openFile(p) {
+  if (!E.buf[p]) {
+    const d = await api(`/api/studio/run/${E.run}/file?${armQ()}&path=${encodeURIComponent(p)}&full=1`);
+    E.buf[p] = { text: d.content, orig: d.content, readonly: d.truncated };
+  }
+  if (!E.tabs.includes(p)) E.tabs.push(p);
+  E.cur = p;
+  show();
+}
+function closeTab(p) {
+  if (dirty(p) && !window.confirm(`Close ${p} and lose the unsaved changes?`)) return;
+  const i = E.tabs.indexOf(p);
+  E.tabs.splice(i, 1);
+  delete E.buf[p];
+  if (E.cur === p) E.cur = E.tabs[Math.min(i, E.tabs.length - 1)] || '';
+  if (E.cur) openFile(E.cur); else show();
+}
+async function refreshFiles() {
+  const d = await api(`/api/studio/run/${E.run}/files?${armQ()}`);
+  E.files = d.files;
+  renderFiles();
+}
+async function save(p = E.cur) {
+  const b = E.buf[p];
+  if (!b || !dirty(p) || b.readonly) return true;
+  try {
+    const d = await api(`/api/studio/run/${E.run}/file`, { method: 'PUT', body: JSON.stringify({ arm: E.arm, path: p, content: b.text }) });
+    b.orig = b.text;
+    await refreshFiles();
+    status(d.saved_to_disk ? 'Saved' : 'Saved (this build was a dry run, so it lives in this session only)');
+    if (p === E.cur) { $('edsave').disabled = true; renderTabs(); }
+    return true;
+  } catch (e) { status('Could not save: ' + e.message, true); return false; }
+}
+async function saveAll() { for (const p of Object.keys(E.buf)) if (!(await save(p))) return false; return true; }
+
+// ---------------------------------------------------------------- Ask Pal
+function meter(session) {
+  const m = $('edmeter');
+  if (!session || !session.asks) { m.textContent = 'Each request goes through the token-saving layer.'; return; }
+  m.replaceChildren(h('b', { text: n(session.pal_tokens) }), ` tokens used over ${session.asks} request${session.asks > 1 ? 's' : ''}. A plain chat that resends the project would use about `,
+    h('b', { text: n(session.plain_estimate) }), session.saved_pct > 0 ? ` (${session.saved_pct}% saved, estimated).` : '. Pal has not saved tokens yet: it pays off as the project and the conversation grow.');
+}
+function renderProposal(pr) {
+  E.proposal = pr;
+  const box = $('eddiff');
+  box.hidden = !pr;
+  $('edcode').hidden = !!pr || !E.cur; $('edgutter').hidden = !!pr || !E.cur; $('edempty').hidden = !!pr || !!E.cur;
+  if (!pr) { box.replaceChildren(); return; }
+  const parts = pr.files.map((f) => h('section', { class: 'dfile' },
+    h('div', { class: 'dhead' }, h('b', { text: f.path }), f.new ? ' (new file)' : ''),
+    h('pre', { class: 'dlines' }, ...f.diff.map(([t, x]) => h('span', { class: 'dl d-' + t, text: (t === 'add' ? '+ ' : t === 'del' ? '- ' : t === 'hunk' ? '' : '  ') + x + '\n' })))));
+  box.replaceChildren(h('div', { class: 'dbar' }, h('span', { text: `Pal suggests changing ${pr.files.length} file${pr.files.length > 1 ? 's' : ''}` }),
+    h('span', { class: 'sp' }), h('button', { type: 'button', class: 'btn', id: 'edreject', text: 'Reject' }), h('button', { type: 'button', class: 'btn primary', id: 'edaccept', text: 'Accept' })), ...parts);
+}
+async function accept() {
+  const pr = E.proposal;
+  if (!pr) return;
+  try {
+    for (const f of pr.files) {
+      await api(`/api/studio/run/${E.run}/file`, { method: 'PUT', body: JSON.stringify({ arm: E.arm, path: f.path, content: f.content }) });
+      if (E.buf[f.path]) E.buf[f.path] = { text: f.content, orig: f.content, readonly: false };
+    }
+    await refreshFiles();
+    say(`Applied to ${pr.files.map((f) => f.path).join(', ')}.`, 'ok');
+    renderProposal(null);
+    const first = pr.files[0].path;
+    if (!E.tabs.includes(first)) await openFile(first); else show();
+  } catch (e) { say('Could not apply the change: ' + e.message, 'bad'); }
+}
+function reject() { renderProposal(null); say('Rejected. Nothing changed.'); show(); }
+function busy(b) { E.busy = b; $('edsend').disabled = b || !$('edask').value.trim(); $('edask').disabled = b; $('edcode').readOnly = b || !!(E.cur && E.buf[E.cur].readonly); $('edstop').hidden = !b; }
+async function ask(text) {
+  if (E.busy || !text) return;
+  if (E.proposal) renderProposal(null);
+  say(text, 'me');
+  busy(true);
+  if (!(await saveAll())) { say('Fix the save problem first, then ask again.', 'bad'); busy(false); return; }
+  const pending = say('Pal is reading the project...', 'wait');
+  const mine = ++E.seq;
+  E.ctl = new AbortController();
+  try {
+    const d = await post(`/api/studio/run/${E.run}/ask`, { arm: E.arm, path: E.cur, instruction: text, api_key: studio.state.apiKey || undefined }, E.ctl.signal);
+    if (mine !== E.seq) return;
+    pending.remove();
+    if (d.message) say(d.message);
+    d.refused.forEach((r) => say(`Refused ${r.path}: ${r.reason}`, 'bad'));
+    if (d.note) say(d.note);
+    const u = d.usage;
+    say(`Read ${n(u.prompt_tokens)} tokens, wrote ${n(u.completion_tokens)}${u.helper_tokens ? `, helper ${n(u.helper_tokens)}` : ''} in ${u.seconds}s. A plain chat would have read about ${n(u.plain_estimate - u.completion_tokens)}.`, 'meta');
+    meter(d.session);
+    if (d.files.length) renderProposal(d); else if (!d.message) say('Pal did not suggest any change.');
+  } catch (e) {
+    if (mine !== E.seq) return;
+    pending.remove();
+    say(e.name === 'AbortError' ? 'Stopped.' : 'Something went wrong: ' + e.message, 'bad');
+  } finally { if (mine === E.seq) busy(false); }
+}
+
+// ---------------------------------------------------------------- opening and closing the editor
+function pickArm(R) {
+  const arms = Object.entries((R.summary || {}).arms || {}).filter(([, a]) => a.files > 0).map(([k]) => k);
+  return arms.includes('pal') ? 'pal' : arms[arms.length - 1] || '';
+}
+studio.editorArm = pickArm;
+async function open(R) {
+  const arm = pickArm(R);
+  if (!arm) return;
+  if (E.run !== R.id || E.arm !== arm) {
+    Object.assign(E, { run: R.id, arm, files: [], tabs: [], cur: '', buf: {}, proposal: null });
+    $('edmsgs').replaceChildren();
+    say('Ask me to change the open file, add a feature, or explain the code. I will show you the change first, and nothing is saved until you accept it.');
+    meter(null);
+    renderProposal(null);
+    $('eddownload').href = `/api/studio/run/${R.id}/download?arm=${encodeURIComponent(arm)}`;
+  }
+  document.querySelector('.mainwrap').hidden = true;
+  $('editor').hidden = false;
+  $('viewchat').classList.remove('active'); $('vieweditor').classList.add('active');
+  $('side').classList.remove('open');
+  await refreshFiles();
+  const first = E.cur || (['index.html', 'main.py', 'readme.md'].map((w) => E.files.find((f) => f.path.toLowerCase() === w)).find(Boolean) || E.files[0] || {}).path || '';
+  if (first) await openFile(first); else show();
+}
+function close() {
+  $('editor').hidden = true;
+  document.querySelector('.mainwrap').hidden = false;
+  $('vieweditor').classList.remove('active'); $('viewchat').classList.add('active');
+}
+studio.openEditor = open;
+
+$('viewchat').addEventListener('click', close);
+$('vieweditor').addEventListener('click', () => { const R = studio.state.runs.slice().reverse().find((r) => pickArm(r)); if (R) open(R); });
+$('edfiles').addEventListener('click', (e) => { const b = e.target.closest('button[data-file]'); if (b && !E.busy) openFile(b.dataset.file); });
+$('edtabs').addEventListener('click', (e) => {
+  const c = e.target.closest('button[data-close]'), t = e.target.closest('button[data-tab]');
+  if (c) closeTab(c.dataset.close); else if (t) openFile(t.dataset.tab);
+});
+$('edcode').addEventListener('input', () => { const b = E.buf[E.cur]; if (!b) return; b.text = $('edcode').value; $('edsave').disabled = !dirty(E.cur); status(dirty(E.cur) ? 'Unsaved changes' : 'Saved'); gutter(); renderTabs(); renderFiles(); });
+$('edcode').addEventListener('scroll', () => { $('edgutter').scrollTop = $('edcode').scrollTop; });
+['keyup', 'click'].forEach((ev) => $('edcode').addEventListener(ev, caret));
+$('edcode').addEventListener('keydown', (e) => {
+  if (e.key === 'Tab' && !e.shiftKey) {                       // a code editor keeps the focus and inserts two spaces
+    e.preventDefault();
+    const c = $('edcode'), a = c.selectionStart;
+    c.setRangeText('  ', a, c.selectionEnd, 'end');
+    c.dispatchEvent(new Event('input'));
+  }
+});
+$('editor').addEventListener('keydown', (e) => { if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 's') { e.preventDefault(); save(); } });
+$('edsave').addEventListener('click', () => save());
+$('eddiff').addEventListener('click', (e) => { if (e.target.closest('#edaccept')) accept(); else if (e.target.closest('#edreject')) reject(); });
+$('edform').addEventListener('submit', (e) => { e.preventDefault(); const t = $('edask').value.trim(); $('edask').value = ''; ask(t); });
+$('edask').addEventListener('input', () => { $('edsend').disabled = E.busy || !$('edask').value.trim(); });
+$('edask').addEventListener('keydown', (e) => { if (e.key === 'Enter' && !e.shiftKey && !e.isComposing) { e.preventDefault(); $('edform').requestSubmit(); } });
+$('edstop').addEventListener('click', () => { if (E.ctl) E.ctl.abort(); });
+$('ednew').addEventListener('submit', async (e) => {
+  e.preventDefault();
+  const name = $('ednewname').value.trim();
+  if (!name || !has()) return;
+  try {
+    await api(`/api/studio/run/${E.run}/file`, { method: 'PUT', body: JSON.stringify({ arm: E.arm, path: name, content: '' }) });
+    $('ednewname').value = '';
+    await refreshFiles();
+    const f = E.files.find((x) => x.path.toLowerCase() === name.toLowerCase().replace(/\\/g, '/'));
+    await openFile(f ? f.path : name);
+  } catch (err) { status('Could not create the file: ' + err.message, true); }
+});
+window.addEventListener('beforeunload', (e) => { if (Object.keys(E.buf).some(dirty)) { e.preventDefault(); e.returnValue = ''; } });
+studio.editor = E;
+});
+})();

pal/web/static/fonts/LICENSE-Inter.txt

@@ -0,0 +1,3 @@
+Inter, Copyright 2016-2023 The Inter Project Authors (https://github.com/rsms/inter).
+Licensed under the SIL Open Font License, Version 1.1 (https://openfontlicense.org).
+These files are a Latin subset of the unmodified design, converted to WOFF2.

pal/web/static/inter.css

@@ -0,0 +1,5 @@
+/* Inter (https://rsms.me/inter), SIL Open Font License 1.1: Latin subset, served from this app so no page loads anything from another site. */
+@font-face{font-family:"Inter";font-style:normal;font-weight:400;font-display:swap;src:url("/static/fonts/inter-400.woff2") format("woff2")}
+@font-face{font-family:"Inter";font-style:normal;font-weight:500;font-display:swap;src:url("/static/fonts/inter-500.woff2") format("woff2")}
+@font-face{font-family:"Inter";font-style:normal;font-weight:600;font-display:swap;src:url("/static/fonts/inter-600.woff2") format("woff2")}
+@font-face{font-family:"Inter";font-style:normal;font-weight:700;font-display:swap;src:url("/static/fonts/inter-700.woff2") format("woff2")}