tina4ruby 3.13.34 → 3.13.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e94bf682abd45afc1478f5a2a14f9a5de1d669badbffd6c9c3d283a2ee97bcfd
-  data.tar.gz: f9fabc99e68b59c138fd8e89e33291997c0de1389b35f5e58640acb6e47c8533
+  metadata.gz: 7266dfb9cb9605c62b61d64de0c2586ff6824f2a22ad87aae74403f1d171c495
+  data.tar.gz: 0f9dffee4f4242c9c03899b79742a314bde065308da3e852c1af76fb1ade6be9
 SHA512:
-  metadata.gz: c76ab57f8ea6309d5612dd5c6f5141dff666c80e792715c5b2e3f8718f10860a25cbd149844f435bfb497ce26da7d13b1738e1bf132fb581196cf2a85717cd02
-  data.tar.gz: fbf2ce202dee833fa5e9489abb2811649f95a03f073610850c004fc3b6a1827987be0c52c61d8d80778ae9e054beac097a441b110af52bcc62deaca68e79a3cd
+  metadata.gz: ad75e74701786bf08fd4fc3c143a0d5f6731dbe0aa5feb5d46afb5c2472a113daa9dd0d2962f616c0a811318fed23091e40248117aee22923ea7fa35a81b6ab5
+  data.tar.gz: c5622aff3bf9fb522969dbe5431ae1a2aa8416712ade87ccd277529418a1aea6a427a25a211198342cfca0bebcff81305db70e6be01a0a11cfd7a2e99ebd6a9a

data/lib/tina4/dev_admin.rb

@@ -392,12 +392,30 @@ module Tina4
           reload_type = body["type"] || "reload"
           Tina4::Log.info("External reload trigger: #{reload_type}#{@reload_file.empty? ? '' : " (#{@reload_file})"}")
           # Re-discover so files dropped into src/routes/ register without
-          # a server restart. Idempotent — already-loaded files are skipped.
+          # a server restart. Idempotent — already-loaded files are skipped,
+          # changed files are re-loaded (mtime-tracked).
           begin
             Tina4::Router.rescan_routes!
           rescue StandardError => e
             Tina4::Log.error("Re-discover on reload failed: #{e.message}")
           end
+          # WebSocket-primary reload: push an instant message to every browser
+          # connected on /__dev_reload. The toolbar client (and the dev-admin
+          # dashboard) act on this immediately — the mtime poll above is only a
+          # fallback for when the socket is down. CSS changes swap stylesheets;
+          # everything else triggers a full page reload. We normalise the wire
+          # `type` to "css"/"reload" (the clients only react to css/reload/change)
+          # but still echo the caller's original type in the HTTP response.
+          # Wrapped so a broadcast failure — or zero connected clients — never
+          # 500s the reload endpoint.
+          begin
+            ws_type = reload_type == "css" ? "css" : "reload"
+            Tina4::DevReload.broadcast(
+              JSON.generate({ type: ws_type, file: @reload_file, mtime: @reload_mtime })
+            )
+          rescue StandardError => e
+            Tina4::Log.error("Dev-reload WebSocket broadcast failed: #{e.message}")
+          end
           json_response({ ok: true, type: reload_type })
         when ["GET", "/__dev/api/status"]
           json_response(status_payload)
@@ -614,6 +632,14 @@ module Tina4
         when ["POST", "/__dev/api/mcp/call"]
           body = read_json_body(env) || {}
           json_response(mcp_tool_call(body))
+        # JSON-RPC + SSE endpoints that real MCP clients (Claude Code/Desktop)
+        # speak. Mounted on the same dispatch as the REST shim above and gated
+        # on the same enabled? (TINA4_DEBUG) check, so disabled → 404. They
+        # share the default MCP server's tool registry with the REST shim.
+        when ["POST", "/__dev/mcp"], ["POST", "/__dev/mcp/message"]
+          mcp_jsonrpc(env)
+        when ["GET", "/__dev/mcp/sse"]
+          mcp_sse_handshake
         when ["GET", "/__dev/api/scaffold"]
           json_response(scaffold_templates)
         when ["POST", "/__dev/api/scaffold/run"]
@@ -1250,24 +1276,120 @@ module Tina4
         resolved
       end
 
+      # Noise dirs + hidden dot-entries are hidden from the file browser,
+      # except the env files — verbatim parity with PHP/Python dev-admin.
+      DEV_FILES_IGNORED = %w[__pycache__ node_modules vendor .git venv .venv dist target .tina4].freeze
+
+      def dev_files_hidden?(name)
+        return true if DEV_FILES_IGNORED.include?(name)
+        name.start_with?(".") && name != ".env" && name != ".env.example"
+      end
+
+      # Same 4-status mapping Python/PHP use for a porcelain code.
+      def dev_git_status_label(code)
+        return "untracked" if code == "??"
+        return "modified" if code.include?("M")
+        return "added" if code.include?("A")
+        return "deleted" if code.include?("D")
+        "clean"
+      end
+
+      # Branch + porcelain status map for the file browser (mirrors PHP/Python
+      # dev-admin). Paths git reports are relative to the repo root (always
+      # forward-slash); the project root may sit inside a larger repo, so the
+      # toplevel is returned too for rebasing. Empty on any error / no git.
+      def dev_git_info(root)
+        require "shellwords" unless defined?(Shellwords)
+        esc = Shellwords.escape(root)
+        inside = `cd #{esc} && git rev-parse --is-inside-work-tree 2>/dev/null`.strip
+        return { branch: "", git_root: nil, status: {} } unless inside == "true"
+
+        branch = `cd #{esc} && git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+        top = `cd #{esc} && git rev-parse --show-toplevel 2>/dev/null`.strip
+        git_root = top.empty? ? nil : top.tr("\\", "/").sub(%r{/+\z}, "")
+
+        status = {}
+        `cd #{esc} && git status --porcelain -uall 2>/dev/null`.each_line do |line|
+          line = line.chomp
+          next if line.length < 4
+          code = line[0, 2].strip
+          path = line[3..].to_s.strip
+          if (idx = path.index(" -> ")) # rename/copy — keep destination
+            path = path[(idx + 4)..]
+          end
+          next if path.nil? || path.empty?
+          status[path] = code
+        end
+        { branch: branch, git_root: git_root, status: status }
+      rescue StandardError
+        { branch: "", git_root: nil, status: {} }
+      end
+
       def files_list(env)
+        # Response shape matches tina4-python / tina4-php 1:1 so the dev-admin
+        # SPA works against every framework: each entry carries `is_dir`,
+        # `has_children`, `git_status` and `size`; the payload carries `branch`.
         rel = query_param(env, "path") || "."
-        begin
-          target = safe_project_path(rel)
-          return { error: "Not found" } unless File.exist?(target)
-          return { error: "Not a directory" } unless File.directory?(target)
-          entries = Dir.children(target).sort.map do |name|
-            full = File.join(target, name)
-            {
-              name: name,
-              type: File.directory?(full) ? "dir" : "file",
-              size: File.file?(full) ? File.size(full) : 0
-            }
+        root = File.expand_path(Dir.pwd)
+        git = dev_git_info(root)
+
+        # Missing/invalid paths return an empty-but-valid shape (not an error
+        # body): the SPA restores expanded-folder state from localStorage and
+        # non-existent folders would otherwise spam the console.
+        target = begin
+          safe_project_path(rel)
+        rescue StandardError
+          nil
+        end
+        unless target && File.directory?(target)
+          return { path: rel, branch: git[:branch], entries: [], error: "not a directory" }
+        end
+
+        root_fwd = root.tr("\\", "/")
+        cwd_in_git = ""
+        if git[:git_root] && git[:git_root] != root_fwd && root_fwd.start_with?(git[:git_root])
+          cwd_in_git = root_fwd[git[:git_root].length..].to_s.sub(%r{\A/+}, "")
+          cwd_in_git += "/" unless cwd_in_git.empty?
+        end
+
+        entries = Dir.children(target).sort.filter_map do |name|
+          next if dev_files_hidden?(name)
+          full = File.join(target, name)
+          entry_rel = full[root.length..].to_s.sub(%r{\A/+}, "").tr("\\", "/")
+          is_dir = File.directory?(full)
+
+          # git status for this entry (same mapping PHP/Python use)
+          git_path = cwd_in_git + entry_rel
+          label = "clean"
+          if (code = git[:status][git_path])
+            label = dev_git_status_label(code)
+          elsif is_dir
+            prefix = "#{git_path}/" # propagate dirty status from any child
+            hit = git[:status].find { |gf, _| gf.start_with?(prefix) }
+            label = (hit && hit[1] == "??") ? "untracked" : "modified" if hit
           end
-          { path: rel, entries: entries, count: entries.size }
-        rescue => e
-          { error: e.message }
+
+          # has_children: does the dir contain anything visible?
+          has_children = nil
+          if is_dir
+            has_children = begin
+              Dir.children(full).any? { |c| !dev_files_hidden?(c) }
+            rescue StandardError
+              false
+            end
+          end
+
+          {
+            name: name,
+            path: entry_rel,
+            is_dir: is_dir,
+            has_children: has_children,
+            git_status: label,
+            size: is_dir ? nil : (File.size(full) rescue 0)
+          }
         end
+
+        { path: rel, branch: git[:branch], entries: entries, count: entries.size }
       end
 
       def file_read_payload(rel)
@@ -1431,6 +1553,29 @@ module Tina4
         JSON.parse(raw)
       end
 
+      # Native MCP JSON-RPC endpoint (POST /__dev/mcp[/message]). Real MCP
+      # clients POST a JSON-RPC 2.0 request; we hand the parsed body straight
+      # to the default server's handle_message and echo the response. A
+      # notification (no id) yields an empty 204, mirroring Python.
+      def mcp_jsonrpc(env)
+        body = read_json_body(env) || {}
+        server = Tina4._default_mcp_server
+        raw = server.handle_message(body)
+        if raw.nil? || raw.empty?
+          [204, { "content-type" => "application/json; charset=utf-8" }, []]
+        else
+          [200, { "content-type" => "application/json; charset=utf-8" }, [raw]]
+        end
+      end
+
+      # SSE handshake (GET /__dev/mcp/sse). Tells the client where to POST
+      # JSON-RPC messages via the standard `endpoint` event, then the client
+      # switches to POST /__dev/mcp/message. Body + content-type match Python.
+      def mcp_sse_handshake
+        body = "event: endpoint\ndata: /__dev/mcp/message\n\n"
+        [200, { "content-type" => "text/event-stream" }, [body]]
+      end
+
       def scaffold_templates
         # Expose built-in scaffold targets for the dev-admin UI.
         { templates: [

data/lib/tina4/mcp.rb

@@ -423,8 +423,17 @@ module Tina4
 
   @_default_mcp_server = nil
 
+  # The default dev MCP server, mounted at /__dev/mcp. Built lazily on first
+  # access and pre-loaded with the built-in dev tools (database_query,
+  # file_read, route_list, …) so both the REST shim (/__dev/api/mcp/*) and
+  # the JSON-RPC + SSE endpoints (/__dev/mcp[/message], /__dev/mcp/sse)
+  # share one fully-populated tool registry.
   def self._default_mcp_server
-    @_default_mcp_server ||= McpServer.new("/__dev/mcp", name: "Tina4 Dev Tools")
+    @_default_mcp_server ||= begin
+      server = McpServer.new("/__dev/mcp", name: "Tina4 Dev Tools")
+      McpDevTools.register(server)
+      server
+    end
   end
 
   # Register a block as an MCP tool.
@@ -661,12 +670,13 @@ module Tina4
 
       # ── Route Tools ───────────────────────────────────
       server.register_tool("route_list", lambda {
-        routes = Tina4::Router.routes
-        routes.map do |route|
+        # Tina4::Router.routes returns Route objects (attr_readers), not
+        # Hashes — use accessors, never [] subscript.
+        Tina4::Router.routes.map do |route|
           {
-            "method"        => route[:method].to_s,
-            "path"          => route[:path].to_s,
-            "auth_required" => !route[:auth_handler].nil?
+            "method"        => route.method.to_s,
+            "path"          => route.path.to_s,
+            "auth_required" => route.auth_required ? true : false
           }
         end
       }, "List all registered routes")