Skip to main content

snip_sync/
lib.rs

1// The `format!("{}", var)` patterns below are inherited from the
2// pre-existing main.rs implementation. They were not flagged by clippy
3// when the code lived in a binary crate's `#[cfg(test)] mod tests`
4// (binary test targets are not always checked by `cargo clippy
5// --all-targets`), but moving the code into the library makes them
6// visible to lib test compilation. The lint suppression keeps the
7// refactor minimal; a follow-up should inline the args.
8//
9// Similarly, `RateLimiter::new()` and a few other constructors predate
10// the refactor and never carried a `Default` impl. Suppressing
11// `new_without_default` here keeps the diff focused.
12#![allow(clippy::uninlined_format_args, clippy::new_without_default)]
13
14pub mod bootstrap;
15pub mod cert;
16pub mod cli;
17pub mod db;
18pub mod editor;
19pub mod metrics;
20pub mod orchestration;
21pub mod paths;
22pub mod premade;
23pub mod process;
24pub mod rate_limiter;
25pub mod server_lock;
26#[cfg(any(test, feature = "test-helpers"))]
27pub mod test_helpers;
28#[cfg(any(test, feature = "test-helpers"))]
29pub mod test_observer;
30
31pub use db::Database;
32pub use metrics::Metrics;
33pub use premade::PremadeManager;
34pub use rate_limiter::RateLimiter;
35
36use serde::Deserialize;
37use snip_proto::{
38    CreateLibraryRequest, CreateLibraryResponse, DeleteLibraryRequest, DeleteLibraryResponse,
39    GetPremadeLibraryRequest, GetPremadeLibraryResponse, GetSnippetsRequest, HealthRequest,
40    HealthResponse, Library, ListLibrariesRequest, ListLibrariesResponse,
41    ListPremadeLibrariesRequest, ListPremadeLibrariesResponse,
42    PremadeLibrary as ProtoPremadeLibrary, PushSnippetsRequest, PushSnippetsResponse,
43    RegisterRequest, RegisterResponse, SearchPremadeLibrariesRequest,
44    SearchPremadeLibrariesResponse, Snippet as ProtoSnippet, SnippetList, SyncRequest,
45    SyncResponse, snippet_sync_server::SnippetSync,
46};
47use std::net::SocketAddr;
48use std::path::PathBuf;
49use std::sync::Arc;
50use std::time::Duration;
51use tonic::{Request, Response, Status};
52
53/// Extract the API key from a gRPC request's `authorization` metadata.
54/// Falls back to the body `api_key` field for backward compatibility.
55pub fn extract_api_key<T>(request: &Request<T>, body_api_key: &str) -> String {
56    request
57        .metadata()
58        .get("authorization")
59        .and_then(|v| v.to_str().ok())
60        .and_then(|v| v.strip_prefix("Bearer "))
61        .filter(|v| !v.is_empty())
62        .unwrap_or(body_api_key)
63        .to_string()
64}
65
66fn strip_port(addr: &str) -> String {
67    if let Some(close_bracket) = addr.find("]:") {
68        return addr[1..close_bracket].to_string();
69    }
70    // Bare IPv6 addresses contain multiple colons but no brackets.
71    // They have no port to strip, so return as-is.
72    if !addr.starts_with('[') && addr.matches(':').count() > 1 {
73        return addr.to_string();
74    }
75    if let Some(colon_pos) = addr.rfind(':')
76        && !addr.starts_with('[')
77    {
78        return addr[..colon_pos].to_string();
79    }
80    addr.to_string()
81}
82
83pub const DEFAULT_MAX_COMMAND_LENGTH: usize = 1024;
84pub const DEFAULT_MAX_DESCRIPTION_LENGTH: usize = 1024;
85pub const DEFAULT_MAX_TAGS: usize = 50;
86pub const DEFAULT_MAX_TAG_LENGTH: usize = 100;
87pub const DEFAULT_MAX_ID_LENGTH: usize = 128;
88pub const DEFAULT_MAX_DEVICE_ID_LENGTH: usize = 128;
89pub const DEFAULT_MAX_API_KEY_LENGTH: usize = 512;
90pub const DEFAULT_MAX_SYNC_SNIPPETS: usize = 10000;
91pub const DEFAULT_REQUEST_TIMEOUT_SECS: u64 = 30;
92pub const DEFAULT_RATE_LIMIT_PER_MINUTE: u32 = 120;
93pub const DEFAULT_DB_MAX_CONNECTIONS: u32 = 5;
94pub const DEFAULT_GRPC_MAX_MESSAGE_SIZE: u32 = 4 * 1024 * 1024; // 4 MiB
95pub const MAX_REQUEST_LIMIT: i32 = 1000;
96
97#[derive(Deserialize, Default)]
98pub struct ConfigFile {
99    pub server: Option<ServerConfig>,
100}
101
102#[derive(Deserialize, Default)]
103pub struct ServerConfig {
104    pub grpc_host: Option<String>,
105    pub grpc_port: Option<u16>,
106    pub http_host: Option<String>,
107    pub http_port: Option<u16>,
108    pub database: Option<DatabaseConfig>,
109    pub premade: Option<PremadeConfig>,
110    pub limits: Option<LimitsConfig>,
111    pub rate_limit: Option<RateLimitConfig>,
112    pub metrics: Option<MetricsConfig>,
113    pub cors: Option<CorsConfig>,
114}
115
116#[derive(Deserialize, Default)]
117pub struct DatabaseConfig {
118    pub path: Option<String>,
119    pub max_connections: Option<u32>,
120}
121
122#[derive(Deserialize, Default)]
123pub struct PremadeConfig {
124    pub directory: Option<String>,
125}
126
127#[derive(Deserialize, Default)]
128pub struct LimitsConfig {
129    pub max_command_length: Option<usize>,
130    pub max_description_length: Option<usize>,
131    pub max_tags: Option<usize>,
132    pub max_tag_length: Option<usize>,
133    pub max_id_length: Option<usize>,
134    pub max_device_id_length: Option<usize>,
135    pub max_api_key_length: Option<usize>,
136    pub request_timeout_secs: Option<u64>,
137    pub grpc_max_message_size: Option<u32>,
138}
139
140#[derive(Deserialize, Default)]
141pub struct RateLimitConfig {
142    pub requests_per_minute: Option<u32>,
143    pub trusted_proxies: Option<Vec<String>>,
144}
145
146#[derive(Deserialize, Default)]
147pub struct MetricsConfig {
148    pub username: Option<String>,
149    pub password: Option<String>,
150}
151
152#[derive(Deserialize, Default)]
153pub struct CorsConfig {
154    pub allowed_origins: Option<String>,
155}
156
157#[derive(Clone, Debug)]
158pub struct Config {
159    pub grpc_host: String,
160    pub grpc_port: u16,
161    pub http_host: String,
162    pub http_port: u16,
163    pub db_path: String,
164    pub db_max_connections: u32,
165    pub premade_dir: PathBuf,
166    pub max_command_length: usize,
167    pub max_description_length: usize,
168    pub max_tags: usize,
169    pub max_tag_length: usize,
170    pub max_id_length: usize,
171    pub max_device_id_length: usize,
172    pub max_api_key_length: usize,
173    pub request_timeout_secs: u64,
174    pub grpc_max_message_size: u32,
175    pub rate_limit_per_minute: u32,
176    pub trusted_proxies: Vec<String>,
177    pub metrics_username: Option<String>,
178    pub metrics_password: Option<String>,
179    pub cors_allowed_origins: Vec<String>,
180}
181
182#[derive(Debug, thiserror::Error)]
183pub enum ConfigLoadError {
184    #[error("failed to read configuration file {path}: {source}")]
185    Read {
186        path: PathBuf,
187        source: std::io::Error,
188    },
189    #[error("failed to parse configuration file {path}: {source}")]
190    Parse {
191        path: PathBuf,
192        source: toml::de::Error,
193    },
194    #[error("invalid environment variable {name}={value:?}: {reason}")]
195    InvalidEnvironment {
196        name: &'static str,
197        value: String,
198        reason: String,
199    },
200    #[error("invalid configuration value {name}={value:?}: {reason}")]
201    InvalidRange {
202        name: &'static str,
203        value: String,
204        reason: String,
205    },
206}
207
208/// Parse an optional environment variable, returning the typed value if present and valid.
209///
210/// Missing variable → `Ok(None)`. Present and valid → `Ok(Some(value))`.
211/// Present and invalid → `Err(ConfigLoadError::InvalidEnvironment)`.
212pub fn parse_env<T>(
213    env: &impl Fn(&str) -> Option<String>,
214    name: &'static str,
215) -> Result<Option<T>, ConfigLoadError>
216where
217    T: std::str::FromStr,
218    T::Err: std::fmt::Display,
219{
220    match env(name) {
221        Some(val) => match val.parse::<T>() {
222            Ok(parsed) => Ok(Some(parsed)),
223            Err(e) => Err(ConfigLoadError::InvalidEnvironment {
224                name,
225                value: val,
226                reason: e.to_string(),
227            }),
228        },
229        None => Ok(None),
230    }
231}
232
233/// Parse an optional boolean environment variable.
234///
235/// Accepted true values (case-insensitive): `true`, `1`, `yes`, `on`
236/// Accepted false values (case-insensitive): `false`, `0`, `no`, `off`
237///
238/// Missing variable → `Ok(None)`. Present and valid → `Ok(Some(bool))`.
239/// Present and invalid → `Err(ConfigLoadError::InvalidEnvironment)`.
240pub fn parse_bool_env(
241    env: &impl Fn(&str) -> Option<String>,
242    name: &'static str,
243) -> Result<Option<bool>, ConfigLoadError> {
244    match env(name) {
245        Some(val) => match val.to_lowercase().as_str() {
246            "true" | "1" | "yes" | "on" => Ok(Some(true)),
247            "false" | "0" | "no" | "off" => Ok(Some(false)),
248            _ => Err(ConfigLoadError::InvalidEnvironment {
249                name,
250                value: val,
251                reason: "expected one of: true, 1, yes, on, false, 0, no, off".to_string(),
252            }),
253        },
254        None => Ok(None),
255    }
256}
257
258impl Config {
259    pub fn load() -> Result<Self, ConfigLoadError> {
260        let config_path = paths::config_path();
261        Self::load_from(&config_path, &|name| std::env::var(name).ok())
262    }
263
264    fn load_from(
265        config_path: &std::path::Path,
266        env: &impl Fn(&str) -> Option<String>,
267    ) -> Result<Self, ConfigLoadError> {
268        let config_file = match std::fs::read_to_string(config_path) {
269            Ok(content) => toml::from_str(&content).map_err(|source| ConfigLoadError::Parse {
270                path: config_path.to_path_buf(),
271                source,
272            })?,
273            Err(e) if e.kind() == std::io::ErrorKind::NotFound => ConfigFile::default(),
274            Err(source) => {
275                return Err(ConfigLoadError::Read {
276                    path: config_path.to_path_buf(),
277                    source,
278                });
279            }
280        };
281
282        let server = config_file.server.unwrap_or_default();
283
284        let config = Self {
285            grpc_host: env("GRPC_HOST")
286                .or_else(|| server.grpc_host.clone())
287                .unwrap_or_else(|| "127.0.0.1".to_string()),
288            grpc_port: parse_env(env, "GRPC_PORT")?
289                .or(server.grpc_port)
290                .unwrap_or(50051),
291            http_host: env("HTTP_HOST")
292                .or_else(|| server.http_host.clone())
293                .unwrap_or_else(|| "127.0.0.1".to_string()),
294            http_port: parse_env(env, "HTTP_PORT")?
295                .or(server.http_port)
296                .unwrap_or(50050),
297            db_path: env("DATABASE_URL")
298                .or_else(|| server.database.as_ref().and_then(|d| d.path.clone()))
299                .unwrap_or_else(|| paths::default_db_path().to_string_lossy().into_owned()),
300            db_max_connections: parse_env(env, "DB_MAX_CONNECTIONS")?
301                .or(server.database.as_ref().and_then(|d| d.max_connections))
302                .unwrap_or(DEFAULT_DB_MAX_CONNECTIONS),
303            premade_dir: env("PREMADE_DIR")
304                .map(PathBuf::from)
305                .or_else(|| {
306                    server
307                        .premade
308                        .as_ref()
309                        .and_then(|p| p.directory.clone())
310                        .map(PathBuf::from)
311                })
312                .unwrap_or_else(paths::default_premade_dir),
313            max_command_length: parse_env(env, "MAX_COMMAND_LENGTH")?
314                .or(server.limits.as_ref().and_then(|l| l.max_command_length))
315                .unwrap_or(DEFAULT_MAX_COMMAND_LENGTH),
316            max_description_length: parse_env(env, "MAX_DESCRIPTION_LENGTH")?
317                .or(server
318                    .limits
319                    .as_ref()
320                    .and_then(|l| l.max_description_length))
321                .unwrap_or(DEFAULT_MAX_DESCRIPTION_LENGTH),
322            max_tags: parse_env(env, "MAX_TAGS")?
323                .or(server.limits.as_ref().and_then(|l| l.max_tags))
324                .unwrap_or(DEFAULT_MAX_TAGS),
325            max_tag_length: parse_env(env, "MAX_TAG_LENGTH")?
326                .or(server.limits.as_ref().and_then(|l| l.max_tag_length))
327                .unwrap_or(DEFAULT_MAX_TAG_LENGTH),
328            max_id_length: parse_env(env, "MAX_ID_LENGTH")?
329                .or(server.limits.as_ref().and_then(|l| l.max_id_length))
330                .unwrap_or(DEFAULT_MAX_ID_LENGTH),
331            max_device_id_length: parse_env(env, "MAX_DEVICE_ID_LENGTH")?
332                .or(server.limits.as_ref().and_then(|l| l.max_device_id_length))
333                .unwrap_or(DEFAULT_MAX_DEVICE_ID_LENGTH),
334            max_api_key_length: parse_env(env, "MAX_API_KEY_LENGTH")?
335                .or(server.limits.as_ref().and_then(|l| l.max_api_key_length))
336                .unwrap_or(DEFAULT_MAX_API_KEY_LENGTH),
337            request_timeout_secs: parse_env(env, "REQUEST_TIMEOUT_SECS")?
338                .or(server.limits.as_ref().and_then(|l| l.request_timeout_secs))
339                .unwrap_or(DEFAULT_REQUEST_TIMEOUT_SECS),
340            grpc_max_message_size: parse_env(env, "GRPC_MAX_MESSAGE_SIZE")?
341                .or(server.limits.as_ref().and_then(|l| l.grpc_max_message_size))
342                .unwrap_or(DEFAULT_GRPC_MAX_MESSAGE_SIZE),
343            rate_limit_per_minute: parse_env(env, "RATE_LIMIT_PER_MINUTE")?
344                .or(server
345                    .rate_limit
346                    .as_ref()
347                    .and_then(|r| r.requests_per_minute))
348                .unwrap_or(DEFAULT_RATE_LIMIT_PER_MINUTE),
349            trusted_proxies: env("TRUSTED_PROXIES")
350                .map(|v| {
351                    v.split(',')
352                        .map(|s| s.trim().to_string())
353                        .filter(|s| !s.is_empty() && s.parse::<std::net::IpAddr>().is_ok())
354                        .collect()
355                })
356                .or_else(|| server.rate_limit.as_ref()?.trusted_proxies.clone())
357                .unwrap_or_default(),
358            metrics_username: env("METRICS_USERNAME")
359                .or_else(|| server.metrics.as_ref().and_then(|m| m.username.clone())),
360            metrics_password: env("METRICS_PASSWORD")
361                .or_else(|| server.metrics.as_ref().and_then(|m| m.password.clone())),
362            cors_allowed_origins: env("CORS_ALLOWED_ORIGINS")
363                .or_else(|| server.cors.as_ref().and_then(|c| c.allowed_origins.clone()))
364                .map(|v| {
365                    v.split(',')
366                        .map(str::trim)
367                        .filter(|origin| !origin.is_empty())
368                        .map(ToOwned::to_owned)
369                        .collect()
370                })
371                .unwrap_or_default(),
372        };
373
374        config.validate()?;
375        Ok(config)
376    }
377
378    fn validate(&self) -> Result<(), ConfigLoadError> {
379        if self.grpc_port == 0 {
380            return Err(ConfigLoadError::InvalidRange {
381                name: "GRPC_PORT",
382                value: self.grpc_port.to_string(),
383                reason: "port must be nonzero".into(),
384            });
385        }
386        if self.http_port == 0 {
387            return Err(ConfigLoadError::InvalidRange {
388                name: "HTTP_PORT",
389                value: self.http_port.to_string(),
390                reason: "port must be nonzero".into(),
391            });
392        }
393        if self.db_max_connections == 0 {
394            return Err(ConfigLoadError::InvalidRange {
395                name: "DB_MAX_CONNECTIONS",
396                value: self.db_max_connections.to_string(),
397                reason: "must be at least 1".into(),
398            });
399        }
400        if self.request_timeout_secs == 0 {
401            return Err(ConfigLoadError::InvalidRange {
402                name: "REQUEST_TIMEOUT_SECS",
403                value: self.request_timeout_secs.to_string(),
404                reason: "must be at least 1".into(),
405            });
406        }
407        if self.grpc_max_message_size == 0 {
408            return Err(ConfigLoadError::InvalidRange {
409                name: "GRPC_MAX_MESSAGE_SIZE",
410                value: self.grpc_max_message_size.to_string(),
411                reason: "must be greater than 0".into(),
412            });
413        }
414        if self.max_command_length == 0 {
415            return Err(ConfigLoadError::InvalidRange {
416                name: "MAX_COMMAND_LENGTH",
417                value: self.max_command_length.to_string(),
418                reason: "must be nonzero".into(),
419            });
420        }
421        if self.max_description_length == 0 {
422            return Err(ConfigLoadError::InvalidRange {
423                name: "MAX_DESCRIPTION_LENGTH",
424                value: self.max_description_length.to_string(),
425                reason: "must be nonzero".into(),
426            });
427        }
428        if self.max_tags == 0 {
429            return Err(ConfigLoadError::InvalidRange {
430                name: "MAX_TAGS",
431                value: self.max_tags.to_string(),
432                reason: "must be nonzero".into(),
433            });
434        }
435        if self.max_tag_length == 0 {
436            return Err(ConfigLoadError::InvalidRange {
437                name: "MAX_TAG_LENGTH",
438                value: self.max_tag_length.to_string(),
439                reason: "must be nonzero".into(),
440            });
441        }
442        if self.max_id_length == 0 {
443            return Err(ConfigLoadError::InvalidRange {
444                name: "MAX_ID_LENGTH",
445                value: self.max_id_length.to_string(),
446                reason: "must be nonzero".into(),
447            });
448        }
449        if self.max_device_id_length == 0 {
450            return Err(ConfigLoadError::InvalidRange {
451                name: "MAX_DEVICE_ID_LENGTH",
452                value: self.max_device_id_length.to_string(),
453                reason: "must be nonzero".into(),
454            });
455        }
456        if self.max_api_key_length == 0 {
457            return Err(ConfigLoadError::InvalidRange {
458                name: "MAX_API_KEY_LENGTH",
459                value: self.max_api_key_length.to_string(),
460                reason: "must be nonzero".into(),
461            });
462        }
463        if self.rate_limit_per_minute == 0 {
464            return Err(ConfigLoadError::InvalidRange {
465                name: "RATE_LIMIT_PER_MINUTE",
466                value: self.rate_limit_per_minute.to_string(),
467                reason: "must be nonzero".into(),
468            });
469        }
470        Ok(())
471    }
472
473    pub fn ensure_config_file() {
474        if let Err(e) = bootstrap::ensure_config_file() {
475            tracing::warn!("{}", e);
476        }
477    }
478}
479
480#[derive(Clone)]
481pub struct AppState {
482    pub config: Config,
483    pub metrics: Metrics,
484    pub db: Arc<Database>,
485}
486
487pub struct SnipSyncService {
488    pub db: Arc<Database>,
489    pub rate_limiter: Arc<RateLimiter>,
490    pub config: Config,
491    pub metrics: Metrics,
492    pub premade_manager: PremadeManager,
493    /// Test-only: most recent `authorization` header value observed by
494    /// the gRPC handlers. Used by integration tests to assert that the
495    /// sync client actually sends a non-empty bearer token in metadata
496    /// (catching the auth-header regression where `request.api_key` was
497    /// read instead of the caller's API key).
498    #[cfg(any(test, feature = "test-helpers"))]
499    pub captured_auth_header: Arc<std::sync::Mutex<Option<String>>>,
500    /// Test-only: optional request observer for telemetry tests.
501    /// When set, `record_request` and `record_request_finished` emit
502    /// sanitized events to the observer.
503    #[cfg(any(test, feature = "test-helpers"))]
504    pub test_observer: Option<Arc<dyn crate::test_observer::TestRequestObserver>>,
505    /// Test-only: fail `PushSnippets` after this many successful calls.
506    /// Each successful push decrements the counter; when it reaches zero
507    /// the next push returns an internal error. Set to `None` to disable.
508    #[cfg(any(test, feature = "test-helpers"))]
509    pub push_fail_after: Arc<std::sync::atomic::AtomicU32>,
510    /// Test-only: internal counter for push failure injection.
511    /// Starts at 0 and increments on each PushSnippets call.
512    #[cfg(any(test, feature = "test-helpers"))]
513    pub push_fail_counter: Arc<std::sync::atomic::AtomicU32>,
514}
515
516impl SnipSyncService {
517    pub fn record_request(&self, method: &str) {
518        self.metrics
519            .requests_total
520            .with_label_values(&[method])
521            .inc();
522        tracing::trace!("Request: {}", method);
523        #[cfg(feature = "test-helpers")]
524        if let Some(ref obs) = self.test_observer {
525            use crate::test_observer::{RequestStarted, now_millis, operation_name_for_method};
526            let sequence = obs.allocate_sequence();
527            let concurrent = obs.current_concurrent();
528            obs.request_started(RequestStarted {
529                sequence,
530                started_at_unix_ms: now_millis(),
531                method: method.to_string(),
532                operation: operation_name_for_method(method).to_string(),
533                authenticated_user_id: None,
534                authenticated_device_id: None,
535                target_library_id: None,
536                request_revision: None,
537                payload_len: 0,
538                payload_sha256: String::new(),
539                payload_contains_plaintext_sentinel: false,
540                concurrent_at_start: concurrent,
541            });
542        }
543    }
544
545    #[cfg_attr(not(feature = "test-helpers"), allow(unused_variables))]
546    pub fn record_request_finished(&self, method: &str, success: bool) {
547        #[cfg(feature = "test-helpers")]
548        if let Some(ref obs) = self.test_observer {
549            use crate::test_observer::RequestFinished;
550            let sequence = obs.last_started_sequence_for_method(method);
551            obs.request_finished(RequestFinished {
552                sequence,
553                finished_at_unix_ms: crate::test_observer::now_millis(),
554                success,
555                response_revision: None,
556            });
557        }
558    }
559
560    /// Update the last started request's authenticated IDs.
561    ///
562    /// Called after authentication resolves the user and device IDs.
563    /// Only active with `test-helpers` feature.
564    #[cfg_attr(not(feature = "test-helpers"), allow(unused_variables))]
565    pub fn update_request_ids(
566        &self,
567        method: &str,
568        user_id: Option<String>,
569        device_id: Option<String>,
570        library_id: Option<String>,
571    ) {
572        #[cfg(feature = "test-helpers")]
573        if let Some(ref obs) = self.test_observer {
574            obs.update_ids_for_last_method(method, user_id, device_id, library_id);
575        }
576    }
577
578    pub fn record_request_duration(&self, method: &str, start: std::time::Instant) {
579        let duration = start.elapsed().as_secs_f64();
580        self.metrics
581            .request_duration_seconds
582            .with_label_values(&[method])
583            .observe(duration);
584        tracing::debug!("Request {} completed in {:.3}s", method, duration);
585    }
586
587    pub fn record_rate_limit(&self) {
588        self.metrics.rate_limit_hits.inc();
589    }
590
591    pub fn record_auth_failure(&self) {
592        self.metrics.auth_failures.inc();
593    }
594
595    pub fn record_sync(&self, direction: &str) {
596        self.metrics
597            .sync_operations_total
598            .with_label_values(&[direction])
599            .inc();
600    }
601
602    pub fn record_library_op(&self, operation: &str) {
603        self.metrics
604            .library_operations_total
605            .with_label_values(&[operation])
606            .inc();
607    }
608
609    fn request_api_key<T>(&self, request: &Request<T>, body_api_key: &str) -> String {
610        let api_key = extract_api_key(request, body_api_key);
611        #[cfg(any(test, feature = "test-helpers"))]
612        self.capture_test_auth_header(&api_key);
613        api_key
614    }
615
616    #[cfg(any(test, feature = "test-helpers"))]
617    fn capture_test_auth_header(&self, api_key: &str) {
618        if !api_key.is_empty() {
619            let mut slot = self
620                .captured_auth_header
621                .lock()
622                .unwrap_or_else(|e| e.into_inner());
623            if slot.is_none() {
624                *slot = Some(format!("Bearer {api_key}"));
625            }
626        }
627    }
628
629    pub async fn authenticate_and_rate_limit(&self, api_key: &str) -> Result<String, Status> {
630        self.authenticate_and_rate_limit_with_duration(api_key, None)
631            .await
632    }
633
634    /// Like `authenticate_and_rate_limit`, but records request duration on
635    /// failure so the histogram captures latency for error responses.
636    pub async fn authenticate_and_rate_limit_with_duration(
637        &self,
638        api_key: &str,
639        start: Option<std::time::Instant>,
640    ) -> Result<String, Status> {
641        if api_key.is_empty() {
642            if let Some(s) = start {
643                self.record_request_duration("auth", s);
644            }
645            return Err(Status::unauthenticated("API key is required"));
646        }
647        if api_key.len() > self.config.max_api_key_length {
648            if let Some(s) = start {
649                self.record_request_duration("auth", s);
650            }
651            return Err(Status::invalid_argument(format!(
652                "API key exceeds maximum length of {} bytes",
653                self.config.max_api_key_length
654            )));
655        }
656
657        if !self
658            .rate_limiter
659            .allow(
660                api_key,
661                self.config.rate_limit_per_minute as usize,
662                Duration::from_secs(60),
663            )
664            .await
665        {
666            self.record_rate_limit();
667            if let Some(s) = start {
668                self.record_request_duration("auth", s);
669            }
670            return Err(Status::resource_exhausted("Rate limit exceeded"));
671        }
672
673        let user_id = self
674            .db
675            .get_user_by_api_key(api_key)
676            .await
677            .map_err(|_| {
678                if let Some(s) = start {
679                    self.record_request_duration("auth", s);
680                }
681                Status::internal("Internal error")
682            })?
683            .ok_or_else(|| {
684                self.record_auth_failure();
685                if let Some(s) = start {
686                    self.record_request_duration("auth", s);
687                }
688                Status::unauthenticated("Invalid API key")
689            })?;
690
691        Ok(user_id)
692    }
693
694    pub fn validate_snippet(&self, snippet: &ProtoSnippet) -> Result<(), Status> {
695        if snippet.id.is_empty() {
696            return Err(Status::invalid_argument("Snippet ID is required"));
697        }
698        if snippet.id.len() > self.config.max_id_length {
699            return Err(Status::invalid_argument(format!(
700                "Snippet ID exceeds maximum length of {} bytes",
701                self.config.max_id_length
702            )));
703        }
704
705        if snippet.device_id.is_empty() {
706            return Err(Status::invalid_argument("Device ID is required"));
707        }
708        if snippet.device_id.len() > self.config.max_device_id_length {
709            return Err(Status::invalid_argument(format!(
710                "Device ID exceeds maximum length of {} bytes",
711                self.config.max_device_id_length
712            )));
713        }
714
715        if !snippet.encrypted && snippet.command.len() > self.config.max_command_length {
716            return Err(Status::invalid_argument(format!(
717                "Command exceeds maximum length of {} bytes",
718                self.config.max_command_length
719            )));
720        }
721
722        if !snippet.encrypted && snippet.command.trim().is_empty() {
723            return Err(Status::invalid_argument("Snippet command is required"));
724        }
725
726        if snippet.encrypted && (snippet.command.is_empty() || snippet.command.trim().is_empty()) {
727            return Err(Status::invalid_argument(
728                "Encrypted snippet payload is required",
729            ));
730        }
731
732        if snippet.description.len() > self.config.max_description_length {
733            return Err(Status::invalid_argument(format!(
734                "Description exceeds maximum length of {} bytes",
735                self.config.max_description_length
736            )));
737        }
738
739        if snippet.tags.len() > self.config.max_tags {
740            return Err(Status::invalid_argument(format!(
741                "Too many tags (max {})",
742                self.config.max_tags
743            )));
744        }
745
746        for tag in &snippet.tags {
747            if tag.len() > self.config.max_tag_length {
748                return Err(Status::invalid_argument(format!(
749                    "Tag '{}' exceeds maximum length of {} bytes",
750                    tag, self.config.max_tag_length
751                )));
752            }
753        }
754
755        // Sample server time once to avoid micro-boundary disagreement
756        // between consecutive timestamp checks.
757        let now = chrono::Utc::now().timestamp();
758        let tolerance = 300; // 5 minutes
759
760        if snippet.updated_at > now + tolerance {
761            let skew = snippet.updated_at - now;
762            return Err(Status::invalid_argument(format!(
763                "updated_at is {} seconds ahead of server time; \
764                 synchronize the client clock and retry",
765                skew
766            )));
767        }
768        if snippet.created_at > now + tolerance {
769            let skew = snippet.created_at - now;
770            return Err(Status::invalid_argument(format!(
771                "created_at is {} seconds ahead of server time; \
772                 synchronize the client clock and retry",
773                skew
774            )));
775        }
776        if snippet.created_at < 0 || snippet.updated_at < 0 {
777            return Err(Status::invalid_argument("Timestamps must be non-negative"));
778        }
779        if snippet.created_at > snippet.updated_at {
780            return Err(Status::invalid_argument(
781                "created_at must not be greater than updated_at",
782            ));
783        }
784
785        Ok(())
786    }
787}
788
789#[tonic::async_trait]
790impl SnippetSync for SnipSyncService {
791    async fn health(
792        &self,
793        _request: Request<HealthRequest>,
794    ) -> Result<Response<HealthResponse>, Status> {
795        let request_id = uuid::Uuid::new_v4();
796        let start = std::time::Instant::now();
797        self.record_request("health");
798        tracing::debug!(request_id = %request_id, "Health check");
799        let healthy = self.db.ping().await.is_ok();
800        self.record_request_duration("health", start);
801        self.record_request_finished("health", healthy);
802        Ok(Response::new(HealthResponse {
803            healthy,
804            version: env!("CARGO_PKG_VERSION").to_string(),
805        }))
806    }
807
808    async fn register(
809        &self,
810        request: Request<RegisterRequest>,
811    ) -> Result<Response<RegisterResponse>, Status> {
812        let request_id = uuid::Uuid::new_v4();
813        let start = std::time::Instant::now();
814        self.record_request("register");
815        tracing::info!(request_id = %request_id, "Register request");
816
817        // Use peer IP address for rate limiting (device_id is client-controlled)
818        // tonic populates request.extensions() with the peer SocketAddr
819        let peer_ip = request
820            .extensions()
821            .get::<SocketAddr>()
822            .map(|addr| addr.ip().to_string());
823
824        let rate_limit_key = if let Some(ref ip) = peer_ip
825            && self.config.trusted_proxies.contains(ip)
826        {
827            request
828                .metadata()
829                .get("x-forwarded-for")
830                .and_then(|v| v.to_str().ok())
831                .and_then(|header| header.split(',').next())
832                .map(|s| strip_port(s.trim()))
833                .unwrap_or_else(|| ip.clone())
834        } else {
835            peer_ip.unwrap_or_else(|| "unknown".to_string())
836        };
837
838        if !self
839            .rate_limiter
840            .allow(
841                &rate_limit_key,
842                self.config.rate_limit_per_minute as usize,
843                Duration::from_secs(60),
844            )
845            .await
846        {
847            self.record_rate_limit();
848            self.record_request_duration("register", start);
849            self.record_request_finished("register", false);
850            return Err(Status::resource_exhausted(
851                "Rate limit exceeded for registration",
852            ));
853        }
854
855        let _req = request.into_inner();
856
857        let api_key = uuid::Uuid::new_v4().to_string();
858
859        match self.db.create_user(&api_key).await {
860            Ok(device_id) => {
861                if uuid::Uuid::parse_str(&device_id).is_err() {
862                    tracing::error!(
863                        request_id = %request_id,
864                        "Generated device_id is not a valid UUID: {}",
865                        device_id
866                    );
867                    self.record_request_duration("register", start);
868                    self.record_request_finished("register", false);
869                    return Err(Status::internal(
870                        "Internal error: invalid device ID generated",
871                    ));
872                }
873                tracing::info!(
874                    request_id = %request_id,
875                    device_id = %device_id,
876                    "Created new user"
877                );
878                self.record_request_duration("register", start);
879                self.record_request_finished("register", true);
880                Ok(Response::new(RegisterResponse {
881                    success: true,
882                    api_key,
883                    message: "Account created successfully".to_string(),
884                    device_id,
885                }))
886            }
887            Err(e) => {
888                tracing::error!(request_id = %request_id, "Failed to create user: {}", e);
889                self.record_request_duration("register", start);
890                self.record_request_finished("register", false);
891                Err(Status::internal("Internal error"))
892            }
893        }
894    }
895
896    async fn get_snippets(
897        &self,
898        request: Request<GetSnippetsRequest>,
899    ) -> Result<Response<SnippetList>, Status> {
900        let request_id = uuid::Uuid::new_v4();
901        let start = std::time::Instant::now();
902        self.record_request("get_snippets");
903        tracing::info!(request_id = %request_id, "GetSnippets request");
904        let api_key = self.request_api_key(&request, &request.get_ref().api_key);
905        let req = request.into_inner();
906
907        let user_id = self
908            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
909            .await
910            .inspect_err(|_| {
911                self.record_request_finished("get_snippets", false);
912            })?;
913
914        let library_id = if req.library_id.is_empty() {
915            self.db.get_default_library(&user_id).await.map_err(|e| {
916                self.record_request_duration("get_snippets", start);
917                self.record_request_finished("get_snippets", false);
918                tracing::error!("Internal error: {}", e);
919                Status::internal("Internal error")
920            })?
921        } else {
922            if !self
923                .db
924                .verify_library_ownership(&user_id, &req.library_id)
925                .await
926                .map_err(|e| {
927                    self.record_request_duration("get_snippets", start);
928                    self.record_request_finished("get_snippets", false);
929                    tracing::error!("Internal error: {}", e);
930                    Status::internal("Internal error")
931                })?
932            {
933                tracing::warn!(
934                    "User {} attempted to access library {} without ownership",
935                    user_id,
936                    req.library_id
937                );
938                self.record_request_duration("get_snippets", start);
939                self.record_request_finished("get_snippets", false);
940                return Err(Status::not_found("Library not found"));
941            }
942            req.library_id
943        };
944
945        // Update observer with authenticated identity after resolution.
946        self.update_request_ids(
947            "get_snippets",
948            Some(user_id.clone()),
949            None,
950            Some(library_id.clone()),
951        );
952
953        let limit = if req.limit > 0 {
954            req.limit.clamp(1, MAX_REQUEST_LIMIT)
955        } else {
956            100
957        };
958        let offset = if req.offset > 0 { req.offset } else { 0 };
959
960        let (snippets, total) = self
961            .db
962            .get_snippets(&user_id, &library_id, req.since, limit, offset, false)
963            .await
964            .map_err(|e| {
965                self.record_request_duration("get_snippets", start);
966                self.record_request_finished("get_snippets", false);
967                tracing::error!("Internal error: {}", e);
968                Status::internal("Internal error")
969            })?;
970
971        let has_more = offset.saturating_add(snippets.len() as i32) < total;
972
973        let proto_snippets: Vec<ProtoSnippet> = snippets
974            .into_iter()
975            .map(|s| ProtoSnippet {
976                id: s.id,
977                description: s.description,
978                command: s.command,
979                tags: s.tags,
980                created_at: s.created_at,
981                updated_at: s.updated_at,
982                device_id: s.device_id,
983                deleted: s.deleted,
984                encrypted: s.encrypted,
985            })
986            .collect();
987
988        self.record_request_duration("get_snippets", start);
989
990        let result = Ok(Response::new(SnippetList {
991            snippets: proto_snippets,
992            total_count: total,
993            has_more,
994        }));
995        self.record_request_finished("get_snippets", result.is_ok());
996        result
997    }
998
999    async fn push_snippets(
1000        &self,
1001        request: Request<PushSnippetsRequest>,
1002    ) -> Result<Response<PushSnippetsResponse>, Status> {
1003        let request_id = uuid::Uuid::new_v4();
1004        let start = std::time::Instant::now();
1005        self.record_request("push_snippets");
1006        tracing::info!(request_id = %request_id, "PushSnippets request");
1007        let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1008        let req = request.into_inner();
1009
1010        let user_id = self
1011            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1012            .await
1013            .inspect_err(|_| {
1014                self.record_request_finished("push_snippets", false);
1015            })?;
1016
1017        let library_id = if req.library_id.is_empty() {
1018            self.db.get_default_library(&user_id).await.map_err(|e| {
1019                self.record_request_duration("push_snippets", start);
1020                self.record_request_finished("push_snippets", false);
1021                tracing::error!("Internal error: {}", e);
1022                Status::internal("Internal error")
1023            })?
1024        } else {
1025            if !self
1026                .db
1027                .verify_library_ownership(&user_id, &req.library_id)
1028                .await
1029                .map_err(|e| {
1030                    self.record_request_duration("push_snippets", start);
1031                    self.record_request_finished("push_snippets", false);
1032                    tracing::error!("Internal error: {}", e);
1033                    Status::internal("Internal error")
1034                })?
1035            {
1036                tracing::warn!(
1037                    "User {} attempted to push to library {} without ownership",
1038                    user_id,
1039                    req.library_id
1040                );
1041                self.record_request_duration("push_snippets", start);
1042                self.record_request_finished("push_snippets", false);
1043                return Err(Status::not_found("Library not found"));
1044            }
1045            req.library_id
1046        };
1047
1048        // Update observer with authenticated identity after resolution.
1049        self.update_request_ids(
1050            "push_snippets",
1051            Some(user_id.clone()),
1052            req.snippets.first().map(|s| s.device_id.clone()),
1053            Some(library_id.clone()),
1054        );
1055
1056        if req.snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
1057            self.record_request_duration("push_snippets", start);
1058            self.record_request_finished("push_snippets", false);
1059            return Err(Status::invalid_argument(format!(
1060                "Too many snippets in push request (max {}), got {}",
1061                DEFAULT_MAX_SYNC_SNIPPETS,
1062                req.snippets.len()
1063            )));
1064        }
1065
1066        // Test-only failure injection: fail on the Nth PushSnippets call.
1067        // push_fail_after stores the 1-indexed failure point. A value of
1068        // u32::MAX means "disabled" (never fail). The internal counter
1069        // starts at 0 and increments on each push; when it reaches the
1070        // threshold the push is rejected.
1071        #[cfg(feature = "test-helpers")]
1072        {
1073            let threshold = self
1074                .push_fail_after
1075                .load(std::sync::atomic::Ordering::SeqCst);
1076            if threshold != u32::MAX {
1077                let count = self
1078                    .push_fail_counter
1079                    .fetch_add(1, std::sync::atomic::Ordering::SeqCst)
1080                    + 1;
1081                if count >= threshold {
1082                    self.record_request_duration("push_snippets", start);
1083                    self.record_request_finished("push_snippets", false);
1084                    return Err(Status::internal("test-injected push failure"));
1085                }
1086            }
1087        }
1088
1089        let mut accepted = 0;
1090        let mut rejected = 0;
1091
1092        let mut tx = self.db.pool().begin().await.map_err(|e| {
1093            self.record_request_duration("push_snippets", start);
1094            self.record_request_finished("push_snippets", false);
1095            tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
1096            Status::internal("Internal error")
1097        })?;
1098
1099        for snippet in req.snippets {
1100            if let Err(e) = self.validate_snippet(&snippet) {
1101                rejected += 1;
1102                tracing::warn!(request_id = %request_id, snippet_id = %snippet.id, reason = %e, "Snippet validation failed");
1103                continue;
1104            }
1105
1106            let db_snippet = db::Snippet {
1107                id: snippet.id.clone(),
1108                description: snippet.description,
1109                command: snippet.command,
1110                tags: snippet.tags,
1111                created_at: snippet.created_at,
1112                updated_at: snippet.updated_at,
1113                device_id: snippet.device_id,
1114                deleted: snippet.deleted,
1115                encrypted: snippet.encrypted,
1116            };
1117
1118            match self
1119                .db
1120                .upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
1121                .await
1122            {
1123                Ok(_) => accepted += 1,
1124                Err(e) => {
1125                    tracing::warn!(
1126                        request_id = %request_id,
1127                        snippet_id = %snippet.id,
1128                        reason = %e,
1129                        "Snippet upsert failed"
1130                    );
1131                    rejected += 1;
1132                }
1133            }
1134        }
1135
1136        tx.commit().await.map_err(|e| {
1137            self.record_request_duration("push_snippets", start);
1138            self.record_request_finished("push_snippets", false);
1139            tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
1140            Status::internal("Internal error")
1141        })?;
1142
1143        self.record_request_duration("push_snippets", start);
1144
1145        let result = Ok(Response::new(PushSnippetsResponse {
1146            success: rejected == 0,
1147            message: format!("Accepted {}, rejected {}", accepted, rejected),
1148            accepted_count: accepted,
1149            rejected_count: rejected,
1150        }));
1151        self.record_request_finished("push_snippets", result.is_ok());
1152        result
1153    }
1154
1155    async fn sync(&self, request: Request<SyncRequest>) -> Result<Response<SyncResponse>, Status> {
1156        let request_id = uuid::Uuid::new_v4();
1157        let start = std::time::Instant::now();
1158        self.record_request("sync");
1159        tracing::info!(request_id = %request_id, "Sync request");
1160        let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1161        let req = request.into_inner();
1162
1163        let user_id = self
1164            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1165            .await
1166            .inspect_err(|_| {
1167                self.record_request_finished("sync", false);
1168            })?;
1169
1170        if req.local_snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
1171            self.record_request_duration("sync", start);
1172            self.record_request_finished("sync", false);
1173            return Err(Status::invalid_argument(format!(
1174                "Too many snippets in sync request (max {}), got {}",
1175                DEFAULT_MAX_SYNC_SNIPPETS,
1176                req.local_snippets.len()
1177            )));
1178        }
1179
1180        self.record_sync("bidirectional");
1181
1182        let library_id = if req.library_id.is_empty() {
1183            self.db.get_default_library(&user_id).await.map_err(|e| {
1184                self.record_request_duration("sync", start);
1185                self.record_request_finished("sync", false);
1186                tracing::error!("Internal error: {}", e);
1187                Status::internal("Internal error")
1188            })?
1189        } else {
1190            if !self
1191                .db
1192                .verify_library_ownership(&user_id, &req.library_id)
1193                .await
1194                .map_err(|e| {
1195                    self.record_request_duration("sync", start);
1196                    self.record_request_finished("sync", false);
1197                    tracing::error!("Internal error: {}", e);
1198                    Status::internal("Internal error")
1199                })?
1200            {
1201                tracing::warn!(
1202                    "User {} attempted to sync with library {} without ownership",
1203                    user_id,
1204                    req.library_id
1205                );
1206                self.record_request_duration("sync", start);
1207                self.record_request_finished("sync", false);
1208                return Err(Status::not_found("Library not found"));
1209            }
1210            req.library_id
1211        };
1212
1213        // Update observer with authenticated identity after resolution.
1214        self.update_request_ids(
1215            "sync",
1216            Some(user_id.clone()),
1217            req.local_snippets.first().map(|s| s.device_id.clone()),
1218            Some(library_id.clone()),
1219        );
1220
1221        let mut skipped_ids = Vec::new();
1222
1223        let mut tx = self.db.pool().begin().await.map_err(|e| {
1224            self.record_request_duration("sync", start);
1225            self.record_request_finished("sync", false);
1226            tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
1227            Status::internal("Internal error")
1228        })?;
1229
1230        for snippet in &req.local_snippets {
1231            if let Err(e) = self.validate_snippet(snippet) {
1232                tracing::warn!(
1233                    request_id = %request_id,
1234                    snippet_id = %snippet.id,
1235                    reason = %e,
1236                    "Snippet skipped: validation failed"
1237                );
1238                skipped_ids.push(snippet.id.clone());
1239                continue;
1240            }
1241
1242            if snippet.updated_at <= req.last_sync_timestamp {
1243                continue;
1244            }
1245
1246            let db_snippet = db::Snippet {
1247                id: snippet.id.clone(),
1248                description: snippet.description.clone(),
1249                command: snippet.command.clone(),
1250                tags: snippet.tags.clone(),
1251                created_at: snippet.created_at,
1252                updated_at: snippet.updated_at,
1253                device_id: snippet.device_id.clone(),
1254                deleted: snippet.deleted,
1255                encrypted: snippet.encrypted,
1256            };
1257
1258            if let Err(e) = self
1259                .db
1260                .upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
1261                .await
1262            {
1263                tracing::warn!(
1264                    request_id = %request_id,
1265                    snippet_id = %snippet.id,
1266                    reason = %e,
1267                    "Snippet skipped: upsert failed"
1268                );
1269                skipped_ids.push(snippet.id.clone());
1270            }
1271        }
1272
1273        tx.commit().await.map_err(|e| {
1274            self.record_request_duration("sync", start);
1275            self.record_request_finished("sync", false);
1276            tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
1277            Status::internal("Internal error")
1278        })?;
1279
1280        let limit = if req.limit > 0 {
1281            req.limit.clamp(1, MAX_REQUEST_LIMIT)
1282        } else {
1283            1000
1284        };
1285
1286        let offset = if req.offset > 0 { req.offset } else { 0 };
1287
1288        let (snippets, total) = self
1289            .db
1290            .get_snippets(
1291                &user_id,
1292                &library_id,
1293                req.last_sync_timestamp,
1294                limit,
1295                offset,
1296                true,
1297            )
1298            .await
1299            .map_err(|e| {
1300                self.record_request_duration("sync", start);
1301                self.record_request_finished("sync", false);
1302                tracing::error!("Internal error: {}", e);
1303                Status::internal("Internal error")
1304            })?;
1305
1306        let has_more = offset.saturating_add(snippets.len() as i32) < total;
1307
1308        let timestamp = if has_more {
1309            // Don't advance timestamp when paginating — client needs to fetch remaining pages
1310            req.last_sync_timestamp
1311        } else {
1312            self.db
1313                .get_latest_timestamp(&user_id, &library_id)
1314                .await
1315                .map_err(|e| {
1316                    self.record_request_duration("sync", start);
1317                    self.record_request_finished("sync", false);
1318                    tracing::error!("Internal error: {}", e);
1319                    Status::internal("Internal error")
1320                })?
1321        };
1322
1323        let proto_snippets: Vec<ProtoSnippet> = snippets
1324            .into_iter()
1325            .map(|s| ProtoSnippet {
1326                id: s.id,
1327                description: s.description,
1328                command: s.command,
1329                tags: s.tags,
1330                created_at: s.created_at,
1331                updated_at: s.updated_at,
1332                device_id: s.device_id,
1333                deleted: s.deleted,
1334                encrypted: s.encrypted,
1335            })
1336            .collect();
1337
1338        let skipped_count = skipped_ids.len() as i32;
1339
1340        tracing::info!(
1341            request_id = %request_id,
1342            snippets_synced = proto_snippets.len(),
1343            skipped_count = skipped_count,
1344            has_more = has_more,
1345            "Sync completed"
1346        );
1347
1348        self.record_request_duration("sync", start);
1349
1350        let result = Ok(Response::new(SyncResponse {
1351            success: true,
1352            message: if skipped_count > 0 {
1353                format!("Sync completed, {} snippets skipped", skipped_count)
1354            } else {
1355                "Sync completed".to_string()
1356            },
1357            snippets: proto_snippets,
1358            server_timestamp: timestamp,
1359            skipped_count,
1360            skipped_ids,
1361            has_more,
1362            total_count: total,
1363        }));
1364        self.record_request_finished("sync", result.is_ok());
1365        result
1366    }
1367
1368    async fn create_library(
1369        &self,
1370        request: Request<CreateLibraryRequest>,
1371    ) -> Result<Response<CreateLibraryResponse>, Status> {
1372        let request_id = uuid::Uuid::new_v4();
1373        let start = std::time::Instant::now();
1374        self.record_request("create_library");
1375        self.record_library_op("create");
1376        tracing::info!(request_id = %request_id, "CreateLibrary request");
1377        let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1378        let req = request.into_inner();
1379
1380        let user_id = self
1381            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1382            .await
1383            .inspect_err(|_| {
1384                self.record_request_finished("create_library", false);
1385            })?;
1386
1387        let result = match self.db.create_library(&user_id, &req.name).await {
1388            Ok(lib_id) => {
1389                tracing::info!("Created library '{}' for user {}", req.name, user_id);
1390                self.record_request_duration("create_library", start);
1391                Ok(Response::new(CreateLibraryResponse {
1392                    success: true,
1393                    library_id: lib_id,
1394                    message: format!("Library '{}' created successfully", req.name),
1395                }))
1396            }
1397            Err(db::DbError::Conflict(msg)) => {
1398                self.record_request_duration("create_library", start);
1399                Err(Status::already_exists(msg))
1400            }
1401            Err(db::DbError::Validation(msg)) => {
1402                self.record_request_duration("create_library", start);
1403                Err(Status::invalid_argument(msg))
1404            }
1405            Err(db::DbError::NotFound(msg)) => {
1406                self.record_request_duration("create_library", start);
1407                Err(Status::invalid_argument(msg))
1408            }
1409            Err(db::DbError::Internal(msg)) => {
1410                tracing::error!("Internal error creating library: {}", msg);
1411                self.record_request_duration("create_library", start);
1412                Err(Status::internal("Internal error"))
1413            }
1414            Err(db::DbError::Database(e)) => {
1415                tracing::error!("Database error creating library: {}", e);
1416                self.record_request_duration("create_library", start);
1417                Err(Status::internal("Internal error"))
1418            }
1419        };
1420        self.record_request_finished("create_library", result.is_ok());
1421        result
1422    }
1423
1424    async fn list_libraries(
1425        &self,
1426        request: Request<ListLibrariesRequest>,
1427    ) -> Result<Response<ListLibrariesResponse>, Status> {
1428        let request_id = uuid::Uuid::new_v4();
1429        let start = std::time::Instant::now();
1430        self.record_request("list_libraries");
1431        self.record_library_op("list");
1432        tracing::info!(request_id = %request_id, "ListLibraries request");
1433        let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1434        let req = request.into_inner();
1435
1436        let user_id = self
1437            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1438            .await
1439            .inspect_err(|_| {
1440                self.record_request_finished("list_libraries", false);
1441            })?;
1442
1443        let limit = if req.limit > 0 {
1444            req.limit.clamp(1, MAX_REQUEST_LIMIT)
1445        } else {
1446            50
1447        };
1448        let offset = if req.offset > 0 { req.offset } else { 0 };
1449
1450        let (libraries, total) = self
1451            .db
1452            .list_libraries(&user_id, limit, offset)
1453            .await
1454            .map_err(|e| {
1455                self.record_request_duration("list_libraries", start);
1456                self.record_request_finished("list_libraries", false);
1457                tracing::error!("Internal error: {}", e);
1458                Status::internal("Internal error")
1459            })?;
1460
1461        let has_more = offset.saturating_add(libraries.len() as i32) < total;
1462
1463        let proto_libraries: Vec<Library> = libraries
1464            .into_iter()
1465            .map(|l| Library {
1466                id: l.id,
1467                name: l.name,
1468                created_at: l.created_at,
1469                snippet_count: l.snippet_count,
1470            })
1471            .collect();
1472
1473        self.record_request_duration("list_libraries", start);
1474
1475        let result = Ok(Response::new(ListLibrariesResponse {
1476            libraries: proto_libraries,
1477            total_count: total,
1478            has_more,
1479        }));
1480        self.record_request_finished("list_libraries", result.is_ok());
1481        result
1482    }
1483
1484    async fn delete_library(
1485        &self,
1486        request: Request<DeleteLibraryRequest>,
1487    ) -> Result<Response<DeleteLibraryResponse>, Status> {
1488        let request_id = uuid::Uuid::new_v4();
1489        let start = std::time::Instant::now();
1490        self.record_request("delete_library");
1491        self.record_library_op("delete");
1492        tracing::info!(request_id = %request_id, "DeleteLibrary request");
1493        let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1494        let req = request.into_inner();
1495
1496        let user_id = self
1497            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1498            .await
1499            .inspect_err(|_| {
1500                self.record_request_finished("delete_library", false);
1501            })?;
1502
1503        // Prevent deleting default library — resolve the actual UUID, not
1504        // the literal string "default" which is just the library name.
1505        if req.library_id.is_empty() || req.library_id == "default" {
1506            self.record_request_duration("delete_library", start);
1507            self.record_request_finished("delete_library", false);
1508            return Err(Status::invalid_argument("Cannot delete default library"));
1509        }
1510        if let Ok(default_id) = self.db.get_default_library(&user_id).await
1511            && req.library_id == default_id
1512        {
1513            self.record_request_duration("delete_library", start);
1514            self.record_request_finished("delete_library", false);
1515            return Err(Status::invalid_argument("Cannot delete default library"));
1516        }
1517
1518        let result = match self.db.delete_library(&user_id, &req.library_id).await {
1519            Ok(_) => {
1520                tracing::info!("Deleted library {} for user {}", req.library_id, user_id);
1521                Ok(Response::new(DeleteLibraryResponse {
1522                    success: true,
1523                    message: "Library deleted successfully".to_string(),
1524                }))
1525            }
1526            Err(db::DbError::NotFound(msg)) => Err(Status::not_found(msg)),
1527            Err(db::DbError::Conflict(msg)) => Err(Status::failed_precondition(msg)),
1528            Err(db::DbError::Validation(msg)) => Err(Status::invalid_argument(msg)),
1529            Err(db::DbError::Internal(msg)) => {
1530                tracing::error!("Internal error deleting library: {}", msg);
1531                Err(Status::internal("Internal error"))
1532            }
1533            Err(db::DbError::Database(e)) => {
1534                tracing::error!("Failed to delete library: {}", e);
1535                Err(Status::internal("Internal error"))
1536            }
1537        };
1538        self.record_request_duration("delete_library", start);
1539        self.record_request_finished("delete_library", result.is_ok());
1540        result
1541    }
1542
1543    async fn list_premade_libraries(
1544        &self,
1545        request: Request<ListPremadeLibrariesRequest>,
1546    ) -> Result<Response<ListPremadeLibrariesResponse>, Status> {
1547        let request_id = uuid::Uuid::new_v4();
1548        let start = std::time::Instant::now();
1549        self.record_request("list_premade_libraries");
1550        tracing::info!(request_id = %request_id, "ListPremadeLibraries request");
1551        let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1552        let _req = request.into_inner();
1553
1554        let user_id = self
1555            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1556            .await
1557            .inspect_err(|_| {
1558                self.record_request_finished("list_premade_libraries", false);
1559            })?;
1560
1561        let libraries = self.premade_manager.list();
1562
1563        let proto_libraries: Vec<ProtoPremadeLibrary> = libraries
1564            .into_iter()
1565            .map(|l| ProtoPremadeLibrary {
1566                name: l.name,
1567                filename: l.filename,
1568                description: l.description,
1569                snippet_count: l.snippet_count,
1570                tags: l.tags,
1571            })
1572            .collect();
1573
1574        tracing::info!(
1575            request_id = %request_id,
1576            user_id = %user_id,
1577            count = proto_libraries.len(),
1578            "ListPremadeLibraries completed"
1579        );
1580
1581        let count = proto_libraries.len() as i32;
1582
1583        self.record_request_duration("list_premade_libraries", start);
1584
1585        let result = Ok(Response::new(ListPremadeLibrariesResponse {
1586            libraries: proto_libraries,
1587            has_more: false,
1588            total_count: count,
1589        }));
1590        self.record_request_finished("list_premade_libraries", result.is_ok());
1591        result
1592    }
1593
1594    async fn get_premade_library(
1595        &self,
1596        request: Request<GetPremadeLibraryRequest>,
1597    ) -> Result<Response<GetPremadeLibraryResponse>, Status> {
1598        let request_id = uuid::Uuid::new_v4();
1599        let start = std::time::Instant::now();
1600        self.record_request("get_premade_library");
1601        tracing::info!(request_id = %request_id, "GetPremadeLibrary request");
1602        let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1603        let req = request.into_inner();
1604
1605        let user_id = self
1606            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1607            .await
1608            .inspect_err(|_| {
1609                self.record_request_finished("get_premade_library", false);
1610            })?;
1611
1612        if req.filename.is_empty() {
1613            self.record_request_duration("get_premade_library", start);
1614            self.record_request_finished("get_premade_library", false);
1615            return Err(Status::invalid_argument("Filename is required"));
1616        }
1617
1618        if req.filename.contains("..") || req.filename.contains('/') || req.filename.contains('\\')
1619        {
1620            self.record_request_duration("get_premade_library", start);
1621            self.record_request_finished("get_premade_library", false);
1622            return Err(Status::invalid_argument("Invalid filename"));
1623        }
1624
1625        let sanitized: String = req
1626            .filename
1627            .chars()
1628            .filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_' || *c == '.')
1629            .collect();
1630
1631        if sanitized.is_empty() || sanitized.len() > 64 {
1632            self.record_request_duration("get_premade_library", start);
1633            self.record_request_finished("get_premade_library", false);
1634            return Err(Status::invalid_argument("Invalid filename"));
1635        }
1636        if sanitized != req.filename {
1637            self.record_request_duration("get_premade_library", start);
1638            self.record_request_finished("get_premade_library", false);
1639            return Err(Status::invalid_argument("Invalid filename"));
1640        }
1641
1642        let content = match self.premade_manager.get(&sanitized) {
1643            Ok(c) => c,
1644            Err(e) => {
1645                self.record_request_duration("get_premade_library", start);
1646                self.record_request_finished("get_premade_library", false);
1647                return Err(e);
1648            }
1649        };
1650
1651        tracing::info!("User {} fetched premade library '{}'", user_id, sanitized);
1652
1653        self.record_request_duration("get_premade_library", start);
1654
1655        let result = Ok(Response::new(GetPremadeLibraryResponse {
1656            success: true,
1657            name: sanitized.clone(),
1658            content,
1659            message: "Library fetched successfully".to_string(),
1660        }));
1661        self.record_request_finished("get_premade_library", result.is_ok());
1662        result
1663    }
1664
1665    async fn search_premade_libraries(
1666        &self,
1667        request: Request<SearchPremadeLibrariesRequest>,
1668    ) -> Result<Response<SearchPremadeLibrariesResponse>, Status> {
1669        let request_id = uuid::Uuid::new_v4();
1670        let start = std::time::Instant::now();
1671        self.record_request("search_premade_libraries");
1672        tracing::info!(request_id = %request_id, "SearchPremadeLibraries request");
1673        let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1674        let req = request.into_inner();
1675
1676        let _user_id = self
1677            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1678            .await
1679            .inspect_err(|_| {
1680                self.record_request_finished("search_premade_libraries", false);
1681            })?;
1682
1683        if req.query.is_empty() {
1684            self.record_request_duration("search_premade_libraries", start);
1685            self.record_request_finished("search_premade_libraries", false);
1686            return Err(Status::invalid_argument("Query is required"));
1687        }
1688
1689        let results = self.premade_manager.search(&req.query);
1690
1691        let proto_libraries: Vec<ProtoPremadeLibrary> = results
1692            .into_iter()
1693            .map(|l| ProtoPremadeLibrary {
1694                name: l.name,
1695                filename: l.filename,
1696                description: l.description,
1697                snippet_count: l.snippet_count,
1698                tags: l.tags,
1699            })
1700            .collect();
1701
1702        let count = proto_libraries.len() as i32;
1703
1704        tracing::info!(
1705            request_id = %request_id,
1706            query = %req.query,
1707            count = count,
1708            "SearchPremadeLibraries completed"
1709        );
1710
1711        self.record_request_duration("search_premade_libraries", start);
1712
1713        let result = Ok(Response::new(SearchPremadeLibrariesResponse {
1714            libraries: proto_libraries,
1715            total_count: count,
1716        }));
1717        self.record_request_finished("search_premade_libraries", result.is_ok());
1718        result
1719    }
1720}
1721
1722#[cfg(test)]
1723mod tests {
1724    use super::*;
1725    use snip_proto::{
1726        CreateLibraryRequest, GetPremadeLibraryRequest, GetSnippetsRequest, HealthRequest,
1727        ListLibrariesRequest, PushSnippetsRequest, RegisterRequest, Snippet as ProtoSnippet,
1728        SyncRequest,
1729    };
1730
1731    pub async fn setup_test_service() -> SnipSyncService {
1732        setup_test_service_with_rate_limit(DEFAULT_RATE_LIMIT_PER_MINUTE).await
1733    }
1734
1735    async fn setup_test_service_with_rate_limit(rate_limit_per_minute: u32) -> SnipSyncService {
1736        let db = Arc::new(Database::connect("sqlite::memory:", 5).await.unwrap());
1737        let config = Config {
1738            grpc_host: "127.0.0.1".to_string(),
1739            grpc_port: 50051,
1740            http_host: "127.0.0.1".to_string(),
1741            http_port: 50050,
1742            db_path: "sqlite::memory:".to_string(),
1743            db_max_connections: 5,
1744            premade_dir: PathBuf::from("premade-libraries"),
1745            max_command_length: 1024,
1746            max_description_length: 1024,
1747            max_tags: 50,
1748            max_tag_length: 100,
1749            max_id_length: 128,
1750            max_device_id_length: 128,
1751            max_api_key_length: 512,
1752            request_timeout_secs: 30,
1753            grpc_max_message_size: 4 * 1024 * 1024,
1754            rate_limit_per_minute,
1755            trusted_proxies: vec![],
1756            metrics_username: None,
1757            metrics_password: None,
1758            cors_allowed_origins: vec![],
1759        };
1760        let metrics = Metrics::fallback();
1761        let rate_limiter = Arc::new(RateLimiter::new());
1762        let premade_manager = PremadeManager::new(PathBuf::from("premade-libraries"));
1763
1764        SnipSyncService {
1765            db,
1766            rate_limiter,
1767            config,
1768            metrics,
1769            premade_manager,
1770            #[cfg(any(test, feature = "test-helpers"))]
1771            captured_auth_header: Arc::new(std::sync::Mutex::new(None)),
1772            test_observer: None,
1773            push_fail_after: Arc::new(std::sync::atomic::AtomicU32::new(u32::MAX)),
1774            push_fail_counter: Arc::new(std::sync::atomic::AtomicU32::new(0)),
1775        }
1776    }
1777
1778    pub async fn register_test_user(service: &SnipSyncService) -> String {
1779        let req = Request::new(RegisterRequest {
1780            device_id: "test-device".to_string(),
1781        });
1782        let resp = service.register(req).await.unwrap();
1783        resp.into_inner().api_key
1784    }
1785
1786    #[tokio::test]
1787    async fn test_health_check() {
1788        let service = setup_test_service().await;
1789        let req = Request::new(HealthRequest {});
1790        let resp = service.health(req).await.unwrap();
1791        let health = resp.into_inner();
1792        assert!(health.healthy);
1793        assert_eq!(health.version, env!("CARGO_PKG_VERSION"));
1794    }
1795
1796    #[tokio::test]
1797    async fn test_register_creates_user() {
1798        let service = setup_test_service().await;
1799        let req = Request::new(RegisterRequest {
1800            device_id: "test-device".to_string(),
1801        });
1802        let resp = service.register(req).await.unwrap();
1803        let reg = resp.into_inner();
1804        assert!(reg.success);
1805        assert!(!reg.api_key.is_empty());
1806        assert!(!reg.device_id.is_empty());
1807        assert!(uuid::Uuid::parse_str(&reg.device_id).is_ok());
1808    }
1809
1810    #[tokio::test]
1811    async fn test_register_rate_limiting() {
1812        let service = setup_test_service_with_rate_limit(3).await;
1813        for _ in 0..3 {
1814            let req = Request::new(RegisterRequest {
1815                device_id: "test-device".to_string(),
1816            });
1817            let _ = service.register(req).await;
1818        }
1819        let req = Request::new(RegisterRequest {
1820            device_id: "test-device".to_string(),
1821        });
1822        let resp = service.register(req).await;
1823        assert!(resp.is_err());
1824        assert_eq!(resp.unwrap_err().code(), tonic::Code::ResourceExhausted);
1825    }
1826
1827    #[tokio::test]
1828    async fn test_create_and_list_libraries() {
1829        let service = setup_test_service().await;
1830        let api_key = register_test_user(&service).await;
1831
1832        let req = Request::new(CreateLibraryRequest {
1833            api_key: api_key.clone(),
1834            name: "test-lib".to_string(),
1835        });
1836        let resp = service.create_library(req).await.unwrap();
1837        let create = resp.into_inner();
1838        assert!(create.success);
1839        assert!(!create.library_id.is_empty());
1840
1841        let req = Request::new(ListLibrariesRequest {
1842            api_key: api_key.clone(),
1843            limit: 100,
1844            offset: 0,
1845        });
1846        let resp = service.list_libraries(req).await.unwrap();
1847        let list = resp.into_inner();
1848        assert_eq!(list.libraries.len(), 2);
1849        assert!(list.libraries.iter().any(|l| l.name == "test-lib"));
1850    }
1851
1852    #[tokio::test]
1853    async fn test_create_duplicate_library_name() {
1854        let service = setup_test_service().await;
1855        let api_key = register_test_user(&service).await;
1856
1857        let req = Request::new(CreateLibraryRequest {
1858            api_key: api_key.clone(),
1859            name: "test-lib".to_string(),
1860        });
1861        let _ = service.create_library(req).await.unwrap();
1862
1863        let req = Request::new(CreateLibraryRequest {
1864            api_key: api_key.clone(),
1865            name: "test-lib".to_string(),
1866        });
1867        let resp = service.create_library(req).await;
1868        assert!(resp.is_err());
1869        assert_eq!(resp.unwrap_err().code(), tonic::Code::AlreadyExists);
1870    }
1871
1872    #[tokio::test]
1873    async fn test_invalid_api_key() {
1874        let service = setup_test_service().await;
1875        let req = Request::new(GetSnippetsRequest {
1876            api_key: "invalid-key".to_string(),
1877            library_id: String::new(),
1878            limit: 100,
1879            offset: 0,
1880            since: 0,
1881        });
1882        let resp = service.get_snippets(req).await;
1883        assert!(resp.is_err());
1884        assert_eq!(resp.unwrap_err().code(), tonic::Code::Unauthenticated);
1885    }
1886
1887    #[tokio::test]
1888    async fn test_validate_snippet_empty_id() {
1889        let service = setup_test_service().await;
1890        let snippet = ProtoSnippet {
1891            id: String::new(),
1892            description: "test".to_string(),
1893            command: "echo hello".to_string(),
1894            tags: vec![],
1895            created_at: 0,
1896            updated_at: 0,
1897            device_id: "device".to_string(),
1898            deleted: false,
1899            encrypted: false,
1900        };
1901        let result = service.validate_snippet(&snippet);
1902        assert!(result.is_err());
1903        assert!(result.unwrap_err().message().contains("ID is required"));
1904    }
1905
1906    #[tokio::test]
1907    async fn test_validate_snippet_oversized_command() {
1908        let service = setup_test_service().await;
1909        let snippet = ProtoSnippet {
1910            id: "test-id".to_string(),
1911            description: "test".to_string(),
1912            command: "x".repeat(2000),
1913            tags: vec![],
1914            created_at: 0,
1915            updated_at: 0,
1916            device_id: "device".to_string(),
1917            deleted: false,
1918            encrypted: false,
1919        };
1920        let result = service.validate_snippet(&snippet);
1921        assert!(result.is_err());
1922        assert!(result.unwrap_err().message().contains("maximum length"));
1923    }
1924
1925    #[tokio::test]
1926    async fn test_validate_snippet_future_timestamp() {
1927        let service = setup_test_service().await;
1928        let future = chrono::Utc::now().timestamp() + 600;
1929        let snippet = ProtoSnippet {
1930            id: "test-id".to_string(),
1931            description: "test".to_string(),
1932            command: "echo hello".to_string(),
1933            tags: vec![],
1934            created_at: future,
1935            updated_at: future,
1936            device_id: "device".to_string(),
1937            deleted: false,
1938            encrypted: false,
1939        };
1940        let result = service.validate_snippet(&snippet);
1941        assert!(result.is_err());
1942        let msg = result.unwrap_err().message().to_string();
1943        assert!(
1944            msg.contains("ahead of server time"),
1945            "Expected clock skew message, got: {msg}"
1946        );
1947    }
1948
1949    #[tokio::test]
1950    async fn test_validate_snippet_negative_timestamp() {
1951        let service = setup_test_service().await;
1952        let snippet = ProtoSnippet {
1953            id: "test-id".to_string(),
1954            description: "test".to_string(),
1955            command: "echo hello".to_string(),
1956            tags: vec![],
1957            created_at: -1,
1958            updated_at: -1,
1959            device_id: "device".to_string(),
1960            deleted: false,
1961            encrypted: false,
1962        };
1963        let result = service.validate_snippet(&snippet);
1964        assert!(result.is_err());
1965        assert!(result.unwrap_err().message().contains("non-negative"));
1966    }
1967
1968    #[tokio::test]
1969    async fn test_validate_snippet_clock_skew_reports_magnitude() {
1970        let service = setup_test_service().await;
1971        let now = chrono::Utc::now().timestamp();
1972        let snippet = ProtoSnippet {
1973            id: "skew-id".to_string(),
1974            description: "test".to_string(),
1975            command: "echo hello".to_string(),
1976            tags: vec![],
1977            created_at: now,
1978            updated_at: now + 742, // 742 seconds ahead
1979            device_id: "device".to_string(),
1980            deleted: false,
1981            encrypted: false,
1982        };
1983        let result = service.validate_snippet(&snippet);
1984        assert!(result.is_err());
1985        let msg = result.unwrap_err().message().to_string();
1986        assert!(
1987            msg.contains("742"),
1988            "Clock skew message should contain magnitude, got: {msg}"
1989        );
1990        assert!(
1991            msg.contains("synchronize the client clock"),
1992            "Clock skew message should contain corrective action, got: {msg}"
1993        );
1994    }
1995
1996    #[tokio::test]
1997    async fn test_validate_snippet_created_ahead_reports_skew() {
1998        let service = setup_test_service().await;
1999        let now = chrono::Utc::now().timestamp();
2000        let snippet = ProtoSnippet {
2001            id: "skew-created".to_string(),
2002            description: "test".to_string(),
2003            command: "echo hello".to_string(),
2004            tags: vec![],
2005            created_at: now + 500,
2006            updated_at: now, // updated_at is fine, only created_at is ahead
2007            device_id: "device".to_string(),
2008            deleted: false,
2009            encrypted: false,
2010        };
2011        let result = service.validate_snippet(&snippet);
2012        assert!(result.is_err());
2013        let msg = result.unwrap_err().message().to_string();
2014        assert!(
2015            msg.contains("created_at"),
2016            "Should mention created_at: {msg}"
2017        );
2018        assert!(msg.contains("500"), "Should contain skew magnitude: {msg}");
2019    }
2020
2021    #[tokio::test]
2022    async fn test_validate_snippet_too_many_tags() {
2023        let service = setup_test_service().await;
2024        let snippet = ProtoSnippet {
2025            id: "test-id".to_string(),
2026            description: "test".to_string(),
2027            command: "echo hello".to_string(),
2028            tags: (0..100).map(|i| format!("tag{}", i)).collect(),
2029            created_at: 0,
2030            updated_at: 0,
2031            device_id: "device".to_string(),
2032            deleted: false,
2033            encrypted: false,
2034        };
2035        let result = service.validate_snippet(&snippet);
2036        assert!(result.is_err());
2037        assert!(result.unwrap_err().message().contains("Too many tags"));
2038    }
2039
2040    #[tokio::test]
2041    async fn test_validate_snippet_valid() {
2042        let service = setup_test_service().await;
2043        let snippet = ProtoSnippet {
2044            id: "test-id".to_string(),
2045            description: "test".to_string(),
2046            command: "echo hello".to_string(),
2047            tags: vec!["bash".to_string()],
2048            created_at: 0,
2049            updated_at: 0,
2050            device_id: "device".to_string(),
2051            deleted: false,
2052            encrypted: false,
2053        };
2054        assert!(service.validate_snippet(&snippet).is_ok());
2055    }
2056
2057    #[tokio::test]
2058    async fn test_cross_user_library_access_denied() {
2059        let service = setup_test_service().await;
2060        let api_key1 = register_test_user(&service).await;
2061
2062        let req = Request::new(CreateLibraryRequest {
2063            api_key: api_key1.clone(),
2064            name: "user1-lib".to_string(),
2065        });
2066        let resp = service.create_library(req).await.unwrap();
2067        let library_id = resp.into_inner().library_id;
2068
2069        let api_key2 = register_test_user(&service).await;
2070
2071        let req = Request::new(GetSnippetsRequest {
2072            api_key: api_key2,
2073            library_id,
2074            limit: 100,
2075            offset: 0,
2076            since: 0,
2077        });
2078        let resp = service.get_snippets(req).await;
2079        assert!(resp.is_err());
2080        assert_eq!(resp.unwrap_err().code(), tonic::Code::NotFound);
2081    }
2082
2083    #[tokio::test]
2084    async fn test_push_and_get_snippets() {
2085        let service = setup_test_service().await;
2086        let api_key = register_test_user(&service).await;
2087
2088        let req = Request::new(CreateLibraryRequest {
2089            api_key: api_key.clone(),
2090            name: "test-lib".to_string(),
2091        });
2092        let resp = service.create_library(req).await.unwrap();
2093        let library_id = resp.into_inner().library_id;
2094
2095        let snippet = ProtoSnippet {
2096            id: "snippet-1".to_string(),
2097            description: "Test snippet".to_string(),
2098            command: "echo hello".to_string(),
2099            tags: vec!["test".to_string()],
2100            created_at: chrono::Utc::now().timestamp(),
2101            updated_at: chrono::Utc::now().timestamp(),
2102            device_id: "device-1".to_string(),
2103            deleted: false,
2104            encrypted: false,
2105        };
2106        let req = Request::new(PushSnippetsRequest {
2107            api_key: api_key.clone(),
2108            library_id: library_id.clone(),
2109            snippets: vec![snippet],
2110        });
2111        let resp = service.push_snippets(req).await.unwrap();
2112        let push = resp.into_inner();
2113        assert_eq!(push.accepted_count, 1);
2114        assert_eq!(push.rejected_count, 0);
2115
2116        let req = Request::new(GetSnippetsRequest {
2117            api_key: api_key.clone(),
2118            library_id,
2119            limit: 100,
2120            offset: 0,
2121            since: 0,
2122        });
2123        let resp = service.get_snippets(req).await.unwrap();
2124        let list = resp.into_inner();
2125        assert_eq!(list.snippets.len(), 1);
2126        assert_eq!(list.snippets[0].id, "snippet-1");
2127        assert_eq!(list.snippets[0].command, "echo hello");
2128    }
2129
2130    #[tokio::test]
2131    async fn test_delete_library() {
2132        let service = setup_test_service().await;
2133        let api_key = register_test_user(&service).await;
2134
2135        let req = Request::new(CreateLibraryRequest {
2136            api_key: api_key.clone(),
2137            name: "to-delete".to_string(),
2138        });
2139        let resp = service.create_library(req).await.unwrap();
2140        let library_id = resp.into_inner().library_id;
2141
2142        let req = Request::new(snip_proto::DeleteLibraryRequest {
2143            api_key: api_key.clone(),
2144            library_id: library_id.clone(),
2145        });
2146        let resp = service.delete_library(req).await.unwrap();
2147        assert!(resp.into_inner().success);
2148
2149        let req = Request::new(ListLibrariesRequest {
2150            api_key: api_key.clone(),
2151            limit: 100,
2152            offset: 0,
2153        });
2154        let resp = service.list_libraries(req).await.unwrap();
2155        let list = resp.into_inner();
2156        assert_eq!(list.libraries.len(), 1);
2157        assert_eq!(list.libraries[0].name, "default");
2158    }
2159
2160    #[tokio::test]
2161    async fn test_delete_default_library_blocked() {
2162        let service = setup_test_service().await;
2163        let api_key = register_test_user(&service).await;
2164
2165        let req = Request::new(snip_proto::DeleteLibraryRequest {
2166            api_key: api_key.clone(),
2167            library_id: "default".to_string(),
2168        });
2169        let resp = service.delete_library(req).await;
2170        assert!(resp.is_err());
2171        assert!(resp.unwrap_err().message().contains("Cannot delete"));
2172    }
2173
2174    #[tokio::test]
2175    async fn test_sync_basic() {
2176        let service = setup_test_service().await;
2177        let api_key = register_test_user(&service).await;
2178
2179        let req = Request::new(CreateLibraryRequest {
2180            api_key: api_key.clone(),
2181            name: "sync-test".to_string(),
2182        });
2183        let resp = service.create_library(req).await.unwrap();
2184        let library_id = resp.into_inner().library_id;
2185
2186        let req = Request::new(SyncRequest {
2187            api_key: api_key.clone(),
2188            local_snippets: vec![],
2189            last_sync_timestamp: 0,
2190            library_id,
2191            limit: 1000,
2192            offset: 0,
2193        });
2194        let resp = service.sync(req).await.unwrap();
2195        let sync = resp.into_inner();
2196        assert_eq!(sync.snippets.len(), 0);
2197    }
2198
2199    #[tokio::test]
2200    async fn test_premade_filename_with_unsafe_characters_is_rejected() {
2201        let service = setup_test_service().await;
2202        let api_key = register_test_user(&service).await;
2203
2204        let req = Request::new(GetPremadeLibraryRequest {
2205            api_key,
2206            filename: "valid-name!.toml".to_string(),
2207        });
2208        let error = service.get_premade_library(req).await.unwrap_err();
2209
2210        assert_eq!(error.code(), tonic::Code::InvalidArgument);
2211        assert_eq!(error.message(), "Invalid filename");
2212    }
2213
2214    #[test]
2215    fn config_load_missing_file_uses_defaults() {
2216        let dir = tempfile::tempdir().unwrap();
2217        let path = dir.path().join("missing.toml");
2218        let config = Config::load_from(&path, &|_| None).unwrap();
2219        assert_eq!(config.grpc_port, 50051);
2220        assert_eq!(config.http_port, 50050);
2221    }
2222
2223    #[test]
2224    fn config_load_merges_file_and_environment_overrides() {
2225        let dir = tempfile::tempdir().unwrap();
2226        let path = dir.path().join("config.toml");
2227        std::fs::write(
2228            &path,
2229            "[server]\ngrpc_port = 51000\nhttp_host = \"192.0.2.10\"\n",
2230        )
2231        .unwrap();
2232        let config = Config::load_from(&path, &|name| {
2233            (name == "GRPC_PORT").then(|| "52000".to_string())
2234        })
2235        .unwrap();
2236        assert_eq!(config.grpc_port, 52000);
2237        assert_eq!(config.http_host, "192.0.2.10");
2238    }
2239
2240    #[test]
2241    fn config_load_rejects_malformed_existing_file() {
2242        let dir = tempfile::tempdir().unwrap();
2243        let path = dir.path().join("config.toml");
2244        std::fs::write(&path, "[server\n").unwrap();
2245        let error = match Config::load_from(&path, &|_| None) {
2246            Ok(_) => panic!("malformed config unexpectedly loaded"),
2247            Err(error) => error,
2248        };
2249        let message = error.to_string();
2250        assert!(message.contains(&path.display().to_string()));
2251        assert!(message.contains("parse"));
2252    }
2253
2254    #[test]
2255    fn config_load_rejects_unreadable_existing_path() {
2256        let dir = tempfile::tempdir().unwrap();
2257        let error = match Config::load_from(dir.path(), &|_| None) {
2258            Ok(_) => panic!("directory unexpectedly loaded as config"),
2259            Err(error) => error,
2260        };
2261        assert!(
2262            error
2263                .to_string()
2264                .contains(&dir.path().display().to_string())
2265        );
2266    }
2267
2268    #[test]
2269    fn parse_env_valid_numeric_override() {
2270        let env = |name: &str| match name {
2271            "GRPC_PORT" => Some("60000".to_string()),
2272            _ => None,
2273        };
2274        let val: Option<u16> = parse_env(&env, "GRPC_PORT").unwrap();
2275        assert_eq!(val, Some(60000));
2276    }
2277
2278    #[test]
2279    fn parse_env_malformed_numeric_returns_invalid_environment() {
2280        let env = |name: &str| match name {
2281            "GRPC_PORT" => Some("not-a-number".to_string()),
2282            _ => None,
2283        };
2284        let err = parse_env::<u16>(&env, "GRPC_PORT").unwrap_err();
2285        match err {
2286            ConfigLoadError::InvalidEnvironment { name, value, .. } => {
2287                assert_eq!(name, "GRPC_PORT");
2288                assert_eq!(value, "not-a-number");
2289            }
2290            other => panic!("expected InvalidEnvironment, got: {other}"),
2291        }
2292    }
2293
2294    #[test]
2295    fn parse_env_missing_variable_returns_none() {
2296        let env = |_name: &str| -> Option<String> { None };
2297        let val: Option<u16> = parse_env(&env, "GRPC_PORT").unwrap();
2298        assert_eq!(val, None);
2299    }
2300
2301    #[test]
2302    fn parse_bool_env_accepted_true_spellings() {
2303        for input in &["true", "1", "yes", "on", "TRUE", "Yes", "ON"] {
2304            let env = |_: &str| Some(input.to_string());
2305            let val = parse_bool_env(&env, "FLAG").unwrap();
2306            assert_eq!(val, Some(true), "expected true for {input:?}");
2307        }
2308    }
2309
2310    #[test]
2311    fn parse_bool_env_accepted_false_spellings() {
2312        for input in &["false", "0", "no", "off", "FALSE", "No", "OFF"] {
2313            let env = |_: &str| Some(input.to_string());
2314            let val = parse_bool_env(&env, "FLAG").unwrap();
2315            assert_eq!(val, Some(false), "expected false for {input:?}");
2316        }
2317    }
2318
2319    #[test]
2320    fn parse_bool_env_unknown_value_fails() {
2321        let env = |_: &str| Some("maybe".to_string());
2322        let err = parse_bool_env(&env, "FLAG").unwrap_err();
2323        match err {
2324            ConfigLoadError::InvalidEnvironment { name, value, .. } => {
2325                assert_eq!(name, "FLAG");
2326                assert_eq!(value, "maybe");
2327            }
2328            other => panic!("expected InvalidEnvironment, got: {other}"),
2329        }
2330    }
2331
2332    #[test]
2333    fn parse_bool_env_missing_variable_returns_none() {
2334        let env = |_name: &str| -> Option<String> { None };
2335        let val = parse_bool_env(&env, "FLAG").unwrap();
2336        assert_eq!(val, None);
2337    }
2338
2339    #[test]
2340    fn config_validate_rejects_zero_grpc_port() {
2341        let dir = tempfile::tempdir().unwrap();
2342        let path = dir.path().join("config.toml");
2343        std::fs::write(&path, "[server]\ngrpc_port = 0\n").unwrap();
2344        let err = Config::load_from(&path, &|_| None).unwrap_err();
2345        match err {
2346            ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "GRPC_PORT"),
2347            other => panic!("expected InvalidRange, got: {other}"),
2348        }
2349    }
2350
2351    #[test]
2352    fn config_validate_rejects_zero_db_max_connections() {
2353        let dir = tempfile::tempdir().unwrap();
2354        let path = dir.path().join("config.toml");
2355        std::fs::write(&path, "[server.database]\nmax_connections = 0\n").unwrap();
2356        let err = Config::load_from(&path, &|_| None).unwrap_err();
2357        match err {
2358            ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "DB_MAX_CONNECTIONS"),
2359            other => panic!("expected InvalidRange, got: {other}"),
2360        }
2361    }
2362
2363    #[test]
2364    fn config_validate_rejects_zero_request_timeout() {
2365        let dir = tempfile::tempdir().unwrap();
2366        let path = dir.path().join("config.toml");
2367        std::fs::write(&path, "[server.limits]\nrequest_timeout_secs = 0\n").unwrap();
2368        let err = Config::load_from(&path, &|_| None).unwrap_err();
2369        match err {
2370            ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "REQUEST_TIMEOUT_SECS"),
2371            other => panic!("expected InvalidRange, got: {other}"),
2372        }
2373    }
2374
2375    #[test]
2376    fn config_load_rejects_malformed_numeric_env() {
2377        let dir = tempfile::tempdir().unwrap();
2378        let path = dir.path().join("config.toml");
2379        std::fs::write(&path, "").unwrap();
2380        let env = |name: &str| match name {
2381            "GRPC_PORT" => Some("abc".to_string()),
2382            _ => None,
2383        };
2384        let err = Config::load_from(&path, &env).unwrap_err();
2385        match err {
2386            ConfigLoadError::InvalidEnvironment { name, .. } => assert_eq!(name, "GRPC_PORT"),
2387            other => panic!("expected InvalidEnvironment, got: {other}"),
2388        }
2389    }
2390
2391    #[test]
2392    fn config_validate_rejects_zero_max_id_length() {
2393        let dir = tempfile::tempdir().unwrap();
2394        let path = dir.path().join("config.toml");
2395        std::fs::write(&path, "[server.limits]\nmax_id_length = 0\n").unwrap();
2396        let err = Config::load_from(&path, &|_| None).unwrap_err();
2397        match err {
2398            ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "MAX_ID_LENGTH"),
2399            other => panic!("expected InvalidRange, got: {other}"),
2400        }
2401    }
2402
2403    #[test]
2404    fn config_validate_rejects_zero_max_device_id_length() {
2405        let dir = tempfile::tempdir().unwrap();
2406        let path = dir.path().join("config.toml");
2407        std::fs::write(&path, "[server.limits]\nmax_device_id_length = 0\n").unwrap();
2408        let err = Config::load_from(&path, &|_| None).unwrap_err();
2409        match err {
2410            ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "MAX_DEVICE_ID_LENGTH"),
2411            other => panic!("expected InvalidRange, got: {other}"),
2412        }
2413    }
2414
2415    #[test]
2416    fn config_validate_rejects_zero_max_api_key_length() {
2417        let dir = tempfile::tempdir().unwrap();
2418        let path = dir.path().join("config.toml");
2419        std::fs::write(&path, "[server.limits]\nmax_api_key_length = 0\n").unwrap();
2420        let err = Config::load_from(&path, &|_| None).unwrap_err();
2421        match err {
2422            ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "MAX_API_KEY_LENGTH"),
2423            other => panic!("expected InvalidRange, got: {other}"),
2424        }
2425    }
2426
2427    #[test]
2428    fn config_validate_rejects_zero_rate_limit_per_minute() {
2429        let dir = tempfile::tempdir().unwrap();
2430        let path = dir.path().join("config.toml");
2431        std::fs::write(&path, "[server.rate_limit]\nrequests_per_minute = 0\n").unwrap();
2432        let err = Config::load_from(&path, &|_| None).unwrap_err();
2433        match err {
2434            ConfigLoadError::InvalidRange { name, .. } => {
2435                assert_eq!(name, "RATE_LIMIT_PER_MINUTE")
2436            }
2437            other => panic!("expected InvalidRange, got: {other}"),
2438        }
2439    }
2440
2441    #[test]
2442    fn config_validate_accepts_valid_boundary_values() {
2443        let dir = tempfile::tempdir().unwrap();
2444        let path = dir.path().join("config.toml");
2445        std::fs::write(
2446            &path,
2447            "[server.limits]\nmax_id_length = 1\nmax_device_id_length = 1\nmax_api_key_length = 1\n[server.rate_limit]\nrequests_per_minute = 1\n",
2448        )
2449        .unwrap();
2450        let config = Config::load_from(&path, &|_| None).unwrap();
2451        assert_eq!(config.max_id_length, 1);
2452        assert_eq!(config.max_device_id_length, 1);
2453        assert_eq!(config.max_api_key_length, 1);
2454        assert_eq!(config.rate_limit_per_minute, 1);
2455    }
2456}