space-architect 9.2.1 → 9.4.0

data/lib/space_architect/jobs_client.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require "async/http/client"
-require "async/http/endpoint"
-require "json"
-
-module Space::Architect
-  # HTTP client for the space-server jobs API, modeled on RunCreator: Bearer
-  # auth, injectable async-http client, Space::Core::Error on any failure.
-  class JobsClient
-    # Poll bound for #wait_for_run_id: 2s * 30 attempts = 60s. Both are
-    # injectable kwargs so tests need not sleep real seconds.
-    POLL_INTERVAL_SECONDS = 2
-    POLL_MAX_ATTEMPTS     = 30
-
-    def initialize(host, token, client: nil)
-      @host   = host.chomp("/")
-      @token  = token
-      @client = client
-    end
-
-    # GET /jobs — returns the "jobs" array (owner-scoped, newest-first).
-    def list
-      get_json("/jobs")["jobs"]
-    end
-
-    # GET /jobs/:id — returns the job JSON.
-    def show(id)
-      get_json("/jobs/#{id}")
-    end
-
-    # POST /jobs — submits a job spec (harness/prompt/environment) and returns the
-    # created job's integer id. Raises Space::Core::Error on any failure, modeled on
-    # RunCreator#create (same 20x-status + integer-id checks).
-    def create(spec)
-      Sync do
-        with_client do |c|
-          response = c.post("/jobs", headers: headers, body: JSON.generate(spec))
-          parsed   = parse_json(response, "POST /jobs", expected_status: 201)
-          id       = parsed["id"]
-          raise Space::Core::Error, "POST /jobs: missing or non-integer id in response: #{parsed.inspect[0, 200]}" \
-            unless id.is_a?(Integer)
-
-          id
-        end
-      end
-    end
-
-    # POST /jobs/:id/cancel — returns {"id"=>.., "status"=>"canceled"}.
-    def cancel(id)
-      Sync do
-        with_client do |c|
-          response = c.post("/jobs/#{id}/cancel", headers: headers, body: nil)
-          parse_json(response, "POST /jobs/#{id}/cancel")
-        end
-      end
-    end
-
-    # GET /runs/:id/stream — yields each SSE event's data: payload to the
-    # block as it arrives. Returns when the stream reports run_complete or
-    # closes cleanly. Raises Space::Core::Error on a non-200 response.
-    def stream(run_id, &block)
-      Sync do
-        with_client do |c|
-          response = c.get("/runs/#{run_id}/stream", headers: headers)
-          unless response.status == 200
-            body = response.read || ""
-            raise Space::Core::Error, "GET /runs/#{run_id}/stream failed (#{response.status}): #{body[0, 200]}"
-          end
-
-          read_sse(response, &block)
-        end
-      end
-    end
-
-    # Polls GET /jobs/:id until run_id is present, waiting `interval` seconds
-    # between attempts, up to `attempts` tries. Raises Space::Core::Error if
-    # the bound is exceeded.
-    def wait_for_run_id(id, interval: POLL_INTERVAL_SECONDS, attempts: POLL_MAX_ATTEMPTS)
-      attempts.times do |i|
-        run_id = show(id)["run_id"]
-        return run_id if run_id
-        sleep interval unless i == attempts - 1
-      end
-      raise Space::Core::Error, "job #{id}: no run_id after #{attempts} attempts (#{attempts * interval}s)"
-    end
-
-    private
-
-    def get_json(path)
-      Sync do
-        with_client do |c|
-          response = c.get(path, headers: headers)
-          parse_json(response, "GET #{path}")
-        end
-      end
-    end
-
-    def with_client
-      if @client
-        yield @client
-      else
-        Async::HTTP::Client.open(Async::HTTP::Endpoint.parse(@host)) { |c| yield c }
-      end
-    end
-
-    def headers
-      [
-        ["authorization", "Bearer #{@token}"],
-        ["content-type",  "application/json"]
-      ]
-    end
-
-    def parse_json(response, what, expected_status: 200)
-      status = response.status
-      body   = response.read || ""
-      raise Space::Core::Error, "#{what} failed (#{status}): #{body[0, 200]}" unless status == expected_status
-
-      JSON.parse(body)
-    end
-
-    # Buffers chunks and splits on the SSE event terminator ("\n\n"). Each
-    # event's data: line(s) are joined and yielded; an event whose data JSON
-    # carries type == "run_complete" ends the stream.
-    def read_sse(response)
-      buffer = +""
-      response.each do |chunk|
-        buffer << chunk
-        while (boundary = buffer.index("\n\n"))
-          event = buffer.slice!(0..boundary + 1)
-          data  = event.each_line.select { |line| line.start_with?("data:") }
-                        .map { |line| line.sub(/\Adata:\s?/, "").chomp }
-                        .join("\n")
-          next if data.empty?
-
-          yield data
-          parsed = begin
-            JSON.parse(data)
-          rescue JSON::ParserError
-            nil
-          end
-          return if parsed.is_a?(Hash) && parsed["type"] == "run_complete"
-        end
-      end
-    end
-  end
-end

data/lib/space_architect/run_creator.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "async/http/client"
-require "async/http/endpoint"
-require "json"
-
-module Space::Architect
-  class RunCreator
-    def initialize(host, token, client: nil)
-      @host   = host.chomp("/")
-      @token  = token
-      @client = client
-    end
-
-    # POSTs to /runs and returns the integer run id.
-    # Raises Space::Core::Error on any failure — never returns nil.
-    def create
-      Sync do
-        if @client
-          response = @client.post("/runs", headers: headers, body: nil)
-          parse_response(response)
-        else
-          Async::HTTP::Client.open(Async::HTTP::Endpoint.parse(@host)) do |c|
-            response = c.post("/runs", headers: headers, body: nil)
-            parse_response(response)
-          end
-        end
-      end
-    end
-
-    private
-
-    def headers
-      [
-        ["authorization", "Bearer #{@token}"],
-        ["content-type",  "application/json"]
-      ]
-    end
-
-    def parse_response(response)
-      status = response.status
-      body   = response.read || ""
-      raise Space::Core::Error, "POST /runs failed (#{status}): #{body[0, 200]}" unless status == 201
-
-      parsed = JSON.parse(body)
-      id     = parsed["id"]
-      raise Space::Core::Error, "POST /runs: missing or non-integer id in response: #{body[0, 200]}" \
-        unless id.is_a?(Integer)
-
-      id
-    end
-  end
-end

data/lib/space_architect/session_sync/bin_path.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-
-module Space::Architect
-  module SessionSync
-    # Resolves the absolute path to the `architect` executable the plist
-    # should invoke, imitating RepoTender::CLI::Daemon::Helpers::Resolve's
-    # detect_bin_path precedence: an env override (tests), the dev checkout's
-    # exe/architect, `which architect`, then the installed gem's bin.
-    module BinPath
-      module_function
-
-      def detect(env: ENV)
-        override = env["SPACE_ARCHITECT_BIN_PATH"]
-        return override if override && !override.empty?
-
-        dev = File.expand_path("../../../exe/architect", __dir__)
-        return dev if File.exist?(dev)
-
-        out, _err, status = Open3.capture3("which", "architect")
-        return out.strip if status.success? && !out.strip.empty?
-
-        Gem.bin_path("space-architect", "architect")
-      end
-    end
-  end
-end

data/lib/space_architect/session_sync/cursor.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "fileutils"
-
-module Space::Architect
-  module SessionSync
-    # Machine-managed cursor at $XDG_STATE_HOME/space-architect/session-sync.yaml
-    # (imitates RepoTender::State::Store's load/write/emit shape). Keyed by
-    # absolute source path; each entry records the size + mtime observed the
-    # last time that file was uploaded.
-    class Cursor
-      Entry = Data.define(:size, :mtime) do
-        def initialize(size:, mtime:) = super
-      end
-
-      def self.load(path)
-        raw = read_yaml(path)
-        raw.each_with_object({}) do |(k, v), acc|
-          acc[k] = Entry.new(size: v["size"], mtime: v["mtime"])
-        end
-      end
-
-      def self.write(path, entries)
-        FileUtils.mkdir_p(File.dirname(path))
-        payload = entries.each_with_object({}) { |(k, v), acc| acc[k] = {"size" => v.size, "mtime" => v.mtime} }
-        tmp = "#{path}.tmp.#{Process.pid}"
-        begin
-          File.write(tmp, YAML.dump(payload, line_width: -1))
-          File.rename(tmp, path)
-        ensure
-          File.delete(tmp) if File.exist?(tmp)
-        end
-      end
-
-      def self.read_yaml(path)
-        return {} unless File.exist?(path)
-
-        YAML.safe_load_file(path, permitted_classes: [], aliases: false) || {}
-      end
-    end
-  end
-end

data/lib/space_architect/session_sync/plist.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module Space::Architect
-  module SessionSync
-    # Hand-rolled launchd plist emitter for the session-sync agent, imitating
-    # RepoTender::Launchd::Plist's shape. Under launchd's bare PATH, a bare
-    # env-relative ruby binstub shebang resolves to macOS system Ruby instead
-    # of the caller's toolchain, so ProgramArguments names the interpreter
-    # explicitly (ruby_bin) rather than relying on shebang resolution — no
-    # mise wrapping needed, since the sync itself pins no toolchain at run
-    # time.
-    class Plist
-      DEFAULT_PATH = "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
-
-      HEADER = <<~XML
-        <?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-        <plist version="1.0">
-        <dict>
-      XML
-      FOOTER = "</dict>\n</plist>\n"
-
-      class << self
-        # @param label [String]            The job label (reverse-DNS; on-disk plist basename).
-        # @param refresh_interval [Integer] StartInterval in seconds (must be > 0).
-        # @param log_dir [String]          Absolute directory for stdout/stderr logs.
-        # @param bin_path [String]         Absolute path to the architect bin script.
-        # @param ruby_bin [String]         Absolute path to the ruby to run bin_path under.
-        # @param host [String]             --host value passed to `sessions sync`.
-        # @param env [Hash]                EnvironmentVariables dict; must contain a non-empty
-        #                                  SessionSync::TOKEN_ENV value (resolved by the caller —
-        #                                  never resolved here). PATH defaults to DEFAULT_PATH
-        #                                  unless the caller supplies its own.
-        # @return [String] the full plist XML.
-        def call(label:, refresh_interval:, log_dir:, bin_path:, ruby_bin:, host:, env:)
-          raise ArgumentError, "label is required" if label.to_s.empty?
-          raise ArgumentError, "refresh_interval must be > 0" unless refresh_interval.is_a?(Integer) && refresh_interval > 0
-          %w[log_dir bin_path ruby_bin].each do |k|
-            v = binding.local_variable_get(k)
-            raise ArgumentError, "#{k} must be absolute (got #{v.inspect})" unless v.is_a?(String) && File.absolute_path?(v)
-          end
-          raise ArgumentError, "host is required" if host.to_s.empty?
-          raise ArgumentError, "env[#{SessionSync::TOKEN_ENV}] is required" if env.to_h[SessionSync::TOKEN_ENV].to_s.empty?
-
-          out_log = File.join(log_dir, "#{label}.out.log")
-          err_log = File.join(log_dir, "#{label}.err.log")
-
-          body = +""
-          body << key("Label") << string(label) << "\n"
-          body << key("ProgramArguments") << "\n" << array([
-            ruby_bin,
-            bin_path,
-            "sessions",
-            "sync",
-            "--host", host
-          ])
-          body << key("EnvironmentVariables") << "\n" << dict({"PATH" => DEFAULT_PATH}.merge(env.to_h))
-          body << key("StartInterval") << integer(refresh_interval) << "\n"
-          body << key("RunAtLoad") << boolean(true) << "\n"
-          body << key("ProcessType") << string("Background") << "\n"
-          body << key("StandardOutPath") << string(out_log) << "\n"
-          body << key("StandardErrorPath") << string(err_log) << "\n"
-
-          HEADER + body + FOOTER
-        end
-
-        private
-
-        def key(name)
-          "  <key>#{escape(name)}</key>\n"
-        end
-
-        def escape(s)
-          s.to_s
-            .gsub("&", "&amp;")
-            .gsub("<", "&lt;")
-            .gsub(">", "&gt;")
-            .gsub("\"", "&quot;")
-            .gsub("'", "&apos;")
-        end
-
-        def string(s)
-          "  <string>#{escape(s)}</string>"
-        end
-
-        def integer(i)
-          "  <integer>#{Integer(i)}</integer>"
-        end
-
-        def boolean(b)
-          "  <#{b ? "true" : "false"}/>"
-        end
-
-        def array(items)
-          out = +"  <array>\n"
-          items.each { |arg| out << "    <string>#{escape(arg)}</string>\n" }
-          out << "  </array>"
-        end
-
-        def dict(hash)
-          out = +"  <dict>\n"
-          hash.each do |k, v|
-            out << "    <key>#{escape(k)}</key>\n"
-            out << "    <string>#{escape(v)}</string>\n"
-          end
-          out << "  </dict>"
-        end
-      end
-    end
-  end
-end

data/lib/space_architect/session_sync/runner.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "cursor"
-require_relative "session_id"
-
-module Space::Architect
-  module SessionSync
-    # One sync pass: scans the pi + claude session roots, decides
-    # upload/skip per the frozen cursor rules, uploads via the injected
-    # client, and persists the updated cursor (unless dry_run).
-    class Runner
-      RECENT_MTIME_SECONDS = 60
-
-      def initialize(client:, state_path:, pi_root:, claude_root:, now: -> { Time.now }, dry_run: false)
-        @client = client
-        @state_path = state_path
-        @pi_root = pi_root
-        @claude_root = claude_root
-        @now = now
-        @dry_run = dry_run
-      end
-
-      def call
-        cursor = Cursor.load(@state_path)
-        results = files.map { |path, session_id| process(path, session_id, cursor) }
-        Cursor.write(@state_path, cursor) unless @dry_run
-        results
-      end
-
-      private
-
-      def process(path, session_id, cursor)
-        stat = File.stat(path)
-        recorded = cursor[path]
-
-        return {path: path, session_id: session_id, action: :skipped, reason: "recent mtime"} if recent_mtime?(stat)
-        return {path: path, session_id: session_id, action: :skipped, reason: "unchanged"} if recorded && recorded.size >= stat.size
-
-        return {path: path, session_id: session_id, action: :would_upload} if @dry_run
-
-        response = @client.upload(path: path, session_id: session_id)
-        if [200, 201].include?(response[:status])
-          cursor[path] = Cursor::Entry.new(size: stat.size, mtime: stat.mtime.to_i)
-          {path: path, session_id: session_id, action: response[:status] == 201 ? :uploaded : :updated,
-           conversation_id: response[:conversation_id]}
-        else
-          {path: path, session_id: session_id, action: :failed, status: response[:status], errors: response[:errors]}
-        end
-      end
-
-      def recent_mtime?(stat)
-        (@now.call - stat.mtime) < RECENT_MTIME_SECONDS
-      end
-
-      def files
-        pi = Space::Core::Paths.content_tree(@pi_root).select { |p| p.end_with?(".jsonl") }
-          .map { |p| [p, SessionId.for_pi(p)] }
-        claude = Space::Core::Paths.content_tree(@claude_root).select { |p| p.end_with?(".jsonl") }
-          .map { |p| [p, SessionId.for_claude(p)] }
-        pi + claude
-      end
-    end
-  end
-end

data/lib/space_architect/session_sync/session_id.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Space::Architect
-  module SessionSync
-    # Frozen session-id derivation rules for the two store shapes:
-    #   pi:     <mangled-cwd>/<timestamp>_<sessionId>.jsonl -> part after the last "_"
-    #   claude: <mangled-cwd>/<sessionId>.jsonl             -> basename minus ".jsonl"
-    module SessionId
-      def self.for_pi(path)
-        base = File.basename(path, ".jsonl")
-        idx = base.rindex("_")
-        idx ? base[(idx + 1)..] : base
-      end
-
-      def self.for_claude(path)
-        File.basename(path, ".jsonl")
-      end
-    end
-  end
-end

data/lib/space_architect/session_sync.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "session_sync/session_id"
-require_relative "session_sync/cursor"
-require_relative "session_sync/runner"
-require_relative "session_sync/plist"
-require_relative "session_sync/bin_path"
-
-module Space::Architect
-  # Session-sync rail's laptop half: scans ~/.pi/agent/sessions/**/*.jsonl and
-  # ~/.claude/projects/**/*.jsonl for conversation files, uploads new/grown
-  # ones to a space-server via ConversationsClient, and installs a per-user
-  # launchd agent that runs the sync on an interval. Opencode (sqlite) is out
-  # of scope for this rail.
-  module SessionSync
-    LABEL = "io.github.jetpks.space-architect.session-sync"
-    APP_NAME = "space-architect"
-    TOKEN_ENV = "SPACE_ARCHITECT_INGEST_TOKEN"
-
-    module_function
-
-    # The one op-read seam under lib/: resolves an op:// ref via `op read`.
-    # Shared by ConversationsClient's default op_resolver and
-    # Sessions::Agent::Install (both test-injectable around this call).
-    def resolve_token(ref)
-      value = IO.popen(["op", "read", ref], &:read)
-      raise Space::Core::Error, "op read failed for #{ref}" unless $?.success?
-
-      value.chomp
-    end
-
-    def state_dir(env: ENV)
-      File.join(Space::Core::XDG.state_home(env: env).to_s, APP_NAME)
-    end
-
-    def default_state_file(env: ENV)
-      File.join(state_dir(env: env), "session-sync.yaml")
-    end
-
-    def default_pi_root(env: ENV)
-      File.join(Space::Core::XDG.home(env: env), ".pi", "agent", "sessions")
-    end
-
-    def default_claude_root(env: ENV)
-      File.join(Space::Core::XDG.home(env: env), ".claude", "projects")
-    end
-
-    def log_dir(env: ENV)
-      File.join(state_dir(env: env), "logs")
-    end
-
-    def launch_agents_dir(env: ENV)
-      File.join(Space::Core::XDG.home(env: env), "Library", "LaunchAgents")
-    end
-  end
-end