lux-hammer 0.3.13 → 0.3.15

data/lib/hammer/cron_web.rb

@@ -0,0 +1,304 @@
+require 'socket'
+require 'cgi'
+require 'json'
+
+class Hammer
+  # Localhost web UI for Hammer::CronServer. Hand-rolled HTTP on stdlib
+  # TCPServer - the gem has no runtime dependencies and the protocol
+  # surface needed here is tiny: parse the request line, drain headers,
+  # route on verb+path, answer with Connection: close. No keep-alive, no
+  # chunked encoding, one short-lived thread per request so a slow
+  # client cannot block the scheduler or other viewers.
+  #
+  # Routes:
+  #   GET  /               jobs table (schedule, last/next run, status)
+  #   GET  /job/<path>     log viewer; ?file=1 shows the rotated log
+  #   POST /job/<path>/run trigger a manual run, redirect back (303)
+  #   GET  /json           live status as JSON, for scripting
+  class CronWeb
+    REFRESH_SECONDS ||= 10
+    TAIL_BYTES      ||= 65_536   # log viewer shows at most the last 64 KB
+
+    def initialize(server, port:, pass: nil)
+      @server = server
+      @port   = port
+      @pass   = pass && !pass.empty? ? pass : nil
+    end
+
+    # Actual bound port - differs from the requested one only when the
+    # caller asked for port 0 (tests grab a free ephemeral port that way).
+    def bound_port
+      @tcp&.addr&.fetch(1)
+    end
+
+    # Bind 127.0.0.1 only - the UI can trigger task runs, it must never
+    # listen on a public interface. Returns self so the caller can hold
+    # the instance for #stop.
+    def start
+      @tcp = TCPServer.new('127.0.0.1', @port)
+      @thread = Thread.new do
+        loop do
+          sock = begin
+            @tcp.accept
+          rescue IOError, Errno::EBADF
+            break   # #stop closed the listener
+          end
+          Thread.new(sock) do |s|
+            begin
+              handle(s)
+            rescue StandardError
+              nil   # a broken client must not take the UI down
+            ensure
+              s.close rescue nil
+            end
+          end
+        end
+      end
+      self
+    rescue Errno::EADDRINUSE
+      raise Hammer::Error, "h:cron web ui: port #{@port} is taken - pick another with --port"
+    end
+
+    # Closing the listener pops the accept loop out with IOError.
+    def stop
+      @tcp&.close
+      @thread&.join(2)
+    end
+
+    private
+
+    # Minimal HTTP: request line + headers, drain any Content-Length body
+    # (our POSTs carry none we care about), then route. With a --pass
+    # configured every route requires HTTP Basic auth first.
+    def handle(sock)
+      line = sock.gets or return
+      verb, target, = line.split(' ', 3)
+      length = 0
+      auth   = nil
+      while (h = sock.gets) && h.strip != ''
+        length = h.split(':', 2).last.to_i    if h =~ /\Acontent-length:/i
+        auth   = h.split(':', 2).last.strip   if h =~ /\Aauthorization:/i
+      end
+      sock.read(length) if length > 0
+
+      return unauthorized(sock) if @pass && !authorized?(auth)
+
+      path, query = target.to_s.split('?', 2)
+      route(sock, verb, CGI.unescape(path.to_s), query.to_s)
+    end
+
+    # Only the password half of `user:pass` is checked - any username
+    # works (`curl -u :secret`). Constant-time compare so the password
+    # can't be guessed byte-by-byte from response timing.
+    def authorized?(header)
+      return false unless header && header =~ /\ABasic (.+)\z/
+      decoded = begin
+        Regexp.last_match(1).unpack1('m')
+      rescue ArgumentError
+        return false
+      end
+      pass = decoded.to_s.split(':', 2)[1].to_s
+      secure_compare(pass, @pass)
+    end
+
+    def secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+      diff = 0
+      a.bytes.zip(b.bytes) { |x, y| diff |= x ^ y }
+      diff.zero?
+    end
+
+    # 401 + the WWW-Authenticate challenge that makes browsers pop the
+    # native login prompt.
+    def unauthorized(sock)
+      body = layout('unauthorized', '<p>401 - password required</p>')
+      sock.write "HTTP/1.1 401 Unauthorized\r\n" \
+                 "WWW-Authenticate: Basic realm=\"h:cron\"\r\n" \
+                 "Content-Type: text/html; charset=utf-8\r\n" \
+                 "Content-Length: #{body.bytesize}\r\n" \
+                 "Connection: close\r\n\r\n"
+      sock.write body
+    end
+
+    def route(sock, verb, path, query)
+      case
+      when verb == 'GET' && path == '/'
+        respond(sock, 200, layout('jobs', index_html))
+      when verb == 'GET' && path == '/json'
+        respond(sock, 200, JSON.pretty_generate(json_status), type: 'application/json')
+      when verb == 'POST' && path =~ %r{\A/job/(.+)/run\z}
+        job_path = Regexp.last_match(1)
+        if @server.run_now(job_path)
+          redirect(sock, "/job/#{CGI.escape(job_path)}")
+        else
+          respond(sock, 404, layout('not found', "<p>unknown job #{h(job_path)}</p>"))
+        end
+      when verb == 'GET' && path =~ %r{\A/job/(.+)\z}
+        job_path = Regexp.last_match(1)
+        if @server.job?(job_path)
+          respond(sock, 200, layout(job_path, job_html(job_path, rotated: query == 'file=1')))
+        else
+          respond(sock, 404, layout('not found', "<p>unknown job #{h(job_path)}</p>"))
+        end
+      else
+        respond(sock, 404, layout('not found', '<p>404</p>'))
+      end
+    end
+
+    # ----- responses -------------------------------------------------------
+
+    def respond(sock, status, body, type: 'text/html; charset=utf-8')
+      text = { 200 => 'OK', 303 => 'See Other', 404 => 'Not Found' }[status] || 'OK'
+      sock.write "HTTP/1.1 #{status} #{text}\r\n" \
+                 "Content-Type: #{type}\r\n" \
+                 "Content-Length: #{body.bytesize}\r\n" \
+                 "Connection: close\r\n\r\n"
+      sock.write body
+    end
+
+    # Post-redirect-get: the browser lands back on a plain GET, so a
+    # refresh never re-triggers the run.
+    def redirect(sock, location)
+      sock.write "HTTP/1.1 303 See Other\r\n" \
+                 "Location: #{location}\r\n" \
+                 "Content-Length: 0\r\n" \
+                 "Connection: close\r\n\r\n"
+    end
+
+    # ----- views -----------------------------------------------------------
+
+    def index_html
+      rows = @server.snapshot.map do |j|
+        badge = status_badge(j)
+        <<~ROW
+          <tr>
+            <td><a href="/job/#{CGI.escape(j[:path])}">#{h(j[:path])}</a></td>
+            <td><code>#{h(j[:cron])}</code></td>
+            <td>#{h(fmt_time(j[:last_run]))}</td>
+            <td>#{badge}</td>
+            <td>#{h(fmt_time(j[:next_run]))}</td>
+            <td>
+              <form method="post" action="/job/#{CGI.escape(j[:path])}/run">
+                <button#{j[:running] ? ' disabled' : ''}>run now</button>
+              </form>
+            </td>
+          </tr>
+        ROW
+      end
+      <<~HTML
+        <table>
+          <tr><th>task</th><th>schedule</th><th>last run</th><th>status</th><th>next run</th><th></th></tr>
+          #{rows.join}
+        </table>
+      HTML
+    end
+
+    def job_html(path, rotated: false)
+      job  = @server.snapshot.find { |j| j[:path] == path }
+      file = log_file(path, rotated: rotated)
+      log  = tail_file(file)
+      <<~HTML
+        <p><a href="/">&larr; all jobs</a></p>
+        <h2>#{h(path)}</h2>
+        <p>
+          <code>#{h(job[:cron])}</code> &middot;
+          #{status_badge(job)} &middot;
+          last run #{h(fmt_time(job[:last_run]))} &middot;
+          next run #{h(fmt_time(job[:next_run]))}
+          #{job[:duration] ? "&middot; took #{format('%.1f', job[:duration])}s" : ''}
+        </p>
+        <form method="post" action="/job/#{CGI.escape(path)}/run">
+          <button#{job[:running] ? ' disabled' : ''}>run now</button>
+        </form>
+        <p class="files">
+          #{rotated ? "<a href=\"/job/#{CGI.escape(path)}\">current log</a>" : '<b>current log</b>'} |
+          #{rotated ? '<b>rotated log</b>' : "<a href=\"/job/#{CGI.escape(path)}?file=1\">rotated log</a>"}
+        </p>
+        <pre>#{h(log)}</pre>
+      HTML
+    end
+
+    def layout(title, body)
+      <<~HTML
+        <!doctype html>
+        <html>
+        <head>
+          <meta charset="utf-8">
+          <meta http-equiv="refresh" content="#{REFRESH_SECONDS}">
+          <title>h:cron - #{h(title)}</title>
+          <style>
+            body { font: 14px/1.5 -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+                   margin: 2rem auto; max-width: 60rem; padding: 0 1rem; color: #222; }
+            h1 a { color: inherit; text-decoration: none; }
+            table { border-collapse: collapse; width: 100%; }
+            th, td { text-align: left; padding: .4rem .8rem; border-bottom: 1px solid #ddd; }
+            th { color: #888; font-weight: 600; }
+            code { background: #f4f4f4; padding: .1rem .3rem; border-radius: 3px; }
+            pre { background: #1a1a1a; color: #ddd; padding: 1rem; border-radius: 6px;
+                  overflow-x: auto; white-space: pre-wrap; word-break: break-all; }
+            button { cursor: pointer; }
+            .ok      { color: #2a7d2a; }
+            .failed, .error { color: #c02626; }
+            .running { color: #b8860b; }
+            .never, .unknown { color: #888; }
+            .files   { color: #888; }
+            footer   { color: #aaa; margin-top: 2rem; font-size: 12px; }
+            @media (prefers-color-scheme: dark) {
+              body { background: #111; color: #ccc; }
+              th, td { border-color: #333; }
+              code { background: #222; }
+            }
+          </style>
+        </head>
+        <body>
+          <h1><a href="/">h:cron</a></h1>
+          #{body}
+          <footer>hammer #{Hammer::VERSION} &middot; #{h(@server.root_dir)} &middot; refreshes every #{REFRESH_SECONDS}s</footer>
+        </body>
+        </html>
+      HTML
+    end
+
+    def status_badge(j)
+      label = j[:running] ? 'running' : (j[:status] || 'never ran')
+      css   = j[:running] ? 'running' : (j[:status] || 'never')
+      extra = !j[:running] && j[:exit_code] ? " (exit #{j[:exit_code]})" : ''
+      "<span class=\"#{h(css)}\">#{h(label)}#{h(extra)}</span>"
+    end
+
+    def json_status
+      @server.snapshot.map do |j|
+        j.merge(last_run: j[:last_run]&.to_i, next_run: j[:next_run]&.to_i)
+      end
+    end
+
+    # ----- helpers ----------------------------------------------------------
+
+    def log_file(path, rotated: false)
+      slug = path.tr(':', '-').gsub(/[^\w.-]/, '-')
+      file = File.join(@server.root_dir, 'log/hammer', "#{slug}.log")
+      rotated ? "#{file}.1" : file
+    end
+
+    # Last TAIL_BYTES of the file - enough for a viewer, cheap even when
+    # the log sits right under the 1 MB rotation cap.
+    def tail_file(file)
+      size = File.size(file)
+      File.open(file) do |f|
+        f.seek([size - TAIL_BYTES, 0].max)
+        data = f.read.to_s
+        size > TAIL_BYTES ? "... (truncated)\n#{data}" : data
+      end
+    rescue Errno::ENOENT
+      '(no log yet)'
+    end
+
+    def fmt_time(t)
+      t ? t.strftime('%F %T') : 'never'
+    end
+
+    def h(text)
+      CGI.escapeHTML(text.to_s)
+    end
+  end
+end

data/lib/hammer/option.rb

@@ -78,5 +78,24 @@ class Hammer
       return '' if default.nil?
       "(default: #{default.inspect})"
     end
+
+    # Structured form for JSON export (`h:json`). The GUI maps `type`
+    # to a form widget; `default`/`required`/`desc` decorate it. Mirrors
+    # the data behind `usage`. `negation` is only meaningful for booleans.
+    def to_h
+      h = {
+        name:        name.to_s,
+        type:        type.to_s,
+        default:     default,
+        required:    required,
+        desc:        desc,
+        placeholder: placeholder,
+        switch:      switch,
+        aliases:     aliases,
+        usage:       usage.strip
+      }
+      h[:negation] = negation if boolean?
+      h
+    end
   end
 end

data/lib/lux-hammer.rb

@@ -2,6 +2,7 @@ require_relative 'hammer/shell'
 require_relative 'hammer/option'
 require_relative 'hammer/parser'
 require_relative 'hammer/command'
+require_relative 'hammer/cron'
 require_relative 'hammer/loader'
 require_relative 'hammer/builder'
 require_relative 'hammer/command_builder'
@@ -62,6 +63,7 @@ class Hammer
       sub.instance_variable_set(:@pending_options, [])
       sub.instance_variable_set(:@pending_alts, [])
       sub.instance_variable_set(:@pending_needs, [])
+      sub.instance_variable_set(:@pending_cron, nil)
     end
 
     # ----- class-level DSL for `def`-style commands ---------------------
@@ -80,6 +82,7 @@ class Hammer
     def opt(name, **o)   ; @pending_options << Option.new(name, **o) end
     def alt(*names)      ; @pending_alts.concat(names) end
     def needs(*names)    ; @pending_needs.concat(names) end
+    def cron(expr)       ; @pending_cron = expr end
 
     def method_added(method_name)
       super
@@ -90,6 +93,7 @@ class Hammer
       @pending_options.each  { |o| cmd.add_option(o) }
       @pending_alts.each     { |n| cmd.add_alt(n) }
       @pending_needs.each    { |n| cmd.add_need(n) }
+      cmd.set_cron(@pending_cron) if @pending_cron
 
       # If the method takes no args, call it without opts. Otherwise pass
       # opts. So both `def build` and `def build(opts)` work.
@@ -104,6 +108,7 @@ class Hammer
       @pending_options  = []
       @pending_alts     = []
       @pending_needs    = []
+      @pending_cron     = nil
     end
 
     # Resolved lazily on first read and memoized, so callers that need the
@@ -183,6 +188,7 @@ class Hammer
       @pending_options  = []
       @pending_alts     = []
       @pending_needs    = []
+      @pending_cron     = nil
     end
 
     # Open a namespace (group of commands). Everything inside the block
@@ -583,6 +589,39 @@ class Hammer
       end
     end
 
+    # Machine-readable spec for `h:json` -> the macOS GUI (and, later,
+    # for lux itself to render the default listing). One hash:
+    #   commands => { group => { full_path => task_meta } }
+    # Grouping/sort mirror the bare-`hammer` listing exactly: group by
+    # the first namespace segment (a bare task sharing a namespace's name
+    # joins that group via section_for), root tasks under "__root",
+    # "__root" first, remaining groups in first-encounter order, tasks
+    # within a group by [depth, name]. Hidden (no-`desc`) tasks are
+    # skipped and the reserved `h:` tree is pruned unless include_builtins.
+    def export_spec(include_builtins: false)
+      groups = {}   # group => { full_path => meta }, in first-encounter order
+
+      each_command(include_builtins: include_builtins) do |path, c|
+        next if c.desc.empty?
+        section = section_for(path, nil, self)
+        key = section == :root ? '__root' : section.to_s
+        (groups[key] ||= {})[path] = c.to_h(path)
+      end
+
+      sort_tasks = ->(h) { h.sort_by { |p, _| [p.count(':'), p] }.to_h }
+      ordered = {}
+      ordered['__root'] = sort_tasks.call(groups.delete('__root')) if groups.key?('__root')
+      groups.each { |k, v| ordered[k] = sort_tasks.call(v) }
+
+      {
+        schema:         1,
+        hammer_version: VERSION,
+        program_name:   program_name,
+        app_desc:       app_desc,
+        commands:       ordered
+      }
+    end
+
     def run_command(cmd, argv, full: nil, quiet: false)
       # -h / --help is reserved on every command. Anywhere before a `--`
       # stop-marker, it short-circuits to per-command help.
@@ -622,7 +661,9 @@ class Hammer
         end
       end
       parts.concat(positional)
-      Shell.say "> #{parts.join(' ')}", :gray
+      # Diagnostic, not program output - to stderr so stdout stays clean
+      # for machine-readable tasks (`h:json`, `h:version`) and pipes.
+      warn Shell.paint("> #{parts.join(' ')}", :gray)
     end
 
     # Fire `before` hooks from root down through the namespace chain.
@@ -703,7 +744,7 @@ class Hammer
         each_command(include_builtins: extended) { |path, c| print_full_block(path, c) unless c.desc.empty? }
       else
         Shell.say ''
-        print_command_list(self, include_builtins: extended)
+        print_command_list(include_builtins: extended)
       end
       print_recipes_section if extended && root.instance_variable_get(:@hammer_binary)
       print_extras if extended
@@ -736,8 +777,8 @@ class Hammer
       Shell.say "Usage: #{program_name} #{prefix}:COMMAND [ARGS]", :cyan
       rows = []
       sibling = find_namespace_sibling(prefix)
-      rows << [prefix, sibling] if sibling && !sibling.desc.empty?
-      ns.each_command(prefix) { |path, c| rows << [path, c] unless c.desc.empty? }
+      rows << [prefix, sibling.to_h(prefix)] if sibling && !sibling.desc.empty?
+      ns.each_command(prefix) { |path, c| rows << [path, c.to_h(path)] unless c.desc.empty? }
       unless rows.empty?
         Shell.say ''
         Shell.say 'Commands:', :yellow
@@ -802,38 +843,30 @@ class Hammer
       Shell.say Hammer::STARTER_HAMMERFILE
     end
 
-    def print_command_list(klass, prefix = nil, include_builtins: true)
-      rows = []
-      # Commands without a `desc` are hidden from listings but still
-      # dispatchable + `hammer`-callable - useful for private helpers
-      # invoked from `before` hooks or other commands (e.g. `:env`, `:app`).
-      klass.each_command(prefix, include_builtins: include_builtins) { |full, c| rows << [full, c] unless c.desc.empty? }
-      return if rows.empty?
-
-      # group by "section" = everything between the view prefix and the
-      # leaf name. Bare leaves go in :root.
-      groups = rows.group_by { |full, _| section_for(full, prefix, klass) }
-      width  = rows.map { |full, _| full.length }.max
-      first  = true
-
-      if (rooted = groups.delete(:root))
-        Shell.say 'Commands:', :yellow
-        emit_rows(rooted.sort_by { |full, _| [full.count(':'), full] }, width)
-        first = false
-      end
-
-      groups.each do |section, items|
-        Shell.say unless first
-        first = false
-        Shell.say "#{section}:", :yellow
-        emit_rows(items.sort_by { |full, _| [full.count(':'), full] }, width)
+    # Pure rendering off `export_spec` - the same grouped structure
+    # `h:json` emits, so the listing and the JSON can never drift.
+    # `export_spec` already does the work: drops hidden (no-`desc`)
+    # tasks, prunes the `h:` tree unless include_builtins, groups by
+    # first namespace segment ("__root" for bare tasks), orders "__root"
+    # first, and sorts each group by [depth, name].
+    def print_command_list(include_builtins: true)
+      groups = export_spec(include_builtins: include_builtins)[:commands]
+      return if groups.empty?
+
+      width = groups.values.flat_map(&:keys).map(&:length).max
+      groups.each_with_index do |(section, tasks), i|
+        Shell.say unless i.zero?
+        Shell.say(section == '__root' ? 'Commands:' : "#{section}:", :yellow)
+        emit_rows(tasks.to_a, width)
       end
     end
 
+    # `rows` is an array of [full_path, task_meta] - the per-task hashes
+    # from `Command#to_h` (also used to render namespace listings).
     def emit_rows(rows, width)
-      rows.each do |full, c|
-        brief = c.alts.empty? ? c.brief : "#{c.brief} (alt: #{c.alts.join(', ')})"
-        brief = "#{brief} #{Shell.paint('(redefined)', :yellow)}" if c.prev_location
+      rows.each do |full, t|
+        brief = t[:alts].empty? ? t[:brief] : "#{t[:brief]} (alt: #{t[:alts].join(', ')})"
+        brief = "#{brief} #{Shell.paint('(redefined)', :yellow)}" if t[:redefined]
         Shell.say "  #{program_name} #{full.ljust(width)}  # #{brief}"
       end
     end
@@ -878,6 +911,7 @@ class Hammer
         Shell.say(stripped.empty? ? '' : "  #{stripped}")
       end unless cmd.desc.empty?
       Shell.say "  alias: #{cmd.alts.join(', ')}" unless cmd.alts.empty?
+      Shell.say "  cron: #{cmd.cron}" if cmd.cron
       unless cmd.options.empty?
         Shell.say ''
         Shell.say 'Options:', :yellow
@@ -1047,6 +1081,7 @@ class Hammer
   def self.cli(argv = ARGV)
     argv = argv.dup
     force_system = !!argv.delete('--system')
+    launch_gui   = !!argv.delete('--gui')
 
     # Shebang invocation: `hammer /path/to/script ...args` (kernel passes
     # the script path as argv[0] for `#!/usr/bin/env hammer` files).
@@ -1060,6 +1095,12 @@ class Hammer
     end
 
     path = force_system ? nil : find_hammerfile(Dir.pwd)
+
+    # `hammer --gui` opens the native macOS runner pointed at this project
+    # (the Hammerfile's dir, or cwd when none was found). The CLI just
+    # launches the bundled app and returns.
+    return launch_gui!(path ? File.dirname(path) : Dir.pwd) if launch_gui
+
     unless path
       # No Hammerfile (or --system) - all built-ins are reachable. Bare
       # `hammer`, `hammer h:recipes`, `hammer h:update`, `hammer h:agents`,
@@ -1188,4 +1229,21 @@ class Hammer
     end
   end
 
+  # Spawn the vendored macOS GUI (gui/Hammer.app), pointed at the project
+  # dir and this hammer binary. Launched directly (not via `open`) so it
+  # inherits the caller's environment - the GUI shells back out to this
+  # same `hammer` for `h:json` and task runs, and that needs the same PATH.
+  def self.launch_gui!(project_dir)
+    bin = File.expand_path('../gui/Hammer.app/Contents/MacOS/HammerGUI', __dir__)
+    unless File.executable?(bin)
+      Shell.print_error "GUI app not found at #{bin}"
+      Shell.say 'build it: ./gui/HammerGUI/build_app.sh', :yellow
+      exit 1
+    end
+    hammer_bin = (File.realpath($PROGRAM_NAME) rescue File.expand_path($PROGRAM_NAME))
+    pid = Process.spawn(bin, '--project', File.expand_path(project_dir), '--hammer', hammer_bin)
+    Process.detach(pid)
+    Shell.say "launched Hammer GUI for #{project_dir} (pid #{pid})", :green
+  end
+
 end

data/recipes/git-helper.rb

@@ -142,8 +142,8 @@ helpers do
       if message.empty?
         run 'git reset --mixed'
         exit
-      elsif message.length < 5
-        say 'Please add better commit message, min length 5 chars', :red
+      elsif message.length < 1
+        say 'Please add better commit message, min length 1 chars', :red
         next
       else
         bump_version

data/recipes/llm.rb

@@ -178,7 +178,7 @@ namespace :prompt do
   def folders
     [
       ['local',  File.join(Dir.pwd, 'doc', 'command')],
-      ['global', File.expand_path('~/dev/skills/command')]
+      ['global', File.expand_path('~/dev/ai/command')]
     ]
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lux-hammer
 version: !ruby/object:Gem::Version
-  version: 0.3.13
+  version: 0.3.15
 platform: ruby
 authors:
 - Dino Reic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-05 00:00:00.000000000 Z
+date: 2026-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -36,10 +36,15 @@ files:
 - "./AGENTS.md"
 - "./README.md"
 - "./bin/hammer"
+- "./gui/Hammer.app/Contents/Info.plist"
+- "./gui/Hammer.app/Contents/MacOS/HammerGUI"
 - "./lib/hammer/builder.rb"
 - "./lib/hammer/builtins.rb"
 - "./lib/hammer/command.rb"
 - "./lib/hammer/command_builder.rb"
+- "./lib/hammer/cron.rb"
+- "./lib/hammer/cron_server.rb"
+- "./lib/hammer/cron_web.rb"
 - "./lib/hammer/dotenv.rb"
 - "./lib/hammer/loader.rb"
 - "./lib/hammer/option.rb"