Files
archie/internal/infrastructure/postgres/harness_secrets.go
T
sam e16ba86b30 feat(harness): ingest OAuth storage and recover workflow write handling
Recover the OAuth storage slice from f6079e9d and the missing workflow persistence error handling from f07c314e, adapted to the current step contract. Require encryption for OAuth token storage and verify RPC round trips and task-grant denial.
2026-09-27 13:09:41 +10:00

108 lines
4.0 KiB
Go

package postgres
import (
"context"
"encoding/json"
"errors"
"fmt"
"time"
"github.com/jackc/pgx/v5"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/infrastructure/bindingcipher"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
)
var _ storecontract.HarnessSecretStore = (*EDA)(nil)
// harnessSecretPayload is the JSON shape sealed into harness_secrets.secret_enc:
// the whole token set behind one envelope, never separate plaintext columns.
type harnessSecretPayload struct {
AccessToken string `json:"access_token"`
RefreshToken string `json:"refresh_token"`
TokenType string `json:"token_type"`
ExpiresAt time.Time `json:"expires_at"`
}
// GetHarnessSecret returns the stored OAuth token set for an org/service
// credential binding, or storecontract.ErrHarnessSecretNotFound.
func (s *EDA) GetHarnessSecret(ctx context.Context, org, service string) (harnesssecret.Secret, error) {
row, err := s.q.GetHarnessSecret(ctx, postgresdb.GetHarnessSecretParams{Org: org, Service: service})
if errors.Is(err, pgx.ErrNoRows) {
return harnesssecret.Secret{}, storecontract.ErrHarnessSecretNotFound
}
if err != nil {
return harnesssecret.Secret{}, fmt.Errorf("postgres: get harness secret: %w", err)
}
payload, err := s.openHarnessSecret(row.SecretEnc)
if err != nil {
return harnesssecret.Secret{}, err
}
return harnesssecret.Secret{
Org: row.Org, Service: row.Service,
AccessToken: payload.AccessToken, RefreshToken: payload.RefreshToken,
TokenType: payload.TokenType, ExpiresAt: payload.ExpiresAt,
UpdatedAt: row.UpdatedAt,
}, nil
}
// PutHarnessSecret upserts an org/service credential binding's OAuth token
// set. Called by the setup terminal's first capture and by the egress
// proxy's every refresh.
func (s *EDA) PutHarnessSecret(ctx context.Context, secret harnesssecret.Secret) error {
if err := secret.Validate(); err != nil {
return err
}
sealed, err := s.sealHarnessSecret(harnessSecretPayload{
AccessToken: secret.AccessToken, RefreshToken: secret.RefreshToken,
TokenType: secret.TokenType, ExpiresAt: secret.ExpiresAt,
})
if err != nil {
return err
}
if err := s.q.PutHarnessSecret(ctx, postgresdb.PutHarnessSecretParams{
Org: secret.Org, Service: secret.Service, SecretEnc: sealed,
}); err != nil {
return fmt.Errorf("postgres: put harness secret: %w", err)
}
return nil
}
// sealHarnessSecret JSON-marshals the token set and encrypts it under
// bindingcipher.HarnessSecretDomain -- its own domain separator, distinct
// from BindingDomain's, so a row cannot be relocated between the two tables
// and still authenticate. OAuth tokens require a configured encryption key;
// the binding store's legacy plaintext fallback does not apply here.
func (s *EDA) sealHarnessSecret(payload harnessSecretPayload) (string, error) {
if s.cipher == nil {
return "", errors.New("postgres: harness secrets require an encryption key")
}
raw, err := json.Marshal(payload)
if err != nil {
return "", fmt.Errorf("postgres: marshal harness secret: %w", err)
}
sealed, err := s.cipher.EncryptDomain(bindingcipher.HarnessSecretDomain, string(raw))
if err != nil {
return "", fmt.Errorf("postgres: encrypt harness secret: %w", err)
}
return sealed, nil
}
// openHarnessSecret reverses sealHarnessSecret.
func (s *EDA) openHarnessSecret(stored string) (harnessSecretPayload, error) {
if s.cipher == nil {
return harnessSecretPayload{}, errors.New("postgres: harness secrets require an encryption key")
}
raw, err := s.cipher.DecryptDomain(bindingcipher.HarnessSecretDomain, stored)
if err != nil {
return harnessSecretPayload{}, fmt.Errorf("postgres: decrypt harness secret: %w", err)
}
var payload harnessSecretPayload
if err := json.Unmarshal([]byte(raw), &payload); err != nil {
return harnessSecretPayload{}, fmt.Errorf("postgres: unmarshal harness secret: %w", err)
}
return payload, nil
}