Files
clawmates/crates/cm-secrets/src/store.rs
T
Omar SobhandClaude Fable 5 add4f79fed Rebrand: TeamClaw -> Clawmates (clawmates.work)
Full-depth rename per the approved plan; the 'claw' product vocabulary
(claws, /claws routes, clawId, Claw Chat) stays — it is now the brand.

- Display brand: Clawmates (manifest, titles, hero, login/rail logo
  'clawmates'); default host app.clawmates.work; registry
  ghcr.io/clawmates
- Crates tc-* -> cm-* (16 crates + all imports); binaries
  clawmates-server/broker/bundler; images clawmates/*; env prefix
  CLAWMATES_* (+ CM_TEST_DATABASE_URL / CM_LIVE_LLM); config
  clawmates.toml; helm chart deploy/helm/clawmates with clawmates-*
  resources; db names clawmates*; sockets /run/clawmates; cookie
  cm_session; kind cluster clawmates-test; seccomp node profile
  clawmates-agent-profile.json
- All 9 Playwright brand assertions updated in lockstep; historical
  spec document left untouched as the only remaining 'TeamClaw'
- Local env migrated: dev pg clawmates-dev-pg/clawmates_dev, shared
  test server clawmates-test-pg, kind cluster recreated with image +
  profile, compose images rebuilt under clawmates/*

Verified end to end: 161 Rust + 68 frontend tests, 29 Playwright
journeys, 4 live kind tests, helm/install/LOC/placeholder gates, and
the clean-room install rehearsal serving the clawmates login page from
a signed bundle of the rebuilt images.

Co-Authored-By: Claude Fable 5 <[email protected]>
2026-06-10 12:31:25 -05:00

62 lines
2.0 KiB
Rust

use cm_domain::WorkspaceId;
use sqlx::PgPool;
use uuid::Uuid;
use crate::crypto::{FileKey, Sealed};
use crate::BrokerError;
/// Encrypted persistence for the `secrets` table. Plaintext exists only
/// transiently inside broker memory during a capability call.
pub struct SecretStore<'a> {
pub pool: &'a PgPool,
pub key: &'a FileKey,
}
impl SecretStore<'_> {
pub async fn store(
&self,
workspace_id: WorkspaceId,
kind: &str,
plaintext: &str,
) -> Result<Uuid, BrokerError> {
let sealed = self.key.seal(plaintext.as_bytes())?;
let id = Uuid::now_v7();
sqlx::query!(
"INSERT INTO secrets (id, workspace_id, kind, ciphertext, nonce)
VALUES ($1, $2, $3, $4, $5)",
id,
workspace_id.as_uuid(),
kind,
sealed.ciphertext,
sealed.nonce,
)
.execute(self.pool)
.await
.map_err(|e| BrokerError::Io(e.to_string()))?;
Ok(id)
}
pub async fn kind(&self, id: Uuid) -> Result<String, BrokerError> {
sqlx::query_scalar!("SELECT kind FROM secrets WHERE id = $1", id)
.fetch_optional(self.pool)
.await
.map_err(|e| BrokerError::Io(e.to_string()))?
.ok_or(BrokerError::NotFound)
}
/// Decrypts a secret for immediate use inside the broker. Callers must
/// never serialize the result onto the wire.
pub async fn reveal_internal(&self, id: Uuid) -> Result<String, BrokerError> {
let row = sqlx::query!("SELECT ciphertext, nonce FROM secrets WHERE id = $1", id)
.fetch_optional(self.pool)
.await
.map_err(|e| BrokerError::Io(e.to_string()))?
.ok_or(BrokerError::NotFound)?;
let plaintext = self.key.open(&Sealed {
ciphertext: row.ciphertext,
nonce: row.nonce,
})?;
String::from_utf8(plaintext).map_err(|e| BrokerError::Crypto(e.to_string()))
}
}