lampson 0.1.0

package/web.syn

@@ -0,0 +1,468 @@
+-- web.syn — Lampson por URL (chat web con SSE)
+--
+--   synsema serve web.syn            → http://127.0.0.1:8080
+--
+-- API:
+--   GET  /                       UI (public/index.html)
+--   GET  /api/sessions           lista de sesiones
+--   GET  /api/sessions/:id       historial de una sesión
+--   POST /api/chat               {session?, message, agent?} → SSE con eventos del loop y "done" al final
+--
+-- Permisos bajo web: el modo (ask|yolo|strict) viene en cada POST /api/chat (selector de la UI; default
+-- LAMPSON_PERMISSION). En "ask", una tool peligrosa emite el evento SSE `approval_request` y el loop
+-- espera (polling de state_*) hasta que la UI responda por POST /api/approve o venza el timeout → deniega.
+-- Nunca se auto-aprueba en silencio.
+--
+-- MIGAS serve: secret() y config() se resuelven DENTRO del handler (globals redactados por request);
+-- las tasks deben definirse ANTES de `serve on`; `send` solo parsea dentro de `stream`, así que
+-- el emisor de eventos se define dentro del bloque stream.
+
+intent: "Web chat for a coding agent: tools from an allow-list, least-privilege per tool, SSE progress"
+
+require serve(8080)
+require net
+require time
+require exec
+require env("LAMPSON_*")
+require env("OS")
+require secret("LAMPSON_*")
+require file("workspace")
+require file("workspace/*")
+require file.read("skills")
+require file.read("skills/*")
+require file.read("lamps")
+require file.read("lamps/*")
+require file("memory")
+require file("memory/*")
+require file(".lampson")
+require file(".lampson/*")
+
+use "./lib/provider.syn" as provider
+use "./lib/tools.syn" as tools
+use "./lib/prompt.syn" as prompt
+use "./lib/loop.syn" as loop
+use "./lib/session.syn" as session
+use "./lib/agents.syn" as agents
+use "./lib/tree.syn" as tree
+use "./lib/git.syn" as git
+use "./lib/tools/proc.syn" as proc
+use "./lib/tools/memo.syn" as memo
+use "./lib/update.syn" as update
+use "./lib/settings.syn" as settings
+use "./lib/trace.syn" as trace
+use "./lib/mcp.syn" as mcp
+use "./lib/lamps.syn" as lamps
+use "./lib/lsp.syn" as lsp
+use "./lib/tools/todo.syn" as todo
+
+let APPROVAL_TIMEOUT be 180
+
+-- Quién puede usar la API (chat con tools, terminal, matar procesos): `serve` escucha en 0.0.0.0, así que
+-- sin esto cualquiera en la LAN tendría una shell en tu proyecto. Política: SOLO loopback. Opt-in para
+-- clientes remotos: LAMPSON_WEB_TOKEN en .env + header `Authorization: Bearer <token>` (la UI web no lo
+-- manda; es para scripts). `auth with` corre ANTES del upgrade WebSocket, así que cubre /api/term.
+task check_client(token, request)
+    let ip be text(ip of request)
+    when ip == "127.0.0.1" or ip == "::1" or ip == "::ffff:127.0.0.1"
+        give {"local": true}
+    let want be env("LAMPSON_WEB_TOKEN", "")
+    when want != "" and token == want
+        give {"local": false}
+    give nothing
+
+-- salida del pty como texto (la doc de 0.6.8 ya lo dice así; is_bytes por si cambia)
+task as_text(x)
+    when is_bytes(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"
+    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, "")
+    set opts to loop.with_mode(opts, mode)
+    give {"cfg": cfg, "system": {"role": "system", "content": prompt.build(agents.env_info(cfg), agents.addendum_for(p))}, "opts": opts, "profile": p}
+
+-- Subagente en background: `agent Child` (lib/agents.syn) solo puede llamar tasks TOP-LEVEL de este
+-- programa; esta es su puerta de entrada. Bajo serve el agente sobrevive al request que lo lanzó.
+task lampson_subagent(spec_json)
+    give agents.run_child_json(spec_json)
+
+-- servers MCP: supervisores (agentes) lanzados al arrancar; los handlers leen su estado del blackboard
+mcp.start_all(8)
+
+-- marca de corrida (blackboard): session.save la estampa en meta.run; reanudar una sesión guardada por
+-- OTRA corrida dispara la nota de procesos muertos (proc.resume_note) para que el modelo no los crea vivos
+share {"id": text(now())} as "lampson:run"
+share {"kind": "web"} as "lampson:ui"
+
+serve on 8080
+    max_streams 50
+    auth with check_client
+    static "./public"
+
+    route "GET /api/sessions" requires auth
+        give {"sessions": session.list()}
+
+    route "GET /api/sessions/:id" requires auth
+        when not session.exists(params.id)
+            give not_found("session not found")
+        let doc be session.load(params.id)
+        let visible be where(doc["messages"], (m) => m["role"] != "system")
+        give {"id": doc["id"], "updated": doc["updated"], "meta": doc["meta"], "messages": visible}
+
+    route "GET /api/config" requires auth
+        let cfg be provider.config()
+        give {"provider": cfg["provider"], "model": cfg["model"], "wire": cfg["wire"], "vision": provider.supports_vision(cfg), "providers": provider.providers(), "configured": provider.configured(), "permission": lower(env("LAMPSON_PERMISSION", "ask")), "agents": agents.names(), "workspace": env("LAMPSON_WORKSPACE", "./workspace"), "profiles": agents.PROFILES}
+
+    -- proveedor/modelo por defecto y API keys → .lampson/config.json (local). La key nunca vuelve al cliente.
+    route "POST /api/settings" requires auth
+        expect body {provider: text}
+        let b be json of request
+        let name be lower(text(b["provider"]))
+        when not contains(provider.PRESETS, name)
+            give fail(400, "unknown provider " + name)
+        when contains(b, "key")
+            settings.set_key(name, text(b["key"]))
+        let model be when contains(b, "model") then trim(text(b["model"])) otherwise ""
+        settings.set_default(name, model)
+        let ncfg be provider.config_for(name, "")
+        give {"ok": true, "providers": provider.providers(), "provider": name, "model": ncfg["model"], "vision": provider.supports_vision(ncfg), "configured": provider.configured()}
+
+    route "POST /api/sessions/delete" requires auth
+        expect body {id: text}
+        let b be json of request
+        give {"result": session.delete(text(b["id"]))}
+
+    route "GET /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).
+    route "GET /api/term" requires auth
+        socket
+            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"])
+                    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)
+
+    route "GET /api/update" requires auth
+        give update.check()
+
+    route "POST /api/update" requires auth
+        give {"result": update.apply()}
+
+    route "GET /api/git" requires auth
+        give git.status()
+
+    route "GET /api/memory" requires auth
+        give {"dir": memo.dir(), "notes": memo.list()}
+
+    route "GET /api/memory/note" requires auth
+        when not contains(query, "name")
+            give fail(400, "name required")
+        give {"name": query.name, "content": memo.note_read(query.name)}
+
+    -- traza legible de una sesión (ver lib/trace.syn)
+    route "GET /api/trace" requires auth
+        when not contains(query, "session")
+            give fail(400, "session required")
+        when not matches(query.session, "[A-Za-z0-9_-]{1,40}")
+            give fail(400, "bad session id")
+        let n be when contains(query, "tail") then floor(number(query.tail)) otherwise 400
+        give {"session": query.session, "file": trace.file_of(query.session), "trace": trace.tail(query.session, n)}
+
+    -- modelos que declara la API del proveedor (para no tipear nombres a ciegas: DeepSeek es case-sensitive)
+    route "GET /api/models" requires auth
+        let pname be when contains(query, "provider") then lower(text(query.provider)) otherwise ""
+        let cfg be provider.config_for(pname, "")
+        give provider.list_models(cfg)
+
+    route "GET /api/todo" requires auth
+        -- ?session=<id> → la lista de esa sesión; sin query, la de la sesión en curso
+        when contains(query, "session") and matches(query.session, "[A-Za-z0-9_-]{1,40}")
+            give {"items": todo.load(query.session)}
+        give {"items": todo.load(nothing)}
+
+    route "GET /api/mcp" requires auth
+        give {"servers": mcp.summary(), "global": mcp.GLOBAL_CONFIG, "project": mcp.PROJECT_CONFIG}
+
+    -- conectar un server MCP desde la UI: se escribe en el mcp.json del scope y arranca su supervisor
+    route "POST /api/mcp/add" requires auth
+        expect body {name: text, command: text}
+        let b be json of request
+        let scope be when contains(b, "scope") then lower(text(b["scope"])) otherwise "global"
+        let envm be when contains(b, "env") then b["env"] otherwise {}
+        try
+            give {"ok": true, "result": mcp.add_server(text(b["name"]), text(b["command"]), envm, scope), "servers": mcp.summary()}
+        recover err
+            give fail(400, text(err))
+
+    route "POST /api/mcp/remove" requires auth
+        expect body {name: text}
+        let b be json of request
+        try
+            give {"ok": true, "result": mcp.remove_server(text(b["name"])), "servers": mcp.summary()}
+        recover err
+            give fail(400, text(err))
+
+    -- language servers (navegación semántica): listar, agregar (preset o comando propio), quitar
+    route "GET /api/lsp" requires auth
+        give {"servers": lsp.summary(), "presets": lsp.PRESETS, "global": lsp.GLOBAL_CONFIG, "project": lsp.PROJECT_CONFIG}
+
+    route "POST /api/lsp/add" requires auth
+        expect body {name: text}
+        let b be json of request
+        let scope be when contains(b, "scope") then lower(text(b["scope"])) otherwise "global"
+        let cmd be when contains(b, "command") then text(b["command"]) otherwise nothing
+        let langs be when contains(b, "languages") then b["languages"] otherwise nothing
+        try
+            give {"ok": true, "result": lsp.add_server(text(b["name"]), cmd, langs, scope), "servers": lsp.summary()}
+        recover err
+            give fail(400, text(err))
+
+    route "POST /api/lsp/remove" requires auth
+        expect body {name: text}
+        let b be json of request
+        try
+            give {"ok": true, "result": lsp.remove_server(text(b["name"])), "servers": lsp.summary()}
+        recover err
+            give fail(400, text(err))
+
+    -- lámparas (plugins de tools): listar y encender/apagar desde la barra superior de la UI
+    route "GET /api/lamps" requires auth
+        give {"lamps": lamps.summary(), "global": lamps.GLOBAL_DIR, "project": lamps.PROJECT_DIR}
+
+    -- el usuario corre una tool de una lámpara encendida él mismo (sin pasar por el modelo)
+    route "POST /api/lamps/run" requires auth
+        expect body {tool: text}
+        let b be json of request
+        let args be when contains(b, "args") then b["args"] otherwise {}
+        try
+            give {"ok": true, "output": lamps.call(text(b["tool"]), args)}
+        recover err
+            give fail(400, text(err))
+
+    route "POST /api/lamps/remove" requires auth
+        expect body {name: text}
+        let b be json of request
+        try
+            give {"ok": true, "result": lamps.remove(text(b["name"])), "lamps": lamps.summary()}
+        recover err
+            give fail(400, text(err))
+
+    route "POST /api/lamps/toggle" requires auth
+        expect body {name: text}
+        let b be json of request
+        let on be contains(b, "enabled") and b["enabled"] == true
+        try
+            give {"ok": true, "result": lamps.set_enabled(text(b["name"]), on), "lamps": lamps.summary()}
+        recover err
+            give fail(400, text(err))
+
+    route "GET /api/agents" requires auth
+        agents.prune(10, 1800)
+        give {"agents": agents.list_children()}
+
+    -- Eventos en vivo para la UI (SSE): lo que publican los supervisores de procesos (proc.<name>: líneas y
+    -- cambios de estado) y los subagentes (subagent.started|done|<id>). Un bus por programa; cada cliente
+    -- tiene su cola acotada (drop_oldest). Heartbeat cada 25 s para que el proxy/navegador no cierre.
+    route "GET /api/events" requires auth
+        stream
+            let sub be bus_subscribe(["proc.*", "subagent.*", "mcp.*"], {"max_queue": 512})
+            let open be true
+            while open
+                let ev be bus_recv(sub, 25)
+                try
+                    when ev == nothing
+                        send {"topic": "ping"} as "event"
+                    otherwise
+                        send {"topic": ev["topic"], "data": ev["data"]} as "event"
+                recover err
+                    set open to false
+            bus_unsubscribe(sub)
+
+    route "GET /api/agents/log" requires auth
+        when not contains(query, "id")
+            give fail(400, "id required")
+        when not matches(query.id, "[a-z]+-[0-9]+")
+            give fail(400, "bad id")
+        try
+            let meta be nothing
+            try
+                set meta to json_decode(read_file(agents.DIR + "/" + query.id + ".json"))
+            recover e2
+                set meta to nothing
+            give {"id": query.id, "log": read_file(agents.DIR + "/" + query.id + ".log"), "agent": meta}
+        recover err
+            give fail(404, "no such sub-agent")
+
+    route "POST /api/agents/stop" requires auth
+        expect body {id: text}
+        let b be json of request
+        when not matches(b["id"], "[a-z]+-[0-9]+")
+            give fail(400, "bad id")
+        write_file(agents.DIR + "/" + b["id"] + ".stop", "stop")
+        bus_publish("subagent." + b["id"], {"kind": "stop", "line": "stop requested from the UI"})
+        give {"result": "stop requested for " + b["id"]}
+
+    route "GET /api/proc" requires auth
+        give {"processes": proc.list()}
+
+    route "GET /api/proc/log" requires auth
+        when not contains(query, "name")
+            give fail(400, "name required")
+        let n be when contains(query, "tail") then number(query.tail) otherwise 200
+        give {"name": query.name, "running": proc.alive(query.name), "log": proc.logs(query.name, n)}
+
+    route "GET /api/ports" requires auth
+        give {"ports": proc.listeners()}
+
+    route "POST /api/ports/kill" requires auth
+        expect body {pid: number}
+        let b be json of request
+        give {"result": proc.kill_pid(b["pid"])}
+
+    route "POST /api/proc/stop" requires auth
+        expect body {name: text}
+        let b be json of request
+        give {"result": proc.halt(b["name"])}
+
+    route "GET /api/file" requires auth
+        when not contains(query, "path")
+            give fail(400, "path required")
+        give tree.file_content(query.path)
+
+    route "POST /api/approve" requires auth
+        expect body {id: text, decision: bool}
+        let b be json of request
+        state_set("approval:" + b["id"], when b["decision"] then "yes" otherwise "no")
+        give {"ok": true}
+
+    route "POST /api/chat" requires auth
+        expect body {message: text}
+        let b be json of request
+        let message be b["message"]
+        let sid be when contains(b, "session") then text(b["session"]) otherwise ""
+        let want be when contains(b, "agent") then lower(text(b["agent"])) otherwise "build"
+        let mode be when contains(b, "permission") then lower(text(b["permission"])) otherwise lower(env("LAMPSON_PERMISSION", "ask"))
+        when mode != "ask" and mode != "yolo" and mode != "strict"
+            set mode to "ask"
+        let pname be when contains(b, "provider") then lower(text(b["provider"])) otherwise ""
+        let pmodel be when contains(b, "model") then text(b["model"]) otherwise ""
+        stream
+            task emit(kind, data, tag)
+                trace.event(sid, kind, data, tag)
+                send {"kind": kind, "data": data, "tag": tag} as "event"
+            -- aprobación humana desde la UI: pregunta por SSE y espera la respuesta (o el timeout)
+            task ask_web(name, args, why)
+                let id be text(floor(now() * 1000)) + "-" + name
+                send {"kind": "approval_request", "data": {"id": id, "name": name, "args": args, "why": why, "timeout": APPROVAL_TIMEOUT}} as "event"
+                let waited be 0
+                let answer be nothing
+                while answer == nothing and waited < APPROVAL_TIMEOUT
+                    set answer to state_get("approval:" + id, nothing)
+                    when answer == nothing
+                        sleep(0.5)
+                        set waited to waited + 0.5
+                state_delete("approval:" + id)
+                let ok be answer == "yes"
+                send {"kind": "approval_result", "data": {"id": id, "approved": ok, "timeout": answer == nothing}} as "event"
+                give ok
+            let ctx be boot(want, mode, ask_web, pname, pmodel)
+            let messages be [ctx["system"]]
+            when sid != ""
+                when session.exists(sid)
+                    let prev_doc be session.load(sid)
+                    let prev be prev_doc["messages"]
+                    set messages to [ctx["system"]] + slice(prev, 1, length(prev))
+                    -- sesión guardada por otra corrida de lampson: sus procesos ya no viven — decírselo
+                    -- al modelo con el estado real (una sola vez: el próximo save re-estampa meta.run)
+                    when session.from_other_run(prev_doc)
+                        let note be proc.resume_note(sid)
+                        when note != ""
+                            set messages to append(messages, {"role": "user", "content": note})
+                            trace.event(sid, "inbox", note, "")
+                            send {"kind": "inbox", "data": note, "tag": ""} as "event"
+                otherwise
+                    set sid to ""
+            when sid == ""
+                set sid to session.new_id()
+            -- sesión actual (blackboard): la tool todo guarda su lista por sesión (lib/tools/todo.syn)
+            share {"id": sid} as "lampson:session"
+            send {"kind": "session", "data": sid} as "event"
+            send {"kind": "mode", "data": {"agent": ctx["profile"], "permission": mode, "provider": ctx["cfg"]["provider"], "model": ctx["cfg"]["model"], "has_key": ctx["cfg"]["has_key"]}} as "event"
+            when starts_with(trim(message), "!")
+                -- comando del USUARIO: sin política de permisos, salida al contexto; el modelo no interviene
+                let cmd be trim(slice(trim(message), 1, length(trim(message))))
+                let bash_tool be agents.registry_for("build")["bash"]
+                send {"kind": "tool_call", "data": {"id": "user", "name": "bash", "args": {"command": cmd}}} as "event"
+                let out be call_tool(bash_tool, {"command": cmd, "timeout": 600})
+                send {"kind": "tool_result", "data": {"call": {"id": "user", "name": "bash", "args": {"command": cmd}}, "output": out}} as "event"
+                set messages to append(messages, {"role": "user", "content": "[The user ran this command in the shell themselves]\n$ " + cmd + "\n" + tools.truncate(out, 6000)})
+                session.save(sid, messages, {"title": session.title_of(messages)})
+                send {"kind": "done", "data": {"text": "", "steps": 0, "usage": {"input": 0, "output": 0}, "stopped": "user_command", "session": sid}} as "event"
+            otherwise
+                -- imágenes pegadas en la UI: [{media_type, data(base64)}] — el cliente ya las redujo; tope 5 MB por mensaje
+                let images be []
+                when contains(b, "images")
+                    let total be 0
+                    each im in b["images"]
+                        when contains(im, "data") and contains(im, "media_type")
+                            set total to total + length(im["data"])
+                            when total <= 5000000
+                                let entry be {"media_type": text(im["media_type"]), "data": text(im["data"])}
+                                when contains(im, "w") and contains(im, "h")
+                                    set entry to {"media_type": text(im["media_type"]), "data": text(im["data"]), "w": floor(number(im["w"])), "h": floor(number(im["h"]))}
+                                set images to append(images, entry)
+                let umsg be {"role": "user", "content": message}
+                when length(images) > 0
+                    set umsg to {"role": "user", "content": message, "images": images}
+                set messages to append(messages, umsg)
+                trace.user(sid, message, ctx["profile"], mode, ctx["cfg"]["model"])
+                let result be loop.run_turn(ctx["cfg"], messages, ctx["opts"], emit)
+                trace.turn_end(sid, result)
+                session.save(sid, result["messages"], {"title": session.title_of(result["messages"])})
+                send {"kind": "done", "data": {"text": result["text"], "steps": result["steps"], "usage": result["usage"], "stopped": result["stopped"], "session": sid}} as "event"