elelem-server 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccf8d43f79bf8e8a3c5c138a05e9e1887d7e212a8ccdef1d498de8133a4c13ca
-  data.tar.gz: 5658cacb63bba0bce48f86b5ce948a1e6e18981caf7e012ddcabc6d5a1e3ec76
+  metadata.gz: 8ae17fb98f2f26fa6e0503d295ece4362a3938e4a44a80561111b6dced5a1deb
+  data.tar.gz: 4e5e7f0f76f667581ad852dc498bb9f5efa2c56540bfa2af50a3c25fe4f6503a
 SHA512:
-  metadata.gz: 989664ee67bf8bc7d48da210b540b14e81e86aaf53a24fa300c61cc36496fade39170f4e7919d59c48bd3cbcf43b3f7cf6754d2f59117423a24a6e370fce5a81
-  data.tar.gz: bf048a10f1f83129bb9e8baf79f5a7cabd959d845a4a996fc34fffa18674609a57c242821b250f4bc3f610aa5abf570a08a9ea841c4239fcbd7554040c67e769
+  metadata.gz: 67b211c138c11bc595ce0e6ca7ab30dc7e47e0cf4350eddc0a835c1250e0f9a58607b7e7b2f8b2d5c00469c3bccdd75b212e4562f7e3731d467d1316116247c5
+  data.tar.gz: c6aaf041c17653e18900731c2ff78876c72763973e5ab5b45c08901c9de43669f2f54ad53cf70a9268e4ca5cdb650edba3772053df867cce2423697d636d7839

data/.github/workflows/release.yml

@@ -0,0 +1,61 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions: {}
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+        with:
+          persist-credentials: false
+      - uses: ruby/setup-ruby@3ff19f5e2baf30647122352b96108b1fbe250c64 # v1.299.0
+        with:
+          ruby-version: "4.0"
+          bundler-cache: true
+      - run: bin/test
+      - run: bin/lint
+
+  release-please:
+    needs: test
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+    steps:
+      - id: release
+        uses: googleapis/release-please-action@45996ed1f6d02564a971a2fa1b5860e934307cf7 # v5.0.0
+        with:
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+
+  publish:
+    needs: release-please
+    if: needs.release-please.outputs.release_created == 'true'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+        with:
+          persist-credentials: false
+      - uses: ruby/setup-ruby@3ff19f5e2baf30647122352b96108b1fbe250c64 # v1.299.0
+        with:
+          ruby-version: "4.0"
+          bundler-cache: true
+      - uses: rubygems/release-gem@7f9650160c1a4e7989fdc9855807bdbd421d8b6b # v1.4.1

data/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.2.1"
+}

data/.rubocop.yml

@@ -0,0 +1,62 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 4.0
+  SuggestExtensions: false
+  Exclude:
+    - "pkg/**/*"
+    - "bin/**/*"
+    - "vendor/**/*"
+    - "fixtures/**/*"
+
+Metrics:
+  Enabled: false
+
+Naming/PredicateMethod:
+  AllowedMethods:
+    - call
+    - run
+    - summarize
+    - prompt
+
+Naming/MethodParameterName:
+  AllowedNames:
+    - me
+    - id
+    - as
+    - io
+
+Style/GlobalVars:
+  Exclude:
+    - "spec/**/*"
+
+Lint/EmptyBlock:
+  Exclude:
+    - "spec/**/*"
+
+Lint/UselessDefaultValueArgument:
+  Enabled: false
+
+Lint/RedundantRequireStatement:
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  IgnoreEmptyBlocks: true
+  AllowUnusedKeywordArguments: true
+
+Style/Documentation:
+  Enabled: false
+
+Style/FormatStringToken:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## [0.2.1](https://github.com/elelem-sh/server/compare/v0.2.0...v0.2.1) (2026-11-15)
+
+
+### Bug Fixes
+
+* build a Session for Config.apply and Agent#turn ([4ab731c](https://github.com/elelem-sh/server/commit/4ab731c02948dfd0c49d1750e680fea0e9b7de75))
+* correlate prompt/answer by id, close /answer pre-approval bug ([ddae723](https://github.com/elelem-sh/server/commit/ddae723c67ef2a44de4a50869f7cbaeab13c9b66))
+* each browser tab gets its own session, and slash commands run as commands ([elelem-sh/elelem.sh#31](https://github.com/elelem-sh/elelem.sh/issues/31)) ([31a6d96](https://github.com/elelem-sh/server/commit/31a6d965704d7faceb23d143f37dbc58dfae4609))
+* require elelem ~> 0.12, the floor builtins/skills actually need ([af2fdac](https://github.com/elelem-sh/server/commit/af2fdac0462ed4774fbb136361502f60555e05bc))
+* server prompt ids are unique across tabs, a claimed tab cannot be evicted, and a closed tab keeps its place for a minute ([aedcf3c](https://github.com/elelem-sh/server/commit/aedcf3c4565ef18e2c48914abc9dc7c5ece08a72))
+* server tabs build without blocking others, free idle places, survive a reload mid-prompt, and keep the token out of the address bar ([163433d](https://github.com/elelem-sh/server/commit/163433d85a5acd3eba7c891bedabc034f455b144))
+* the server answers a bound IPv6 address, and ends a turn before taking the next ([f453fd2](https://github.com/elelem-sh/server/commit/f453fd293985781446d167ea110eb3249ce56cda))
+* the server defaults to the demo provider, since elelem 0.13.1 removed stub ([e7867bc](https://github.com/elelem-sh/server/commit/e7867bc63e9f13a18cadaae5f51e9c8fc945533e))
+* the server listens on 127.0.0.1 and refuses other hosts, origins and non-JSON posts ([elelem-sh/elelem.sh#1](https://github.com/elelem-sh/elelem.sh/issues/1)) ([54197c4](https://github.com/elelem-sh/server/commit/54197c442ae08cc62c3e5e82d54e2ea4efce892b))
+* the server requires the token it prints at start ([elelem-sh/elelem.sh#1](https://github.com/elelem-sh/elelem.sh/issues/1)) ([c76e69c](https://github.com/elelem-sh/server/commit/c76e69c3d8e96e671fe9c8c577863bd0fc41668a))
+* the server runs one turn at a time and the page waits for it ([elelem-sh/elelem.sh#31](https://github.com/elelem-sh/elelem.sh/issues/31)) ([a7fc5d6](https://github.com/elelem-sh/server/commit/a7fc5d6a48113bb53759ef24bc292cd9ce9caafe))
+* the startup line brackets an IPv6 address so the URL works ([641a803](https://github.com/elelem-sh/server/commit/641a8034fdc1d0763150fa01ed76d7ae52a0376d))
+* the web page renders line breaks, code and bold ([elelem-sh/elelem.sh#30](https://github.com/elelem-sh/elelem.sh/issues/30)) ([d29df97](https://github.com/elelem-sh/server/commit/d29df971dcbc0eb8d8c5b32d7a9b8c2816deffbd))

data/exe/elelem-server

@@ -4,14 +4,19 @@
 require "elelem/server"
 require "optparse"
 
-provider = ENV.fetch("ELELEM_PROVIDER", "stub")
+provider = ENV.fetch("ELELEM_PROVIDER", "demo")
 port = 4567
+address = "127.0.0.1"
 
 OptionParser.new do |o|
   o.banner = "Usage: elelem-server [options]"
   o.on("-p", "--provider NAME", "Provider to use (default: #{provider})") { |v| provider = v }
   o.on("--port PORT", Integer, "Port to listen on (default: #{port})") { |v| port = v }
-  o.on("-h", "--help", "Show this help") { puts o; exit }
+  o.on("--bind ADDR", "Address to listen on (default: #{address})") { |v| address = v }
+  o.on("-h", "--help", "Show this help") do
+    puts o
+    exit
+  end
 end.parse!(ARGV)
 
-Elelem::Server.serve(provider: provider, port: port)
+Elelem::Server.serve(provider: provider, port: port, address: address)

data/lib/elelem/server/index.html

@@ -0,0 +1,176 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>elelem</title>
+<style>
+  :root { color-scheme: dark; }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; height: 100dvh; display: flex; flex-direction: column;
+    background: #16161a; color: #e6e6e6;
+    font: 16px/1.55 ui-sans-serif, system-ui, -apple-system, sans-serif;
+  }
+  #log { flex: 1; overflow-y: auto; padding: 1rem; -webkit-overflow-scrolling: touch; }
+  .msg { max-width: 46rem; margin: 0 auto 1rem; padding: .65rem .85rem; border-radius: .6rem; }
+  .user { background: #2d3a4f; }
+  .assistant { background: #22222a; }
+  .thinking { opacity: .55; font-style: italic; white-space: pre-wrap; }
+  .msg pre {
+    background: #0d0d10; padding: .7rem; border-radius: .4rem;
+    overflow-x: auto; font-size: .875rem;
+  }
+  .msg code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+  .prompt { max-width: 46rem; margin: 0 auto 1rem; padding: .85rem; border-radius: .6rem; background: #4a3a1e; }
+  .prompt button {
+    font-size: 1rem; padding: .7rem 1.4rem; margin: .5rem .5rem 0 0;
+    border: 0; border-radius: .5rem; color: #fff; touch-action: manipulation;
+  }
+  .allow { background: #2f7d4f; }
+  .deny { background: #8c3535; }
+  form { display: flex; gap: .5rem; padding: .75rem; padding-bottom: max(.75rem, env(safe-area-inset-bottom));
+         border-top: 1px solid #2c2c33; background: #1b1b20; }
+  textarea {
+    flex: 1; resize: none; font: inherit; padding: .6rem; border-radius: .5rem;
+    border: 1px solid #35353d; background: #101014; color: inherit;
+  }
+  button.send { font-size: 1rem; padding: .6rem 1.2rem; border: 0; border-radius: .5rem; background: #3b6ea5; color: #fff; }
+  button.send:disabled { opacity: .5; }
+</style>
+</head>
+<body>
+<div id="log"></div>
+<form id="composer">
+  <textarea id="input" rows="1" placeholder="Message elelem" autocapitalize="sentences"></textarea>
+  <button class="send" type="submit">Send</button>
+</form>
+<script>
+const log = document.getElementById("log");
+const input = document.getElementById("input");
+let current = null;
+
+const atBottom = () => log.scrollHeight - log.scrollTop - log.clientHeight < 80;
+const scroll = (was) => { if (was) log.scrollTop = log.scrollHeight; };
+
+// The token comes in the URL elelem-server prints. Keep it for reloads in this tab.
+const token = new URLSearchParams(location.search).get("token") || sessionStorage.getItem("elelem-token") || "";
+sessionStorage.setItem("elelem-token", token);
+// Keep the token out of the address bar and history.
+history.replaceState(null, "", "/");
+// Each tab has its own conversation. A reload keeps it; a new tab starts fresh.
+const random = () => (crypto.randomUUID ? crypto.randomUUID() : String(Math.random()).slice(2));
+const tab = sessionStorage.getItem("elelem-tab") || random();
+sessionStorage.setItem("elelem-tab", tab);
+
+function post(path, body) {
+  const headers = { "Content-Type": "application/json", "X-Elelem-Token": token, "X-Elelem-Tab": tab };
+  return fetch(path, { method: "POST", headers: headers, body: JSON.stringify(body) });
+}
+
+function escape(text) {
+  return text.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
+}
+
+function render(text) {
+  return escape(text)
+    .replace(/```(\w*)\n([\s\S]*?)```/g, (_m, _lang, code) => "<pre><code>" + code + "</code></pre>")
+    .replace(/`([^`\n]+)`/g, "<code>$1</code>")
+    .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
+    .replace(/\n/g, "<br>");
+}
+
+function bubble(cls) {
+  const was = atBottom();
+  const el = document.createElement("div");
+  el.className = "msg " + cls;
+  log.appendChild(el);
+  scroll(was);
+  return el;
+}
+
+function append(cls, text) {
+  if (!current || current.dataset.cls !== cls) {
+    current = bubble(cls);
+    current.dataset.cls = cls;
+    current.dataset.raw = "";
+  }
+  const was = atBottom();
+  current.dataset.raw += text;
+  current.innerHTML = render(current.dataset.raw);
+  scroll(was);
+}
+
+function askPermission(id, text) {
+  // A reconnect replays open prompts; show each one once.
+  if (document.querySelector('.prompt[data-id="' + id + '"]')) return;
+  current = null;
+  const was = atBottom();
+  const el = document.createElement("div");
+  el.className = "prompt";
+  el.dataset.id = id;
+  el.innerHTML = "<div>" + escape(text) + "</div>";
+  const respond = (answer) => {
+    el.querySelectorAll("button").forEach((b) => b.remove());
+    el.insertAdjacentHTML("beforeend", "<div><em>" + answer + "</em></div>");
+    post("/answer", { id: el.dataset.id, text: answer });
+  };
+  const allow = document.createElement("button");
+  allow.className = "allow";
+  allow.textContent = "Allow";
+  allow.onclick = () => respond("y");
+  const deny = document.createElement("button");
+  deny.className = "deny";
+  deny.textContent = "Deny";
+  deny.onclick = () => respond("n");
+  el.append(allow, deny);
+  log.appendChild(el);
+  scroll(was);
+}
+
+new EventSource("/events?token=" + encodeURIComponent(token) + "&tab=" + encodeURIComponent(tab)).onmessage = (e) => {
+  const event = JSON.parse(e.data);
+  if (event.type === "content") append("assistant", event.text);
+  else if (event.type === "thinking") append("thinking", event.text);
+  else if (event.type === "prompt") askPermission(event.id, event.text);
+  else if (event.type === "done") { current = null; idle(); }
+};
+
+const send = document.querySelector("#composer .send");
+const idle = () => { send.disabled = false; };
+
+document.getElementById("composer").onsubmit = async (e) => {
+  e.preventDefault();
+  const text = input.value.trim();
+  if (!text || send.disabled) return;
+  send.disabled = true;
+  append("user", text);
+  current = null;
+  input.value = "";
+  try {
+    const res = await post("/message", { text: text });
+    if (res.ok) return;
+    append("thinking", res.status === 409 ? "Still working on the last message. Try again when it is done." : "Not sent: " + res.status);
+    current = null;
+    input.value = text;
+    idle();
+  } catch (_err) {
+    input.value = text;
+    idle();
+  }
+};
+
+input.addEventListener("keydown", (e) => {
+  if (e.key === "Enter" && !e.shiftKey) {
+    e.preventDefault();
+    document.getElementById("composer").requestSubmit();
+  }
+});
+
+input.addEventListener("input", () => {
+  input.style.height = "auto";
+  input.style.height = Math.min(input.scrollHeight, 160) + "px";
+});
+</script>
+</body>
+</html>

data/lib/elelem/server/tab.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Server
+    # One browser tab: its session, and whether a turn is running in it.
+    class Tab
+      attr_reader :session
+
+      def initialize(session)
+        @session = session
+        @lock = Mutex.new
+        @busy = false
+      end
+
+      def terminal
+        @session.output
+      end
+
+      def claim
+        @lock.synchronize { @busy ? false : (@busy = true) }
+      end
+
+      # Busy tabs, and tabs with a page open or seen in the last minute (an
+      # EventSource that is reconnecting), keep their place.
+      def idle?(now = Process.clock_gettime(Process::CLOCK_MONOTONIC), grace: 60)
+        !@lock.synchronize { @busy } && terminal.subscribers.zero? && now - terminal.last_seen > grace
+      end
+
+      # Runs a message or a /command, then tells the page the turn is done.
+      def run(text)
+        text.start_with?("/") ? command(text) : @session.turn(text)
+      rescue StandardError, ScriptError => e
+        terminal.say("Error: #{e.message}")
+      ensure
+        # done first, so the page cannot start a turn before this one says it ended.
+        terminal.done
+        @lock.synchronize { @busy = false }
+      end
+
+      private
+
+      def command(line)
+        name, args = line.delete_prefix("/").split(" ", 2)
+        # /exit would stop the server, and /reload would reload plugins under
+        # every other tab. Restart elelem-server instead.
+        if %w[exit reload].include?(name)
+          return terminal.say("/#{name} is not available in the browser. Restart elelem-server instead.")
+        end
+        return if @session.commands.run(name, args)
+
+        terminal.say(@session.commands.names.join(" "))
+      end
+    end
+  end
+end

data/lib/elelem/server/version.rb

@@ -2,6 +2,6 @@
 
 module Elelem
   class Server
-    VERSION = "0.1.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/elelem/server/web_terminal.rb

@@ -3,27 +3,60 @@
 module Elelem
   class Server
     class WebTerminal
+      # Prompt ids are unique across every tab's terminal, so a page never
+      # mistakes a new prompt for one it already answered.
+      @next_id = 0
+      @ids = Mutex.new
+
+      def self.next_prompt_id
+        @ids.synchronize { @next_id += 1 }
+      end
+
+      attr_reader :last_seen
+
       def initialize
         @subscribers = []
         @mutex = Mutex.new
-        @answers = Queue.new
+        @prompts = {}
+        @open = {}
+        @last_seen = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
 
+      # A page that subscribes again, after a reload, gets the prompts still
+      # waiting for an answer, so the turn does not hang on one it cannot see.
       def subscribe
-        Queue.new.tap { |queue| @mutex.synchronize { @subscribers << queue } }
+        Queue.new.tap do |queue|
+          @mutex.synchronize do
+            @subscribers << queue
+            @open.each_value { |event| queue << event }
+          end
+        end
+      end
+
+      def subscribers
+        @mutex.synchronize { @subscribers.size }
       end
 
       def unsubscribe(queue)
-        @mutex.synchronize { @subscribers.delete(queue) }
+        @mutex.synchronize do
+          @subscribers.delete(queue)
+          @last_seen = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
       end
 
       def interactive?
         true
       end
 
-      def ask(prompt)
-        emit("prompt", prompt)
-        @answers.pop
+      def ask(prompt, **)
+        queue = Queue.new
+        event = @mutex.synchronize do
+          id = self.class.next_prompt_id
+          @prompts[id] = queue
+          @open[id] = { type: "prompt", text: plain(prompt), id: id }
+        end
+        broadcast(event)
+        queue.pop
       end
 
       def thinking(text)
@@ -39,8 +72,7 @@ module Elelem
         say "#{state} #{name}(#{args})"
       end
 
-      def waiting
-      end
+      def waiting; end
 
       def print(text)
         emit("content", text)
@@ -55,8 +87,14 @@ module Elelem
         say(fallback || path)
       end
 
-      def answer(text)
-        @answers << text
+      def answer(id, text)
+        @mutex.synchronize do
+          if @prompts.key?(id)
+            @prompts[id] << text
+            @prompts.delete(id)
+            @open.delete(id)
+          end
+        end
       end
 
       def done
@@ -66,10 +104,14 @@ module Elelem
       private
 
       def emit(type, text)
-        plain = text.to_s.gsub(/\e\[[0-9;]*[a-zA-Z]/, "")
+        plain = plain(text)
         return if plain.strip.empty?
 
-        broadcast(type: type, text: plain)
+        broadcast({ type: type, text: plain })
+      end
+
+      def plain(text)
+        text.to_s.gsub(/\e\[[0-9;]*[a-zA-Z]/, "")
       end
 
       def broadcast(event)

data/lib/elelem/server.rb

@@ -2,26 +2,44 @@
 
 require "elelem"
 require "json"
+require "openssl"
+require "securerandom"
+require "uri"
 require "webrick"
 
 require_relative "server/version"
 require_relative "server/web_terminal"
+require_relative "server/tab"
 
 module Elelem
   class Server
-    def self.serve(provider: "stub", port: 4567, toolbox: Toolbox.new)
-      llm_provider = Config.build_provider(provider)
-      web_terminal = WebTerminal.new
-      agent = Agent.new(llm_provider, toolbox: toolbox, output: web_terminal, input: web_terminal)
-      Config.apply(agent)
-      new(agent, port: port).start
+    INDEX = File.read(File.expand_path("server/index.html", __dir__))
+    LOCAL_HOSTS = %w[localhost 127.0.0.1 [::1]].freeze
+
+    MAX_TABS = 16
+    TAB_ID = /\A[\w-]{1,64}\z/
+
+    # Each browser tab gets its own session, built on its first request.
+    def self.serve(provider: "demo", port: 4567, address: "127.0.0.1")
+      Config.build_provider(provider) # fail at start, not on the first page load
+      new(-> { session_for(provider) }, port: port, address: address).start
+    end
+
+    def self.session_for(provider)
+      terminal = WebTerminal.new
+      Config.build_session(provider, input: terminal, output: terminal)
     end
 
-    def initialize(agent, port: 4567, address: "0.0.0.0")
-      @agent = agent
+    attr_reader :token
+
+    def initialize(build_session, port: 4567, address: "127.0.0.1", token: SecureRandom.hex(16))
+      @build_session = build_session
       @port = port
       @address = address
-      @terminal = agent.output
+      @token = token
+      @tabs = {}
+      @tabs_lock = Mutex.new
+      @build_lock = Mutex.new
     end
 
     def start
@@ -31,202 +49,163 @@ module Elelem
         Logger: WEBrick::Log.new(File::NULL),
         AccessLog: []
       )
-      server.mount_proc("/", &method(:index))
-      server.mount_proc("/events", &method(:events))
-      server.mount_proc("/message", &method(:message))
-      server.mount_proc("/answer", &method(:answer))
+      %i[index events message answer].each do |name|
+        server.mount_proc(name == :index ? "/" : "/#{name}", &guarded(name, token: name != :index))
+      end
 
       trap("INT") { server.shutdown }
-      $stdout.puts "elelem v#{VERSION} listening on http://#{@address}:#{@port}"
+      $stdout.puts "elelem v#{VERSION} listening on http://#{url_host}:#{@port}/?token=#{@token}"
+      $stdout.flush # the URL carries the token; it must show even when stdout is a file
       server.start
     end
 
     private
 
+    # The agent can run commands, so only this machine's own pages may drive it.
+    # The token, printed at start, keeps out other users and programs on the
+    # machine; the page itself holds no secret, so it is served without one.
+    # A Host check stops DNS rebinding; JSON plus a matching Origin stops a
+    # cross-site form or fetch.
+    def guarded(name, token: true)
+      handler = method(name)
+      lambda do |req, res|
+        next handler.call(req, res) if allowed?(req, token: token)
+
+        res.status = 403
+        res.body = "forbidden"
+      end
+    end
+
+    def allowed?(req, token: true)
+      host = req["Host"].to_s
+      return false if token && !token?(req)
+      return false unless local_hosts.include?(host.sub(/:\d+\z/, ""))
+      return true unless req.request_method == "POST"
+
+      json?(req) && same_origin?(req["Origin"], host)
+    end
+
+    # A header from the page's fetch calls; the query string for the first page
+    # load and for EventSource, which cannot set headers.
+    def token?(req)
+      given = req["X-Elelem-Token"] || req.query["token"]
+      given.is_a?(String) && OpenSSL.secure_compare(given, @token)
+    end
+
+    def local_hosts
+      LOCAL_HOSTS + [url_host]
+    end
+
+    # URLs and Host headers put an IPv6 address in brackets.
+    def url_host
+      @address.include?(":") ? "[#{@address}]" : @address
+    end
+
+    def json?(req)
+      req["Content-Type"].to_s.split(";").first.to_s.strip.casecmp?("application/json")
+    end
+
+    def same_origin?(origin, host)
+      return true if origin.nil?
+
+      uri = URI(origin)
+      authority = uri.port == uri.default_port ? uri.host : "#{uri.host}:#{uri.port}"
+      authority == host
+    rescue URI::InvalidURIError
+      false
+    end
+
     def index(_req, res)
+      res["Referrer-Policy"] = "no-referrer"
       res.content_type = "text/html; charset=utf-8"
       res.body = INDEX
     end
 
-    def events(_req, res)
+    def events(req, res)
+      tab = tab_for(req) or return no_tab(res)
+
       res.content_type = "text/event-stream"
       res["Cache-Control"] = "no-cache"
       res.chunked = true
-      res.body = ->(out) { stream(out) }
+      res.body = ->(out) { stream(tab.terminal, out) }
     end
 
-    def stream(out)
-      events = @terminal.subscribe
+    def stream(terminal, out)
+      events = terminal.subscribe
       loop do
-        out.write("data: #{JSON.dump(events.pop)}\n\n")
+        # A ping every 15 seconds finds a closed tab, so its thread ends.
+        event = events.pop(timeout: 15)
+        out.write(event ? "data: #{JSON.dump(event)}\n\n" : ": ping\n\n")
       end
     rescue IOError, Errno::EPIPE, Errno::ECONNRESET
       nil
     ensure
-      @terminal.unsubscribe(events)
+      terminal.unsubscribe(events)
     end
 
+    # One turn at a time per tab: two at once would interleave one conversation.
     def message(req, res)
+      tab = tab_for(req) or return no_tab(res)
       text = JSON.parse(req.body)["text"].to_s
-      Thread.new do
-        @agent.turn(text)
-      rescue => e
-        @terminal.say("Error: #{e.message}")
-      ensure
-        @terminal.done
-      end
+      # Claim under the tabs lock, so the tab cannot be evicted in between.
+      return busy(res) unless @tabs_lock.synchronize { @tabs.value?(tab) && tab.claim }
+
+      Thread.new { tab.run(text) }
       res.status = 204
     end
 
+    def busy(res)
+      res.status = 409
+      res.body = "busy"
+    end
+
     def answer(req, res)
-      @terminal.answer(JSON.parse(req.body)["text"].to_s)
+      tab = tab_for(req) or return no_tab(res)
+      body = JSON.parse(req.body)
+      tab.terminal.answer(body["id"].to_i, body["text"].to_s)
       res.status = 204
     end
 
-    INDEX = <<~HTML
-      <!doctype html>
-      <html lang="en">
-      <head>
-      <meta charset="utf-8">
-      <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
-      <title>elelem</title>
-      <style>
-        :root { color-scheme: dark; }
-        * { box-sizing: border-box; }
-        body {
-          margin: 0; height: 100dvh; display: flex; flex-direction: column;
-          background: #16161a; color: #e6e6e6;
-          font: 16px/1.55 ui-sans-serif, system-ui, -apple-system, sans-serif;
-        }
-        #log { flex: 1; overflow-y: auto; padding: 1rem; -webkit-overflow-scrolling: touch; }
-        .msg { max-width: 46rem; margin: 0 auto 1rem; padding: .65rem .85rem; border-radius: .6rem; }
-        .user { background: #2d3a4f; }
-        .assistant { background: #22222a; }
-        .thinking { opacity: .55; font-style: italic; white-space: pre-wrap; }
-        .msg pre {
-          background: #0d0d10; padding: .7rem; border-radius: .4rem;
-          overflow-x: auto; font-size: .875rem;
-        }
-        .msg code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
-        .prompt { max-width: 46rem; margin: 0 auto 1rem; padding: .85rem; border-radius: .6rem; background: #4a3a1e; }
-        .prompt button {
-          font-size: 1rem; padding: .7rem 1.4rem; margin: .5rem .5rem 0 0;
-          border: 0; border-radius: .5rem; color: #fff; touch-action: manipulation;
-        }
-        .allow { background: #2f7d4f; }
-        .deny { background: #8c3535; }
-        form { display: flex; gap: .5rem; padding: .75rem; padding-bottom: max(.75rem, env(safe-area-inset-bottom));
-               border-top: 1px solid #2c2c33; background: #1b1b20; }
-        textarea {
-          flex: 1; resize: none; font: inherit; padding: .6rem; border-radius: .5rem;
-          border: 1px solid #35353d; background: #101014; color: inherit;
-        }
-        button.send { font-size: 1rem; padding: .6rem 1.2rem; border: 0; border-radius: .5rem; background: #3b6ea5; color: #fff; }
-      </style>
-      </head>
-      <body>
-      <div id="log"></div>
-      <form id="composer">
-        <textarea id="input" rows="1" placeholder="Message elelem…" autocapitalize="sentences"></textarea>
-        <button class="send" type="submit">Send</button>
-      </form>
-      <script>
-      const log = document.getElementById("log");
-      const input = document.getElementById("input");
-      let current = null;
-
-      const atBottom = () => log.scrollHeight - log.scrollTop - log.clientHeight < 80;
-      const scroll = (was) => { if (was) log.scrollTop = log.scrollHeight; };
-
-      function escape(text) {
-        return text.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
-      }
-
-      function render(text) {
-        return escape(text)
-          .replace(/```(\\w*)\\n([\\s\\S]*?)```/g, (_m, _lang, code) => "<pre><code>" + code + "</code></pre>")
-          .replace(/`([^`\\n]+)`/g, "<code>$1</code>")
-          .replace(/\\*\\*([^*]+)\\*\\*/g, "<strong>$1</strong>")
-          .replace(/\\n/g, "<br>");
-      }
-
-      function bubble(cls) {
-        const was = atBottom();
-        const el = document.createElement("div");
-        el.className = "msg " + cls;
-        log.appendChild(el);
-        scroll(was);
-        return el;
-      }
-
-      function append(cls, text) {
-        if (!current || current.dataset.cls !== cls) {
-          current = bubble(cls);
-          current.dataset.cls = cls;
-          current.dataset.raw = "";
-        }
-        const was = atBottom();
-        current.dataset.raw += text;
-        current.innerHTML = render(current.dataset.raw);
-        scroll(was);
-      }
-
-      function askPermission(text) {
-        current = null;
-        const was = atBottom();
-        const el = document.createElement("div");
-        el.className = "prompt";
-        el.innerHTML = "<div>" + escape(text) + "</div>";
-        const respond = (answer) => {
-          el.querySelectorAll("button").forEach((b) => b.remove());
-          el.insertAdjacentHTML("beforeend", "<div><em>" + answer + "</em></div>");
-          fetch("/answer", { method: "POST", body: JSON.stringify({ text: answer }) });
-        };
-        const allow = document.createElement("button");
-        allow.className = "allow";
-        allow.textContent = "Allow";
-        allow.onclick = () => respond("y");
-        const deny = document.createElement("button");
-        deny.className = "deny";
-        deny.textContent = "Deny";
-        deny.onclick = () => respond("n");
-        el.append(allow, deny);
-        log.appendChild(el);
-        scroll(was);
-      }
-
-      new EventSource("/events").onmessage = (e) => {
-        const event = JSON.parse(e.data);
-        if (event.type === "content") append("assistant", event.text);
-        else if (event.type === "thinking") append("thinking", event.text);
-        else if (event.type === "prompt") askPermission(event.text);
-        else if (event.type === "done") current = null;
-      };
-
-      document.getElementById("composer").onsubmit = (e) => {
-        e.preventDefault();
-        const text = input.value.trim();
-        if (!text) return;
-        append("user", text);
-        current = null;
-        input.value = "";
-        fetch("/message", { method: "POST", body: JSON.stringify({ text: text }) });
-      };
-
-      input.addEventListener("keydown", (e) => {
-        if (e.key === "Enter" && !e.shiftKey) {
-          e.preventDefault();
-          document.getElementById("composer").requestSubmit();
-        }
-      });
-
-      input.addEventListener("input", () => {
-        input.style.height = "auto";
-        input.style.height = Math.min(input.scrollHeight, 160) + "px";
-      });
-      </script>
-      </body>
-      </html>
-    HTML
+    # The page sends its tab id as a header, or in the query for EventSource.
+    def tab_for(req)
+      id = req["X-Elelem-Tab"] || req.query["tab"]
+      return unless id.is_a?(String) && id.match?(TAB_ID)
+
+      @tabs_lock.synchronize { @tabs[id] } || new_tab(id)
+    end
+
+    # Built outside @tabs_lock, so a slow provider does not hold up other
+    # tabs, and one at a time, because loading plugins is not thread-safe.
+    def new_tab(id)
+      @build_lock.synchronize do
+        existing = @tabs_lock.synchronize { @tabs[id] }
+        next existing if existing
+        next unless room? # no session is built only to be refused
+
+        add_tab(id, Tab.new(@build_session.call))
+      end
+    end
+
+    def room?
+      @tabs_lock.synchronize { @tabs.size < MAX_TABS || @tabs.each_value.any?(&:idle?) }
+    end
+
+    # At the limit, a tab that is idle with no page open gives up its place.
+    def add_tab(id, tab)
+      @tabs_lock.synchronize do
+        if @tabs.size >= MAX_TABS
+          idle = @tabs.find { |_, other| other.idle? }&.first
+          return unless idle
+
+          @tabs.delete(idle)
+        end
+        @tabs[id] = tab
+      end
+    end
+
+    def no_tab(res)
+      res.status = 400
+      res.body = "missing tab, or too many tabs (#{MAX_TABS})"
+    end
   end
 end

data/release-please-config.json

@@ -0,0 +1,12 @@
+{
+  "bootstrap-sha": "2db5a1c81ce0983d7e4e64772169c0b6dc0b5277",
+  "packages": {
+    ".": {
+      "release-type": "ruby",
+      "package-name": "elelem-server",
+      "version-file": "lib/elelem/server/version.rb",
+      "bump-minor-pre-major": true,
+      "include-component-in-tag": false
+    }
+  }
+}

data/spec/elelem/server/guard_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe Elelem::Server, "request guard" do
+  subject(:server) { described_class.new(-> { session }, port: 4567, token: "secret") }
+
+  let(:session) { double("session", output: double("terminal")) }
+
+  def request(method: "GET", host: "127.0.0.1:4567", query: {}, x_elelem_token: "secret", **headers)
+    headers = headers.merge(x_elelem_token: x_elelem_token).compact
+    fields = { "Host" => host }.merge(headers.transform_keys { |k| k.to_s.split("_").map(&:capitalize).join("-") })
+    double("request", request_method: method, query: query, "[]": nil).tap do |req|
+      fields.each { |name, value| allow(req).to receive(:[]).with(name).and_return(value) }
+    end
+  end
+
+  def allowed?(req) = server.send(:allowed?, req)
+
+  it "refuses a request without the token" do
+    expect(allowed?(request(x_elelem_token: nil))).to be false
+    expect(allowed?(request(x_elelem_token: "guess"))).to be false
+  end
+
+  it "serves the page itself without the token, which holds no secret" do
+    expect(server.send(:allowed?, request(x_elelem_token: nil), token: false)).to be true
+    expect(server.send(:allowed?, request(x_elelem_token: nil, host: "evil.example"), token: false)).to be false
+  end
+
+  it "takes the token from the query string, for the first page load and EventSource" do
+    expect(allowed?(request(x_elelem_token: nil, query: { "token" => "secret" }))).to be true
+  end
+
+  it "makes a new token for each server" do
+    expect(described_class.new(-> { session }).token).not_to eq(described_class.new(-> { session }).token)
+  end
+
+  it "binds to 127.0.0.1 by default" do
+    expect(server.instance_variable_get(:@address)).to eq("127.0.0.1")
+  end
+
+  it "serves the page to localhost, 127.0.0.1 and [::1]" do
+    %w[localhost:4567 127.0.0.1:4567 [::1]:4567].each { |host| expect(allowed?(request(host: host))).to be true }
+  end
+
+  it "answers a bound IPv6 address, which a Host header puts in brackets" do
+    server = described_class.new(-> { session }, port: 4567, address: "2001:db8::5", token: "secret")
+
+    expect(server.send(:allowed?, request(host: "[2001:db8::5]:4567"))).to be true
+  end
+
+  it "refuses another Host, which is what DNS rebinding sends" do
+    expect(allowed?(request(host: "evil.example:4567"))).to be false
+  end
+
+  it "takes a JSON post from its own page" do
+    req = request(method: "POST", content_type: "application/json; charset=utf-8", origin: "http://127.0.0.1:4567")
+
+    expect(allowed?(req)).to be true
+  end
+
+  it "refuses a post that is not JSON, which a cross-site form can send" do
+    expect(allowed?(request(method: "POST", content_type: "text/plain"))).to be false
+  end
+
+  it "refuses a post from another origin" do
+    req = request(method: "POST", content_type: "application/json", origin: "https://evil.example")
+
+    expect(allowed?(req)).to be false
+  end
+end

data/spec/elelem/server/index_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe "the web page" do
+  let(:html) { Elelem::Server::INDEX }
+
+  # The page once lived in a Ruby heredoc, which needed \\n. In a .html file
+  # that is a literal backslash, so no reply rendered its line breaks.
+  it "has no regex escaped for a Ruby string" do
+    expect(html.scan(%r{\.replace\(/[^\n]*\\\\[nwsS*]})).to be_empty
+  end
+
+  it "turns line breaks into <br>" do
+    expect(html).to include(".replace(/\\n/g, \"<br>\")")
+  end
+end

data/spec/elelem/server/serve_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe Elelem::Server, ".session_for" do
+  it "builds a tab session with the demo provider" do
+    session = described_class.session_for("demo")
+
+    expect(session.turn("echo hi")).to start_with("exit 0")
+  end
+end

data/spec/elelem/server/tab_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RSpec.describe Elelem::Server::Tab do
+  subject(:tab) { described_class.new(session) }
+
+  let(:said) { [] }
+  let(:terminal) { double("terminal", done: nil).tap { |t| allow(t).to receive(:say) { |text| said << text } } }
+  let(:commands) { Elelem::Commands.new.tap { |c| c.register("ping", description: "Ping") { said << "pong" } } }
+  let(:session) { double("session", output: terminal, commands: commands, turn: nil) }
+
+  it "runs a slash command instead of sending it to the model" do
+    tab.run("/ping")
+
+    expect(said).to eq(["pong"])
+    expect(session).not_to have_received(:turn)
+  end
+
+  it "lists the commands for an unknown one" do
+    tab.run("/nope")
+
+    expect(said).to eq(["/ping"])
+  end
+
+  it "does not let /exit or /reload reach past this tab" do
+    tab.run("/exit")
+    tab.run("/reload")
+
+    expect(said).to all(match(/not available in the browser/))
+  end
+
+  it "sends anything else to the model, and says when the turn is done" do
+    tab.run("hello")
+
+    expect(session).to have_received(:turn).with("hello")
+    expect(terminal).to have_received(:done)
+  end
+
+  it "keeps its place for a minute after its page goes, so a reconnecting page finds it" do
+    now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    allow(terminal).to receive_messages(subscribers: 0, last_seen: now)
+
+    expect(tab.idle?(now + 30)).to be false
+    expect(tab.idle?(now + 61)).to be true
+  end
+end

data/spec/elelem/server/turn_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+RSpec.describe Elelem::Server, "tabs and turns" do
+  subject(:server) { described_class.new(-> { build.call }, token: "t") }
+
+  let(:gate) { Queue.new }
+  let(:sessions) { [] }
+  let(:build) do
+    lambda do
+      terminal = double("terminal", done: nil, say: nil, subscribers: 0, last_seen: -1_000_000)
+      double("session", output: terminal).tap do |s|
+        allow(s).to receive(:turn) { gate.pop }
+        sessions << s
+      end
+    end
+  end
+
+  def request(tab, text = "hi")
+    double("request", body: JSON.generate(text: text), query: {}).tap do |req|
+      allow(req).to receive(:[]).with("X-Elelem-Tab").and_return(tab)
+    end
+  end
+
+  def post(tab, text = "hi")
+    res = Struct.new(:status, :body).new
+    server.send(:message, request(tab, text), res)
+    res
+  end
+
+  def wait_idle(tab)
+    sleep 0.01 until server.send(:tab_for, request(tab)).claim
+    server.send(:tab_for, request(tab)).instance_variable_set(:@busy, false)
+  end
+
+  it "gives each tab its own session" do
+    post("a")
+    post("b")
+
+    expect(sessions.size).to eq(2)
+    2.times { gate << :finish }
+  end
+
+  it "refuses a second message in the same tab while its turn runs, then takes the next" do
+    expect(post("a").status).to eq(204)
+    expect(post("a").status).to eq(409)
+    expect(post("b").status).to eq(204)
+
+    2.times { gate << :finish }
+    wait_idle("a")
+    expect(post("a").status).to eq(204)
+    gate << :finish
+  end
+
+  it "refuses a request without a tab id" do
+    expect(post(nil).status).to eq(400)
+  end
+
+  it "frees an idle tab's place at the limit, but not a busy one's" do
+    described_class::MAX_TABS.times { |i| post("t#{i}") }
+    expect(post("one-more").status).to eq(400)
+
+    gate << :finish
+    sleep 0.01 until server.instance_variable_get(:@tabs).values.any?(&:idle?)
+    expect(post("one-more").status).to eq(204)
+    described_class::MAX_TABS.times { gate << :finish }
+  end
+
+  it "builds a new tab without holding up the others" do
+    post("a")
+    gate << :finish
+    slow = Queue.new
+    server.instance_variable_set(:@build_session, -> { slow.pop and build.call })
+    Thread.new { server.send(:tab_for, request("slow")) }
+    sleep 0.05
+
+    expect(Timeout.timeout(1) { server.send(:tab_for, request("a")) }).not_to be_nil
+    slow << :go
+  end
+end

data/spec/elelem/server/web_terminal_spec.rb

@@ -101,11 +101,61 @@ RSpec.describe Elelem::Server::WebTerminal do
   end
 
   describe "#ask" do
-    it "emits a prompt and blocks until answered" do
+    it "emits a prompt with an id and blocks until answered with a matching id" do
       thread = Thread.new { subject.ask("Allow?") }
-      expect(events.pop).to eq({ type: "prompt", text: "Allow?" })
-      subject.answer("n")
+      event = events.pop
+      expect(event).to include(type: "prompt", text: "Allow?")
+      subject.answer(event[:id], "n")
       expect(thread.value).to eq("n")
     end
+
+    it "ignores an answer for an id that isn't pending" do
+      thread = Thread.new { subject.ask("Allow?") }
+      event = events.pop
+      subject.answer(event[:id] + 1, "n")
+      subject.answer(event[:id], "y")
+      expect(thread.value).to eq("y")
+    end
+
+    it "does not let an answer sent before any prompt pre-approve the next prompt" do
+      subject.answer(1, "y")
+
+      thread = Thread.new { subject.ask("Allow?") }
+      event = events.pop
+      subject.answer(event[:id], "n")
+
+      expect(thread.value).to eq("n")
+    end
+
+    it "accepts the options a session passes to ask" do
+      thread = Thread.new { subject.ask("Allow?", history: false) }
+      subject.answer(events.pop[:id], "y")
+      expect(thread.value).to eq("y")
+    end
+  end
+
+  it "replays a prompt still waiting for an answer to a page that subscribes again" do
+    terminal = described_class.new
+    asking = Thread.new { terminal.ask("Allow execute `ls`? [Y/n] > ") }
+    sleep 0.01 until terminal.instance_variable_get(:@open).any?
+
+    replay = terminal.subscribe.pop(timeout: 1)
+    expect(replay).to include(type: "prompt", text: "Allow execute `ls`? [Y/n] > ")
+
+    terminal.answer(replay[:id], "y")
+    expect(asking.value).to eq("y")
+    expect(terminal.subscribe.pop(timeout: 0.05)).to be_nil
+  end
+
+  it "numbers prompts across every terminal, so a rebuilt tab never reuses an id" do
+    first = described_class.new
+    second = described_class.new
+    ids = [first, second].map do |terminal|
+      Thread.new { terminal.ask("ok?") }
+      sleep 0.01 until terminal.instance_variable_get(:@open).any?
+      terminal.instance_variable_get(:@open).keys.first.tap { |id| terminal.answer(id, "y") }
+    end
+
+    expect(ids.uniq.size).to eq(2)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elelem-server
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - mo khan
@@ -13,16 +13,22 @@ dependencies:
   name: elelem
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0.11'
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0.11'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -59,22 +65,35 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/release.yml"
+- ".release-please-manifest.json"
 - ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
 - LICENSE.txt
 - Rakefile
 - exe/elelem-server
 - lib/elelem/server.rb
+- lib/elelem/server/index.html
+- lib/elelem/server/tab.rb
 - lib/elelem/server/version.rb
 - lib/elelem/server/web_terminal.rb
+- release-please-config.json
+- spec/elelem/server/guard_spec.rb
+- spec/elelem/server/index_spec.rb
+- spec/elelem/server/serve_spec.rb
+- spec/elelem/server/tab_spec.rb
+- spec/elelem/server/turn_spec.rb
 - spec/elelem/server/web_terminal_spec.rb
 - spec/spec_helper.rb
-homepage: https://src.mokhan.ca/elelem/server
+homepage: https://elelem.sh
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://src.mokhan.ca/elelem/server
-  source_code_uri: https://src.mokhan.ca/elelem/server
+  homepage_uri: https://elelem.sh
+  source_code_uri: https://github.com/elelem-sh/server
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -89,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A web UI server plugin for elelem.
 test_files: []