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