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 conformance_level: None,
349 name: "test-pkg".into(),
350 version: "1.0.0".into(),
351 description: "test".into(),
352 author: None,
353 scope: None,
354 created_at: Utc::now(),
355 updated_at: None,
356 layers: vec![super::super::manifest::PackageLayer::Knowledge],
357 dependencies: vec![],
358 tags: vec!["rust".into()],
359 integrity: {
360 let c = PackageContent::default();
361 let j = serde_json::to_string(&c).unwrap();
362 let mut h = Sha256::new();
363 h.update(j.as_bytes());
364 let ch = format!("{:x}", h.finalize());
365 let composite = format!("test-pkg:1.0.0:{ch}");
366 let mut h2 = Sha256::new();
367 h2.update(composite.as_bytes());
368 let sha = format!("{:x}", h2.finalize());
369 super::super::manifest::PackageIntegrity {
370 sha256: sha,
371 content_hash: ch,
372 byte_size: j.len() as u64,
373 }
374 },
375 provenance: super::super::manifest::PackageProvenance {
376 tool: "lean-ctx".into(),
377 tool_version: "0.0.0".into(),
378 project_hash: None,
379 source_session_id: None,
380 },
381 compatibility: CompatibilitySpec::default(),
382 stats: PackageStats::default(),
383 signature: None,
384 graph_summary: None,
385 marketplace: None,
386 };
387
388 let content = PackageContent::default();
389
390 reg.install(&manifest, &content).unwrap();
391 let list = reg.list().unwrap();
392 assert_eq!(list.len(), 1);
393 assert_eq!(list[0].name, "test-pkg");
394
395 let (loaded_m, _loaded_c) = reg.load_package("test-pkg", "1.0.0").unwrap();
396 assert_eq!(loaded_m.name, "test-pkg");
397
398 let removed = reg.remove("test-pkg", None).unwrap();
399 assert_eq!(removed, 1);
400 assert!(reg.list().unwrap().is_empty());
401 }
402
403 #[test]
404 fn export_import_round_trip() {
405 let dir = tempfile::tempdir().unwrap();
406 let reg = LocalRegistry::open_at(dir.path()).unwrap();
407
408 let content = PackageContent::default();
409 let content_json = serde_json::to_string(&content).unwrap();
410 let mut h = Sha256::new();
411 h.update(content_json.as_bytes());
412 let content_hash = format!("{:x}", h.finalize());
413
414 let manifest = PackageManifest {
415 schema_version: crate::core::contracts::CONTEXT_PACKAGE_V1_SCHEMA_VERSION,
416 conformance_level: None,
417 name: "export-test".into(),
418 version: "2.0.0".into(),
419 description: "round trip test".into(),
420 author: Some("test".into()),
421 scope: None,
422 created_at: Utc::now(),
423 updated_at: None,
424 layers: vec![super::super::manifest::PackageLayer::Knowledge],
425 dependencies: vec![],
426 tags: vec![],
427 integrity: {
428 let composite = format!("export-test:2.0.0:{content_hash}");
429 let mut h2 = Sha256::new();
430 h2.update(composite.as_bytes());
431 super::super::manifest::PackageIntegrity {
432 sha256: format!("{:x}", h2.finalize()),
433 content_hash,
434 byte_size: content_json.len() as u64,
435 }
436 },
437 provenance: super::super::manifest::PackageProvenance {
438 tool: "lean-ctx".into(),
439 tool_version: "0.0.0".into(),
440 project_hash: None,
441 source_session_id: None,
442 },
443 compatibility: CompatibilitySpec::default(),
444 stats: PackageStats::default(),
445 signature: None,
446 graph_summary: None,
447 marketplace: None,
448 };
449
450 reg.install(&manifest, &content).unwrap();
451
452 let export_path = dir.path().join("test.ctxpkg");
453 let bytes = reg
454 .export_to_file("export-test", "2.0.0", &export_path)
455 .unwrap();
456 assert!(bytes > 0);
457
458 let reg2 = LocalRegistry::open_at(&dir.path().join("other")).unwrap();
459 let imported = reg2.import_from_file(&export_path).unwrap();
460 assert_eq!(imported.name, "export-test");
461 assert_eq!(reg2.list().unwrap().len(), 1);
462 }
463
464 #[test]
465 fn legacy_lctxpkg_extension_accepted() {
466 let dir = tempfile::tempdir().unwrap();
467 let reg = LocalRegistry::open_at(dir.path()).unwrap();
468
469 let content = PackageContent::default();
470 let content_json = serde_json::to_string(&content).unwrap();
471 let mut h = Sha256::new();
472 h.update(content_json.as_bytes());
473 let content_hash = format!("{:x}", h.finalize());
474 let composite = format!("legacy-test:1.0.0:{content_hash}");
475 let mut h2 = Sha256::new();
476 h2.update(composite.as_bytes());
477
478 let manifest = PackageManifest {
479 schema_version: crate::core::contracts::CONTEXT_PACKAGE_V1_SCHEMA_VERSION,
480 conformance_level: None,
481 name: "legacy-test".into(),
482 version: "1.0.0".into(),
483 description: "legacy extension test".into(),
484 author: None,
485 scope: None,
486 created_at: Utc::now(),
487 updated_at: None,
488 layers: vec![super::super::manifest::PackageLayer::Knowledge],
489 dependencies: vec![],
490 tags: vec![],
491 integrity: super::super::manifest::PackageIntegrity {
492 sha256: format!("{:x}", h2.finalize()),
493 content_hash,
494 byte_size: content_json.len() as u64,
495 },
496 provenance: super::super::manifest::PackageProvenance {
497 tool: "lean-ctx".into(),
498 tool_version: "0.0.0".into(),
499 project_hash: None,
500 source_session_id: None,
501 },
502 compatibility: CompatibilitySpec::default(),
503 stats: PackageStats::default(),
504 signature: None,
505 graph_summary: None,
506 marketplace: None,
507 };
508
509 reg.install(&manifest, &content).unwrap();
510
511 let legacy_path = dir.path().join("test.lctxpkg");
512 reg.export_to_file("legacy-test", "1.0.0", &legacy_path)
513 .unwrap();
514
515 let reg2 = LocalRegistry::open_at(&dir.path().join("other")).unwrap();
516 let imported = reg2.import_from_file(&legacy_path).unwrap();
517 assert_eq!(imported.name, "legacy-test");
518 }
519
520 #[test]
521 fn unsupported_extension_rejected() {
522 let dir = tempfile::tempdir().unwrap();
523 let reg = LocalRegistry::open_at(dir.path()).unwrap();
524 let bad_path = dir.path().join("test.json");
525 std::fs::write(&bad_path, "{}").unwrap();
526 assert!(reg.import_from_file(&bad_path).is_err());
527 }
528}