collavre 0.24.0 → 0.25.0

data/app/services/collavre/cli_proxy/client.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Collavre
+  module CliProxy
+    class Client
+      class Error < StandardError
+        attr_reader :status, :code, :details
+
+        def initialize(message, status: nil, code: nil, details: nil)
+          super(message)
+          @status = status
+          @code = code
+          @details = details
+        end
+      end
+
+      def initialize(gateway:, workspace: nil, user_key: nil, http_client: nil)
+        @gateway = gateway
+        @workspace = workspace
+        @user_key = user_key
+        @http_client = http_client || default_http_client
+      end
+
+      def engines
+        request(:get, "/v1/auth/engines")
+      end
+
+      def engine_status(engine)
+        request(:get, "/v1/auth/#{segment(engine)}/status")
+      end
+
+      def create_auth_session(engine, flow:, provisioning_url:)
+        request(
+          :post,
+          "/v1/auth/#{segment(engine)}/sessions",
+          body: { flow: flow, provisioning_url: provisioning_url }.compact
+        )
+      end
+
+      def auth_session(engine, session_id)
+        request(:get, "/v1/auth/#{segment(engine)}/sessions/#{segment(session_id)}")
+      end
+
+      def submit_auth_session(engine, session_id, value, base_url: nil)
+        request(
+          :post,
+          "/v1/auth/#{segment(engine)}/sessions/#{segment(session_id)}",
+          body: { value: value, base_url: base_url }.compact
+        )
+      end
+
+      def cancel_auth_session(engine, session_id)
+        request(:delete, "/v1/auth/#{segment(engine)}/sessions/#{segment(session_id)}")
+      end
+
+      def provision_status
+        request(:get, "/v1/provision")
+      end
+
+      # Registers the workspace manifest URL and applies it, without a login.
+      # The login-carried provisioning_url does the same thing as a side effect
+      # of authenticating; this route is how an already-authenticated workspace
+      # gets (re)provisioned.
+      def provision_register_manifest(url)
+        request(:post, "/v1/provision/manifest", body: { url: url })
+      end
+
+      def provision_sync
+        request(:post, "/v1/provision/sync")
+      end
+
+      def provision_approve(type, name)
+        request(:post, "/v1/provision/items/#{segment(type)}/#{segment(name)}/approve")
+      end
+
+      def provision_delete(type, name)
+        request(:delete, "/v1/provision/items/#{segment(type)}/#{segment(name)}")
+      end
+
+      private
+
+      def default_http_client
+        requires_endpoint_policy = !@gateway.owner.system_admin? &&
+          !@gateway.desktop_loopback?
+        policy = EndpointPolicy.new if requires_endpoint_policy
+        Collavre::HttpClient.new(open_timeout: 5, read_timeout: 35, endpoint_policy: policy)
+      end
+
+      def request(method, path, body: nil)
+        headers = {
+          "Authorization" => "Bearer #{@gateway.admin_key}",
+          "Accept" => "application/json"
+        }
+        headers["X-CLI-Proxy-User-Key"] = @user_key if @user_key.present?
+        headers.merge!(Identity.headers(gateway: @gateway, workspace: @workspace, method: method, path: path)) if @workspace
+        headers["Content-Type"] = "application/json" if body
+
+        response = if method == :delete
+          @http_client.delete(@gateway.proxy_path(path), headers: headers)
+        elsif method == :get
+          @http_client.get(@gateway.proxy_path(path), headers: headers)
+        else
+          @http_client.public_send(
+            method,
+            @gateway.proxy_path(path),
+            body: body&.to_json,
+            headers: headers
+          )
+        end
+        parsed = parse_body(response)
+        return parsed || {} if response.success?
+
+        error = parsed.is_a?(Hash) ? (parsed["error"] || parsed) : {}
+        raise Error.new(
+          error["message"].presence || response.message,
+          status: response.code,
+          code: error["code"],
+          details: parsed
+        )
+      rescue Collavre::HttpClient::ConnectionError => e
+        raise Error.new(e.message, code: "proxy_unreachable")
+      rescue EndpointPolicy::UnsafeEndpoint
+        raise Error.new(I18n.t("collavre.agent_gateways.unsafe_endpoint"), code: "unsafe_proxy_endpoint")
+      end
+
+      # A failure may answer with a non-JSON body: the proxy itself answers JSON
+      # throughout, but anything in front of it (a reverse proxy, a gateway
+      # error page) does not. Keep the HTTP status in that case so a caller can
+      # branch on it — a 404 is how an endpoint this proxy version lacks reports
+      # itself — instead of collapsing it into a status-less parse error.
+      def parse_body(response)
+        response.json
+      rescue JSON::ParserError => e
+        raise Error.new("Invalid JSON from CLI proxy", details: e.message) if response.success?
+
+        nil
+      end
+
+      def segment(value)
+        value = value.to_s
+        raise ArgumentError, "Invalid path segment" unless value.match?(/\A[A-Za-z0-9][A-Za-z0-9._-]{0,127}\z/)
+
+        value
+      end
+    end
+  end
+end

data/app/services/collavre/cli_proxy/endpoint_policy.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "resolv"
+require "uri"
+
+module Collavre
+  module CliProxy
+    class EndpointPolicy
+      class UnsafeEndpoint < StandardError; end
+
+      DISALLOWED_RANGES = [
+        IPAddr.new("0.0.0.0/8"),
+        IPAddr.new("10.0.0.0/8"),
+        IPAddr.new("100.64.0.0/10"),
+        IPAddr.new("127.0.0.0/8"),
+        IPAddr.new("169.254.0.0/16"),
+        IPAddr.new("172.16.0.0/12"),
+        IPAddr.new("192.0.0.0/24"),
+        IPAddr.new("192.0.2.0/24"),
+        IPAddr.new("192.168.0.0/16"),
+        IPAddr.new("198.18.0.0/15"),
+        IPAddr.new("198.51.100.0/24"),
+        IPAddr.new("203.0.113.0/24"),
+        IPAddr.new("224.0.0.0/4"),
+        IPAddr.new("240.0.0.0/4"),
+        IPAddr.new("::/128"),
+        IPAddr.new("::1/128"),
+        IPAddr.new("100::/64"),
+        IPAddr.new("2001:db8::/32"),
+        IPAddr.new("fc00::/7"),
+        IPAddr.new("fe80::/10"),
+        IPAddr.new("ff00::/8")
+      ].freeze
+
+      def initialize(resolver: Resolv)
+        @resolver = resolver
+      end
+
+      def resolve!(url)
+        uri = parsed_https_url!(url)
+
+        addresses = @resolver.getaddresses(uri.hostname).uniq
+        raise UnsafeEndpoint if addresses.empty? || addresses.any? { |address| unsafe_ip?(address) }
+
+        addresses
+      rescue URI::InvalidURIError, Resolv::ResolvError, SocketError, ArgumentError
+        raise UnsafeEndpoint
+      end
+
+      def safe_literal?(url)
+        uri = parsed_https_url!(url)
+
+        literal = IPAddr.new(uri.hostname)
+        !unsafe_ip?(literal)
+      rescue IPAddr::InvalidAddressError
+        !uri.hostname.casecmp("localhost").zero? && !uri.hostname.downcase.end_with?(".localhost")
+      rescue URI::InvalidURIError, UnsafeEndpoint
+        false
+      end
+
+      private
+
+      def parsed_https_url!(url)
+        uri = url.is_a?(URI) ? url : URI.parse(url.to_s)
+        raise UnsafeEndpoint unless uri.is_a?(URI::HTTPS) && uri.hostname.present?
+        raise UnsafeEndpoint if uri.userinfo.present? || uri.query.present? || uri.fragment.present?
+
+        uri
+      end
+
+      def unsafe_ip?(address)
+        ip = address.is_a?(IPAddr) ? address : IPAddr.new(address)
+        ip = ip.native if ip.ipv4_mapped?
+        DISALLOWED_RANGES.any? { |range| range.include?(ip) }
+      rescue IPAddr::InvalidAddressError
+        true
+      end
+    end
+  end
+end

data/app/services/collavre/cli_proxy/identity.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Collavre
+  module CliProxy
+    class Identity
+      HEADER_NAMES = {
+        tenant: "X-CLI-Proxy-Tenant-ID",
+        user: "X-CLI-Proxy-User-ID",
+        workspace: "X-CLI-Proxy-Workspace-ID",
+        timestamp: "X-CLI-Proxy-Identity-Timestamp",
+        signature: "X-CLI-Proxy-Identity-Signature"
+      }.freeze
+
+      # The workspace header is part of the signed payload. Signing it outside
+      # the HMAC would let anyone holding a completion key retarget the request
+      # at another workspace of the same user.
+      PAYLOAD_VERSION = "v2"
+
+      def self.headers(gateway:, workspace:, method:, path:, at: Time.current)
+        secret = gateway.identity_secret.to_s
+        return {} if secret.blank?
+
+        timestamp = at.to_i.to_s
+        payload = [
+          PAYLOAD_VERSION,
+          method.to_s.upcase,
+          path,
+          timestamp,
+          gateway.tenant_id,
+          workspace.proxy_credential_id,
+          workspace.proxy_workspace_id
+        ].join("\n")
+        signature = OpenSSL::HMAC.hexdigest("SHA256", secret, payload)
+
+        {
+          HEADER_NAMES[:tenant] => gateway.tenant_id,
+          HEADER_NAMES[:user] => workspace.proxy_credential_id,
+          HEADER_NAMES[:workspace] => workspace.proxy_workspace_id,
+          HEADER_NAMES[:timestamp] => timestamp,
+          HEADER_NAMES[:signature] => signature
+        }
+      end
+    end
+  end
+end

data/app/services/collavre/cli_proxy/safe_net_http_adapter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "faraday/net_http"
+
+module Collavre
+  module CliProxy
+    class SafeNetHttpAdapter < Faraday::Adapter::NetHttp
+      def net_http_connection(env)
+        uri = env[:url]
+        pinned_ip = EndpointPolicy.new.resolve!(uri).first
+        port = uri.port || 443
+
+        Net::HTTP.new(uri.hostname, port, nil).tap do |http|
+          http.ipaddr = pinned_ip
+        end
+      end
+    end
+  end
+end

data/app/services/collavre/command_menu_service.rb

@@ -36,16 +36,6 @@ module Collavre
             { name: "agent_name", type: "string", format: "mention", required: false, description: I18n.t("collavre.comments.command_menu.topic_agent_hint") }
           ]
         },
-        {
-          name: "work",
-          label: "/work",
-          description: I18n.t("collavre.comments.command_menu.work_description"),
-          args: I18n.t("collavre.comments.command_menu.work_args"),
-          input_schema: [
-            { name: "agent_name", type: "string", format: "mention", required: true, description: I18n.t("collavre.comments.command_menu.work_agent_hint") },
-            { name: "context", type: "string", required: false, description: I18n.t("collavre.comments.command_menu.work_context_hint") }
-          ]
-        },
         {
           name: "compress",
           label: "/compress",

data/app/services/collavre/comment_move_service.rb

@@ -20,8 +20,8 @@ module Collavre
 
       moved_count = perform_move(comments, target_origin, new_topic_id)
 
-      Comment.broadcast_badges(@creative)
-      Comment.broadcast_badges(target_origin) unless target_origin == @creative
+      Comment.broadcast_badges_later(@creative)
+      Comment.broadcast_badges_later(target_origin) unless target_origin == @creative
 
       { success: true, moved_count: moved_count }
     end
@@ -34,13 +34,14 @@ module Collavre
       if target_creative_id.present?
         target_creative = Creative.find_by(id: target_creative_id)
         raise MoveError, I18n.t("collavre.comments.move_invalid_target") unless target_creative
-        [ target_creative.effective_origin, nil ]
+        target_origin = target_creative.effective_origin
+        [ target_origin, target_origin.main_topic.id ]
       elsif !target_topic_id.nil?
-        new_topic_id = target_topic_id.presence
+        new_topic_id = target_topic_id.presence&.to_i
         if new_topic_id.present? && !creative.topics.exists?(id: new_topic_id)
           raise MoveError, I18n.t("collavre.comments.move_invalid_topic", default: "Invalid topic")
         end
-        [ creative, new_topic_id ]
+        [ creative, new_topic_id || creative.main_topic.id ]
       else
         raise MoveError, I18n.t("collavre.comments.move_invalid_target")
       end
@@ -62,14 +63,24 @@ module Collavre
     def perform_move(comments, target_origin, new_topic_id)
       moved_count = 0
       ActiveRecord::Base.transaction do
+        locked_topics = lock_move_topics(comments, new_topic_id)
+        locked_source_creative = lock_legacy_source_creative(comments)
+        validate_destination_topic!(locked_topics, new_topic_id, target_origin)
+
         comments.each do |comment|
+          validate_source_comment!(comment, locked_topics, locked_source_creative)
           same_creative = comment.creative_id == target_origin.id
-          same_topic = comment.topic_id.to_s == new_topic_id.to_s
-          next if same_creative && same_topic
+          next if same_creative && comment.topic_id.to_s == new_topic_id.to_s
 
           if same_creative
+            preserve_unread_state_for_topic_move(comment, new_topic_id)
             comment.update!(topic_id: new_topic_id)
           else
+            preserve_unread_state_for_topic_move(
+              comment,
+              new_topic_id || target_origin.main_topic.id,
+              destination_creative: target_origin
+            )
             comment.update!(creative: target_origin, topic_id: new_topic_id)
             broadcast_move_removal(comment, comment.creative)
           end
@@ -79,6 +90,84 @@ module Collavre
       moved_count
     end
 
+    def lock_legacy_source_creative(comments)
+      return creative unless comments.any? { |comment| comment.topic_id.nil? }
+
+      Creative.lock.find(creative.id)
+    end
+
+    # TopicMove takes the source topic lock before sweeping its comments. Lock
+    # every source plus the destination in one deterministic order, so an
+    # existing-comment move cannot write a stale topic_id after that sweep.
+    def lock_move_topics(comments, destination_topic_id)
+      topic_ids = (comments.map(&:topic_id) + [ destination_topic_id ]).compact.uniq.sort
+      Topic.where(id: topic_ids).order(:id).lock.index_by(&:id)
+    end
+
+    def validate_destination_topic!(locked_topics, topic_id, target_origin)
+      return if locked_topics[topic_id]&.creative_id == target_origin.id
+
+      raise MoveError, I18n.t("collavre.comments.move_invalid_topic", default: "Invalid topic")
+    end
+
+    def validate_source_comment!(comment, locked_topics, locked_source_creative)
+      original_topic_id = comment.topic_id
+      comment.reload
+      source_topic = locked_topics[original_topic_id]
+      source_membership_valid = original_topic_id.nil? || source_topic&.creative_id == locked_source_creative.id
+      return if comment.creative_id == creative.id && comment.topic_id == original_topic_id &&
+                source_membership_valid
+
+      raise MoveError, I18n.t("collavre.comments.move_not_allowed")
+    end
+
+    # A topic watermark is an ordered cursor, so a comment moved into a topic
+    # whose cursor is already beyond its id would otherwise become read without
+    # the recipient seeing it. Lower only affected recipients' destination
+    # cursor to just before the moved comment; this is deliberately
+    # conservative and may re-show later destination comments as unread.
+    def preserve_unread_state_for_topic_move(comment, destination_topic_id, destination_creative: creative)
+      source_topic_id = comment.topic_id
+      readable_user_ids = CreativeShare.readable_user_ids_from_shares(
+        destination_creative,
+        readers_affected_by(comment, destination_creative)
+      )
+      readable_user_ids.each do |user_id|
+        source_pointers = CommentReadPointer.where(user_id: user_id, creative: creative).index_by(&:topic_id)
+        destination_pointers = if destination_creative == creative
+          source_pointers
+        else
+          CommentReadPointer.where(user_id: user_id, creative: destination_creative).index_by(&:topic_id)
+        end
+        source_watermark = watermark_for(source_pointers, source_topic_id)
+        destination_watermark = watermark_for(destination_pointers, destination_topic_id)
+        next unless source_watermark < comment.id && destination_watermark >= comment.id
+
+        destination_pointer = destination_pointers[destination_topic_id] || CommentReadPointer.find_or_create_by!(
+          user_id: user_id, creative: destination_creative, topic_id: destination_topic_id
+        )
+        destination_pointer.update!(last_read_comment_id: comment.id - 1)
+      end
+    end
+
+    # A named pointer with a nil cursor is an explicit initial watermark. It
+    # must win over the retained legacy fallback, otherwise a topic preserved
+    # when the legacy lane advanced is incorrectly treated as already read.
+    def watermark_for(pointers, topic_id)
+      return pointers.fetch(topic_id).last_read_comment_id.to_i if pointers.key?(topic_id)
+
+      pointers[nil]&.last_read_comment_id.to_i || 0
+    end
+
+    # Private comments are visible only to their author and approver. Rewinding
+    # another user's cursor would make unrelated destination comments unread.
+    def readers_affected_by(comment, destination_creative)
+      reader_ids = CommentReadPointer.where(creative: [ creative, destination_creative ]).distinct.pluck(:user_id)
+      return reader_ids unless comment.private?
+
+      reader_ids & [ comment.user_id, comment.approver_id ].compact
+    end
+
     def broadcast_move_removal(comment, original_creative)
       return if comment.private?
 

data/app/services/collavre/comment_snapshot_restore_service.rb

@@ -11,14 +11,13 @@ module Collavre
 
     def call
       ActiveRecord::Base.transaction do
-        # Lock the snapshot row to prevent concurrent restore (P2 fix)
-        locked_snapshot = CommentSnapshot.lock.find(@snapshot.id)
+        locked_snapshot = lock_snapshot
 
         if locked_snapshot.restored_at.present?
           raise RestoreError, I18n.t("collavre.comment_snapshots.already_restored")
         end
 
-        validate_permission!
+        validate_permission!(locked_snapshot)
 
         # Build a mapping from old comment IDs to new comments for quoted_comment_id restoration
         old_id_to_new = {}
@@ -71,8 +70,15 @@ module Collavre
 
     private
 
-    def validate_permission!
-      creative = @snapshot.creative
+    # TopicMove locks topic -> snapshots. Match that order so restoration
+    # cannot deadlock relocation while recreating comments.
+    def lock_snapshot
+      Topic.lock.find(@snapshot.topic_id) if @snapshot.topic_id
+      CommentSnapshot.lock.find(@snapshot.id)
+    end
+
+    def validate_permission!(snapshot)
+      creative = snapshot.creative
       unless creative.has_permission?(@user, :write)
         raise RestoreError, I18n.t("collavre.comment_snapshots.not_authorized")
       end

data/app/services/collavre/comments/action_executor.rb

@@ -179,7 +179,19 @@ module Collavre
 
           raise InvalidActionError, "Tool name is required" if tool_name.blank?
 
-          # Execute the tool via MetaToolService
+          # Claim the paused turn before the tool runs. Stop stays reachable while a
+          # turn waits on approval, and stopping it leaves the approval comment on
+          # screen — approving afterwards would fire the side effect for a turn that
+          # is already gone, since the resumed job just exits on a cancelled task.
+          task = task_id.present? ? claim_pending_task!(task_id, tool_call_id) : nil
+
+          # Already claimed — hand back what that run recorded. A duplicate entry in
+          # one actions array shares the row lock, so the approval marker is the only
+          # thing standing between it and a second side effect plus a second resume.
+          if task&.pending_tool_call&.dig("approved")
+            return task.pending_tool_call["result"]
+          end
+
           result = begin
             ::Tools::MetaToolService.new.call(
               action: "call",
@@ -191,30 +203,46 @@ module Collavre
             { error: e.message }
           end
 
-          # If there's a task to resume, update it and re-queue the job
-          if task_id.present?
-            task = Task.find_by(id: task_id)
-            if task
-              # Mark the tool call as approved with its result
-              task.update!(
-                pending_tool_call: {
-                  tool_name: tool_name,
-                  tool_call_id: tool_call_id,
-                  arguments: arguments,
-                  approved: true,
-                  result: result,
-                  approved_at: Time.current.iso8601
-                }
-              )
-
-              # Resume the AI agent job
-              AiAgentJob.perform_later(task)
-            end
+          if task
+            task.update!(
+              pending_tool_call: {
+                tool_name: tool_name,
+                tool_call_id: tool_call_id,
+                arguments: arguments,
+                approved: true,
+                result: result,
+                approved_at: Time.current.iso8601
+              }
+            )
+
+            AiAgentJob.perform_later(task)
           end
 
           result
         end
 
+        # The row lock is held until the outer transaction commits, so a Stop racing
+        # this approval either blocks and lands after it or wins and makes the claim
+        # fail. A missing task keeps the pre-existing "run, nothing to resume" path.
+        # The status stays pending_approval on purpose: only AiAgentJob may promote
+        # it to running, since a Stop before the job starts relies on a
+        # HELD_SLOT_WITHOUT_WORKER status to release the slot it still holds.
+        def claim_pending_task!(task_id, tool_call_id)
+          task = Task.lock.find_by(id: task_id)
+          return nil unless task
+
+          unless task.status == "pending_approval"
+            raise InvalidActionError, I18n.t("collavre.comments.approve_task_not_pending")
+          end
+
+          # A re-paused turn leaves its earlier approval comment behind.
+          unless task.pending_tool_call&.dig("tool_call_id") == tool_call_id
+            raise InvalidActionError, I18n.t("collavre.comments.approve_task_superseded")
+          end
+
+          task
+        end
+
         def process_action(payload)
           unless payload.is_a?(Hash)
             raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_format")

data/app/services/collavre/comments/command_processor.rb

@@ -29,7 +29,6 @@ module Collavre
         [
           Collavre::Comments::CalendarCommand.new(comment: comment, user: user),
           Collavre::Comments::TopicCommand.new(comment: comment, user: user),
-          Collavre::Comments::WorkCommand.new(comment: comment, user: user),
           Collavre::Comments::CompressCommand.new(comment: comment, user: user)
         ]
       end