1use chrono::{DateTime, Utc};
2use serde::{Deserialize, Serialize};
3use sha2::{Digest, Sha256};
4use std::path::{Path, PathBuf};
5
6use super::content::PackageContent;
7use super::manifest::PackageManifest;
8
9const INDEX_FILE: &str = "package-index.json";
10const PACKAGES_DIR: &str = "packages";
11
12#[derive(Debug, Clone, Serialize, Deserialize)]
13pub struct PackageIndex {
14 pub schema_version: u32,
15 pub updated_at: DateTime<Utc>,
16 pub entries: Vec<PackageEntry>,
17}
18
19#[derive(Debug, Clone, Serialize, Deserialize)]
20pub struct PackageEntry {
21 pub name: String,
22 pub version: String,
23 pub description: String,
24 pub installed_at: DateTime<Utc>,
25 pub layers: Vec<String>,
26 pub sha256: String,
27 pub byte_size: u64,
28 #[serde(default)]
29 pub tags: Vec<String>,
30 #[serde(default)]
31 pub auto_load: bool,
32}
33
34impl PackageIndex {
35 fn new() -> Self {
36 Self {
37 schema_version: crate::core::contracts::CONTEXT_PACKAGE_V1_SCHEMA_VERSION,
38 updated_at: Utc::now(),
39 entries: Vec::new(),
40 }
41 }
42}
43
44pub struct LocalRegistry {
45 root: PathBuf,
46}
47
48impl LocalRegistry {
49 pub fn open() -> Result<Self, String> {
50 let data_dir = crate::core::data_dir::lean_ctx_data_dir()?;
51 let root = data_dir.join(PACKAGES_DIR);
52 std::fs::create_dir_all(&root).map_err(|e| format!("create packages dir: {e}"))?;
53 Ok(Self { root })
54 }
55
56 pub fn open_at(root: &Path) -> Result<Self, String> {
57 std::fs::create_dir_all(root).map_err(|e| format!("create packages dir: {e}"))?;
58 Ok(Self {
59 root: root.to_path_buf(),
60 })
61 }
62
63 pub fn root(&self) -> &Path {
64 &self.root
65 }
66
67 pub fn install(
68 &self,
69 manifest: &PackageManifest,
70 content: &PackageContent,
71 ) -> Result<PathBuf, String> {
72 manifest.validate().map_err(|errs| errs.join("; "))?;
73
74 let pkg_dir = self.package_dir(&manifest.name, &manifest.version);
75 std::fs::create_dir_all(&pkg_dir).map_err(|e| format!("create package dir: {e}"))?;
76
77 let manifest_json = serde_json::to_string_pretty(manifest).map_err(|e| e.to_string())?;
78 atomic_write(&pkg_dir.join("manifest.json"), manifest_json.as_bytes())?;
79
80 let content_json = serde_json::to_string_pretty(content).map_err(|e| e.to_string())?;
81 atomic_write(&pkg_dir.join("content.json"), content_json.as_bytes())?;
82
83 let mut index = self.load_index()?;
84 index
85 .entries
86 .retain(|e| !(e.name == manifest.name && e.version == manifest.version));
87 index.entries.push(PackageEntry {
88 name: manifest.name.clone(),
89 version: manifest.version.clone(),
90 description: manifest.description.clone(),
91 installed_at: Utc::now(),
92 layers: manifest
93 .layers
94 .iter()
95 .map(|l| l.as_str().to_string())
96 .collect(),
97 sha256: manifest.integrity.sha256.clone(),
98 byte_size: manifest.integrity.byte_size,
99 tags: manifest.tags.clone(),
100 auto_load: false,
101 });
102 index.updated_at = Utc::now();
103 self.save_index(&index)?;
104
105 Ok(pkg_dir)
106 }
107
108 pub fn remove(&self, name: &str, version: Option<&str>) -> Result<u32, String> {
109 let mut index = self.load_index()?;
110 let before = index.entries.len();
111
112 let to_remove: Vec<(String, String)> = index
113 .entries
114 .iter()
115 .filter(|e| e.name == name && version.is_none_or(|v| e.version == v))
116 .map(|e| (e.name.clone(), e.version.clone()))
117 .collect();
118
119 for (n, v) in &to_remove {
120 let dir = self.package_dir(n, v);
121 if dir.exists() {
122 let _ = std::fs::remove_dir_all(&dir);
123 }
124 }
125
126 index.entries.retain(|e| {
127 !to_remove
128 .iter()
129 .any(|(n, v)| e.name == *n && e.version == *v)
130 });
131
132 let removed = (before - index.entries.len()) as u32;
133 if removed > 0 {
134 index.updated_at = Utc::now();
135 self.save_index(&index)?;
136 }
137
138 Ok(removed)
139 }
140
141 pub fn list(&self) -> Result<Vec<PackageEntry>, String> {
142 let index = self.load_index()?;
143 Ok(index.entries)
144 }
145
146 pub fn get(&self, name: &str, version: Option<&str>) -> Result<Option<PackageEntry>, String> {
147 let index = self.load_index()?;
148 Ok(index
149 .entries
150 .into_iter()
151 .find(|e| e.name == name && version.is_none_or(|v| e.version == v)))
152 }
153
154 pub fn load_package(
155 &self,
156 name: &str,
157 version: &str,
158 ) -> Result<(PackageManifest, PackageContent), String> {
159 let pkg_dir = self.package_dir(name, version);
160 if !pkg_dir.exists() {
161 return Err(format!("package {name}@{version} not found"));
162 }
163
164 let manifest_json = std::fs::read_to_string(pkg_dir.join("manifest.json"))
165 .map_err(|e| format!("read manifest: {e}"))?;
166 let content_json = std::fs::read_to_string(pkg_dir.join("content.json"))
167 .map_err(|e| format!("read content: {e}"))?;
168
169 let manifest: PackageManifest =
170 serde_json::from_str(&manifest_json).map_err(|e| format!("parse manifest: {e}"))?;
171 let content: PackageContent =
172 serde_json::from_str(&content_json).map_err(|e| format!("parse content: {e}"))?;
173
174 verify_integrity(&manifest, &content)?;
175
176 Ok((manifest, content))
177 }
178
179 pub fn set_auto_load(&self, name: &str, version: &str, auto_load: bool) -> Result<(), String> {
180 let mut index = self.load_index()?;
181 if let Some(entry) = index
182 .entries
183 .iter_mut()
184 .find(|e| e.name == name && e.version == version)
185 {
186 entry.auto_load = auto_load;
187 index.updated_at = Utc::now();
188 self.save_index(&index)?;
189 } else {
190 return Err(format!("package {name}@{version} not found in index"));
191 }
192 Ok(())
193 }
194
195 pub fn auto_load_packages(&self) -> Result<Vec<PackageEntry>, String> {
196 let index = self.load_index()?;
197 Ok(index.entries.into_iter().filter(|e| e.auto_load).collect())
198 }
199
200 pub fn export_to_file(&self, name: &str, version: &str, output: &Path) -> Result<u64, String> {
201 let (manifest, content) = self.load_package(name, version)?;
202
203 let bundle = ExportBundle { manifest, content };
204 let json = serde_json::to_string_pretty(&bundle).map_err(|e| e.to_string())?;
205 let bytes = json.as_bytes();
206
207 atomic_write(output, bytes)?;
208 Ok(bytes.len() as u64)
209 }
210
211 pub fn import_from_file(&self, path: &Path) -> Result<PackageManifest, String> {
212 if !crate::core::contracts::is_package_file(path) {
213 let ext = path
214 .extension()
215 .and_then(|e| e.to_str())
216 .unwrap_or("(none)");
217 return Err(format!(
218 "unsupported file extension '.{ext}' — expected .{} or .{}",
219 crate::core::contracts::PACKAGE_EXTENSION,
220 crate::core::contracts::LEGACY_PACKAGE_EXTENSION,
221 ));
222 }
223
224 let meta = std::fs::metadata(path).map_err(|e| format!("stat package file: {e}"))?;
225 if meta.len() > crate::core::contracts::MAX_PACKAGE_FILE_BYTES {
226 return Err(format!(
227 "package file too large ({} bytes, max {} bytes)",
228 meta.len(),
229 crate::core::contracts::MAX_PACKAGE_FILE_BYTES,
230 ));
231 }
232
233 let json = std::fs::read_to_string(path).map_err(|e| format!("read package file: {e}"))?;
234 let bundle: ExportBundle =
235 serde_json::from_str(&json).map_err(|e| format!("parse package: {e}"))?;
236
237 bundle.manifest.validate().map_err(|errs| errs.join("; "))?;
238
239 verify_integrity(&bundle.manifest, &bundle.content)?;
240
241 self.install(&bundle.manifest, &bundle.content)?;
242 Ok(bundle.manifest)
243 }
244
245 fn package_dir(&self, name: &str, version: &str) -> PathBuf {
246 self.root.join(format!("{name}-{version}"))
247 }
248
249 fn load_index(&self) -> Result<PackageIndex, String> {
250 let path = self.root.join(INDEX_FILE);
251 if !path.exists() {
252 return Ok(PackageIndex::new());
253 }
254 let json = std::fs::read_to_string(&path).map_err(|e| format!("read index: {e}"))?;
255 serde_json::from_str(&json).map_err(|e| format!("parse index: {e}"))
256 }
257
258 fn save_index(&self, index: &PackageIndex) -> Result<(), String> {
259 let json = serde_json::to_string_pretty(index).map_err(|e| e.to_string())?;
260 atomic_write(&self.root.join(INDEX_FILE), json.as_bytes())
261 }
262}
263
264#[derive(Debug, Serialize, Deserialize)]
265struct ExportBundle {
266 manifest: PackageManifest,
267 content: PackageContent,
268}
269
270fn verify_integrity(manifest: &PackageManifest, content: &PackageContent) -> Result<(), String> {
271 let canonical = serde_json::to_string(content).map_err(|e| e.to_string())?;
272 let content_bytes = canonical.as_bytes();
273
274 let mut h1 = Sha256::new();
275 h1.update(content_bytes);
276 let actual_content_hash = format!("{:x}", h1.finalize());
277
278 if actual_content_hash != manifest.integrity.content_hash {
279 return Err(format!(
280 "integrity check failed: content_hash mismatch (expected {}, got {actual_content_hash})",
281 manifest.integrity.content_hash
282 ));
283 }
284
285 let expected_sha256 = {
286 let composite = format!(
287 "{}:{}:{actual_content_hash}",
288 manifest.name, manifest.version
289 );
290 let mut h2 = Sha256::new();
291 h2.update(composite.as_bytes());
292 format!("{:x}", h2.finalize())
293 };
294
295 if manifest.integrity.sha256 != expected_sha256 {
296 return Err(format!(
297 "integrity check failed: sha256 mismatch (expected {expected_sha256}, got {})",
298 manifest.integrity.sha256
299 ));
300 }
301
302 if manifest.integrity.byte_size != content_bytes.len() as u64 {
303 return Err(format!(
304 "integrity check failed: byte_size mismatch (expected {}, got {})",
305 manifest.integrity.byte_size,
306 content_bytes.len()
307 ));
308 }
309
310 Ok(())
311}
312
313fn atomic_write(path: &Path, data: &[u8]) -> Result<(), String> {
314 if path.exists()
315 && path
316 .symlink_metadata()
317 .is_ok_and(|m| m.file_type().is_symlink())
318 {
319 return Err(format!(
320 "refusing to write through symlink: {}",
321 path.display()
322 ));
323 }
324 let parent = path.parent().ok_or_else(|| "invalid path".to_string())?;
325 let tmp = parent.join(format!(
326 ".{}.tmp",
327 path.file_name().and_then(|s| s.to_str()).unwrap_or("pkg")
328 ));
329 std::fs::write(&tmp, data).map_err(|e| format!("write tmp: {e}"))?;
330 std::fs::rename(&tmp, path).map_err(|e| format!("rename: {e}"))?;
331 Ok(())
332}
333
334#[cfg(test)]
335mod tests {
336 use super::*;
337 use crate::core::context_package::manifest::{CompatibilitySpec, PackageStats};
338
339 #[test]
340 fn registry_round_trip() {
341 let dir = tempfile::tempdir().unwrap();
342 let reg = LocalRegistry::open_at(dir.path()).unwrap();
343
344 assert!(reg.list().unwrap().is_empty());
345
346 let manifest = PackageManifest {
347 schema_version: crate::core::contracts::CONTEXT_PACKAGE_V1_SCHEMA_VERSION,
348 name: "test-pkg".into(),
349 version: "1.0.0".into(),
350 description: "test".into(),
351 author: None,
352 created_at: Utc::now(),
353 updated_at: None,
354 layers: vec![super::super::manifest::PackageLayer::Knowledge],
355 dependencies: vec![],
356 tags: vec!["rust".into()],
357 integrity: {
358 let c = PackageContent::default();
359 let j = serde_json::to_string(&c).unwrap();
360 let mut h = Sha256::new();
361 h.update(j.as_bytes());
362 let ch = format!("{:x}", h.finalize());
363 let composite = format!("test-pkg:1.0.0:{ch}");
364 let mut h2 = Sha256::new();
365 h2.update(composite.as_bytes());
366 let sha = format!("{:x}", h2.finalize());
367 super::super::manifest::PackageIntegrity {
368 sha256: sha,
369 content_hash: ch,
370 byte_size: j.len() as u64,
371 }
372 },
373 provenance: super::super::manifest::PackageProvenance {
374 tool: "lean-ctx".into(),
375 tool_version: "0.0.0".into(),
376 project_hash: None,
377 source_session_id: None,
378 },
379 compatibility: CompatibilitySpec::default(),
380 stats: PackageStats::default(),
381 };
382
383 let content = PackageContent::default();
384
385 reg.install(&manifest, &content).unwrap();
386 let list = reg.list().unwrap();
387 assert_eq!(list.len(), 1);
388 assert_eq!(list[0].name, "test-pkg");
389
390 let (loaded_m, _loaded_c) = reg.load_package("test-pkg", "1.0.0").unwrap();
391 assert_eq!(loaded_m.name, "test-pkg");
392
393 let removed = reg.remove("test-pkg", None).unwrap();
394 assert_eq!(removed, 1);
395 assert!(reg.list().unwrap().is_empty());
396 }
397
398 #[test]
399 fn export_import_round_trip() {
400 let dir = tempfile::tempdir().unwrap();
401 let reg = LocalRegistry::open_at(dir.path()).unwrap();
402
403 let content = PackageContent::default();
404 let content_json = serde_json::to_string(&content).unwrap();
405 let mut h = Sha256::new();
406 h.update(content_json.as_bytes());
407 let content_hash = format!("{:x}", h.finalize());
408
409 let manifest = PackageManifest {
410 schema_version: crate::core::contracts::CONTEXT_PACKAGE_V1_SCHEMA_VERSION,
411 name: "export-test".into(),
412 version: "2.0.0".into(),
413 description: "round trip test".into(),
414 author: Some("test".into()),
415 created_at: Utc::now(),
416 updated_at: None,
417 layers: vec![super::super::manifest::PackageLayer::Knowledge],
418 dependencies: vec![],
419 tags: vec![],
420 integrity: {
421 let composite = format!("export-test:2.0.0:{content_hash}");
422 let mut h2 = Sha256::new();
423 h2.update(composite.as_bytes());
424 super::super::manifest::PackageIntegrity {
425 sha256: format!("{:x}", h2.finalize()),
426 content_hash,
427 byte_size: content_json.len() as u64,
428 }
429 },
430 provenance: super::super::manifest::PackageProvenance {
431 tool: "lean-ctx".into(),
432 tool_version: "0.0.0".into(),
433 project_hash: None,
434 source_session_id: None,
435 },
436 compatibility: CompatibilitySpec::default(),
437 stats: PackageStats::default(),
438 };
439
440 reg.install(&manifest, &content).unwrap();
441
442 let export_path = dir.path().join("test.ctxpkg");
443 let bytes = reg
444 .export_to_file("export-test", "2.0.0", &export_path)
445 .unwrap();
446 assert!(bytes > 0);
447
448 let reg2 = LocalRegistry::open_at(&dir.path().join("other")).unwrap();
449 let imported = reg2.import_from_file(&export_path).unwrap();
450 assert_eq!(imported.name, "export-test");
451 assert_eq!(reg2.list().unwrap().len(), 1);
452 }
453
454 #[test]
455 fn legacy_lctxpkg_extension_accepted() {
456 let dir = tempfile::tempdir().unwrap();
457 let reg = LocalRegistry::open_at(dir.path()).unwrap();
458
459 let content = PackageContent::default();
460 let content_json = serde_json::to_string(&content).unwrap();
461 let mut h = Sha256::new();
462 h.update(content_json.as_bytes());
463 let content_hash = format!("{:x}", h.finalize());
464 let composite = format!("legacy-test:1.0.0:{content_hash}");
465 let mut h2 = Sha256::new();
466 h2.update(composite.as_bytes());
467
468 let manifest = PackageManifest {
469 schema_version: crate::core::contracts::CONTEXT_PACKAGE_V1_SCHEMA_VERSION,
470 name: "legacy-test".into(),
471 version: "1.0.0".into(),
472 description: "legacy extension test".into(),
473 author: None,
474 created_at: Utc::now(),
475 updated_at: None,
476 layers: vec![super::super::manifest::PackageLayer::Knowledge],
477 dependencies: vec![],
478 tags: vec![],
479 integrity: super::super::manifest::PackageIntegrity {
480 sha256: format!("{:x}", h2.finalize()),
481 content_hash,
482 byte_size: content_json.len() as u64,
483 },
484 provenance: super::super::manifest::PackageProvenance {
485 tool: "lean-ctx".into(),
486 tool_version: "0.0.0".into(),
487 project_hash: None,
488 source_session_id: None,
489 },
490 compatibility: CompatibilitySpec::default(),
491 stats: PackageStats::default(),
492 };
493
494 reg.install(&manifest, &content).unwrap();
495
496 let legacy_path = dir.path().join("test.lctxpkg");
497 reg.export_to_file("legacy-test", "1.0.0", &legacy_path)
498 .unwrap();
499
500 let reg2 = LocalRegistry::open_at(&dir.path().join("other")).unwrap();
501 let imported = reg2.import_from_file(&legacy_path).unwrap();
502 assert_eq!(imported.name, "legacy-test");
503 }
504
505 #[test]
506 fn unsupported_extension_rejected() {
507 let dir = tempfile::tempdir().unwrap();
508 let reg = LocalRegistry::open_at(dir.path()).unwrap();
509 let bad_path = dir.path().join("test.json");
510 std::fs::write(&bad_path, "{}").unwrap();
511 assert!(reg.import_from_file(&bad_path).is_err());
512 }
513}