@tutorialkit-rb/cli 0.1.5 → 0.1.8

package/template/src/templates/default/lib/http-bridge.js

@@ -0,0 +1,55 @@
+// HTTP bridge for Ruby WASM — registers global.wasmHttpBridge
+// Follows the same pattern as PGLite (global.pglite = new PGLite4Rails(...))
+
+export function initHttpBridge() {
+  global.wasmHttpBridge = {
+    async fetch(url, method, headersJson, body) {
+      try {
+        const headers = JSON.parse(headersJson);
+        const options = { method, headers };
+        if (body && method !== 'GET' && method !== 'HEAD') {
+          options.body = body;
+        }
+
+        console.log(`[http-bridge] ${method} ${url}`);
+        options.signal = AbortSignal.timeout(30000);
+        const response = await fetch(url, options);
+        console.log(`[http-bridge] ${response.status} ${url}`);
+
+        const contentType = response.headers.get('content-type') || '';
+        const isBinary = /octet-stream|image\/|audio\/|video\/|application\/pdf|application\/zip/.test(contentType);
+
+        let responseBody;
+        if (isBinary) {
+          const buffer = await response.arrayBuffer();
+          const bytes = new Uint8Array(buffer);
+          let binary = '';
+          for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          responseBody = btoa(binary);
+        } else {
+          responseBody = await response.text();
+        }
+
+        const responseHeaders = {};
+        response.headers.forEach((v, k) => { responseHeaders[k] = v; });
+
+        return JSON.stringify({
+          ok: true,
+          status: response.status,
+          headers: responseHeaders,
+          body: responseBody,
+          binary: isBinary
+        });
+      } catch (error) {
+        const detail = error.cause ? `${error.message} (cause: ${error.cause.message || error.cause})` : error.message;
+        console.error(`[http-bridge] ERROR ${method} ${url}: ${detail}`);
+        return JSON.stringify({
+          ok: false,
+          error: detail
+        });
+      }
+    }
+  };
+}

package/template/src/templates/default/lib/patches/http_bridge.rb

@@ -0,0 +1,167 @@
+require "net/http"
+require "json"
+require "base64"
+require "uri"
+
+# WASM has no socket extension, so SocketError is never defined.
+# faraday-net_http references it at class load time.
+SocketError = Class.new(StandardError) unless defined?(SocketError)
+
+# OpenSSL is not available in WASM. Stub the module so code that
+# references OpenSSL::SSL (e.g. Faraday, Net::HTTP) doesn't crash.
+# Actual HTTPS is handled by the browser's native fetch via the JS bridge.
+unless defined?(OpenSSL::SSL)
+  module OpenSSL
+    class OpenSSLError < StandardError; end
+    module SSL
+      class SSLError < OpenSSLError; end
+      VERIFY_NONE = 0
+      VERIFY_PEER = 1
+      VERIFY_FAIL_IF_NO_PEER_CERT = 2
+      VERIFY_CLIENT_ONCE = 4
+      OP_ALL = 0x80000BFF
+      OP_NO_SSLv2 = 0x01000000
+      OP_NO_SSLv3 = 0x02000000
+      OP_NO_TLSv1 = 0x04000000
+
+      class SSLContext
+        attr_accessor :verify_mode, :cert_store, :min_version, :max_version, :options
+        def set_params(**params); self; end
+      end
+
+      class SSLSocket
+        def initialize(io, ctx = nil); end
+        def connect; self; end
+        def hostname=(h); end
+        def sync_close=(v); end
+      end
+    end
+  end
+end
+
+module WasmHTTP
+  MESSAGES = {
+    200 => "OK", 201 => "Created", 202 => "Accepted", 204 => "No Content",
+    301 => "Moved Permanently", 302 => "Found", 303 => "See Other", 304 => "Not Modified",
+    307 => "Temporary Redirect", 308 => "Permanent Redirect",
+    400 => "Bad Request", 401 => "Unauthorized", 403 => "Forbidden",
+    404 => "Not Found", 405 => "Method Not Allowed", 408 => "Request Timeout",
+    409 => "Conflict", 422 => "Unprocessable Entity", 429 => "Too Many Requests",
+    500 => "Internal Server Error", 502 => "Bad Gateway", 503 => "Service Unavailable",
+    504 => "Gateway Timeout"
+  }.freeze
+
+  class Connection
+    class << self
+      attr_accessor :proxy_url, :proxy_hosts
+    end
+
+    def request(uri, method: "GET", headers: {}, body: nil)
+      target = resolve_proxy(uri.to_s)
+
+      result_js = JS.global[:wasmHttpBridge].fetch(
+        target,
+        method.to_s,
+        headers.to_json,
+        body.to_s
+      ).await
+
+      result = JSON.parse(result_js.to_s)
+
+      unless result["ok"]
+        raise SocketError, "HTTP request failed: #{result["error"]}"
+      end
+
+      build_response(result)
+    end
+
+    private
+
+    def resolve_proxy(url)
+      return url unless self.class.proxy_url
+
+      begin
+        host = URI(url).host
+      rescue URI::InvalidURIError
+        return url
+      end
+      return url unless host
+
+      if self.class.proxy_hosts&.any? { |h| host == h || host.end_with?(".#{h}") }
+        "#{self.class.proxy_url}#{url}"
+      else
+        url
+      end
+    end
+
+    def build_response(result)
+      status = result["status"]
+      klass = Net::HTTPResponse::CODE_TO_OBJ[status.to_s] || Net::HTTPUnknownResponse
+      response = klass.new("1.1", status, MESSAGES[status] || "Unknown")
+      response.instance_variable_set(:@read, true)
+
+      result["headers"]&.each { |k, v| response[k] = v }
+
+      body = result["binary"] ? Base64.decode64(result["body"]) : result["body"]
+      response.instance_variable_set(:@body, body)
+
+      response
+    end
+  end
+end
+
+Net::HTTP.prepend(Module.new do
+  def request(req, body = nil, &block)
+    req.body = body if body && req.body.nil?
+
+    scheme = use_ssl? ? "https" : "http"
+    default_port = use_ssl? ? 443 : 80
+    port_str = port == default_port ? "" : ":#{port}"
+    uri = "#{scheme}://#{address}#{port_str}#{req.path}"
+
+    headers = {}
+    req.each_header { |k, v| headers[k] = v }
+
+    response = WasmHTTP::Connection.new.request(
+      uri, method: req.method, headers: headers, body: req.body
+    )
+
+    # Faraday's NetHttp adapter passes a block to request() where it
+    # calls save_http_response to set env.status. Without yielding,
+    # the status is never set and RubyLLM's error middleware fails.
+    yield response if block
+
+    response
+  end
+
+  def connect; end
+
+  def do_start
+    @started = true
+    self
+  end
+
+  def do_finish
+    @started = false
+  end
+end)
+
+if defined?(Faraday)
+  class Faraday::Adapter::WasmHTTP < Faraday::Adapter
+    def call(env)
+      super
+      response = ::WasmHTTP::Connection.new.request(
+        env.url.to_s,
+        method: env.method.to_s.upcase,
+        headers: env.request_headers.to_h,
+        body: env.body
+      )
+      save_response(env, response.code.to_i, response.body) do |resp_headers|
+        response.each_header { |k, v| resp_headers[k] = v }
+      end
+    end
+  end
+
+  Faraday::Adapter.register_middleware(wasm_http: Faraday::Adapter::WasmHTTP)
+  Faraday.default_adapter = :wasm_http
+end

package/template/src/templates/default/lib/rails.js

@@ -1,18 +1,35 @@
+import { bootProgress } from './boot-progress.js';
 import { RubyVM } from "@ruby/wasm-wasi";
 import { WASI } from "wasi";
 import fs from "fs/promises";
 import { PGLite4Rails } from "./database.js";
+import { initHttpBridge } from './http-bridge.js';
+
+function timer() {
+  const start = performance.now();
+  return () => {
+    const ms = performance.now() - start;
+    return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+  };
+}
 
-const rubyWasm = new URL("../node_modules/@ruby/wasm-wasi/dist/ruby.wasm", import.meta.url).pathname;
+const defaultWasmPath = new URL("../node_modules/@ruby/wasm-wasi/dist/ruby.wasm", import.meta.url).pathname;
 
-const railsRootDir = new URL("../workspace/store", import.meta.url).pathname;
+const railsRootDir = new URL("../workspace", import.meta.url).pathname;
 const pgDataDir = new URL("../pgdata", import.meta.url).pathname;
 
 export default async function initVM(vmopts = {}) {
-  const { args, skipRails } = vmopts;
+  const totalTimer = timer();
+  const { args, skipRails, wasmPath } = vmopts;
   const env = vmopts.env || {};
-  const binary = await fs.readFile(rubyWasm);
+
+  // --- WASM load + compile ---
+  const wasmTimer = timer();
+  bootProgress.updateStep('Loading Ruby WASM...');
+  const binary = await fs.readFile(wasmPath || defaultWasmPath);
   const module = await WebAssembly.compile(binary);
+  bootProgress.updateProgress(100);
+  bootProgress.log(`WASM load + compile (${wasmTimer()})`);
 
   const RAILS_ENV = env.RAILS_ENV || process.env.RAILS_ENV;
   if (RAILS_ENV) env.RAILS_ENV = RAILS_ENV;
@@ -24,6 +41,9 @@ export default async function initVM(vmopts = {}) {
 
   const cliArgs = args?.length ? ['ruby.wasm'].concat(args) : undefined;
 
+  // --- VM instantiation ---
+  const vmTimer = timer();
+  bootProgress.updateStep('Initializing Ruby VM...');
   const wasi = new WASI(
     {
       env: {"RUBYOPT": "-EUTF-8 -W0", ...env},
@@ -41,29 +61,56 @@ export default async function initVM(vmopts = {}) {
     wasip1: wasi,
     args: cliArgs
   });
+  bootProgress.log(`VM instantiation (${vmTimer()})`);
 
   if (!skipRails) {
+    const railsTimer = timer();
+    bootProgress.updateStep('Bootstrapping Rails...');
+
     const pglite = new PGLite4Rails(pgDataDir);
     global.pglite = pglite;
 
+    initHttpBridge();
+
+    const httpBridgePatch = await fs.readFile(new URL("./patches/http_bridge.rb", import.meta.url).pathname, 'utf8');
     const authenticationPatch = await fs.readFile(new URL("./patches/authentication.rb", import.meta.url).pathname, 'utf8');
     const appGeneratorPatch = await fs.readFile(new URL("./patches/app_generator.rb", import.meta.url).pathname, 'utf8');
 
     vm.eval(`
+      def _boot_time(label)
+        t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        yield
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t
+        $stderr.puts "[boot] #{label} (#{"%.1f" % elapsed}s)"
+      end
+
       Dir.chdir("${workdir}") unless "${workdir}".empty?
 
       ENV["RACK_HANDLER"] = "wasi"
+      ENV["BUNDLE_GEMFILE"] = "/rails-vm/Gemfile"
+      # Prevent Minitest from enabling parallel mode
+      ENV["MT_CPU"] = "1"
 
-      require "/rails-vm/boot"
+      _boot_time("require /rails-vm/boot") { require "/rails-vm/boot" }
 
       require "js"
 
+      ${httpBridgePatch}
+
       Wasmify::ExternalCommands.register(:server, :console)
 
       ${authenticationPatch}
       ${appGeneratorPatch}
     `)
+
+    bootProgress.updateProgress(100);
+    bootProgress.log(`Rails bootstrap (${railsTimer()})`);
   }
 
+  bootProgress.log(`Total (${totalTimer()})`);
+  bootProgress.updateStep('Ready');
+
   return vm;
 }
+
+export { bootProgress };

package/template/src/templates/default/lib/server.js

@@ -92,6 +92,9 @@ class ResponseOutparam {
         if (location.startsWith("http://localhost:3000/")) {
           res.set("location", location.replace("http://localhost:3000", ""));
         }
+        if (location.startsWith("https://localhost:3000/")) {
+          res.set("location", location.replace("https://localhost:3000", ""));
+        }
       }
 
       let body = response.call("body").toJS();
@@ -293,14 +296,43 @@ export const createRackServer = async (vm, opts = {}) => {
 
   const app = express();
 
+  // --- Observability: log every request before anything else ---
+  app.use((req, res, next) => {
+    const start = Date.now();
+    console.log(`[express] --> ${req.method} ${req.url}`);
+    res.on('finish', () => {
+      console.log(`[express] <-- ${req.method} ${req.url} ${res.statusCode} (${Date.now() - start}ms)`);
+    });
+    next();
+  });
+
+  // --- Health endpoint: bypasses Rails entirely ---
+  app.get('/__healthz', (req, res) => {
+    res.json({ status: 'ok', uptime: process.uptime() });
+  });
+
   const upload = multer({ storage: multer.memoryStorage() });
   app.use(upload.any());
   app.use(createFrameLocationTrackingMiddleware());
 
   const queue = new RequestQueue((req, res) => requestHandler(vm, req, res));
 
+  // --- Request timeout: never hang forever ---
+  const REQUEST_TIMEOUT_MS = 60000;
+
   app.all('*path', async (req, res) => {
-    await queue.respond(req, res)
+    const timer = setTimeout(() => {
+      if (!res.headersSent) {
+        console.error(`[express] TIMEOUT ${req.method} ${req.url} after ${REQUEST_TIMEOUT_MS}ms`);
+        res.status(504).json({ error: 'Request timed out', url: req.url, timeout_ms: REQUEST_TIMEOUT_MS });
+      }
+    }, REQUEST_TIMEOUT_MS);
+
+    try {
+      await queue.respond(req, res);
+    } finally {
+      clearTimeout(timer);
+    }
   });
 
   return app;

package/template/src/templates/default/package.json

@@ -7,7 +7,10 @@
     "dev": "vite",
     "test": "node --disable-warning=ExperimentalWarning ./scripts/test.js",
     "test:watch": "node --disable-warning=ExperimentalWarning --watch --watch-path=./workspace ./scripts/test.js",
-    "postinstall": "chmod +x bin/* && node --disable-warning=ExperimentalWarning ./scripts/wait-for-wasm.js"
+    "postinstall": "chmod +x bin/* && node --disable-warning=ExperimentalWarning ./scripts/wait-for-wasm.js",
+    "smoke": "node --disable-warning=ExperimentalWarning --no-turbo-fast-api-calls --loader ./scripts/wasi-loader.mjs ./scripts/smoke-test.js",
+    "smoke:fetch": "node --disable-warning=ExperimentalWarning --no-turbo-fast-api-calls --loader ./scripts/wasi-loader.mjs ./scripts/smoke-test.js --fetch",
+    "smoke:http": "node --disable-warning=ExperimentalWarning --no-turbo-fast-api-calls --loader ./scripts/wasi-loader.mjs ./scripts/smoke-test.js --http"
   },
   "dependencies": {
     "@electric-sql/pglite": "^0.3.1",

package/template/src/templates/default/scripts/rails.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import { join } from 'path';
 import { spawn } from 'child_process';
 
-const railsRootDir = new URL("../workspace/store", import.meta.url).pathname;
+const railsRootDir = new URL("../workspace", import.meta.url).pathname;
 const railsPath = join(railsRootDir, 'bin/rails');
 
 const waitBinRails = async () => {