hiiro 0.1.388 → 0.1.389

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75bc072edb723fca8202393111317406374a79d033efd727f5f2e6de708a1eca
-  data.tar.gz: 220302e41947fce7f174a11040b363ae101c29ab0dc39ac8014302e076da36b2
+  metadata.gz: 7702a9aa5a7b32c1f0038e95551844d0da347fcaebeaf84ae074190839f35b56
+  data.tar.gz: 06e1c1ce29d001051f5b8190a36163577c75c5a38eacc6407b49c305f62ec944
 SHA512:
-  metadata.gz: e73489ef10468e4d7d95c1eb122ca5554c25e0ed2ea039497e1618a4c82130acdec2aa1458cbed31a55ad3be95d3bc7472bee53564aa9289df57e9d2902a87f2
-  data.tar.gz: 8b76fd1f7b729ad8773a2fbffad8b6ab6eceaaa1a4cd7895517fe8ea28fed98c8a590e61b43d2ece451af86a29c316bc1f1c09d0580dfe2702758f23e6e20a9b
+  metadata.gz: c595c3d03f9effac1ea185d1307a56116c08abf981a045a2b3a9de7108c3b63902b8de08664bfaec3f726f30319a34c8469b9e23c5783619cee36ab17bc9fe8a
+  data.tar.gz: ebd3be17857932e7ab261beb8635c65a9b7e802058dd5d653753770665571ad097c6b179f03d04a12b9dd3b67bb1b1a98b89ecf2ba58723f87419504c1e3e024

data/README.md

@@ -73,6 +73,49 @@ Saved files can be listed, printed, copied back to the clipboard, opened,
 edited, or removed with `h save ls|show|copy|open|edit|rm`. See
 [docs/h-save.md](docs/h-save.md).
 
+### Extract files, directories, and links
+
+`h extract files`, `h extract dirs`, and `h extract links` read text from stdin
+or input files and print one unique match per line, in first-encounter order.
+
+```sh
+# Read text from stdin
+printf '%s\n' 'README.md:12:3' 'README.md' | h extract files
+printf '%s\n' 'docs/' './docs/' | h extract dirs
+printf '%s\n' '(https://example.org/a_(b)).' | h extract links
+
+# Read text from input files
+h extract files build.log
+h extract dirs build.log
+h extract links notes.txt build.log
+```
+
+Files and directories must exist and match the requested type. Relative paths
+are checked against the current directory by default. Repeat `--base-dir DIR`
+or `-b DIR` to replace that default with explicit bases. A match under any one
+base is enough:
+
+```sh
+h extract files --base-dir /path/to/project -b /path/to/other-project build.log
+```
+
+Base directories affect path checks, not the locations of input files. Output
+preserves the original path spelling rather than expanding or normalizing it.
+Quotes and surrounding wrappers are removed, as are `:line` and `:line:column`
+suffixes. Quoted paths can contain spaces, such as `"src/my file.rb:12:3"`.
+Links must use HTTP or HTTPS. Trailing punctuation is removed, while balanced
+parentheses in URLs are kept.
+
+`--no-check` skips filesystem checks and uses text heuristics, not actual
+existence or type. Files need a slash or a dotted filename and cannot end in a
+slash. Directories need a slash and cannot have a dotted basename. These rules
+can misclassify paths or omit real files and directories:
+
+```sh
+printf '%s\n' '"src/my file.rb:12:3"' | h extract files --no-check
+printf '%s\n' 'missing/output/' | h extract dirs --no-check
+```
+
 ### Task CLI
 
 `t` and `tt` are gem executables in `exe/`, installed alongside `h`. They are thin
@@ -167,6 +210,7 @@ See the [task command reference](docs/t.md) for all commands and the [workflow i
 | `h commit` | Select commits using fuzzy finder |
 | `h config` | Open config files (vim, git, Herdr, zsh, starship, claude) |
 | `h env` | Append safely quoted environment variables |
+| [`h extract`](#extract-files-directories-and-links) | Extract file paths, directories, and HTTP(S) links from text |
 | `h link` | Manage saved links with URL, description, and shorthand |
 | `h pane` | Herdr pane management |
 | `h plugin` | Manage hiiro plugins (list, edit, search) |

data/bin/h-extract

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'hiiro'
+
+options = Hiiro::Options.setup do
+  option(:base_dir, short: :b, multi: true, desc: 'Base directory for relative path checks (repeatable; default: cwd)')
+  flag(:no_check, desc: 'Extract path-shaped text without checking the filesystem')
+end
+
+clean_url = lambda do |url|
+  url = url.sub(/[.,;:!?]+\z/, '')
+  { ')' => '(', ']' => '[', '}' => '{' }.each do |closing, opening|
+    url = url.chop while url.end_with?(closing) && url.count(closing) > url.count(opening)
+  end
+  url.sub(/[.,;:!?]+\z/, '')
+end
+
+Hiiro.run(*ARGV) do
+  %i[files dirs links].each do |kind|
+    add_subcmd(kind) do |*args|
+      vals = options.parse!(args)
+      if vals.help?
+        puts "Usage: h extract #{kind} [options] [input-file ...]"
+        puts options.help_text
+        next
+      end
+
+      abort("--base-dir requires a directory") if vals.base_dir.any? { |base| base.nil? || base.empty? }
+      bases = vals.base_dir.empty? ? [Dir.pwd] : vals.base_dir.map { |base| File.expand_path(base) }
+      input = Hiiro::Shell.read_input(*vals.args)
+      matches = if kind == :links
+        input.scan(%r{https?://[^\s<>"'`]+}i).map { |url| clean_url.call(url) }
+      else
+        # Consume URLs whole so their slash-separated pieces cannot become paths.
+        tokens = input.scan(%r{https?://[^\s<>"'`]+|(?<![[:alnum:]])(?:"[^"\n]+"|'[^'\n]+'|`[^`\n]+`)|[^\s<>"'`()\[\]{},;=]+}i)
+        tokens.filter_map do |token|
+          quoted = ['"', "'", '`'].include?(token[0])
+          original = quoted ? token[1...-1] : token
+          path = original.sub(/[.!?:]+\z/, '').sub(/:\d+(?::\d+)?\z/, '')
+          next if path.empty? || path.match?(%r{\A[a-z][a-z0-9+.-]*://}i)
+
+          if vals.no_check
+            next unless path.include?('/') || path.match?(/\A[^\s]+\.[^\s.]+\z/)
+            next if kind == :files && path.end_with?('/')
+            next if kind == :dirs && File.basename(path).match?(/\.[^.]+\z/)
+          else
+            path = [original, path].uniq.find do |candidate|
+              bases.any? do |base|
+                full_path = File.expand_path(candidate, base)
+                kind == :files ? File.file?(full_path) : File.directory?(full_path)
+              end
+            end
+            next unless path
+          end
+          path
+        end
+      end
+      puts matches.uniq
+    end
+  end
+end

data/bin/h-mcp

@@ -1,29 +1,15 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# h mcp — manage MCP servers from the local registry (http://localhost:15245).
-#
-# Subcommands:
-#   h mcp list                servers served by the registry
-#   h mcp ui                  open the registry web UI
-#   h mcp sync <agent>        write registry servers into an agent's MCP config
-#   h mcp status              drift check: registry vs each agent's config
-#   h mcp test <name>         MCP initialize handshake through the proxy
-#   h mcp url <name>          print a server's local proxy URL
-#   h mcp info <name>         full registry record for a server
-#   h mcp agents              known sync targets and their config paths
-#
-# sync targets: omp, codex, claude, cursor, vscode, gemini, windsurf, opencode
-# Unknown targets fall back to running `omp` headless (web search allowed) to
-# research that agent's MCP config format and apply it.
-
+# Local MCP registry, SDK commands, and HTTP-only legacy client sync.
 require 'hiiro'
 require 'json'
-require 'net/http'
 require 'uri'
+require 'digest'
 require 'fileutils'
+require 'tempfile'
+require_relative 'lib/h_mcp_catalog'
 
-DEFAULT_ENDPOINT = 'http://localhost:15245/api/servers'
 OMP_SCHEMA = 'https://raw.githubusercontent.com/can1357/oh-my-pi/main/packages/coding-agent/src/config/mcp-schema.json'
 HTTP_ENTRY = ->(url) { { 'type' => 'http', 'url' => url } }
 
@@ -33,20 +19,12 @@ AGENT_TARGETS = {
   'codex'    => ->(home) { [File.join(home, '.codex', 'config.toml'), nil, nil] },
   'claude'   => ->(home) { [File.join(home, '.claude.json'), ['mcpServers'], HTTP_ENTRY] },
   'cursor'   => ->(home) { [File.join(home, '.cursor', 'mcp.json'), ['mcpServers'], ->(u) { { 'url' => u } }] },
-  'vscode'   => ->(_home) { [nil, ['servers'], HTTP_ENTRY] }, # project-only
+  'vscode'   => ->(_home) { [nil, ['servers'], HTTP_ENTRY] },
   'gemini'   => ->(home) { [File.join(home, '.gemini', 'settings.json'), ['mcpServers'], ->(u) { { 'httpUrl' => u } }] },
   'windsurf' => ->(home) { [File.join(home, '.codeium', 'windsurf', 'mcp_config.json'), ['mcpServers'], ->(u) { { 'serverUrl' => u } }] },
   'opencode' => ->(home) { [File.join(home, '.config', 'opencode', 'opencode.json'), ['mcp'], ->(u) { { 'type' => 'remote', 'url' => u, 'enabled' => true } }] },
 }.freeze
 
-def fetch_registry(endpoint)
-  uri = URI.parse(endpoint)
-  res = Net::HTTP.get_response(uri)
-  raise "endpoint #{endpoint} returned HTTP #{res.code}" unless res.is_a?(Net::HTTPSuccess)
-  JSON.parse(res.body, symbolize_names: true)
-end
-
-# agent => project-level config path (relative to cwd); omp/codex/vscode handled inline
 PROJECT_PATHS = {
   'claude'   => '.mcp.json',
   'cursor'   => '.cursor/mcp.json',
@@ -55,329 +33,389 @@ PROJECT_PATHS = {
   'opencode' => 'opencode.json',
 }.freeze
 
-def registry_servers(endpoint)
-  fetch_registry(endpoint).each_with_object({}) do |s, h|
-    name = s[:display_name].to_s.strip
-    url = s[:short_url].to_s.strip
-    h[name] = url unless name.empty? || url.empty?
+def local_servers(catalog)
+  catalog.registry.each_with_object({}) do |registration, servers|
+    next if registration['enabled'] == false
+    name = registration.fetch('name')
+    server = catalog.resolve(name)
+    next unless server['enabled']
+    unless server['transport'] == 'http'
+      raise %(#{name} uses #{server['transport']}; legacy sync/status supports HTTP URLs only)
+    end
+    settings = catalog.connection_settings(server)
+    uri = URI.parse(settings.fetch(:url))
+    raise %(#{name} requires an absolute HTTP or HTTPS URL) unless uri.is_a?(URI::HTTP) && uri.host
+    servers[name] = settings
   end
 end
 
-def registry_url?(value, authority)
-  return false unless value.is_a?(Hash)
-  url = value['url'] || value['httpUrl'] || value['serverUrl']
-  url.is_a?(String) && url.include?(authority)
+def target_entries(agent, servers, builder)
+  servers.to_h do |name, settings|
+    if agent == 'codex'
+      unless settings.fetch(:headers).empty?
+        raise %(codex: #{name} requires HTTP headers; legacy Codex sync supports unauthenticated URL-only settings)
+      end
+      entry = { 'url' => settings.fetch(:url) }
+    else
+      entry = builder.call(settings.fetch(:url))
+      entry['headers'] = settings.fetch(:headers) unless settings.fetch(:headers).empty?
+    end
+    [name, entry]
+  end
+end
+
+def export_fingerprint(value)
+  canonical = lambda do |item|
+    case item
+    when Hash then item.keys.sort.to_h { |key| [key, canonical.call(item[key])] }
+    when Array then item.map { |entry| canonical.call(entry) }
+    else item
+    end
+  end
+  Digest::SHA256.hexdigest(JSON.generate(canonical.call(value)))
 end
 
 def backup(path)
-  FileUtils.cp(path, "#{path}.bak-#{Time.now.strftime('%Y%m%d%H%M%S')}") if File.exist?(path)
+  return unless File.exist?(path)
+  destination = "#{path}.bak-#{Time.now.strftime('%Y%m%d%H%M%S%6N')}"
+  FileUtils.cp(path, destination)
+  File.chmod(0600, destination)
+end
+
+def write_config(path, content)
+  destination = File.symlink?(path) ? File.realpath(path) : path
+  FileUtils.mkdir_p(File.dirname(destination))
+  Tempfile.create(['.h-mcp-', '.tmp'], File.dirname(destination)) do |file|
+    file.write(content)
+    file.flush
+    file.fsync
+    backup(path)
+    File.rename(file.path, destination)
+  end
 end
 
-def sync_json(path:, container_keys:, servers:, authority:, opts:, schema: nil, &entry_for)
+def sync_json(path:, container_keys:, servers:, store:, opts:, schema: nil)
   data = File.exist?(path) ? JSON.parse(File.read(path)) : {}
+  raise %(expected configuration object in #{path}) unless data.is_a?(Hash)
+  before = JSON.generate(data)
   data = { '$schema' => schema }.merge(data) if schema && !data.key?('$schema')
-  container = container_keys.inject(data) { |h, k| h[k] ||= {} }
-
-  before = container.keys.sort
-  servers.each { |name, url| container[name] = entry_for.call(url) }
+  container = container_keys.inject(data) do |parent, key|
+    raise %(expected server container object in #{path}) unless parent.is_a?(Hash)
+    parent[key] = {} unless parent.key?(key)
+    parent.fetch(key)
+  end
+  raise %(expected server container object in #{path}) unless container.is_a?(Hash)
+  ownership = store.sync_state(path)
   removed = []
   if opts.prune
-    container.each_key do |name|
-      next if servers.key?(name)
-      next unless registry_url?(container[name], authority)
-      removed << name
-      container.delete(name)
+    (ownership.keys - servers.keys).each do |name|
+      if !container.key?(name)
+        ownership.delete(name)
+      elsif export_fingerprint(container[name]) == ownership[name]
+        container.delete(name)
+        ownership.delete(name)
+        removed << name
+      end
     end
   end
-  after = container.keys.sort
-
-  changed = (before != after) || servers.any? { |n, u| container[n] != entry_for.call(u) }
+  servers.each do |name, entry|
+    container[name] = entry
+    ownership[name] = export_fingerprint(entry)
+  end
   if opts.dry_run
     puts "[dry-run] #{path}"
-    puts JSON.pretty_generate(container)
-  elsif changed || !File.exist?(path)
-    FileUtils.mkdir_p(File.dirname(path))
-    backup(path)
-    File.write(path, JSON.pretty_generate(data) + "\n")
-    puts "wrote #{path}"
+    puts JSON.pretty_generate(data)
   else
-    puts "unchanged #{path}"
+    if !File.exist?(path) || JSON.generate(data) != before
+      write_config(path, JSON.pretty_generate(data) + "\n")
+      puts "wrote #{path}"
+    else
+      puts "unchanged #{path}"
+    end
+    store.save_sync_state(path, ownership)
   end
-  puts "  servers: #{after.join(', ')}"
+  puts "  servers: #{container.keys.sort.join(', ')}"
   puts "  pruned: #{removed.join(', ')}" unless removed.empty?
 end
 
+TOML_KEY = /"(?:[^"\\\r\n]|\\.)*"|'[^'\r\n]*'|[A-Za-z0-9_-]+/
+CODEX_URL_LINE = /\A([ \t]*url[ \t]*=[ \t]*)("(?:[^"\\\r\n]|\\.)*"|'[^'\r\n]*')([ \t]*(?:#[^\r\n]*)?(?:\r?\n)?)\z/
+
 def toml_key(name)
-  name =~ /\A[A-Za-z0-9_-]+\z/ ? name : "\"#{name.gsub('"', '\"')}\""
+  name.match?(/\A[A-Za-z0-9_-]+\z/) ? name : name.to_json
 end
 
-def sync_codex(path:, servers:, authority:, opts:)
-  text = File.exist?(path) ? File.read(path) : ''
-  servers.each do |name, url|
-    key = toml_key(name)
-    header = /^\[mcp_servers\.#{Regexp.escape(key)}\]\s*$/
-    lines = text.lines
-    start = lines.index { |l| l =~ header }
-    if start
-      stop = ((start + 1)...lines.length).find { |i| lines[i] =~ /^\[/ } || lines.length
-      block = lines[start...stop]
-      if block.any? { |l| l =~ /^\s*command\s*=/ }
-        warn "codex: '#{name}' is command-based; leaving untouched"
+def toml_string(value)
+  value.start_with?('"') ? JSON.parse(value) : value[1...-1]
+end
+
+# Deliberately limited to surgical URL blocks, not a TOML serializer.
+def codex_blocks(text)
+  lines = text.lines
+  lines.each do |line|
+    next if line.lstrip.start_with?('#')
+    if line.include?('"""') || line.include?("'''")
+      raise 'codex: multiline TOML strings are unsupported by surgical URL sync/status'
+    end
+    if line.match?(/\A[ \t]*(?:mcp_servers|"mcp_servers"|'mcp_servers')[ \t]*(?:\.|=)/)
+      raise 'codex: inline or dotted MCP definitions are unsupported; use simple [mcp_servers.NAME] URL blocks'
+    end
+  end
+  headers = lines.each_index.select { |index| lines[index].lstrip.start_with?('[') }
+  blocks = {}
+  headers.each_with_index do |start, index|
+    header = lines[start]
+    next unless header.match?(/\A[ \t]*\[\[?[ \t]*(?:mcp_servers|"mcp_servers"|'mcp_servers')(?:[ \t]*[.\]])/)
+    match = header.match(/\A[ \t]*\[[ \t]*mcp_servers[ \t]*\.[ \t]*(#{TOML_KEY.source})([^\]\r\n]*)\][ \t]*(?:#[^\r\n]*)?(?:\r?\n)?\z/)
+    raise 'codex: unsupported MCP table shape; use simple [mcp_servers.NAME] URL blocks' unless match
+    begin
+      name = match[1].start_with?('"', "'") ? toml_string(match[1]) : match[1]
+    rescue JSON::ParserError
+      raise 'codex: unsupported quoted MCP table key'
+    end
+    tail = match[2].strip
+    unless tail.empty?
+      raise 'codex: unsupported MCP table key' unless tail.start_with?('.')
+      blocks[name] ||= {}
+      blocks[name][:error] = 'MCP subtables are unsupported by URL-only sync'
+      next
+    end
+    raise %(codex: duplicate MCP table for #{name}) if blocks.dig(name, :range)
+    stop = headers[index + 1] || lines.length
+    block_lines = lines[start...stop]
+    block = { range: start...stop, text: block_lines.join, error: blocks.dig(name, :error) }
+    block_lines.each_with_index do |line, offset|
+      next if offset.zero? || line.strip.empty? || line.lstrip.start_with?('#')
+      assignment = CODEX_URL_LINE.match(line)
+      if !assignment || block.key?(:url_line)
+        block[:error] ||= 'expected a URL-only block; command, authentication, duplicate URL, and extra settings are unsupported'
         next
       end
-      if (i = block.index { |l| l =~ /^\s*url\s*=/ })
-        block[i] = "url = #{url.to_json}\n"
-      else
-        block.insert(1, "url = #{url.to_json}\n")
+      begin
+        url = toml_string(assignment[2])
+        uri = URI.parse(url)
+        raise URI::InvalidURIError unless uri.is_a?(URI::HTTP) && uri.host
+        block.merge!(url: url, url_line: offset)
+      rescue JSON::ParserError, URI::InvalidURIError
+        block[:error] ||= 'expected a single-line absolute HTTP or HTTPS URL'
       end
-      lines[start...stop] = block
-      text = lines.join
-    else
-      text += "\n[mcp_servers.#{key}]\nurl = #{url.to_json}\n"
     end
+    blocks[name] = block
   end
+  blocks
+end
 
+def sync_codex(path:, servers:, store:, opts:)
+  original = File.exist?(path) ? File.read(path) : ''
+  text = original.dup
+  blocks = codex_blocks(text)
+  servers.each_key do |name|
+    error = blocks.dig(name, :error)
+    raise %(codex: cannot update #{name}: #{error}) if error
+  end
+  ownership = store.sync_state(path)
+  edits, removed = [], []
   if opts.prune
-    lines = text.lines
-    ranges = []
-    i = 0
-    while i < lines.length
-      if lines[i] =~ /^\[mcp_servers\.([^\]]+)\]\s*$/
-        name = Regexp.last_match(1).delete('"')
-        j = ((i + 1)...lines.length).find { |k| lines[k] =~ /^\[/ } || lines.length
-        if !servers.key?(name) && lines[i...j].any? { |l| l =~ /^\s*url\s*=.*#{Regexp.escape(authority)}/ }
-          ranges << (i...j)
-          puts "  pruned codex server: #{name}"
-        end
-        i = j
-      else
-        i += 1
+    (ownership.keys - servers.keys).each do |name|
+      block = blocks[name]
+      if !block
+        ownership.delete(name)
+      elsif !block[:error] && block[:range] && export_fingerprint(block[:text]) == ownership[name]
+        edits << [block[:range], []]
+        ownership.delete(name)
+        removed << name
       end
     end
-    ranges.reverse_each { |r| lines[r] = [] }
-    text = lines.join
   end
-
+  servers.each do |name, entry|
+    block = blocks[name]
+    next unless block
+    updated = block.fetch(:text).lines
+    if block.key?(:url_line)
+      offset = block.fetch(:url_line)
+      assignment = CODEX_URL_LINE.match(updated[offset])
+      updated[offset] = assignment[1] + entry.fetch('url').to_json + assignment[3]
+    else
+      updated[0] += "\n" unless updated[0].end_with?("\n")
+      updated.insert(1, "url = #{entry.fetch('url').to_json}\n")
+    end
+    edits << [block.fetch(:range), updated]
+  end
+  lines = text.lines
+  edits.sort_by { |range, _| range.begin }.reverse_each { |range, replacement| lines[range] = replacement }
+  text = lines.join
+  servers.each do |name, entry|
+    next if blocks.key?(name)
+    text += "\n" unless text.empty? || text.end_with?("\n")
+    text += "[mcp_servers.#{toml_key(name)}]\nurl = #{entry.fetch('url').to_json}\n"
+  end
+  updated_blocks = codex_blocks(text)
+  servers.each_key { |name| ownership[name] = export_fingerprint(updated_blocks.fetch(name).fetch(:text)) }
   if opts.dry_run
     puts "[dry-run] #{path}"
     puts text
-  elsif !File.exist?(path) || text != File.read(path)
-    backup(path)
-    File.write(path, text)
-    puts "wrote #{path}"
   else
-    puts "unchanged #{path}"
+    if !File.exist?(path) || text != original
+      write_config(path, text)
+      puts "wrote #{path}"
+    else
+      puts "unchanged #{path}"
+    end
+    store.save_sync_state(path, ownership)
   end
+  puts "  pruned: #{removed.join(', ')}" unless removed.empty?
 end
 
-def fallback_omp(agent, servers, opts)
-  payload = JSON.pretty_generate(servers.map { |n, u| { name: n, url: u } })
-  prompt = <<~PROMPT
-    Configure MCP (Model Context Protocol) servers for the agent/CLI tool called "#{agent}" on this machine.
-
-    Here is the server list JSON from the local MCP registry. Each entry is a remote
-    streamable-HTTP MCP endpoint reachable locally with no auth headers:
-
-    #{payload}
-
-    Steps:
-    1. Determine where "#{agent}" keeps its MCP server configuration (config file path
-       and exact entry format). Search the web / official docs if you are unsure.
-    2. Merge every server above into that config under its exact name, as a remote
-       HTTP MCP entry pointing at its url. Preserve all unrelated existing entries
-       and settings in the file. Back up the file before modifying it.
-    3. Re-read the file to verify the result parses and contains the new entries.
-    4. Report the file path, the format used, and what changed. Do not modify
-       anything else on this machine.
-  PROMPT
-
-  if opts.dry_run
-    puts '[dry-run] would invoke omp with prompt:'
-    puts prompt
-    return
+def config_entries(agent, path, names: [])
+  return {} unless File.exist?(path)
+  if agent == 'codex'
+    codex_blocks(File.read(path)).to_h do |name, block|
+      raise %(codex: cannot compare #{name}: #{block[:error]}) if block[:error] && names.include?(name)
+      [name, block[:error] ? nil : { 'url' => block[:url] }]
+    end
+  else
+    _, keys, = AGENT_TARGETS.fetch(agent).call(Dir.home)
+    data = JSON.parse(File.read(path))
+    container = keys.inject(data) do |parent, key|
+      raise %(expected configuration object in #{path}) unless parent.is_a?(Hash)
+      parent.fetch(key, {})
+    end
+    raise %(expected server container object in #{path}) unless container.is_a?(Hash)
+    container
   end
+end
 
-  omp = ENV.fetch('OMP_BIN', 'omp')
-  unless system('which', omp, out: File::NULL, err: File::NULL)
-    abort "unknown agent '#{agent}' and no omp binary found to research it"
+def sync_options(args, status: false)
+  parser = Hiiro::Options.setup do
+    option(:profile, desc: 'OMP profile name')
+    flag(:project, short: 'P', desc: 'use project-level config in cwd')
+    if status
+      flag(:json, desc: 'machine-readable definition comparison')
+    else
+      flag(:prune, short: 'p', desc: 'remove unchanged stale entries previously exported here')
+      flag(:dry_run, long: 'dry-run', short: 'n', desc: 'print proposed config without writing')
+    end
   end
-  puts "unknown agent '#{agent}' — handing off to omp to research and apply..."
-  system(omp, '-p', '--yolo', '--no-session', '--max-time', '10m', prompt) or
-    abort 'omp fallback failed'
+  tokens = args.dup
+  until tokens.empty?
+    argument = tokens.shift
+    break if argument == '--'
+    next unless argument.start_with?('-')
+    if argument.start_with?('--')
+      token, value = argument.split('=', 2)
+      definition = parser.option_set.definition_for(token)
+      raise %(unknown option #{token}; use --help) unless definition
+      if definition.flag?
+        raise %(#{token} does not take a value) if value
+      elsif value.nil?
+        raise %(#{token} requires a value) if tokens.empty? || tokens.first.start_with?('-')
+        tokens.shift
+      elsif value.empty?
+        raise %(#{token} requires a value)
+      end
+    else
+      flags = argument.delete_prefix('-').chars.map { |char| parser.option_set.definition_for("-#{char}") }
+      raise %(unknown option #{argument}; use --help) if flags.empty? || flags.any? { |flag| !flag || !flag.flag? }
+    end
+  end
+  parser.parse(args)
 end
 
-def config_entries(agent, path)
-  return {} unless path && File.exist?(path)
-  if agent == 'codex'
-    entries = {}
-    File.read(path).scan(/^\[mcp_servers\.(?:\"([^\"]+)\"|([^\]]+))\]\s*\n(.*?)(?=^\[|\z)/m) do |quoted, bare, body|
-      url = body[/^\s*url\s*=\s*"([^"]+)"/, 1]
-      entries[quoted || bare] = url if url
+def target_config(agent, opts)
+  raise %(unknown agent #{agent}; choose #{AGENT_TARGETS.keys.join(', ')}) unless AGENT_TARGETS.key?(agent)
+  if opts[:profile]
+    raise '--profile is only supported for omp' unless agent == 'omp'
+    raise 'select --profile or --project, not both' if opts.project
+    unless opts[:profile].match?(/\A[A-Za-z0-9_.-]+\z/) && !%w[. ..].include?(opts[:profile])
+      raise '--profile must be a profile name, not a path'
     end
-    entries
-  else
-    _, keys, = AGENT_TARGETS[agent].call(Dir.home)
-    data = JSON.parse(File.read(path))
-    container = (keys || ['mcpServers']).inject(data) { |h, k| h.is_a?(Hash) ? h[k] : nil } || {}
-    container.transform_values { |v| v.is_a?(Hash) ? (v['url'] || v['httpUrl'] || v['serverUrl']) : nil }.compact
   end
-rescue JSON::ParserError
-  {}
+  path, keys, builder = AGENT_TARGETS.fetch(agent).call(Dir.home)
+  if opts.project || agent == 'vscode'
+    relative = { 'omp' => '.omp/mcp.json', 'codex' => '.codex/config.toml', 'vscode' => '.vscode/mcp.json' }[agent] || PROJECT_PATHS.fetch(agent)
+    path = File.join(Dir.pwd, relative)
+  elsif opts[:profile]
+    path = File.join(Dir.home, '.omp', 'profiles', opts[:profile], 'agent', 'mcp.json')
+  end
+  [File.expand_path(path), keys, builder]
 end
 
 def print_table(rows)
   return puts '(no results)' if rows.empty?
   keys = rows.first.keys
-  widths = keys.map { |k| [k.to_s.length, rows.map { |r| r[k].to_s.length }.max].max.clamp(0, 60) }
-  header = keys.each_with_index.map { |k, i| k.to_s.ljust(widths[i]) }.join('  ')
+  widths = keys.map { |key| [key.to_s.length, rows.map { |row| row[key].to_s.length }.max].max.clamp(0, 60) }
+  header = keys.each_with_index.map { |key, index| key.to_s.ljust(widths[index]) }.join('  ')
   puts header
   puts '-' * header.length
   rows.each do |row|
-    puts keys.each_with_index.map { |k, i| row[k].to_s.ljust(widths[i]) }.join('  ')
+    puts keys.each_with_index.map { |key, index| row[key].to_s.ljust(widths[index]) }.join('  ')
   end
   puts "(#{rows.length} rows)"
 end
 
 Hiiro.run(*ARGV) do
-  add_subcmd(:ls, :list) do |*args|
-    opts = Hiiro::Options.parse(args) { option(:endpoint, default: DEFAULT_ENDPOINT, desc: 'registry endpoint') }
-    rows = fetch_registry(opts[:endpoint]).map do |s|
-      {
-        name: s[:display_name],
-        url: s[:short_url],
-        auth: s[:auth_status],
-        last_used: s[:last_used_at].to_s.sub('T', ' ').sub(/Z.*/, ''),
-      }
-    end
-    print_table(rows)
-  end
-
-  add_subcmd(:ui) do |*args|
-    opts = Hiiro::Options.parse(args) { option(:endpoint, default: DEFAULT_ENDPOINT, desc: 'registry endpoint') }
-    base = "http://#{URI.parse(opts[:endpoint]).authority}"
-    system('open', base)
+  %w[ls list info add import remove configured discover saved tools tool call guide test url].each do |command|
+    add_subcmd(command.to_sym) { |*args| MCPCommands.run(command, args) }
   end
 
   add_subcmd(:sync) do |*args|
-    opts = Hiiro::Options.parse(args) do
-      option(:endpoint, default: DEFAULT_ENDPOINT, desc: 'registry endpoint')
-      option(:profile, desc: 'omp profile name')
-      flag(:project, short: 'P', desc: 'write project-level config in cwd')
-      flag(:prune, short: 'p', desc: 'remove registry-sourced entries gone upstream')
-      flag(:dry_run, short: 'n', desc: 'print changes without writing')
+    opts = sync_options(args)
+    next puts(opts.help_text) if opts.help?
+    if opts.args.empty?
+      puts 'Usage: h mcp sync AGENT [--prune] [--dry-run] [--project | --profile NAME]'
+      next puts("agents: #{AGENT_TARGETS.keys.join(', ')}")
     end
+    raise 'sync accepts one AGENT' unless opts.args.length == 1
     agent = opts.args.first
-    unless agent
-      puts "Usage: h mcp sync <agent> [--prune] [--dry-run] [--project] [--profile NAME] [--endpoint URL]"
-      puts "agents: #{AGENT_TARGETS.keys.join(', ')} (anything else: researched + applied via omp)"
-      next
-    end
-
-    servers = registry_servers(opts[:endpoint])
-    authority = URI.parse(opts[:endpoint]).authority
-    home = Dir.home
-
-    case agent
-    when 'omp'
-      path =
-        if opts.project then File.join(Dir.pwd, '.omp', 'mcp.json')
-        elsif opts.profile then File.join(home, '.omp', 'profiles', opts.profile, 'agent', 'mcp.json')
-        else File.join(home, '.omp', 'agent', 'mcp.json')
-        end
-      sync_json(path: path, container_keys: ['mcpServers'], servers: servers,
-                authority: authority, opts: opts, schema: OMP_SCHEMA, &HTTP_ENTRY)
-    when 'codex'
-      path = opts.project ? File.join(Dir.pwd, '.codex', 'config.toml')
-                          : File.join(home, '.codex', 'config.toml')
-      sync_codex(path: path, servers: servers, authority: authority, opts: opts)
-    when 'vscode'
-      sync_json(path: File.join(Dir.pwd, '.vscode', 'mcp.json'), container_keys: ['servers'],
-                servers: servers, authority: authority, opts: opts, &HTTP_ENTRY)
-    when *AGENT_TARGETS.keys
-      path, keys, builder = AGENT_TARGETS[agent].call(home)
-      if opts.project
-        rel = PROJECT_PATHS[agent] or abort "no project-level config known for #{agent}"
-        path = File.join(Dir.pwd, rel)
-      end
-      sync_json(path: path, container_keys: keys, servers: servers,
-                authority: authority, opts: opts, &builder)
+    path, keys, builder = target_config(agent, opts)
+    catalog = MCPCatalog.new
+    entries = target_entries(agent, local_servers(catalog), builder)
+    if agent == 'codex'
+      sync_codex(path: path, servers: entries, store: catalog.store, opts: opts)
     else
-      fallback_omp(agent, servers, opts)
+      sync_json(path: path, container_keys: keys, servers: entries, store: catalog.store, opts: opts,
+                schema: agent == 'omp' ? OMP_SCHEMA : nil)
     end
+  rescue StandardError => error
+    abort %(h mcp sync: #{MCPCommands.error_message(error)})
   end
 
   add_subcmd(:status) do |*args|
-    opts = Hiiro::Options.parse(args) { option(:endpoint, default: DEFAULT_ENDPOINT, desc: 'registry endpoint') }
-    servers = registry_servers(opts[:endpoint])
-    authority = URI.parse(opts[:endpoint]).authority
-    home = Dir.home
-    rows = []
-    AGENT_TARGETS.each do |agent, target|
-      path, = target.call(home)
-      next unless path
-      next unless File.exist?(path)
-      entries = config_entries(agent, path)
-      missing = servers.keys - entries.keys
-      stale = entries.keys.reject { |n| servers.key?(n) || !entries[n].to_s.include?(authority) }
-      next if missing.empty? && stale.empty?
-      rows << { agent: agent, missing_upstream: missing.join(','), stale_in_config: stale.join(',') }
+    opts = sync_options(args, status: true)
+    next puts(opts.help_text) if opts.help?
+    raise 'status accepts at most one AGENT' if opts.args.length > 1
+    selected = opts.args.first
+    agents = selected ? [selected] : (opts[:profile] ? ['omp'] : AGENT_TARGETS.keys)
+    targets = agents.map { |agent| [agent, *target_config(agent, opts)] }
+    catalog = MCPCatalog.new
+    servers = local_servers(catalog)
+    rows = targets.filter_map do |agent, path, _keys, builder|
+      next unless selected || File.exist?(path)
+      expected = target_entries(agent, servers, builder)
+      entries = config_entries(agent, path, names: expected.keys)
+      ownership = catalog.store.sync_state(path)
+      { agent: agent, config: path, missing: (expected.keys - entries.keys).sort,
+        changed: (expected.keys & entries.keys).reject { |name| entries[name] == expected[name] }.sort,
+        stale: (ownership.keys - expected.keys).select { |name| entries.key?(name) }.sort }
     end
-    if rows.empty?
-      puts 'all existing agent configs are in sync with the registry'
+    if opts.json
+      puts JSON.pretty_generate(rows)
     else
-      print_table(rows)
-      puts "run: h mcp sync <agent> --prune"
-    end
-  end
-
-  add_subcmd(:test) do |*args|
-    opts = Hiiro::Options.parse(args) { option(:endpoint, default: DEFAULT_ENDPOINT, desc: 'registry endpoint') }
-    name = opts.args.first
-    abort 'usage: h mcp test <name>' unless name
-    url = registry_servers(opts[:endpoint])[name]
-    abort "no such server '#{name}' (try: h mcp list)" unless url
-
-    uri = URI.parse(url)
-    body = {
-      jsonrpc: '2.0', id: 1, method: 'initialize',
-      params: { protocolVersion: '2025-03-26', capabilities: {},
-                clientInfo: { name: 'h-mcp', version: '1.0' } },
-    }.to_json
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.read_timeout = 10
-    res = http.post(uri.path, body, 'Content-Type' => 'application/json',
-                                     'Accept' => 'application/json, text/event-stream')
-    payload = res.body[/^data: (.+)$/m, 1] || res.body
-    info = JSON.parse(payload).dig('result', 'serverInfo') || {}
-    if info.empty?
-      puts "FAIL #{name}: HTTP #{res.code}, no serverInfo in response"
-      exit 1
+      drift = rows.reject { |row| row[:missing].empty? && row[:changed].empty? && row[:stale].empty? }
+      if drift.empty?
+        puts 'all inspected agent configs are in sync with enabled local HTTP registrations'
+      else
+        print_table(drift.map { |row| row.transform_values { |value| value.is_a?(Array) ? value.join(',') : value } })
+        puts 'run: h mcp sync AGENT [--prune] with the same project/profile selection'
+      end
     end
-    puts "OK   #{name}: #{info['name']} #{info['version']}"
-  end
-
-  add_subcmd(:url) do |*args|
-    opts = Hiiro::Options.parse(args) { option(:endpoint, default: DEFAULT_ENDPOINT, desc: 'registry endpoint') }
-    name = opts.args.first
-    abort 'usage: h mcp url <name>' unless name
-    url = registry_servers(opts[:endpoint])[name]
-    abort "no such server '#{name}'" unless url
-    puts url
-  end
-
-  add_subcmd(:info) do |*args|
-    opts = Hiiro::Options.parse(args) { option(:endpoint, default: DEFAULT_ENDPOINT, desc: 'registry endpoint') }
-    name = opts.args.first
-    abort 'usage: h mcp info <name>' unless name
-    record = fetch_registry(opts[:endpoint]).find { |s| s[:display_name] == name }
-    abort "no such server '#{name}'" unless record
-    puts JSON.pretty_generate(JSON.parse(record.to_json))
+  rescue StandardError => error
+    abort %(h mcp status: #{MCPCommands.error_message(error)})
   end
 
   add_subcmd(:agents) do
-    home = Dir.home
     rows = AGENT_TARGETS.map do |agent, target|
-      path, = target.call(home)
+      path, = target.call(Dir.home)
       { agent: agent, config: path || '(project-only)', exists: path && File.exist?(path) ? 'yes' : 'no' }
     end
     print_table(rows)

data/docs/README.md

@@ -68,6 +68,7 @@ Quick-reference index of all `h-*` executables and the main `h` entry point.
 | Command | Description |
 |---------|-------------|
 | [h-bg](h-bg.md) | Run commands in background Herdr tabs with history tracking |
+| [h-extract](../README.md#extract-files-directories-and-links) | Extract file paths, directories, and HTTP(S) links from text |
 | [h-img](h-img.md) | Save or base64-encode images from clipboard or file |
 | [h-save](h-save.md) | Save clipboard text or images to ~/saved |
 | [h-misc](h-misc.md) | Miscellaneous utilities (symlink destination reporting) |

data/docs/h.md

@@ -48,6 +48,7 @@ These are separate `bin/h-*` executables dispatched by `h`:
 | [`h config`](h-config.md) | Open config files in editor |
 | [`h cpr`](h-cpr.md) | Shortcut to current branch's PR |
 | [`h db`](h-db.md) | SQLite database inspection and management |
+| [`h extract`](../README.md#extract-files-directories-and-links) | Extract file paths, directories, and HTTP(S) links from text |
 | [`h img`](h-img.md) | Image clipboard utilities |
 | [`h link`](h-link.md) | URL bookmark management |
 | [`h misc`](h-misc.md) | Miscellaneous utilities |

data/lib/hiiro/version.rb

@@ -1,4 +1,4 @@
 class Hiiro
-  VERSION = "0.1.388"
+  VERSION = "0.1.389"
   SUPPORTED_RUBY_VERSION = ">= 3.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.388
+  version: 0.1.389
 platform: ruby
 authors:
 - Joshua Toyota
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -169,6 +169,7 @@ files:
 - bin/h-dsstore
 - bin/h-dsstore-read
 - bin/h-env
+- bin/h-extract
 - bin/h-git
 - bin/h-herdr
 - bin/h-home