tep 0.11.5 → 0.11.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0f6e0ace2299c85ad62734b3af3b5b5a704994d2c0769f3151f1741b2c7ec26
-  data.tar.gz: 0d57c798029526125f7698d20c9f6419c557381b0d99ebb55be2ca35a8e819d4
+  metadata.gz: 33b663dcc38571d71f8a729f7ed1f8da6ea8a89e1eb6bd49619beac977da2727
+  data.tar.gz: af7b47e7e3440372325744d1274e70e41216db757ac224ca2364c1a422b5064a
 SHA512:
-  metadata.gz: c5bc56857336297807d32345e8957dfafb714c6f15445da6b69a833b2d41090a4c3a8918ca89f5ec02bdbb593db1ed79996fb3ef5a271aec768358fe26604e67
-  data.tar.gz: 8fadaa359cdee7cd715e61e89c83ce29e82d471cfb2f00489c365f98078f7d50368aba77542fbe5e3fa6873898803a499c77913fac2dd32e01914cf3bdb7d5d0
+  metadata.gz: ed5ce816c591c5464d624e3094798d3ce8c8c03c7128e3881541cf874a0735e62f468d7d4f781e793e6ae02f2bcb642119fdc49157394acb69cb027a014d9b6e
+  data.tar.gz: 484a1cdae65a65cbe5da98d8c2aa22add1b4a562e35ab7cfb38f9137856bcad77ad773b07d191fb425a5e6307fe18a71856d47ad3766e8a03191622314ba2989

data/README.md

@@ -4,37 +4,41 @@
 
 # Tep
 
-A Sinatra-flavoured web framework that compiles to a native binary
-via [Spinel][spinel].
+A Sinatra-flavoured web framework that compiles to a **native binary**
+via [Spinel][spinel]. You write a Sinatra-style `app.rb`:
 
-> **Current release:** [v0.11.0](https://github.com/OriPekelman/tep/releases/tag/v0.11.0)
-> — now on [RubyGems](https://rubygems.org/gems/tep) (`gem install tep`):
-> TLS, HTTP caching, connection pooling, PG raise-on-error + embeddings,
-> on top of the agentic surface (Auth, Broadcast, Presence, LiveView, MCP).
+```ruby
+require 'sinatra'
+
+get '/hi/:name' do
+  "hi, " + params[:name] + "!"
+end
+```
+
+…and get `./app` — a single static executable, ~80 KB, **no Ruby
+runtime**, doing ~150k req/s. Beyond routing / sessions / templates, the
+[batteries ↓](#whats-in-the-box) cover auth (bearer / cookie / OAuth2),
+SQLite, opt-in PostgreSQL, WebSockets, Broadcast + Presence + LiveView,
+an MCP tool catalog, TLS, a pooled HTTP client, and an OpenAI-compatible
+LLM client + server.
+
+> **Current release:** [v0.11.6](https://github.com/OriPekelman/tep/releases/tag/v0.11.6)
+> on [RubyGems](https://rubygems.org/gems/tep) — `gem install tep`.
 > Pre-alpha; API still in motion.
 
-> **Why Tep exists.** Two complementary goals:
->
-> 1. **Exercise Spinel against real-world Ruby code.** Tep is the
->    largest pure-Ruby application Spinel compiles end-to-end. Every
->    Sinatra idiom, every battery, every demo doubles as a torture
->    test for the AOT compiler's codegen + analyzer. Bugs surface
->    here, get reduced to minimal repros, and land upstream as PRs
->    or issues against [matz/spinel](https://github.com/matz/spinel).
->    If something doesn't work in Tep, the bug is usually in Spinel,
->    and that's the point.
->
-> 2. **Be the harness for [toy][toy].** Toy is Tep's sibling
->    project: a machine-learning framework written in pure Ruby and
->    compiled by Spinel. Toy needs an HTTP/MCP layer for serving
->    models, exposing training tools to agents (Claude Code et al.),
->    streaming inference results, and wiring presence into
->    collaborative training sessions. Tep is that layer. Every
->    battery in Tep is shaped by what Toy actually needs to ship.
->
-> Tep happens to be useful as a general web framework too — fast,
-> single-binary, Sinatra-shaped — but the design choices are made
-> through these two lenses.
+<details>
+<summary><b>Why Tep exists</b> — it's a deliberate Spinel torture test + toy's serving layer</summary>
+
+Tep is the largest pure-Ruby application Spinel compiles end-to-end:
+every Sinatra idiom and battery doubles as a torture test for the AOT
+compiler's codegen + analyzer, and bugs found here get reduced to
+minimal repros and land upstream as
+[matz/spinel](https://github.com/matz/spinel) PRs. It's also the
+HTTP / MCP / serving layer for its sibling [toy][toy] — a pure-Ruby ML
+framework Spinel compiles — so every battery is shaped by what toy
+needs to ship. Tep is a genuinely useful general web framework too, but
+the design choices are made through those two lenses.
+</details>
 
 [toy]: https://github.com/OriPekelman/toy
 
@@ -107,7 +111,7 @@ gem install. Recommended Ruby manager:
 [`rv`](https://github.com/spinel-coop/rv) — fast version+gem
 manager from the Spinel Cooperative (separate project from the
 matz/spinel AOT compiler Tep compiles through; same Ruby
-neighbourhood). `.ruby-version` in this repo pins 3.4.0; `rv
+neighbourhood). `.ruby-version` in this repo pins 4.0.0; `rv
 shell` makes `rv run rake test` just work. Build deps on Linux:
 `build-essential`, `libsqlite3-dev`. macOS: Xcode CLI tools.
 
@@ -174,7 +178,7 @@ through Spinel.
 | `Tep::WebSocket` | RFC 6455 server-side WebSocket. `websocket '/chat' do \|ws\| ... end` DSL lowers to Frame + Handshake + Driver + Connection. Requires `set :scheduler, :scheduled`. |
 | `Tep::Parallel`  | grosser/parallel-shaped fork fan-out. |
 | `Tep::Job`       | sidekiq-shaped queue over SQLite. |
-| `PG`             | ruby-pg-shape libpq client: `PG::Connection`, `PG::Result`, `PG::Error`; surface mirrors the `pg` gem (`exec` / `exec_params` / `escape_*` / `fields` / `values` / `getvalue` / `sql_state`). Designed so an eventual ActiveRecord-on-spinel port reuses the existing AR adapter with minimal divergence — see `docs/PG-BATTERY.md`. |
+| `PG`             | **Opt-in** ruby-pg-shape libpq client — `require "tep/pg"` (so non-PG apps don't link libpq). `PG::Connection`, `PG::Result`, `PG::Error`; surface mirrors the `pg` gem (`exec` / `exec_params` / `escape_*` / `fields` / `values` / `getvalue` / `sql_state`). Designed so an eventual ActiveRecord-on-spinel port reuses the existing AR adapter with minimal divergence — see `docs/PG-BATTERY.md`. |
 | `Tep::Auth`      | Principal+delegate identity (`Tep::Identity` / `Tep::AgentDelegation`) + provider chain. Three providers shipped: `Tep::AuthBearerToken` (JWT-HS256), `Tep::AuthSessionCookie` (signed cookie), `Tep::AuthOAuth2` (authorization-code grant issuance for bots/agents). Same `req.identity` surface regardless of provider; agents are first-class (`identity.agent?`, `identity.acting_via.agent_id`, capability subsetting). |
 | `Tep::Broadcast` | In-process pub-sub + cross-worker via PG LISTEN/NOTIFY. Subscribe an fd to a topic (`subscribe` raw, `subscribe_ws` WS-frame-wrapped); publish writes to every matching subscriber. The seam Presence and LiveView build on. |
 | `Tep::Presence`  | Topic-keyed who's-here registry, agent-aware. `Tep::Presence.track(req, topic, fd)` records a (principal, session, topic) tuple with a 3-state structured status (`:available | :busy | :blocked` + free-text note + expiry). Diffs broadcast on join/leave/status; PG-mirror for cross-worker `list_global` snapshots. |

data/bin/tep

@@ -1610,7 +1610,14 @@ def rewrite_block(src, force_string: true)
     # are handled separately so they can contain commas or spaces.
     pairs = $2.scan(/(\w+):\s*("[^"]*"|'[^']*'|[^,}]+?)\s*(?=,|\z)/)
     setters = pairs.map { |k, v| %{__l["#{k}"] = (#{v.strip}).to_s} }.join("; ")
-    "(__l = Tep.str_hash; #{setters}; tep_view_#{view}(__l, req.ivars))"
+    # Build the locals hash INSIDE the first argument (a sequence
+    # expression that returns __l), rather than `(__l = ...; render(__l))`
+    # with __l a bare arg. In the latter shape spinel (recent master)
+    # hoists the `render`'s arg temp -- `_t = __l` -- above the in-sequence
+    # `__l = str_hash()` assignment, so render receives the pre-assignment
+    # (empty) hash and every interpolated value blanks (matz/spinel#1478).
+    # Keeping the assignment inside the arg evaluation defeats the hoist.
+    "tep_view_#{view}((__l = Tep.str_hash; #{setters}; __l), req.ivars)"
   end
   s = s.gsub(/(?<![\w.])erb\s+:(\w+)/, 'tep_view_\1(Tep.str_hash, req.ivars)')
 
@@ -1619,7 +1626,8 @@ def rewrite_block(src, force_string: true)
     view = $1
     pairs = $2.scan(/(\w+):\s*("[^"]*"|'[^']*'|[^,}]+?)\s*(?=,|\z)/)
     setters = pairs.map { |k, v| %{__l["#{k}"] = (#{v.strip}).to_s} }.join("; ")
-    "(__l = Tep.str_hash; #{setters}; tep_mustache_#{view}(__l, req.ivars))"
+    # Same arg-hoist avoidance as the erb form above (matz/spinel#1478).
+    "tep_mustache_#{view}((__l = Tep.str_hash; #{setters}; __l), req.ivars)"
   end
   s = s.gsub(/(?<![\w.])mustache\s+:(\w+)/, 'tep_mustache_\1(Tep.str_hash, req.ivars)')
 

data/examples/pg_hello.rb

@@ -68,15 +68,16 @@ get '/error' do
     out = "rescued PG::UndefinedTable\n" +
           "sqlstate: " + c.last_sqlstate + "\n" +
           "is undefined-table? " + (c.last_sqlstate == "42P01" ? "yes" : "no") + "\n" +
-          # WORKAROUND -- REMOVE WHEN UPSTREAM LANDS: `e.is_a?(PG::Error)`
-          # miscompiles at spinel master (whole-program is_a? on a deep
-          # exception subclass vs an ancestor -- e here is rescued as
-          # PG::UndefinedTable, a PG::Error subclass, so this is always
-          # "yes"). Minimal `rescue Sub => e; e.is_a?(Super)` repros
-          # compile fine; it only trips in the full program. Hardcoded
-          # to "yes" to keep the example building for the re-pin. See
-          # matz/spinel#1434, tep#196. Original:
+          # WORKAROUND -- still open at SPINEL_PIN (re-checked at the
+          # ad2b71ad re-pin: `e.is_a?(PG::Error)` here is rejected as
+          # `unsupported call: is_a? recv=LocalVariableRead argc=1`).
+          # `e` is the rescued exception, typed PG::UndefinedTable -- a
+          # whole-program is_a? against the namespaced ancestor PG::Error
+          # isn't lowered yet. Minimal `rescue Sub => e; e.is_a?(Super)`
+          # compiles fine; only the full program trips it. Since `e` is
+          # always a PG::Error subclass here, hardcode "yes". Restore
           #   (e.is_a?(PG::Error) ? "yes" : "no")
+          # once is_a?-on-rescued-namespaced-ancestor lowers. See tep#196.
           "is PG::Error? " + "yes" + "\n" +
           "message: " + e.message
   end

data/lib/tep/pg.rb

@@ -197,34 +197,19 @@ module PG
           h = Pg.tep_pg_connect(opts)
         end
       else
-        # ============ WORKAROUND -- REMOVE WHEN UPSTREAM LANDS ============
-        # Hash-conninfo form. The `opts.each` below miscompiles at spinel
-        # master: `opts` is a String|Hash param, but in this is_a?(String)
-        # ELSE branch spinel types it String (the is_a?-else narrowing
-        # gap, matz/spinel#1434) and rejects `opts.each` as String#each
-        # -- the lone blocker to re-pinning tep onto master (tep#196).
-        #
-        # The Hash form is currently UNUSED + untested in tep and toy:
-        # every PG::Connection.new / PG.connect caller passes a String
-        # conninfo (AR connects with the String form too). So we stub
-        # this dead branch to a failed connection to unblock the re-pin.
-        #
-        # RESTORE the original kv-pack loop (preserved below) once the
-        # upstream narrowing fix lands, and re-add Hash-form test
-        # coverage. Until then a Hash arg yields a failed Connection
-        # (connected? == false) rather than a miscompile.
-        #
-        #   keys = ""
-        #   vals = ""
-        #   n = 0
-        #   opts.each do |k, v|
-        #     keys = keys + k + "\0"
-        #     vals = vals + v + "\0"
-        #     n += 1
-        #   end
-        #   h = Pg.tep_pg_connect_kv(keys, vals, n)
-        h = -1
-        # =================================================================
+        # Hash-conninfo form: pack the key/value pairs into NUL-delimited
+        # buffers for the C shim. (`opts` narrows to Hash in this
+        # is_a?(String) ELSE branch -- the narrowing gap that blocked the
+        # re-pin, matz/spinel#1434, is fixed as of the SPINEL_PIN bump.)
+        keys = ""
+        vals = ""
+        n = 0
+        opts.each do |k, v|
+          keys = keys + k + "\0"
+          vals = vals + v + "\0"
+          n += 1
+        end
+        h = Pg.tep_pg_connect_kv(keys, vals, n)
       end
       if h < 0
         # Slot 0 holds the most recent connect-failure error message

data/lib/tep/proxy.rb

@@ -62,7 +62,7 @@ module Tep
   # wins (whichever setter you called second).
   #
   # Default shape: max_attempts=1 (no retry, back-compat).
-  class Proxy
+  class Proxy < Tep::Handler
     class RetryPolicy
       attr_accessor :max_attempts, :base_backoff_ms, :backoff_multiplier
       attr_accessor :retry_on_status
@@ -125,7 +125,7 @@ module Tep
     end
   end
 
-  class Proxy < Tep::Handler
+  class Proxy
     attr_accessor :upstream, :timeout
     # Body size caps (chunk 6.6). max_request_body_bytes bounds the
     # inbound body the proxy will accept (over -> 413 Payload Too

data/lib/tep/shell.rb

@@ -36,18 +36,29 @@ module Tep
 
     # Read a file's contents. Useful for /proc/loadavg, /proc/meminfo,
     # /sys/class/thermal/.../temp, and similar small-text endpoints.
-    # Returns "" on open failure (spinel's File.read swallows fopen
-    # errors and returns the empty string -- matches the prior
-    # sphttp_file_read behaviour).
+    # Returns "" on open failure. Spinel's File.read now raises a
+    # CRuby-correct Errno on a missing/unreadable path (it used to
+    # silently return ""); we rescue here to preserve this helper's
+    # never-raise contract -- a handler reading /proc should get "" for
+    # an absent file, not a 502'd worker.
     def self.read(path)
-      File.read(path)
+      begin
+        File.read(path)
+      rescue => e
+        ""
+      end
     end
 
     # Bounded read: slice after the fact. The cap is mostly a
     # defensive cue -- callers that need it should be reading
-    # bounded /proc files anyway.
+    # bounded /proc files anyway. Same never-raise contract as #read.
     def self.read_limited(path, max_bytes)
-      out = File.read(path)
+      out = ""
+      begin
+        out = File.read(path)
+      rescue => e
+        out = ""
+      end
       out.length > max_bytes ? out[0, max_bytes] : out
     end
 

data/lib/tep/version.rb

@@ -1,3 +1,3 @@
 module Tep
-  VERSION = "0.11.5"
+  VERSION = "0.11.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tep
 version: !ruby/object:Gem::Version
-  version: 0.11.5
+  version: 0.11.6
 platform: ruby
 authors:
 - Ori Pekelman