machina-auth 0.1.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 376d280c6510f8afa38049e22a0c73df81355c57571b83ef571d547e340ee7c3
-  data.tar.gz: 13ce052358975310f67e3b3a65daee423fb48ddc9e2490632b548c66aa0f32d9
+  metadata.gz: 95a0c331d428907d79a618631f8b39aea1aa20e297090e44229aed0bc93c0324
+  data.tar.gz: 1489dd29fdf00291cb414b57f198d210bd9e1af818d373b4064b7cda6c0f1b66
 SHA512:
-  metadata.gz: 271245b4d9c4e3a28d4feafe688d9c3e1985d28566f5f86037ab68ef76fa246f266c67b5dad94ad0d23b111844f9c9e9224e656f97bdeaf9ef76efaf4f18311b
-  data.tar.gz: f719e7340acaab6a85ea6b96408c639e0608c797dcbd64f57fa9f5fa76921c5a6ccaac3d0c2751932d77de0ca1019fd4f127479f9b461686b6b0b36c99206c95
+  metadata.gz: '08a671be6f57a8ef5098444165e335e33cfb85e371f7d34d7842699854bab66050f1de191dc203839dc7c4b94dc72a556803699bc08333e453a5552fd0b94007'
+  data.tar.gz: 236485e85bfc0ef18afc0ddde3251b411f8579ff90b1fa870958b403e2175fbfbfce751d9c629d787c9848f709473e7f7f3779843ab6232b100aee27f1acfb83

data/lib/machina/authorized.rb

@@ -5,9 +5,9 @@ module Machina
   # their organization/workspace context, and granted permissions.
   class Authorized
     attr_reader :user_id, :user_email, :user_name, :avatar_url,
-                :organization_id, :org_name, :org_personal, :org_role,
-                :workspace_id, :workspace_name,
-                :session_id, :expires_at, :type
+                :organization_id, :org_name, :org_slug, :org_personal, :org_role,
+                :workspace_id, :workspace_name, :workspace_slug,
+                :session_id, :expires_at, :type, :integration_name
 
     def initialize(data = {})
       assign_user_attrs(data)
@@ -65,6 +65,7 @@ module Machina
     def assign_org_attrs(data)
       @organization_id = data.dig('organization', 'id')
       @org_name        = data.dig('organization', 'name')
+      @org_slug        = data.dig('organization', 'slug')
       @org_personal    = data.dig('organization', 'personal')
       @org_role        = data.dig('membership', 'policy_name') || data.dig('organization', 'role')
     end
@@ -72,13 +73,15 @@ module Machina
     def assign_workspace_attrs(data)
       @workspace_id   = data.dig('workspace', 'id')
       @workspace_name = data.dig('workspace', 'name')
+      @workspace_slug = data.dig('workspace', 'slug')
     end
 
     def assign_session_attrs(data)
-      @type       = data.dig('session', 'type')&.to_sym
-      @session_id = data.dig('session', 'id') || data['session_id']
-      raw_expires = data.dig('session', 'expires_at') || data['expires_at']
-      @expires_at = raw_expires ? Time.zone.parse(raw_expires) : nil
+      @type             = data.dig('session', 'type')&.to_sym
+      @session_id       = data.dig('session', 'id') || data['session_id']
+      @integration_name = data.dig('session', 'integration_name')
+      raw_expires       = data.dig('session', 'expires_at') || data['expires_at']
+      @expires_at       = raw_expires ? Time.zone.parse(raw_expires) : nil
     end
 
     EMPTY = new.freeze # rubocop:disable Lint/UselessConstantScoping

data/lib/machina/identity_client.rb

@@ -19,8 +19,17 @@ module Machina
       @connection = connection
     end
 
-    def resolve_session(token)
-      post('/internal/v1/sessions/resolve', { token: })
+    # @param token [String] raw session token (ps_) or API key (mk_)
+    # @param workspace_id [String, nil] optional workspace UUID hint for org-scoped API keys
+    # @param workspace_slug [String, nil] optional workspace slug hint (alternative to id)
+    # @param organization_slug [String, nil] optional organization slug; identity service
+    #   rejects with 403 if the value does not match the token's bound organization
+    def resolve_session(token, workspace_id: nil, workspace_slug: nil, organization_slug: nil)
+      payload = { token: }
+      payload[:workspace_id]      = workspace_id      if workspace_id
+      payload[:workspace_slug]    = workspace_slug    if workspace_slug
+      payload[:organization_slug] = organization_slug if organization_slug
+      post('/internal/v1/sessions/resolve', payload)
     end
 
     def revoke_session(token)

data/lib/machina/middleware/authentication/hints.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Machina
+  module Middleware
+    class Authentication
+      # Value object representing the workspace + organization hints supplied
+      # with a resolve request. Read from Rack env or request headers, then
+      # forwarded to the identity service as kwargs.
+      #
+      # Sources, in order:
+      #
+      # 1. `env['machina.workspace_hint']` / `env['machina.organization_hint']`
+      #    — set by the product's routes or a Rack middleware when the URL
+      #    itself scopes to an org/workspace (e.g. `/mcp/:org/:workspace`).
+      # 2. `X-Machina-Workspace-Hint` / `X-Machina-Organization-Hint` request
+      #    headers — fallback for clients that can't influence the URL.
+      #
+      # The values are passed through verbatim to the identity service. The
+      # organization hint is enforced as a match against the token's bound
+      # organization (403 on mismatch).
+      # Slug/UUID disambiguation is cheap: UUIDs match a narrow pattern.
+      # Anything else is treated as a slug.
+      HINT_UUID_RE = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
+      private_constant :HINT_UUID_RE
+
+      Hints = Data.define(:workspace, :organization) do
+        def self.from(env, request)
+          new(
+            workspace: env['machina.workspace_hint'].presence ||
+              request.headers['X-Machina-Workspace-Hint'].presence,
+            organization: env['machina.organization_hint'].presence ||
+              request.headers['X-Machina-Organization-Hint'].presence,
+          )
+        end
+
+        def empty?
+          workspace.nil? && organization.nil?
+        end
+
+        def to_resolve_kwargs
+          kwargs = {}
+          kwargs[HINT_UUID_RE.match?(workspace) ? :workspace_id : :workspace_slug] = workspace if workspace
+          kwargs[:organization_slug] = organization if organization
+          kwargs
+        end
+
+        def cache_suffix
+          empty? ? '' : ":#{organization}:#{workspace}"
+        end
+      end
+    end
+  end
+end

data/lib/machina/middleware/authentication.rb

@@ -1,44 +1,53 @@
 # frozen_string_literal: true
 
+require_relative 'authentication/hints'
+
 module Machina
   module Middleware
     # Rack middleware that extracts authentication tokens from incoming requests,
     # resolves them against the identity service, and sets Current.authorized.
     class Authentication
+      TRANSIENT_FAILURE = :transient_failure
+      private_constant :TRANSIENT_FAILURE
+
       def initialize(app)
         @app = app
       end
 
       def call(env)
         request = ActionDispatch::Request.new(env)
-        # Skip paths allow the developer to disable the middleware from validating
-        # any token or headers on any matched URL or Path.
         return @app.call(env) if skip_path?(request)
 
         token = extract_token(request)
         return @app.call(env) if token.blank?
 
-        session_data = resolve_session(token)
-
-        # Token present but invalid/expired: clear the stale cache entry and
-        # fall through with nil authorized. API callers get 401 from the
-        # controller; browser users get redirected to login by authenticate!.
-        return handle_expired_token(env, request, token) unless session_data
-
-        Machina::Current.authorized = Machina::Authorized.new(session_data)
-
-        @app.call(env)
+        dispatch_session(env, request, token, Hints.from(env, request))
       ensure
         Machina::Current.reset
       end
 
       private
 
-      # Checks whether the request matches any configured skip path.
-      #
-      # Strings match as path prefixes. Regexes match against both the
-      # request path and the full URL, allowing pattern-based exclusions
-      # on host, path, or any combination.
+      def dispatch_session(env, request, token, hints)
+        session_data = resolve_session(token, hints)
+
+        if session_data.is_a?(Hash)
+          Machina::Current.authorized = Machina::Authorized.new(session_data)
+          return @app.call(env)
+        end
+
+        if transient_failure?(session_data)
+          @app.call(env)
+        else
+          handle_expired_token(env, request, token, hints)
+        end
+      end
+
+      def transient_failure?(result)
+        result == TRANSIENT_FAILURE
+      end
+
+      # Strings match as path prefixes; regexes match path or full URL.
       def skip_path?(request)
         return false if Machina.config.skip_paths.blank?
 
@@ -53,12 +62,9 @@ module Machina
         end
       end
 
-      # Clears the cache entry for the expired token and, when the token
-      # originated from the session cookie, deletes that cookie so the
-      # browser stops sending it on subsequent requests. This prevents a
-      # redirect loop where an expired cookie shadows fresh callback tokens.
-      def handle_expired_token(env, request, token)
-        Machina.cache.delete(cache_key(token))
+      # Clears the cache and cookie for a token that Console explicitly rejected.
+      def handle_expired_token(env, request, token, hints)
+        Machina.cache.delete(cache_key(token, hints))
 
         status, headers, body = @app.call(env)
         Rack::Utils.delete_cookie_header!(headers, 'machina_session') if request.cookies['machina_session'] == token
@@ -66,37 +72,49 @@ module Machina
       end
 
       def extract_token(request)
-        request.params['token']
+        extract_param_token(request)
           || request.cookies['machina_session']
           || extract_bearer(request)
           || request.headers['X-Api-Key']
       end
 
+      def extract_param_token(request)
+        request.params['token']
+      rescue ActionDispatch::Http::Parameters::ParseError
+        nil
+      end
+
       def extract_bearer(request)
         auth_header = request.headers['Authorization'].to_s
         match = auth_header.match(/\ABearer\s+(.+)\z/)
         match && match[1]
       end
 
-      def resolve_session(token)
-        cached = Machina.cache.read(cache_key(token))
-        return cached if cached.present? && !(cached.is_a?(Hash) && cached[:stale])
-
-        fetch_from_identity_service(token)
+      def resolve_session(token, hints)
+        cached = Machina.cache.read(cache_key(token, hints))
+        return cached if cached.present? && !(cached.is_a?(Hash) && cached['stale'])
+
+        fetch_from_identity_service(token, hints)
+      rescue Faraday::Error => e
+        # Network-level failures (connection refused, timeout, DNS) are
+        # transient — return stale cached data when available, otherwise
+        # signal transient failure so the caller preserves the cookie.
+        Rails.logger.warn("[machina] Identity service unreachable: #{e.class} — #{e.message}")
+        cached.presence || TRANSIENT_FAILURE
       rescue StandardError
         nil
       end
 
-      def fetch_from_identity_service(token)
-        response = Machina.identity_client.resolve_session(token)
+      def fetch_from_identity_service(token, hints)
+        response = Machina.identity_client.resolve_session(token, **hints.to_resolve_kwargs)
 
         unless response.success?
-          Machina.cache.delete(cache_key(token))
+          Machina.cache.delete(cache_key(token, hints))
           return nil
         end
 
         data = unwrap_payload(response.parsed)
-        Machina.cache.write(cache_key(token), data, expires_in: Machina.config.cache_ttl)
+        Machina.cache.write(cache_key(token, hints), data, expires_in: Machina.config.cache_ttl)
         cache_workspace_ref(data)
         data
       end
@@ -106,25 +124,18 @@ module Machina
       end
 
       def cache_workspace_ref(data)
-        workspace    = data['workspace']
-        organization = data['organization']
-
+        workspace, organization = data.values_at('workspace', 'organization')
         return unless workspace.is_a?(Hash) && organization.is_a?(Hash)
         return unless defined?(Machina::WorkspaceRef) && Machina::WorkspaceRef.table_exists?
 
         ref = Machina::WorkspaceRef.find_or_initialize_by(tenant_ref: workspace['id'])
-
-        ref.name = workspace['name']
-        ref.cached_at = Time.current
-        ref.organization_id = organization['id']
-
-        ref.save!
+        ref.update!(name: workspace['name'], cached_at: Time.current, organization_id: organization['id'])
       rescue StandardError
         nil
       end
 
-      def cache_key(token)
-        "machina:session:#{token}"
+      def cache_key(token, hints)
+        "machina:session:#{token}#{hints.cache_suffix}"
       end
     end
   end

data/lib/machina/test_helpers.rb

@@ -127,7 +127,8 @@ module Machina
       {
         'id' => '00000000-0000-4000-a000-000000001000',
         'type' => 'platform_session',
-        'expires_at' => (Time.now.utc + 86_400).iso8601
+        'expires_at' => (Time.now.utc + 86_400).iso8601,
+        'integration_name' => nil
       }
     end
   end

data/lib/machina/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Machina
-  VERSION = '0.1.7'
+  VERSION = '0.3.0'
 end

data/lib/machina/webhook_receiver.rb

@@ -63,7 +63,7 @@ module Machina
         entry = cache.read(key)
         next unless entry.is_a?(Hash)
 
-        cache.write(key, entry.merge(stale: true))
+        cache.write(key, entry.merge('stale' => true))
       end
     end
 

data/spec/contracts/session_resolution_contract_spec.rb

@@ -68,6 +68,26 @@ RSpec.describe 'Session Resolution Contract' do
       end.not_to raise_error
     end
 
+    it 'accepts an optional workspace_id hint' do
+      expect do
+        ConsoleSchema.validate!(
+          { 'token' => 'mk_abc', 'workspace_id' => 'b2c3d4e5-f6a7-8901-bcde-f12345678901' },
+          schema_key,
+          'request.body',
+        )
+      end.not_to raise_error
+    end
+
+    it 'accepts an optional workspace_slug hint' do
+      expect do
+        ConsoleSchema.validate!(
+          { 'token' => 'mk_abc', 'workspace_slug' => 'zar' },
+          schema_key,
+          'request.body',
+        )
+      end.not_to raise_error
+    end
+
     it 'fails when token is missing' do
       expect { ConsoleSchema.validate!({}, schema_key, 'request.body') }.to raise_error(/Schema validation failed/)
     end

data/spec/machina/authorized_spec.rb

@@ -18,6 +18,7 @@ RSpec.describe Machina::Authorized do
     it 'exposes organization attributes' do
       expect(authorized.organization_id).to eq('a1b2c3d4-e5f6-7890-abcd-ef1234567890')
       expect(authorized.org_name).to eq('ZAR')
+      expect(authorized.org_slug).to eq('zar')
       expect(authorized.org_personal).to be(false)
       expect(authorized.org_role).to eq('admin')
     end
@@ -25,6 +26,15 @@ RSpec.describe Machina::Authorized do
     it 'exposes workspace attributes' do
       expect(authorized.workspace_id).to eq('b2c3d4e5-f6a7-8901-bcde-f12345678901')
       expect(authorized.workspace_name).to eq('Primary')
+      expect(authorized.workspace_slug).to eq('primary')
+    end
+
+    it 'returns nil for slugs when missing from payload (older Console)' do
+      data['organization'].delete('slug')
+      data['workspace'].delete('slug')
+      auth = described_class.new(data)
+      expect(auth.org_slug).to be_nil
+      expect(auth.workspace_slug).to be_nil
     end
 
     it 'aliases tenant_ref to workspace_id' do
@@ -36,6 +46,18 @@ RSpec.describe Machina::Authorized do
     end
   end
 
+  describe '#integration_name' do
+    it 'returns nil when not set' do
+      expect(authorized.integration_name).to be_nil
+    end
+
+    it 'returns the value from session data' do
+      data['session']['integration_name'] = 'GitHub Webhooks'
+      auth = described_class.new(data)
+      expect(auth.integration_name).to eq('GitHub Webhooks')
+    end
+  end
+
   describe '#type' do
     it 'returns a symbol' do
       expect(authorized.type).to eq(:platform_session)

data/spec/machina/identity_client_spec.rb

@@ -25,6 +25,29 @@ RSpec.describe Machina::IdentityClient do
     expect(response.parsed).to eq('data' => { 'user' => { 'id' => 'd7e60485-114e-4142-8dc2-c3612f920cc9' } })
   end
 
+  it 'forwards a workspace_id hint when provided' do
+    stubs.post('/internal/v1/sessions/resolve') do |env|
+      expect(JSON.parse(env.body)).to eq(
+        'token' => 'mk_123',
+        'workspace_id' => 'b2c3d4e5-f6a7-8901-bcde-f12345678901',
+      )
+      [200, { 'Content-Type' => 'application/json' }, JSON.generate(data: {})]
+    end
+
+    response = client.resolve_session('mk_123', workspace_id: 'b2c3d4e5-f6a7-8901-bcde-f12345678901')
+    expect(response).to be_success
+  end
+
+  it 'forwards a workspace_slug hint when provided' do
+    stubs.post('/internal/v1/sessions/resolve') do |env|
+      expect(JSON.parse(env.body)).to eq('token' => 'mk_123', 'workspace_slug' => 'zar')
+      [200, { 'Content-Type' => 'application/json' }, JSON.generate(data: {})]
+    end
+
+    response = client.resolve_session('mk_123', workspace_slug: 'zar')
+    expect(response).to be_success
+  end
+
   it 'syncs permissions for a product' do
     product_id = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
 

data/spec/machina/middleware/authentication_spec.rb

@@ -42,6 +42,106 @@ RSpec.describe Machina::Middleware::Authentication do
     expect(workspace_ref).to have_attributes(name: 'Primary')
   end
 
+  describe 'workspace hint forwarding' do
+    let(:mock) { MockResponses.session_resolution }
+
+    it 'forwards a slug hint from env to the identity client and keys the cache by it' do
+      expect(identity_client).to receive(:resolve_session)
+        .with('mk_abc', workspace_slug: 'my-org')
+        .and_return(Machina::IdentityClient::Response.new(status: 200, body: mock))
+
+      env = Rack::MockRequest.env_for('/mcp', 'HTTP_AUTHORIZATION' => 'Bearer mk_abc')
+      env['machina.workspace_hint'] = 'my-org'
+
+      status, = middleware.call(env)
+      expect(status).to eq(200)
+      expect(Machina.cache.read('machina:session:mk_abc::my-org')).to be_a(Hash)
+    end
+
+    it 'forwards a uuid hint as workspace_id rather than slug' do
+      uuid = 'b2c3d4e5-f6a7-8901-bcde-f12345678901'
+      expect(identity_client).to receive(:resolve_session)
+        .with('mk_abc', workspace_id: uuid)
+        .and_return(Machina::IdentityClient::Response.new(status: 200, body: mock))
+
+      env = Rack::MockRequest.env_for('/mcp', 'HTTP_AUTHORIZATION' => 'Bearer mk_abc')
+      env['machina.workspace_hint'] = uuid
+
+      status, = middleware.call(env)
+      expect(status).to eq(200)
+    end
+
+    it 'reads the X-Machina-Workspace-Hint header when env is unset' do
+      expect(identity_client).to receive(:resolve_session)
+        .with('mk_abc', workspace_slug: 'zar')
+        .and_return(Machina::IdentityClient::Response.new(status: 200, body: mock))
+
+      env = Rack::MockRequest.env_for('/mcp',
+                                      'HTTP_AUTHORIZATION' => 'Bearer mk_abc',
+                                      'HTTP_X_MACHINA_WORKSPACE_HINT' => 'zar')
+
+      status, = middleware.call(env)
+      expect(status).to eq(200)
+    end
+
+    it 'does not forward a hint when none is set' do
+      expect(identity_client).to receive(:resolve_session)
+        .with('mk_abc')
+        .and_return(Machina::IdentityClient::Response.new(status: 200, body: mock))
+
+      env = Rack::MockRequest.env_for('/mcp', 'HTTP_AUTHORIZATION' => 'Bearer mk_abc')
+
+      status, = middleware.call(env)
+      expect(status).to eq(200)
+    end
+
+    it 'forwards organization_slug from env to the identity client' do
+      expect(identity_client).to receive(:resolve_session)
+        .with('mk_abc', organization_slug: 'zar', workspace_slug: 'default')
+        .and_return(Machina::IdentityClient::Response.new(status: 200, body: mock))
+
+      env = Rack::MockRequest.env_for('/mcp', 'HTTP_AUTHORIZATION' => 'Bearer mk_abc')
+      env['machina.organization_hint'] = 'zar'
+      env['machina.workspace_hint']    = 'default'
+
+      status, = middleware.call(env)
+      expect(status).to eq(200)
+      expect(Machina.cache.read('machina:session:mk_abc:zar:default')).to be_a(Hash)
+    end
+
+    it 'reads the X-Machina-Organization-Hint header when env is unset' do
+      expect(identity_client).to receive(:resolve_session)
+        .with('mk_abc', organization_slug: 'zar')
+        .and_return(Machina::IdentityClient::Response.new(status: 200, body: mock))
+
+      env = Rack::MockRequest.env_for('/mcp',
+                                      'HTTP_AUTHORIZATION' => 'Bearer mk_abc',
+                                      'HTTP_X_MACHINA_ORGANIZATION_HINT' => 'zar')
+
+      status, = middleware.call(env)
+      expect(status).to eq(200)
+    end
+
+    it 'caches hinted and unhinted responses under separate keys' do
+      allow(identity_client).to receive(:resolve_session)
+        .with('mk_abc')
+        .and_return(Machina::IdentityClient::Response.new(status: 200, body: mock))
+      allow(identity_client).to receive(:resolve_session)
+        .with('mk_abc', workspace_slug: 'zar')
+        .and_return(Machina::IdentityClient::Response.new(status: 200, body: mock))
+
+      plain_env = Rack::MockRequest.env_for('/mcp', 'HTTP_AUTHORIZATION' => 'Bearer mk_abc')
+      middleware.call(plain_env)
+
+      hinted_env = Rack::MockRequest.env_for('/mcp', 'HTTP_AUTHORIZATION' => 'Bearer mk_abc')
+      hinted_env['machina.workspace_hint'] = 'zar'
+      middleware.call(hinted_env)
+
+      expect(Machina.cache.read('machina:session:mk_abc')).to be_a(Hash)
+      expect(Machina.cache.read('machina:session:mk_abc::zar')).to be_a(Hash)
+    end
+  end
+
   it 'passes through with nil authorized when resolution fails' do
     allow(identity_client).to receive(:resolve_session).and_return(
       Machina::IdentityClient::Response.new(status: 404, body: '{}'),
@@ -57,7 +157,7 @@ RSpec.describe Machina::Middleware::Authentication do
   it 'evicts cached session and passes through when Console returns non-200 on stale re-fetch' do
     token = 'ps_stale_token'
     cache_key = "machina:session:#{token}"
-    stale_data = MockResponses.session_resolution_minimal['data'].merge(stale: true)
+    stale_data = MockResponses.session_resolution_minimal['data'].merge('stale' => true)
 
     Machina.cache.write(cache_key, stale_data, expires_in: 5.minutes)
 
@@ -160,6 +260,61 @@ RSpec.describe Machina::Middleware::Authentication do
     expect(headers['set-cookie']).to be_nil
   end
 
+  it 'falls through to bearer token when request body is malformed JSON' do
+    mock = MockResponses.session_resolution
+    allow(identity_client).to receive(:resolve_session).with('ps_bearer').and_return(
+      Machina::IdentityClient::Response.new(status: 200, body: mock),
+    )
+
+    env = Rack::MockRequest.env_for(
+      '/resource',
+      method: 'POST',
+      input: 'not valid json',
+      'CONTENT_TYPE' => 'application/json',
+      'HTTP_AUTHORIZATION' => 'Bearer ps_bearer',
+    )
+
+    status, _headers, body = middleware.call(env)
+
+    expect(status).to eq(200)
+    expect(JSON.parse(body.first)['user_id']).to eq(mock['data']['user']['id'])
+  end
+
+  context 'when the identity service is unreachable' do
+    it 'returns stale cached data instead of destroying the session' do
+      token = 'ps_network_blip'
+      cache_key = "machina:session:#{token}"
+      cached_data = MockResponses.session_resolution_minimal['data'].merge('stale' => true)
+
+      Machina.cache.write(cache_key, cached_data, expires_in: 5.minutes)
+
+      allow(identity_client).to receive(:resolve_session).with(token).and_raise(
+        Faraday::ConnectionFailed.new('Connection refused'),
+      )
+
+      env = Rack::MockRequest.env_for('/resource', 'HTTP_AUTHORIZATION' => "Bearer #{token}")
+      status, _headers, body = middleware.call(env)
+
+      expect(status).to eq(200)
+      expect(JSON.parse(body.first)['user_id']).to eq(cached_data['user']['id'])
+    end
+
+    it 'does not delete the cookie on transient network failure' do
+      allow(identity_client).to receive(:resolve_session).with('ps_network_fail').and_raise(
+        Faraday::ConnectionFailed.new('Connection refused'),
+      )
+
+      env = Rack::MockRequest.env_for(
+        '/resource',
+        'HTTP_COOKIE' => 'machina_session=ps_network_fail',
+      )
+
+      _status, headers, _body = middleware.call(env)
+
+      expect(headers['set-cookie']).to be_nil
+    end
+  end
+
   it 'uses the cache on subsequent requests' do
     response = Machina::IdentityClient::Response.new(
       status: 200,

data/spec/machina/test_helpers_spec.rb

@@ -21,6 +21,7 @@ RSpec.describe Machina::TestHelpers do
       expect(authorized.workspace_name).to eq('Test Workspace')
       expect(authorized.session_id).to eq('00000000-0000-4000-a000-000000001000')
       expect(authorized.type).to eq(:platform_session)
+      expect(authorized.integration_name).to be_nil
       expect(authorized.expires_at).to be_a(Time)
       expect(authorized.permissions).to eq([])
     end
@@ -60,6 +61,11 @@ RSpec.describe Machina::TestHelpers do
       expect(authorized.workspace_name).to eq('Staging')
     end
 
+    it 'overrides integration_name via session hash' do
+      authorized = sign_in_as_machina(session: { integration_name: 'Sentry Alerts' })
+      expect(authorized.integration_name).to eq('Sentry Alerts')
+    end
+
     it 'sets permissions' do
       authorized = sign_in_as_machina(permissions: ['reports.view', 'reports.create'])
       expect(authorized.can?('reports.view')).to be(true)

data/spec/machina/webhook_receiver_spec.rb

@@ -36,7 +36,7 @@ RSpec.describe Machina::WebhookReceiver do
       receiver = described_class.new(request, cache:)
 
       expect(receiver.process!).to be(true)
-      expect(cache.read('machina:session:ps_123')).to include(stale: true)
+      expect(cache.read('machina:session:ps_123')).to include('stale' => true)
     end
   end
 

data/spec/support/mock_responses.rb

@@ -13,7 +13,11 @@ module MockResponses
       'data' => {
         'user' => session_user,
         'organization' => session_organization,
-        'workspace' => { 'id' => 'b2c3d4e5-f6a7-8901-bcde-f12345678901', 'name' => 'Primary' },
+        'workspace' => {
+          'id' => 'b2c3d4e5-f6a7-8901-bcde-f12345678901',
+          'name' => 'Primary',
+          'slug' => 'primary'
+        },
         'membership' => { 'id' => 'c3d4e5f6-a7b8-9012-cdef-123456789012', 'policy_name' => 'admin' },
         'permissions' => ['sessions.view'],
         'session' => session_meta
@@ -27,12 +31,12 @@ module MockResponses
   end
 
   def session_organization
-    { 'id' => 'a1b2c3d4-e5f6-7890-abcd-ef1234567890', 'name' => 'ZAR', 'personal' => false }
+    { 'id' => 'a1b2c3d4-e5f6-7890-abcd-ef1234567890', 'name' => 'ZAR', 'slug' => 'zar', 'personal' => false }
   end
 
   def session_meta
     { 'id' => 'd4e5f6a7-b8c9-0123-def0-1234567890ab', 'type' => 'platform_session',
-      'expires_at' => '2026-03-20T12:00:00Z' }
+      'expires_at' => '2026-03-20T12:00:00Z', 'integration_name' => nil }
   end
 
   # A minimal resolution response for cache tests (fewer fields populated).
@@ -42,7 +46,11 @@ module MockResponses
       'data' => {
         'user' => { 'id' => 'd7e60485-114e-4142-8dc2-c3612f920cc9' },
         'organization' => { 'id' => 'a1b2c3d4-e5f6-7890-abcd-ef1234567890' },
-        'workspace' => { 'id' => 'b2c3d4e5-f6a7-8901-bcde-f12345678901', 'name' => 'Primary' },
+        'workspace' => {
+          'id' => 'b2c3d4e5-f6a7-8901-bcde-f12345678901',
+          'name' => 'Primary',
+          'slug' => 'primary'
+        },
         'permissions' => ['sessions.view'],
         'session' => { 'id' => 'd4e5f6a7-b8c9-0123-def0-1234567890ab', 'type' => 'platform_session',
                        'expires_at' => nil }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: machina-auth
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.3.0
 platform: ruby
 authors:
 - ZAR
@@ -152,6 +152,7 @@ files:
 - lib/machina/errors.rb
 - lib/machina/identity_client.rb
 - lib/machina/middleware/authentication.rb
+- lib/machina/middleware/authentication/hints.rb
 - lib/machina/permission_sync.rb
 - lib/machina/tasks/sync.rake
 - lib/machina/test_helpers.rb