lampson 0.2.8 → 0.2.10

package/lib/tools/proc.syn

@@ -38,7 +38,7 @@ task path(name, ext)
     give DIR + "/" + name + "." + ext
 
 task tail_lines(content, n)
-    let lines be split(replace_text(content, "\r", ""), "\n")
+    let lines be split(replace(content, "\r", ""), "\n")
     when length(lines) > n
         set lines to slice(lines, length(lines) - n, length(lines))
     give join(lines, "\n")
@@ -211,7 +211,7 @@ export task resume_note(sid)
     give "[harness] This session was resumed after a lampson restart. Managed processes do NOT survive a restart — anything this conversation started earlier is gone unless listed as running below. Current real state:\n" + join(lines, "\n") + "\nOld logs remain in " + DIR + "/<name>.log. Start a process again with the `process` tool only if it is needed now; do not assume any server is up."
 
 task first_line_of(s)
-    let t be replace_text(text(s), "\r", "")
+    let t be replace(text(s), "\r", "")
     give split(t, "\n")[0]
 
 -- {run, session} actuales (blackboard "lampson:run" / "lampson:session"; vacíos fuera de un entry)
@@ -246,43 +246,61 @@ export task list()
         give []
     give out
 
--- Puertos TCP en escucha (cualquier proceso, gestionado o no): [{port, pid, name, command}] — via proc.sh ports
--- (Windows: netstat+tasklist · Linux: ss · macOS: lsof). Un servidor huérfano no aparece en list(); acá sí.
-export task listeners()
+-- Todos los puertos TCP en escucha con su dueño, en crudo: [{port, pid, name}] — UNA llamada a proc.sh ports
+-- (Windows: netstat+tasklist · Linux: ss · macOS: lsof), sin filtrar y sin la línea de comando. Para encontrar y
+-- parar los procesos de Lampson por su puerto (lib/workspaces.syn): el edge de --domain escucha en :443.
+export task port_owners()
     require exec
     require env("LAMPSON_*")
     require env("OS")
-    require file(".lampson")
-    require file(".lampson/*")
     let out be []
     try
         let r be run(shell(), ["lib/tools/proc.sh", "ports"], 20, {"cwd": "."})
-        let seen be {}
-        each line in split(replace_text(r["stdout"], "\r", ""), "\n")
+        each line in split(replace(r["stdout"], "\r", ""), "\n")
             let parts be where(split(trim(line), " "), (x) => x != "")
-            when length(parts) >= 2
-                let port be floor(number(parts[0]))
-                let nm be when length(parts) >= 3 then parts[2] otherwise "?"
-                when port >= 1024 and port < 49152 and not contains(SYSTEM_PROCS, lower(nm)) and not contains(seen, text(port))
-                    set seen[text(port)] to true
-                    set out to append(out, {"port": port, "pid": floor(number(parts[1])), "name": nm, "command": ""})
+            when length(parts) >= 2 and matches(parts[0], "[0-9]+") and matches(parts[1], "[0-9]+")
+                set out to append(out, {"port": floor(number(parts[0])), "pid": floor(number(parts[1])), "name": when length(parts) >= 3 then parts[2] otherwise "?"})
     recover err
         give out
+    give out
+
+-- Puertos TCP en escucha que le interesan al usuario y al agente (panel «Puertos», tool process): sin los del
+-- sistema ni los efímeros, uno por puerto, con la línea de comando: [{port, pid, name, command}]. Un servidor
+-- huérfano no aparece en list(); acá sí.
+export task listeners()
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file(".lampson")
+    require file(".lampson/*")
+    let out be []
+    let seen be {}
+    each l in port_owners()
+        when l["port"] >= 1024 and l["port"] < 49152 and not contains(SYSTEM_PROCS, lower(l["name"])) and not contains(seen, text(l["port"]))
+            set seen[text(l["port"])] to true
+            set out to append(out, {"port": l["port"], "pid": l["pid"], "name": l["name"], "command": ""})
     -- la línea de comando dice QUÉ es (next dev, un MCP server de otra herramienta, synsema serve…); un run por pid
     let cmds be {}
     let enriched be []
     each l in out
         let key be text(l["pid"])
         when not contains(cmds, key)
-            try
-                let r be run(shell(), ["lib/tools/proc.sh", "info", key], 15, {"cwd": "."})
-                set cmds[key] to trim(replace_text(r["stdout"], "\n", " "))
-            recover err
-                set cmds[key] to ""
+            set cmds[key] to command_of(l["pid"])
         set l["command"] to when length(cmds[key]) > 300 then slice(cmds[key], 0, 300) + "…" otherwise cmds[key]
         set enriched to append(enriched, l)
     give sort_by(enriched, (x) => x["port"])
 
+-- la línea de comando de un pid ("" si no se puede saber) — via proc.sh info
+export task command_of(pid)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    try
+        let r be run(shell(), ["lib/tools/proc.sh", "info", text(floor(pid))], 15, {"cwd": "."})
+        give trim(replace(r["stdout"], "\n", " "))
+    recover err
+        give ""
+
 -- matar un pid ajeno (huérfano de otra herramienta): taskkill /T o kill_tree, via proc.sh
 export task kill_pid(pid)
     require exec

package/lib/tools/qr.js

@@ -0,0 +1,26 @@
+// qr.js <texto> — dibuja un QR en la terminal (lampson --pair): medio bloque por fila de módulos (▀ ▄ █), con
+// colores FORZADOS (negro sobre blanco) para que la cámara lo lea igual con tema claro u oscuro. Usa la misma
+// librería que el QR de la web (public/vendor/qrcode.js).
+const path = require('path');
+const qrcode = require(path.join(__dirname, '..', '..', 'public', 'vendor', 'qrcode.js'));
+
+const text = process.argv[2];
+if (!text) { console.error('uso: node qr.js <texto>'); process.exit(2); }
+const qr = qrcode(0, 'M');
+qr.addData(text);
+qr.make();
+
+const n = qr.getModuleCount();
+const quiet = 3; // margen claro alrededor (la cámara lo necesita para encontrar el código)
+const dark = (r, c) => r >= 0 && c >= 0 && r < n && c < n && qr.isDark(r, c);
+const ON = '\x1b[30;107m', OFF = '\x1b[0m'; // texto negro, fondo blanco brillante
+const lines = [];
+for (let r = -quiet; r < n + quiet; r += 2) {
+  let line = '  ' + ON;
+  for (let c = -quiet; c < n + quiet; c++) {
+    const top = dark(r, c), bottom = dark(r + 1, c);
+    line += top && bottom ? '█' : top ? '▀' : bottom ? '▄' : ' ';
+  }
+  lines.push(line + OFF);
+}
+process.stdout.write(lines.join('\n') + '\n');

package/lib/tools/url.syn

@@ -25,7 +25,7 @@ export task parse(raw)
         give fail("missing URL")
     let u be trim(text(raw))
     -- "https:// host" — el modelo a veces mete un espacio tras el esquema (hermes normalize_url_for_request)
-    set u to replace_re(u, "^([A-Za-z][A-Za-z0-9+.-]*://)\\s+", "\\1")
+    set u to regex_replace(u, "^([A-Za-z][A-Za-z0-9+.-]*://)\\s+", "\\1")
     when u == ""
         give fail("missing URL")
     when length(u) > 2048
@@ -138,14 +138,14 @@ export task host_class(host)
 -- %XX → carácter (para inspeccionar una URL con secretos codificados)
 task percent_decode(s)
     let out be s
-    each m in find_all(s, "%[0-9A-Fa-f]{2}")
+    each m in regex_find_all(s, "%[0-9A-Fa-f]{2}")
         let ch be nothing
         try
             set ch to json_decode("\"\\u00" + slice(m, 1, 3) + "\"")
         recover e
             set ch to nothing
         when ch != nothing
-            set out to replace_text(out, m, ch)
+            set out to replace(out, m, ch)
     give out
 
 export task sensitive(raw)
@@ -153,7 +153,7 @@ export task sensitive(raw)
         give nothing
     let u be text(raw)
     let decoded be percent_decode(u)
-    when length(find_all(u, SECRET_RE)) > 0 or length(find_all(decoded, SECRET_RE)) > 0
+    when length(regex_find_all(u, SECRET_RE)) > 0 or length(regex_find_all(decoded, SECRET_RE)) > 0
         give "an API key or token"
     let p be parse(u)
     when not p["ok"]
@@ -212,7 +212,7 @@ export task resolve(base, href)
 
 -- nombre de archivo estable para la caché/spill de una URL: fetch-<host>-<digest>
 export task slug(host)
-    let s be replace_re(lower(text(host)), "[^a-z0-9._-]", "-")
+    let s be regex_replace(lower(text(host)), "[^a-z0-9._-]", "-")
     when length(s) > 60
         set s to slice(s, 0, 60)
     when s == ""

package/lib/tools.syn

@@ -29,6 +29,26 @@ use "./mcp.syn" as mcp
 use "./plugins.syn" as plugins
 use "./lsp.syn" as lsp
 use "./schedule.syn" as schedule
+use "./computer.syn" as computer
+
+-- la tool computer_use (lib/computer.syn): el escritorio y el navegador del usuario en segundo plano, sobre un
+-- driver externo. Está en el registry siempre, pero al catálogo del modelo solo entra cuando está encendida y el
+-- driver existe (agents.tool_names). Los args llegan planos del JSON del modelo y van a computer.call como map.
+-- OJO: cada propiedad del SPEC tiene que ser un parámetro acá — un arg que no está da "unknown parameter" antes de
+-- llegar a computer.call (2026-09-06: delivery_mode faltaba y el modelo no pudo apretar Enter en Chrome). Lo cubre
+-- un test de unit.test.syn que recorre las propiedades del SPEC.
+task computer_tool(action, pid, window_id, element, x, y, text, key, keys, modifiers, direction, amount, from_x, from_y, to_x, to_y, x1, y1, x2, y2, value, name, path, url, target_id, tab_id, ref, query, screenshot, max_elements, replace, delta_y, delta_x, profile, seconds, button, delivery_mode, option, app, capture_after, fields, goal, steps, enter)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let a be {}
+    each e in [["pid", pid], ["window_id", window_id], ["element", element], ["x", x], ["y", y], ["text", text], ["key", key], ["keys", keys], ["modifiers", modifiers], ["direction", direction], ["amount", amount], ["from_x", from_x], ["from_y", from_y], ["to_x", to_x], ["to_y", to_y], ["x1", x1], ["y1", y1], ["x2", x2], ["y2", y2], ["value", value], ["name", name], ["path", path], ["url", url], ["target_id", target_id], ["tab_id", tab_id], ["ref", ref], ["query", query], ["screenshot", screenshot], ["max_elements", max_elements], ["replace", replace], ["delta_y", delta_y], ["delta_x", delta_x], ["profile", profile], ["seconds", seconds], ["button", button], ["delivery_mode", delivery_mode], ["option", option], ["app", app], ["capture_after", capture_after], ["fields", fields], ["goal", goal], ["steps", steps], ["enter", enter]]
+        when e[1] != nothing
+            set a[e[0]] to e[1]
+    give computer.call(action, a)
 
 -- la task de la tool skill (su SPEC está en tools/skill.syn)
 task skill_tool(name, action, source, scope)
@@ -265,10 +285,11 @@ export task registry()
         "mcp": mcp_tool,
         "plugin": plugin_tool,
         "lsp": lsp_tool,
-        "schedule": schedule_tool
+        "schedule": schedule_tool,
+        "computer_use": computer_tool
     }
 
-export let CATALOG be [t_read.SPEC, t_write.SPEC, t_edit.SPEC, t_ls.SPEC, t_find.SPEC, t_grep.SPEC, LSP_SPEC, t_fetch.SPEC, t_bash.SPEC, t_process.SPEC, t_memo.SPEC, t_todo.SPEC, t_skill.SPEC, MCP_SPEC, PLUGIN_SPEC, SCHEDULE_SPEC]
+export let CATALOG be [t_read.SPEC, t_write.SPEC, t_edit.SPEC, t_ls.SPEC, t_find.SPEC, t_grep.SPEC, LSP_SPEC, t_fetch.SPEC, t_bash.SPEC, t_process.SPEC, t_memo.SPEC, t_todo.SPEC, t_skill.SPEC, MCP_SPEC, PLUGIN_SPEC, SCHEDULE_SPEC, computer.SPEC]
 
 -- Subconjuntos (para perfiles de agente): registry/catálogo filtrados por nombre.
 export task registry_subset(names)

package/lib/trace.syn

@@ -16,7 +16,7 @@ task path(sid)
     give DIR + "/" + sid + ".log"
 
 task one_line(s, max)
-    let t be replace_text(replace_text(text(s), "\r", ""), "\n", " ⏎ ")
+    let t be replace(replace(text(s), "\r", ""), "\n", " ⏎ ")
     when length(t) > max
         give slice(t, 0, max) + "…"
     give t
@@ -105,7 +105,7 @@ export task tail(sid, n)
     require file(".lampson")
     require file(".lampson/*")
     try
-        let lines be split(replace_text(read_file(path(sid)), "\r", ""), "\n")
+        let lines be split(replace(read_file(path(sid)), "\r", ""), "\n")
         when length(lines) > n
             set lines to slice(lines, length(lines) - n, length(lines))
         give join(lines, "\n")

package/lib/tree.syn

@@ -3,35 +3,38 @@ use "./tools/common.syn" as c
 
 let MAX_ENTRIES be 2000
 
-task walk(dir, depth, max_depth, state)
+-- n = entradas contadas hasta ahora en todo el árbol; da {items, n} (listas y mapas son valores: el contador vuelve con give)
+task walk(dir, depth, max_depth, n)
     let out be []
     when depth > max_depth
-        give out
+        give {"items": out, "n": n}
     let entries be []
     try
         set entries to list_dir(dir)
     recover err
-        give out
+        give {"items": out, "n": n}
     each e in entries
-        when state["n"] >= MAX_ENTRIES
-            give out
+        when n >= MAX_ENTRIES
+            give {"items": out, "n": n}
         let rel be c.unws(dir + "/" + e["name"])
         when e["is_dir"]
             when not contains(c.IGNORED_DIRS, e["name"])
-                set state["n"] to state["n"] + 1
-                set out to append(out, {"name": e["name"], "path": rel, "is_dir": true, "children": walk(dir + "/" + e["name"], depth + 1, max_depth, state)})
+                set n to n + 1
+                let sub be walk(dir + "/" + e["name"], depth + 1, max_depth, n)
+                set n to sub["n"]
+                set out to append(out, {"name": e["name"], "path": rel, "is_dir": true, "children": sub["items"]})
         otherwise
-            set state["n"] to state["n"] + 1
+            set n to n + 1
             set out to append(out, {"name": e["name"], "path": rel, "is_dir": false, "size": e["size"]})
     -- carpetas primero
-    give where(out, (x) => x["is_dir"]) + where(out, (x) => not x["is_dir"])
+    give {"items": where(out, (x) => x["is_dir"]) + where(out, (x) => not x["is_dir"]), "n": n}
 
 -- árbol anidado: [{name, path, is_dir, size?, children?}]
 export task tree(max_depth)
     require file.read("workspace")
     require file.read("workspace/*")
-    let state be {"n": 0}
-    give {"entries": walk(c.ROOT, 0, max_depth, state), "count": state["n"], "truncated": state["n"] >= MAX_ENTRIES}
+    let w be walk(c.ROOT, 0, max_depth, 0)
+    give {"entries": w["items"], "count": w["n"], "truncated": w["n"] >= MAX_ENTRIES}
 
 -- render de texto para la terminal (2 niveles, compacto)
 export task render(max_depth, max_lines)
@@ -55,5 +58,18 @@ export task file_content(path)
     require file.read("workspace")
     require file.read("workspace/*")
     let real be c.ws(path)
-    let content be read_file(real)
-    give {"path": c.unws(real), "content": c.truncate(content, 200000), "lines": length(split(content, "\n"))}
+    let rel be c.unws(real)
+    let info be file_info(real)
+    when not info["exists"]
+        raise("\"" + rel + "\" does not exist")
+    when info["is_dir"]
+        raise("\"" + rel + "\" is a folder")
+    -- binarios (sqlite, imágenes, fuentes…): read_file no puede decodificarlos como UTF-8 y el runtime lo reporta
+    -- como "File not found" (engañoso; visto 2026-09-05 con un dev.db de Prisma). En vez de un error, {binary: true}
+    -- y el visor muestra su aviso, sin ensuciar el chat.
+    try
+        let content be read_file(real)
+        -- truncated: el editor de la web lo abre en solo lectura (guardar el recorte destruiría el archivo)
+        give {"path": rel, "content": c.truncate(content, 200000), "lines": length(split(content, "\n")), "truncated": length(content) > 200000, "binary": false, "size": info["size"]}
+    recover err
+        give {"path": rel, "content": "", "lines": 0, "truncated": false, "binary": true, "size": info["size"], "error": text(err)}

package/lib/update.syn

@@ -12,7 +12,7 @@ task run_git(args, secs)
         let r be run("git", args, secs)
         when r["exit_code"] != 0
             give nothing
-        give trim(replace_text(r["stdout"], "\r", ""))
+        give trim(replace(r["stdout"], "\r", ""))
     recover err
         give nothing