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