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