1. 1use std::path::{Path, PathBuf};
2. 2
3. 3use vak_plugin::{InstallOptions, InstallScope, PluginStore};
4. 4
5. 5use crate::cli::{MarketplaceTrustArg, PluginAction, PluginScopeArg};
6. 6
7. 7pub(crate) fn run_plugins(cwd: PathBuf, action: PluginAction) -> i32 {
8. 8 match action {
9. 9 PluginAction::CatalogInspect { path, json } => match vak_plugin::inspect_catalog(&path) {
10. 10 Ok(catalog) => print_value(&catalog, json, |value| {
11. 11 println!(
12. 12 "{} {:?} {} entries\ndigest: {}\ntrace: {}",
13. 13 value.name,
14. 14 value.format,
15. 15 value.entries.len(),
16. 16 value.digest,
17. 17 value.trace_id
18. 18 );
19. 19 for warning in &value.warnings {
20. 20 println!("warning: {warning}");
21. 21 }
22. 22 }),
23. 23 Err(error) => fail(error),
24. 24 },
25. 25 PluginAction::CatalogRegister {
26. 26 path,
27. 27 label,
28. 28 trust,
29. 29 scope,
30. 30 json,
31. 31 } => {
32. 32 let trust = match trust {
33. 33 MarketplaceTrustArg::ManualReview => vak_plugin::MarketplaceTrust::ManualReview,
34. 34 MarketplaceTrustArg::PinnedCommit => vak_plugin::MarketplaceTrust::PinnedCommit,
35. 35 MarketplaceTrustArg::LocalOnly => vak_plugin::MarketplaceTrust::LocalOnly,
36. 36 };
37. 37 match store(&cwd, scope).register_catalog_source(&path, &label, trust) {
38. 38 Ok(source) => print_value(&source, json, |value| {
39. 39 println!(
40. 40 "registered {} {:?} disabled\ntrace: {}",
41. 41 value.label, value.format, value.trace_id
42. 42 )
43. 43 }),
44. 44 Err(error) => fail(error),
45. 45 }
46. 46 }
47. 47 PluginAction::CatalogSources { scope, json } => match store(&cwd, scope).list_sources() {
48. 48 Ok(sources) => print_value(&sources, json, |values| {
49. 49 for source in values {
50. 50 println!(
51. 51 "{} {} {}",
52. 52 source.label,
53. 53 if source.enabled {
54. 54 "enabled"
55. 55 } else {
56. 56 "disabled"
57. 57 },
58. 58 source.trace_id
59. 59 );
60. 60 }
61. 61 }),
62. 62 Err(error) => fail(error),
63. 63 },
64. 64 PluginAction::CatalogSearch { query, scope, json } => {
65. 65 let needle = query.trim().to_lowercase();
66. 66 if needle.is_empty() {
67. 67 eprintln!("error: catalog search query must not be empty");
68. 68 return 2;
69. 69 }
70. 70 let store = store(&cwd, scope);
71. 71 let sources = match store.list_sources() {
72. 72 Ok(sources) => sources,
73. 73 Err(error) => return fail(error),
74. 74 };
75. 75 let mut matches = Vec::new();
76. 76 for source in sources {
77. 77 let inspection = match vak_plugin::inspect_catalog(&source.root) {
78. 78 Ok(inspection) => inspection,
79. 79 Err(error) => return fail(error),
80. 80 };
81. 81 if inspection.digest != source.catalog_digest {
82. 82 return fail(vak_plugin::PluginError::UnsafePackage(format!(
83. 83 "marketplace catalog changed since registration: {}",
84. 84 source.root.display()
85. 85 )));
86. 86 }
87. 87 for entry in inspection.entries {
88. 88 let haystack = format!(
89. 89 "{} {}",
90. 90 entry.name,
91. 91 entry.description.as_deref().unwrap_or_default()
92. 92 )
93. 93 .to_lowercase();
94. 94 if haystack.contains(&needle) {
95. 95 matches.push(serde_json::json!({
96. 96 "source_id": source.id,
97. 97 "source_label": source.label,
98. 98 "source_enabled": source.enabled,
99. 99 "name": entry.name,
100. 100 "version": entry.version,
101. 101 "description": entry.description,
102. 102 "license": entry.license,
103. 103 "catalog_digest": source.catalog_digest,
104. 104 }));
105. 105 }
106. 106 }
107. 107 }
108. 108 if json {
109. 109 println!("{}", serde_json::Value::Array(matches));
110. 110 } else if matches.is_empty() {
111. 111 println!("no marketplace entries matched '{query}'");
112. 112 } else {
113. 113 for entry in matches {
114. 114 println!(
115. 115 "{} — {} [{}; {}]",
116. 116 entry["name"].as_str().unwrap_or("unknown"),
117. 117 entry["description"].as_str().unwrap_or("no description"),
118. 118 entry["source_label"].as_str().unwrap_or("unknown source"),
119. 119 if entry["source_enabled"] == true {
120. 120 "enabled"
121. 121 } else {
122. 122 "disabled"
123. 123 }
124. 124 );
125. 125 }
126. 126 }
127. 127 0
128. 128 }
129. 129 PluginAction::CatalogInstall {
130. 130 catalog,
131. 131 name,
132. 132 scope,
133. 133 allow_unlicensed,
134. 134 json,
135. 135 } => {
136. 136 let store = store(&cwd, scope);
137. 137 let inspection = match vak_plugin::inspect_catalog(&catalog) {
138. 138 Ok(value) => value,
139. 139 Err(error) => return fail(error),
140. 140 };
141. 141 let entry = match inspection.entries.iter().find(|entry| entry.name == name) {
142. 142 Some(entry) => entry,
143. 143 None => return fail(vak_plugin::PluginError::NotInstalled(name)),
144. 144 };
145. 145 let staging = store
146. 146 .packages_root()
147. 147 .join("catalog-staging")
148. 148 .join(&entry.name);
149. 149 let package = match vak_plugin::materialize_catalog_entry(&catalog, entry, &staging) {
150. 150 Ok(path) => path,
151. 151 Err(error) => return fail(error),
152. 152 };
153. 153 let result = store.install_local(
154. 154 &package,
155. 155 InstallOptions {
156. 156 scope: install_scope(scope),
157. 157 allow_unlicensed,
158. 158 },
159. 159 );
160. 160 let _ = std::fs::remove_dir_all(&staging);
161. 161 match result {
162. 162 Ok(plugin) => print_value(&plugin, json, |value| {
163. 163 println!(
164. 164 "installed catalog entry {} {} disabled\ntrace: {}",
165. 165 value.name, value.version, value.trace_id
166. 166 );
167. 167 }),
168. 168 Err(error) => fail(error),
169. 169 }
170. 170 }
171. 171 PluginAction::Inspect { path, json } => match vak_plugin::inspect_package(&path) {
172. 172 Ok(inspection) => print_value(&inspection, json, |value| {
173. 173 println!(
174. 174 "{} {} {} {} files / {} bytes",
175. 175 value.manifest.name,
176. 176 value.manifest.version,
177. 177 value.digest,
178. 178 value.file_count,
179. 179 value.total_bytes
180. 180 );
181. 181 print_capabilities(&value.capabilities);
182. 182 for warning in &value.warnings {
183. 183 println!("warning: {warning}");
184. 184 }
185. 185 }),
186. 186 Err(error) => fail(error),
187. 187 },
188. 188 PluginAction::Install {
189. 189 path,
190. 190 scope,
191. 191 allow_unlicensed,
192. 192 json,
193. 193 } => {
194. 194 let store = store(&cwd, scope);
195. 195 let options = InstallOptions {
196. 196 scope: install_scope(scope),
197. 197 allow_unlicensed,
198. 198 };
199. 199 match store.install_local(&path, options) {
200. 200 Ok(plugin) => print_value(&plugin, json, |value| {
201. 201 println!(
202. 202 "installed {} {} disabled\ndigest: {}\ntrace: {}",
203. 203 value.name, value.version, value.digest, value.trace_id
204. 204 );
205. 205 print_capabilities(&value.capabilities);
206. 206 }),
207. 207 Err(error) => fail(error),
208. 208 }
209. 209 }
210. 210 PluginAction::Update {
211. 211 path,
212. 212 scope,
213. 213 allow_unlicensed,
214. 214 json,
215. 215 } => match store(&cwd, scope).update_local(
216. 216 &path,
217. 217 InstallOptions {
218. 218 scope: install_scope(scope),
219. 219 allow_unlicensed,
220. 220 },
221. 221 ) {
222. 222 Ok(plugin) => print_value(&plugin, json, |value| {
223. 223 println!(
224. 224 "staged update {} {} disabled\ndigest: {}\ntrace: {}",
225. 225 value.name, value.version, value.digest, value.trace_id
226. 226 );
227. 227 }),
228. 228 Err(error) => fail(error),
229. 229 },
230. 230 PluginAction::Enable { name, scope, json } => match store(&cwd, scope).enable(&name) {
231. 231 Ok(plugin) => print_value(&plugin, json, |value| {
232. 232 println!(
233. 233 "enabled {} {} ({})",
234. 234 value.name, value.version, value.digest
235. 235 );
236. 236 }),
237. 237 Err(error) => fail(error),
238. 238 },
239. 239 PluginAction::Disable { name, scope, json } => match store(&cwd, scope).disable(&name) {
240. 240 Ok(plugin) => print_value(&plugin, json, |value| {
241. 241 println!(
242. 242 "disabled {} {} ({})",
243. 243 value.name, value.version, value.digest
244. 244 );
245. 245 }),
246. 246 Err(error) => fail(error),
247. 247 },
248. 248 PluginAction::Rollback { name, scope, json } => match store(&cwd, scope).rollback(&name) {
249. 249 Ok(plugin) => print_value(&plugin, json, |value| {
250. 250 println!(
251. 251 "rolled back {} {} disabled ({})",
252. 252 value.name, value.version, value.digest
253. 253 );
254. 254 }),
255. 255 Err(error) => fail(error),
256. 256 },
257. 257 PluginAction::Versions { name, scope, json } => match store(&cwd, scope).versions(&name) {
258. 258 Ok(plugins) => print_value(&plugins, json, |values| {
259. 259 for value in values {
260. 260 let state = if value.enabled { "enabled" } else { "disabled" };
261. 261 println!(
262. 262 "{} {} {} {}",
263. 263 value.name, value.version, state, value.digest
264. 264 );
265. 265 }
266. 266 }),
267. 267 Err(error) => fail(error),
268. 268 },
269. 269 PluginAction::List { scope, json } => match store(&cwd, scope).list() {
270. 270 Ok(plugins) => print_value(&plugins, json, |values| {
271. 271 if values.is_empty() {
272. 272 println!("no plugins installed for {} scope", scope_name(scope));
273. 273 }
274. 274 for plugin in values {
275. 275 let state = if plugin.enabled {
276. 276 "enabled"
277. 277 } else {
278. 278 "disabled"
279. 279 };
280. 280 println!(
281. 281 "{} {} {} {} {}",
282. 282 plugin.name,
283. 283 plugin.version,
284. 284 state,
285. 285 plugin.format_name(),
286. 286 plugin.digest
287. 287 );
288. 288 }
289. 289 }),
290. 290 Err(error) => fail(error),
291. 291 },
292. 292 PluginAction::Audit { scope, json } => match store(&cwd, scope).load() {
293. 293 Ok(registry) => print_value(&registry.audit, json, |events| {
294. 294 if events.is_empty() {
295. 295 println!("no plugin audit events for {} scope", scope_name(scope));
296. 296 }
297. 297 for event in events {
298. 298 println!(
299. 299 "{} {:?} {} {} {}",
300. 300 event.generation, event.action, event.plugin, event.version, event.trace_id
301. 301 );
302. 302 }
303. 303 }),
304. 304 Err(error) => fail(error),
305. 305 },
306. 306 PluginAction::Remove { name, scope, json } => match store(&cwd, scope).remove(&name) {
307. 307 Ok(plugin) => print_value(&plugin, json, |value| {
308. 308 println!(
309. 309 "removed {} {} ({})",
310. 310 value.name, value.version, value.digest
311. 311 );
312. 312 }),
313. 313 Err(error) => fail(error),
314. 314 },
315. 315 }
316. 316}
317. 317
318. 318fn store(cwd: &Path, scope: PluginScopeArg) -> PluginStore {
319. 319 let home = match scope {
320. 320 PluginScopeArg::User => vak_config::paths::data_home(),
321. 321 PluginScopeArg::Workspace => cwd.join(".vak"),
322. 322 };
323. 323 PluginStore::new(home)
324. 324}
325. 325
326. 326fn install_scope(scope: PluginScopeArg) -> InstallScope {
327. 327 match scope {
328. 328 PluginScopeArg::User => InstallScope::User,
329. 329 PluginScopeArg::Workspace => InstallScope::Workspace,
330. 330 }
331. 331}
332. 332
333. 333fn scope_name(scope: PluginScopeArg) -> &'static str {
334. 334 match scope {
335. 335 PluginScopeArg::User => "user",
336. 336 PluginScopeArg::Workspace => "workspace",
337. 337 }
338. 338}
339. 339
340. 340fn print_value<T: serde::Serialize>(value: &T, json: bool, text: impl FnOnce(&T)) -> i32 {
341. 341 if json {
342. 342 match serde_json::to_string_pretty(value) {
343. 343 Ok(output) => println!("{output}"),
344. 344 Err(error) => {
345. 345 eprintln!("error: could not serialize plugin result: {error}");
346. 346 return 1;
347. 347 }
348. 348 }
349. 349 } else {
350. 350 text(value);
351. 351 }
352. 352 0
353. 353}
354. 354
355. 355fn print_capabilities(value: &vak_plugin::CapabilityInventory) {
356. 356 println!(
357. 357 "components: {} skills, {} commands, {} MCP, {} hooks, {} agents, {} LSP",
358. 358 value.skills.len(),
359. 359 value.commands.len(),
360. 360 value.mcp_manifests.len(),
361. 361 value.hooks.len(),
362. 362 value.agents.len(),
363. 363 value.lsp_manifests.len()
364. 364 );
365. 365 println!(
366. 366 "local execution: {} scripts, {} executable files",
367. 367 value.scripts.len(),
368. 368 value.executables.len()
369. 369 );
370. 370}
371. 371
372. 372fn fail(error: vak_plugin::PluginError) -> i32 {
373. 373 eprintln!("error: {error}");
374. 374 1
375. 375}
376. 376
377. 377trait ManifestFormatName {
378. 378 fn format_name(&self) -> &'static str;
379. 379}
380. 380
381. 381impl ManifestFormatName for vak_plugin::InstalledPlugin {
382. 382 fn format_name(&self) -> &'static str {
383. 383 match self.format {
384. 384 vak_plugin::ManifestFormat::Vak => "vak",
385. 385 vak_plugin::ManifestFormat::Codex => "codex",
386. 386 vak_plugin::ManifestFormat::AgentPlugin => "agent-plugin",
387. 387 vak_plugin::ManifestFormat::Claude => "claude",
388. 388 vak_plugin::ManifestFormat::Copilot => "copilot",
389. 389 vak_plugin::ManifestFormat::Cursor => "cursor",
390. 390 vak_plugin::ManifestFormat::Gemini => "gemini",
391. 391 vak_plugin::ManifestFormat::AgentSkill => "agent-skill",
392. 392 }
393. 393 }
394. 394}
395. 395