smolcoder 0.4.2 → 0.5.0

package/dist/web/channel.js

@@ -0,0 +1,222 @@
+"use strict";
+// SessionChannel: the SessionUI a web session talks to. Same contract the
+// terminal Tui implements, but every event is tagged with the session id and
+// handed to the hub, which multiplexes all sessions onto one SSE stream.
+// Keeps a replay buffer (so a page that connects later sees the transcript),
+// the pending input/approval promises, and a coarse status for the sidebar.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionChannel = void 0;
+exports.stripAnsi = stripAnsi;
+const ui_1 = require("../ui");
+const REPLAY_CAP = 2000;
+class SessionChannel {
+    id;
+    host;
+    slashCommands = [];
+    getStatus = () => "";
+    /** Structured snapshot for the page's status bar; assigned by the hub. */
+    getState = () => ({});
+    hintLeft = "";
+    onModeCycle = null;
+    onCancel = null;
+    onExit = null;
+    phase = "starting";
+    title = "";
+    busyLabel = null;
+    replay = [];
+    closed = false;
+    pendingInput = null;
+    inputQueue = [];
+    exitRequested = false;
+    pending = new Map();
+    askId = 0;
+    constructor(id, host) {
+        this.id = id;
+        this.host = host;
+    }
+    // ---- lifecycle -----------------------------------------------------------
+    start() { }
+    close() {
+        this.closed = true;
+        this.busyLabel = null;
+        this.resolvePending(null);
+        this.host.changed(this.id);
+    }
+    /** Make the session loop's next readInput() return "/exit" without echoing
+     * it as a user message. Used when a session is closed from the sidebar. */
+    requestExit() {
+        this.exitRequested = true;
+        if (this.pendingInput) {
+            const r = this.pendingInput;
+            this.pendingInput = null;
+            r("/exit");
+        }
+    }
+    // ---- input from the page -------------------------------------------------
+    handleMessage(text) {
+        text = text.trim();
+        if (!text || this.closed)
+            return;
+        if (this.pendingInput) {
+            const resolve = this.pendingInput;
+            this.pendingInput = null;
+            this.accept(text);
+            resolve(text);
+        }
+        else {
+            this.inputQueue.push(text);
+        }
+    }
+    handleAnswer(id, value) {
+        if (!this.pending.has(id))
+            return;
+        this.setStatus("busy");
+        this.settle(id, value);
+    }
+    /** Stop button / esc: answer any open prompt with "no"/cancel, then abort
+     * the turn. Without the first step a cancel during an approval prompt
+     * would leave the agent waiting on a promise nothing will resolve. */
+    cancel() {
+        this.resolvePending(null);
+        this.onCancel?.();
+    }
+    resolvePending(value) {
+        for (const id of [...this.pending.keys()])
+            this.settle(id, value);
+    }
+    /** Resolve one prompt and record the outcome in the transcript, so a page
+     * that replays it later (reconnect, resume) sees the answer, not live
+     * buttons for a question nobody is asking any more. */
+    settle(id, value) {
+        const p = this.pending.get(id);
+        if (!p)
+            return;
+        this.pending.delete(id);
+        this.broadcast({ t: "answered", id });
+        if (p.kind === "confirm") {
+            const a = value === "always" ? "always allow" : value === "yes" ? "yes" : "no";
+            this.broadcast({ t: "line", kind: "status", s: `${a} — ${p.label}` });
+        }
+        else if (value === null || value === undefined) {
+            this.broadcast({ t: "line", kind: "status", s: `cancelled — ${p.label}` });
+        }
+        p.resolve(value);
+    }
+    accept(text) {
+        this.setStatus("busy");
+        this.broadcast({ t: "user", s: text });
+        if (!this.title && !text.startsWith("/")) {
+            this.title = text.replace(/\s+/g, " ").slice(0, 60);
+            this.host.changed(this.id);
+        }
+    }
+    setStatus(s) {
+        if (this.phase === s)
+            return;
+        this.phase = s;
+        this.host.changed(this.id);
+    }
+    // ---- event plumbing ------------------------------------------------------
+    broadcast(ev) {
+        ev.sid = this.id;
+        if (ev.t !== "busy" && ev.t !== "state") {
+            this.replay.push(ev);
+            if (this.replay.length > REPLAY_CAP)
+                this.replay.shift();
+            this.host.touched(this.id);
+        }
+        this.host.send(ev);
+    }
+    stateEvent() {
+        return { t: "state", sid: this.id, s: { ...this.getState(), busy: this.busyLabel, title: this.title } };
+    }
+    pushState() {
+        this.host.send(this.stateEvent());
+    }
+    refresh() {
+        this.pushState();
+    }
+    // ---- SessionUI -----------------------------------------------------------
+    readInput() {
+        this.busyLabel = null;
+        this.setStatus("idle");
+        this.pushState();
+        if (this.exitRequested || this.closed)
+            return Promise.resolve("/exit");
+        if (this.inputQueue.length) {
+            const text = this.inputQueue.shift();
+            this.accept(text);
+            return Promise.resolve(text);
+        }
+        return new Promise((resolve) => (this.pendingInput = resolve));
+    }
+    select(title, options) {
+        const id = ++this.askId;
+        this.broadcast({ t: "select", id, title, options });
+        this.setStatus("waiting");
+        return new Promise((resolve) => this.pending.set(id, { kind: "select", label: title, resolve: (i) => resolve(typeof i === "number" ? i : null) }));
+    }
+    confirmCommand(command, reason) {
+        const id = ++this.askId;
+        this.broadcast({ t: "confirm", id, command, reason });
+        this.setStatus("waiting");
+        return new Promise((resolve) => this.pending.set(id, {
+            kind: "confirm",
+            label: command,
+            resolve: (a) => resolve(a === "always" ? "always" : a === "yes" ? "yes" : "no"),
+        }));
+    }
+    token(text) {
+        this.broadcast({ t: "token", s: text });
+    }
+    thinking(text) {
+        this.broadcast({ t: "thinking", s: text });
+    }
+    toolCall(name, args) {
+        this.broadcast({ t: "tool", name, summary: (0, ui_1.summarizeArgs)(name, args) });
+    }
+    toolResult(result) {
+        const lines = result.split("\n");
+        const first = lines[0] ?? "";
+        this.broadcast({
+            t: "result",
+            line: first.slice(0, 160),
+            err: first.startsWith("Error"),
+            extra: lines.length > 1 ? lines.length - 1 : 0,
+        });
+    }
+    planUpdated(plan) {
+        this.broadcast({ t: "plan", steps: plan.steps, current: plan.currentIndex });
+        this.pushState();
+    }
+    println(s = "") {
+        if (s.trim())
+            this.broadcast({ t: "line", kind: "status", s: stripAnsi(s) });
+    }
+    status(s) {
+        this.broadcast({ t: "line", kind: "status", s: stripAnsi(s) });
+    }
+    warn(s) {
+        this.broadcast({ t: "line", kind: "warn", s: stripAnsi(s) });
+    }
+    error(s) {
+        this.broadcast({ t: "line", kind: "error", s: stripAnsi(s) });
+    }
+    turnEnd(label) {
+        this.broadcast({ t: "turnend", label });
+        this.pushState();
+    }
+    startSpinner(label) {
+        this.busyLabel = label;
+        this.broadcast({ t: "busy", label });
+    }
+    stopSpinner() {
+        this.busyLabel = null;
+        this.broadcast({ t: "busy", label: null });
+    }
+}
+exports.SessionChannel = SessionChannel;
+function stripAnsi(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\x1b\[[0-9;]*m/g, "");
+}