commands.rs

src-tauri/src/commands.rs

1. //! The commands the interface can call. Each one delegates to cortex-core.
3. use std::path::{Path, PathBuf};
5. use cortex_core::api::*;
6. use cortex_core::attachments;
7. use cortex_core::chat::{build_request, request_tokens, run_turn};
8. use cortex_core::cost::cost_nanousd;
9. use cortex_core::estimate;
10. use cortex_core::export::{to_markdown, ImageLinks};
11. use cortex_core::pricing;
12. use cortex_core::provider::{Client, ProviderError};
13. use cortex_core::storage::{
14. self, month_start_ms, AttachmentMeta, Conversation, ConversationSummary, NewAttachment, Preset, Provider,
15. SearchHit, DEEPINFRA_ID,
16. };
17. use cortex_core::types::Usage;
18. use tauri::ipc::{Channel, InvokeBody, Request, Response};
19. use tauri::{AppHandle, Emitter, Manager, State, WebviewWindow};
20. use tokio_util::sync::CancellationToken;
22. use crate::state::{lock, AppState};
23. use crate::windows;
25. type R<T> = Result<T, String>;
27. fn e<E: ToString>(err: E) -> String {
28. err.to_string()
29. }
31. pub const SETTINGS_KEY: &str = "settings";
32. pub const DAY_MS: i64 = 24 * 3600 * 1000;
34. pub fn load_settings(state: &AppState) -> Settings {
35. state.db().get_setting::<Settings>(SETTINGS_KEY).ok().flatten().unwrap_or_default()
36. }
38. // ---- app and windows ------------------------------------------------------
40. #[tauri::command]
41. pub fn app_info(state: State<'_, AppState>) -> AppInfo {
42. AppInfo {
43. version: env!("CARGO_PKG_VERSION").into(),
44. platform: std::env::consts::OS.into(),
45. vibrancy: cfg!(target_os = "macos"),
46. data_dir: state.data_dir.display().to_string(),
47. }
48. }
50. /// The page has painted: show the window now, so it never flashes blank.
51. #[tauri::command]
52. pub fn window_ready(window: WebviewWindow) {
53. if window.label() == "main" {
54. let _ = window.show();
55. let _ = window.set_focus();
56. }
57. }
59. #[tauri::command]
60. pub fn show_main(app: AppHandle) {
61. windows::show_main(&app);
62. }
64. #[tauri::command]
65. pub fn quick_open_in_main(app: AppHandle, conversation_id: String) {
66. windows::hide_quick(&app);
67. windows::show_main(&app);
68. let _ = app.emit_to("main", "open-conversation", conversation_id);
69. }
71. #[tauri::command]
72. pub fn hide_quick(app: AppHandle) {
73. windows::hide_quick(&app);
74. }
76. #[tauri::command]
77. pub fn resize_quick(app: AppHandle, height: f64) {
78. if let Some(w) = app.get_webview_window("quick") {
79. let _ = w.set_size(tauri::LogicalSize::new(windows::QUICK_WIDTH, height.clamp(64.0, windows::QUICK_MAX)));
80. }
81. }
83. // ---- providers and keys ---------------------------------------------------
85. #[tauri::command]
86. pub fn list_providers(state: State<'_, AppState>) -> R<Vec<Provider>> {
87. state.db().list_providers().map_err(e)
88. }
90. #[tauri::command]
91. pub fn save_provider(state: State<'_, AppState>, mut provider: Provider) -> R<Provider> {
92. if provider.id.trim().is_empty() {
93. provider.id = storage::new_id();
94. }
95. if provider.id != DEEPINFRA_ID {
96. provider.kind = "openai_compatible".into();
97. }
98. let url = provider.base_url.trim();
99. if !(url.starts_with("http://") || url.starts_with("https://")) {
100. return Err("The address must start with http:// or https://".into());
101. }
102. state.db().upsert_provider(&provider).map_err(e)?;
103. state.db().get_provider(&provider.id).map_err(e)
104. }
106. #[tauri::command]
107. pub fn delete_provider(state: State<'_, AppState>, id: String) -> R<()> {
108. let _ = state.keys.clear(&id);
109. state.db().delete_provider(&id).map_err(e)
110. }
112. /// Check a key with the provider, then store it. A key the provider refuses is
113. /// not stored; one that could not be checked (offline, say) is, and says so.
114. #[tauri::command]
115. pub async fn set_api_key(app: AppHandle, provider_id: String, key: String) -> R<KeySaved> {
116. let key = cortex_core::secrets::clean_key(&key);
117. if key.is_empty() {
118. return Err("The key is empty.".into());
119. }
120. let state = app.state::<AppState>();
121. let provider = state.db().get_provider(&provider_id).map_err(e)?;
122. // Listing models with a bad key gets a 401, so it doubles as a free check.
123. let detail = match Client::new(&provider.base_url, Some(key.clone())).list_models().await {
124. Ok(_) => None,
125. Err(ProviderError::InvalidKey) => {
126. return Err(format!(
127. "{} rejected this key, so it was not saved. Copy the whole key again and paste it.",
128. provider.name
129. ))
130. }
131. Err(err) => Some(err.to_string()),
132. };
133. state.keys.set(&provider_id, &key).map_err(|err| format!("Could not store the key in the keychain: {err}"))?;
134. Ok(KeySaved { accepted: detail.is_none(), detail })
135. }
137. #[tauri::command]
138. pub fn clear_api_key(state: State<'_, AppState>, provider_id: String) -> R<()> {
139. state.keys.clear(&provider_id)
140. }
142. #[tauri::command]
143. pub fn has_api_key(state: State<'_, AppState>, provider_id: String) -> R<bool> {
144. state.keys.has(&provider_id)
145. }
147. // ---- models ---------------------------------------------------------------
149. fn models_response(state: &AppState, provider_id: &str, warning: Option<String>) -> R<ModelsResponse> {
150. let db = state.db();
151. let mut models = db.list_models(provider_id).map_err(e)?;
152. let mut source = db.models_source(provider_id).map_err(e)?;
153. let mut snapshot_date = None;
154. if models.is_empty() && provider_id == DEEPINFRA_ID {
155. // First run offline: the bundled prices.
156. let snap = pricing::snapshot(DEEPINFRA_ID);
157. db.replace_models(DEEPINFRA_ID, &snap.models, "snapshot", 0).map_err(e)?;
158. models = snap.models;
159. snapshot_date = Some(snap.fetched_at);
160. source = Some(("snapshot".into(), 0));
161. }
162. let (source, fetched_at) = source.unwrap_or(("local".into(), 0));
163. Ok(ModelsResponse {
164. models,
165. snapshot_date: (source == "snapshot")
166. .then(|| snapshot_date.unwrap_or_else(|| pricing::snapshot(DEEPINFRA_ID).fetched_at)),
167. fetched_at: (fetched_at > 0).then_some(fetched_at),
168. source,
169. warning,
170. })
171. }
173. #[tauri::command]
174. pub fn list_models(state: State<'_, AppState>, provider_id: String) -> R<ModelsResponse> {
175. models_response(&state, &provider_id, None)
176. }
178. /// Fetch a provider's model list (DeepInfra's carries prices). On failure the
179. /// stored list stays, and the response says why.
180. pub async fn refresh_models_for(app: &AppHandle, provider_id: &str) -> R<ModelsResponse> {
181. let state = app.state::<AppState>();
182. let provider = state.db().get_provider(provider_id).map_err(e)?;
183. let key = state.keys.get(provider_id).ok().flatten();
184. let client = Client::new(&provider.base_url, key);
185. let warning = match client.list_models().await {
186. Ok(v) => {
187. let (models, source) = if provider.kind == "deepinfra" {
188. (pricing::parse_priced_models(provider_id, &v), "live")
189. } else {
190. (pricing::parse_local_models(provider_id, &v), "local")
191. };
192. if models.is_empty() {
193. Some("The provider listed no chat models.".to_string())
194. } else {
195. state.db().replace_models(provider_id, &models, source, storage::now_ms()).map_err(e)?;
196. None
197. }
198. }
199. Err(err) => Some(err.to_string()),
200. };
201. models_response(&state, provider_id, warning)
202. }
204. #[tauri::command]
205. pub async fn refresh_models(app: AppHandle, provider_id: String) -> R<ModelsResponse> {
206. refresh_models_for(&app, &provider_id).await
207. }
209. /// At startup: refresh any list older than a day, quietly.
210. pub async fn refresh_stale(app: AppHandle) {
211. let providers = app.state::<AppState>().db().list_providers().unwrap_or_default();
212. for p in providers {
213. let age = app.state::<AppState>().db().models_source(&p.id).ok().flatten();
214. let stale = match age {
215. Some((src, at)) => src == "snapshot" || storage::now_ms() - at > DAY_MS,
216. None => true,
217. };
218. if stale {
219. let _ = refresh_models_for(&app, &p.id).await;
220. }
221. }
222. let _ = app.emit("models-updated", ());
223. }
225. // ---- conversations --------------------------------------------------------
227. #[tauri::command]
228. pub fn list_conversations(state: State<'_, AppState>, include_archived: bool) -> R<Vec<ConversationSummary>> {
229. state.db().list_conversations(include_archived, 500).map_err(e)
230. }
232. #[tauri::command]
233. pub fn get_conversation(state: State<'_, AppState>, id: String) -> R<ConversationView> {
234. let db = state.db();
235. Ok(ConversationView {
236. conversation: db.get_conversation(&id).map_err(e)?,
237. messages: db.list_messages(&id).map_err(e)?,
238. })
239. }
241. #[tauri::command]
242. pub fn create_conversation(
243. state: State<'_, AppState>,
244. provider_id: String,
245. model_id: String,
246. preset_id: Option<String>,
247. origin: Option<String>,
248. ) -> R<Conversation> {
249. let db = state.db();
250. let preset = match &preset_id {
251. Some(id) => db.list_presets().map_err(e)?.into_iter().find(|p| &p.id == id),
252. None => None,
253. };
254. let (provider_id, model_id) = match &preset {
255. Some(Preset { provider_id: Some(p), model_id: Some(m), .. }) => (p.clone(), m.clone()),
256. _ => (provider_id, model_id),
257. };
258. let system = preset.as_ref().map(|p| p.system_prompt.as_str()).unwrap_or("");
259. let origin = if origin.as_deref() == Some("quick") { "quick" } else { "main" };
260. db.create_conversation(&provider_id, &model_id, system, preset_id.as_deref(), origin).map_err(e)
261. }
263. #[tauri::command]
264. pub fn rename_conversation(state: State<'_, AppState>, id: String, title: String) -> R<()> {
265. state.db().rename_conversation(&id, &title).map_err(e)
266. }
268. #[tauri::command]
269. pub fn set_pinned(state: State<'_, AppState>, id: String, pinned: bool) -> R<()> {
270. state.db().set_pinned(&id, pinned).map_err(e)
271. }
273. #[tauri::command]
274. pub fn set_archived(state: State<'_, AppState>, id: String, archived: bool) -> R<()> {
275. state.db().set_archived(&id, archived).map_err(e)
276. }
278. #[tauri::command]
279. pub fn delete_conversation(state: State<'_, AppState>, id: String) -> R<()> {
280. let paths: Vec<String> = {
281. let db = state.db();
282. let msgs = db.list_messages(&id).map_err(e)?;
283. let mut paths = Vec::new();
284. for m in &msgs {
285. for a in db.attachment_data_for(&m.id).map_err(e)? {
286. paths.extend(a.path);
287. }
288. }
289. db.delete_conversation(&id).map_err(e)?;
290. paths
291. };
292. remove_unused_files(&state, &paths);
293. Ok(())
294. }
296. pub fn remove_unused_files(state: &AppState, paths: &[String]) {
297. for p in paths {
298. if !state.db().attachment_path_in_use(p).unwrap_or(true) {
299. let _ = std::fs::remove_file(p);
300. }
301. }
302. }
304. #[tauri::command]
305. pub fn set_conversation_model(state: State<'_, AppState>, id: String, provider_id: String, model_id: String) -> R<()> {
306. state.db().set_conversation_model(&id, &provider_id, &model_id).map_err(e)
307. }
309. #[tauri::command]
310. pub fn set_system_prompt(
311. state: State<'_, AppState>,
312. id: String,
313. system_prompt: String,
314. preset_id: Option<String>,
315. ) -> R<()> {
316. state.db().set_system_prompt(&id, &system_prompt, preset_id.as_deref()).map_err(e)
317. }
319. #[tauri::command]
320. pub fn truncate_from(state: State<'_, AppState>, conversation_id: String, message_id: String) -> R<()> {
321. state.db().truncate_from(&conversation_id, &message_id).map(|_| ()).map_err(e)
322. }
324. // ---- sending --------------------------------------------------------------
326. #[tauri::command]
327. pub fn send_message(
328. app: AppHandle,
329. state: State<'_, AppState>,
330. req: SendRequest,
331. on_event: Channel<StreamEvent>,
332. ) -> R<SendAck> {
333. let (conv, provider) = {
334. let db = state.db();
335. let conv = db.get_conversation(&req.conversation_id).map_err(e)?;
336. let provider = db.get_provider(&conv.provider_id).map_err(e)?;
337. (conv, provider)
338. };
339. let key = state.keys.get(&provider.id)?;
340. if provider.requires_key && key.as_deref().unwrap_or("").is_empty() {
341. return Err(format!("Add your {} API key in Settings first.", provider.name));
342. }
343. let (user_message, request, assistant, prices) = {
344. let db = state.db();
345. let user_message = if !req.text.trim().is_empty() || !req.attachment_ids.is_empty() {
346. Some(db.insert_user_message(&conv.id, &req.text, &req.attachment_ids).map_err(e)?)
347. } else {
348. None
349. };
350. let request = build_request(&db, &conv.id).map_err(e)?;
351. let assistant = db.insert_assistant_placeholder(&conv.id, &provider.id, &conv.model_id).map_err(e)?;
352. let prices = db.model(&provider.id, &conv.model_id).map_err(e)?.map(|m| m.prices);
353. (user_message, request, assistant, prices)
354. };
356. let stream_id = storage::new_id();
357. let token = CancellationToken::new();
358. lock(&state.streams).insert(stream_id.clone(), token.clone());
359. let client = Client::new(&provider.base_url, key);
360. let (app2, sid, placeholder) = (app.clone(), stream_id.clone(), assistant.clone());
361. tauri::async_runtime::spawn(async move {
362. let state = app2.state::<AppState>();
363. let _ = run_turn(&state.db, &client, &request, &placeholder, prices, &token, |ev| {
364. let _ = on_event.send(ev);
365. })
366. .await;
367. lock(&state.streams).remove(&sid);
368. windows::refresh_tray_spend(&app2);
369. let _ = app2.emit("conversations-changed", ());
370. });
371. Ok(SendAck { stream_id, user_message, assistant_message: assistant })
372. }
374. #[tauri::command]
375. pub fn cancel_stream(state: State<'_, AppState>, stream_id: String) {
376. if let Some(t) = lock(&state.streams).get(&stream_id) {
377. t.cancel();
378. }
379. }
381. /// What sending `text` (plus images) would cost at the input price.
382. #[tauri::command]
383. pub fn estimate_prompt(
384. state: State<'_, AppState>,
385. conversation_id: Option<String>,
386. provider_id: String,
387. model_id: String,
388. text: String,
389. image_count: u32,
390. extra_text: Option<String>,
391. ) -> R<Estimate> {
392. let db = state.db();
393. let history = match &conversation_id {
394. Some(id) => build_request(&db, id).map(|r| request_tokens(&r)).unwrap_or(0),
395. None => 0,
396. };
397. let new = estimate::estimate_prompt([(text.as_str(), image_count as usize)])
398. + estimate::estimate_tokens(extra_text.as_deref().unwrap_or(""));
399. let prompt_tokens = history + new;
400. let model = db.model(&provider_id, &model_id).map_err(e)?;
401. let prompt_cost_nanousd = model
402. .as_ref()
403. .map(|m| cost_nanousd(&Usage { prompt_tokens, completion_tokens: 0, cached_tokens: 0 }, &m.prices))
404. .unwrap_or(0);
405. Ok(Estimate { prompt_tokens, prompt_cost_nanousd, context_length: model.and_then(|m| m.context_length) })
406. }
408. // ---- search, spend, usage -------------------------------------------------
410. #[tauri::command]
411. pub fn search(state: State<'_, AppState>, query: String) -> R<Vec<SearchHit>> {
412. state.db().search(&query, 40).map_err(e)
413. }
415. pub fn spend(state: &AppState) -> R<SpendSummary> {
416. let settings = load_settings(state);
417. let (month, estimated) = state.db().spend_since(month_start_ms(&chrono::Local::now())).map_err(e)?;
418. Ok(SpendSummary {
419. month_nanousd: month,
420. month_estimated: estimated,
421. budget_usd: settings.monthly_budget_usd,
422. budget_level: budget_level(month, settings.monthly_budget_usd),
423. })
424. }
426. #[tauri::command]
427. pub fn spend_summary(state: State<'_, AppState>) -> R<SpendSummary> {
428. spend(&state)
429. }
431. #[tauri::command]
432. pub fn usage_report(state: State<'_, AppState>, days: Option<u32>) -> R<UsageReport> {
433. let now = chrono::Local::now();
434. let since_ms = match days {
435. Some(d) => now.timestamp_millis() - d as i64 * DAY_MS,
436. None => month_start_ms(&now),
437. };
438. let offset_minutes = now.offset().local_minus_utc() / 60;
439. let db = state.db();
440. Ok(UsageReport {
441. by_model: db.usage_by_model(since_ms).map_err(e)?,
442. by_day: db.usage_by_day(since_ms, offset_minutes).map_err(e)?,
443. since_ms,
444. })
445. }
447. // ---- presets and settings -------------------------------------------------
449. #[tauri::command]
450. pub fn list_presets(state: State<'_, AppState>) -> R<Vec<Preset>> {
451. state.db().list_presets().map_err(e)
452. }
454. #[tauri::command]
455. pub fn save_preset(state: State<'_, AppState>, preset: Preset) -> R<Preset> {
456. if preset.name.trim().is_empty() {
457. return Err("Give the preset a name.".into());
458. }
459. state.db().save_preset(&preset).map_err(|err| {
460. if err.to_string().contains("UNIQUE") {
461. "A preset with that name already exists.".to_string()
462. } else {
463. err.to_string()
464. }
465. })
466. }
468. #[tauri::command]
469. pub fn delete_preset(state: State<'_, AppState>, id: String) -> R<()> {
470. state.db().delete_preset(&id).map_err(e)
471. }
473. #[tauri::command]
474. pub fn get_settings(state: State<'_, AppState>) -> Settings {
475. load_settings(&state)
476. }
478. #[tauri::command]
479. pub fn save_settings(app: AppHandle, state: State<'_, AppState>, settings: Settings) -> R<SaveSettingsResult> {
480. let old = load_settings(&state);
481. let mut settings = settings;
482. settings.glass_tint = settings.glass_tint.min(100);
483. let mut shortcut_error = None;
484. if settings.shortcut != old.shortcut {
485. if let Err(err) = windows::set_shortcut(&app, &old.shortcut, &settings.shortcut) {
486. shortcut_error = Some(err);
487. settings.shortcut = old.shortcut.clone();
488. }
489. }
490. state.db().set_setting(SETTINGS_KEY, &settings).map_err(e)?;
491. windows::apply_theme(&app, &settings.theme);
492. if settings.material != old.material {
493. windows::apply_material(&app, &settings.material);
494. }
495. windows::refresh_tray_spend(&app);
496. let _ = app.emit("settings-changed", &settings);
497. Ok(SaveSettingsResult { settings, shortcut_error })
498. }
500. // ---- attachments ----------------------------------------------------------
502. fn ingest(state: &AppState, filename: &str, bytes: &[u8]) -> R<AttachmentMeta> {
503. let filename = Path::new(filename).file_name().and_then(|n| n.to_str()).unwrap_or("file").to_string();
504. if attachments::is_image_name(&filename) {
505. let img = attachments::process_image(&filename, bytes).map_err(e)?;
506. let path = attachments::store(&state.attachments_dir(), &img).map_err(e)?;
507. let path = path.to_string_lossy().to_string();
508. state
509. .db()
510. .insert_attachment(&NewAttachment {
511. kind: "image",
512. filename: &filename,
513. mime: img.mime,
514. byte_size: img.bytes.len() as i64,
515. sha256: &img.sha256,
516. width: Some(img.width),
517. height: Some(img.height),
518. path: Some(&path),
519. text_content: None,
520. })
521. .map_err(e)
522. } else {
523. let text = attachments::read_text(&filename, bytes).map_err(e)?;
524. state
525. .db()
526. .insert_attachment(&NewAttachment {
527. kind: "text",
528. filename: &filename,
529. mime: "text/plain",
530. byte_size: bytes.len() as i64,
531. sha256: &attachments::sha256_hex(bytes),
532. width: None,
533. height: None,
534. path: None,
535. text_content: Some(&text),
536. })
537. .map_err(e)
538. }
539. }
541. /// The native file picker, opened from Rust so no path ever comes from the page.
542. #[tauri::command]
543. pub async fn pick_attachments(app: AppHandle, images_allowed: bool) -> R<Vec<AttachmentMeta>> {
544. use tauri_plugin_dialog::DialogExt;
545. let state = app.state::<AppState>();
546. *lock(&state.dialog_open) = true;
547. let mut exts = vec![
548. "txt", "md", "markdown", "csv", "json", "yaml", "yml", "toml", "log", "py", "rs", "ts", "tsx", "js", "sh",
549. "sql", "html", "css",
550. ];
551. if images_allowed {
552. exts.extend(attachments::IMAGE_EXTENSIONS);
553. }
554. let dialog = app.dialog().file().add_filter(if images_allowed { "Images and text" } else { "Text" }, &exts);
555. let picked = tauri::async_runtime::spawn_blocking(move || dialog.blocking_pick_files()).await;
556. // Cleared before the `?`, or a failed pick would leave it set and the quick
557. // window would never hide on blur again.
558. *lock(&state.dialog_open) = false;
559. let picked = picked.map_err(e)?;
560. let mut out = Vec::new();
561. for f in picked.unwrap_or_default() {
562. let path: PathBuf = f.into_path().map_err(e)?;
563. let bytes = std::fs::read(&path).map_err(e)?;
564. out.push(ingest(&state, &path.to_string_lossy(), &bytes)?);
565. }
566. Ok(out)
567. }
569. /// Pasted or dropped files arrive as a raw body with the name in a header.
570. #[tauri::command]
571. pub fn attach_bytes(state: State<'_, AppState>, request: Request<'_>) -> R<AttachmentMeta> {
572. let InvokeBody::Raw(bytes) = request.body() else {
573. return Err("expected raw bytes".into());
574. };
575. let name = request
576. .headers()
577. .get("x-filename")
578. .and_then(|v| v.to_str().ok())
579. .map(percent_decode)
580. .unwrap_or_else(|| "pasted.png".into());
581. ingest(&state, &name, bytes)
582. }
584. fn percent_decode(s: &str) -> String {
585. let bytes = s.as_bytes();
586. let mut out = Vec::with_capacity(bytes.len());
587. let mut i = 0;
588. while i < bytes.len() {
589. if bytes[i] == b'%' && i + 2 < bytes.len() {
590. if let Ok(v) = u8::from_str_radix(&s[i + 1..i + 3], 16) {
591. out.push(v);
592. i += 3;
593. continue;
594. }
595. }
596. out.push(bytes[i]);
597. i += 1;
598. }
599. String::from_utf8_lossy(&out).into_owned()
600. }
602. /// An attachment's bytes, for previews (a Blob URL on the page).
603. #[tauri::command]
604. pub fn attachment_bytes(state: State<'_, AppState>, id: String) -> R<Response> {
605. let a = state.db().attachment(&id).map_err(e)?;
606. let bytes = match (&a.path, &a.text_content) {
607. (Some(p), _) => std::fs::read(p).map_err(e)?,
608. (None, Some(t)) => t.as_bytes().to_vec(),
609. _ => vec![],
610. };
611. Ok(Response::new(bytes))
612. }
614. #[tauri::command]
615. pub fn discard_attachment(state: State<'_, AppState>, id: String) -> R<()> {
616. let path = state.db().delete_draft_attachment(&id).map_err(e)?;
617. if let Some(p) = path {
618. remove_unused_files(&state, &[p]);
619. }
620. Ok(())
621. }
623. // ---- export ---------------------------------------------------------------
625. #[tauri::command]
626. pub async fn choose_vault_folder(app: AppHandle) -> R<Option<String>> {
627. use tauri_plugin_dialog::DialogExt;
628. let state = app.state::<AppState>();
629. let dialog = app.dialog().file().set_title("Choose the folder chats are exported to");
630. let picked = tauri::async_runtime::spawn_blocking(move || dialog.blocking_pick_folder()).await.map_err(e)?;
631. let Some(dir) = picked else { return Ok(None) };
632. let dir = dir.into_path().map_err(e)?.to_string_lossy().to_string();
633. let mut s = load_settings(&state);
634. s.vault_dir = Some(dir.clone());
635. state.db().set_setting(SETTINGS_KEY, &s).map_err(e)?;
636. Ok(Some(dir))
637. }
639. fn unique_path(dir: &Path, filename: &str) -> PathBuf {
640. let path = dir.join(filename);
641. if !path.exists() {
642. return path;
643. }
644. let (stem, ext) = filename.rsplit_once('.').unwrap_or((filename, "md"));
645. (2..).map(|n| dir.join(format!("{stem} {n}.{ext}"))).find(|p| !p.exists()).unwrap()
646. }
648. #[tauri::command]
649. pub async fn export_conversation(app: AppHandle, id: String) -> R<ExportResult> {
650. let state = app.state::<AppState>();
651. let mut dir = load_settings(&state).vault_dir;
652. if dir.is_none() {
653. dir = choose_vault_folder(app.clone()).await?;
654. }
655. let Some(dir) = dir else { return Err("No export folder chosen.".into()) };
656. let dir = PathBuf::from(dir);
657. let settings = load_settings(&state);
658. let (conv, messages, paths) = {
659. let db = state.db();
660. let conv = db.get_conversation(&id).map_err(e)?;
661. let messages = db.list_messages(&id).map_err(e)?;
662. let mut paths = std::collections::HashMap::new();
663. for m in &messages {
664. for a in db.attachment_data_for(&m.id).map_err(e)? {
665. if let Some(p) = a.path {
666. paths.insert(a.meta.id.clone(), p);
667. }
668. }
669. }
670. (conv, messages, paths)
671. };
672. let links = if settings.image_links == "markdown" { ImageLinks::Markdown } else { ImageLinks::Wiki };
673. let doc = to_markdown(&conv, &messages, &|aid| paths.get(aid).cloned(), links, &chrono::Local::now().timezone());
674. std::fs::create_dir_all(&dir).map_err(e)?;
675. let note = unique_path(&dir, &doc.filename);
676. let mut copied = 0;
677. for f in &doc.files {
678. let target = dir.join(&f.relative_path);
679. if let Some(parent) = target.parent() {
680. std::fs::create_dir_all(parent).map_err(e)?;
681. }
682. if !target.exists() {
683. std::fs::copy(&f.source_path, &target).map_err(e)?;
684. copied += 1;
685. }
686. }
687. // Write beside it, then rename: a vault watcher (or Obsidian) never sees
688. // a half-written note, because the rename is atomic.
689. let tmp = dir.join(format!(".{}.cortex-tmp", note.file_name().and_then(|n| n.to_str()).unwrap_or("note.md")));
690. std::fs::write(&tmp, doc.markdown).map_err(e)?;
691. std::fs::rename(&tmp, &note).map_err(|err| {
692. let _ = std::fs::remove_file(&tmp);
693. err.to_string()
694. })?;
695. Ok(ExportResult { path: note.to_string_lossy().to_string(), files_copied: copied })
696. }
698. #[cfg(test)]
699. mod tests {
700. use super::*;
702. #[test]
703. fn decodes_filenames() {
704. assert_eq!(percent_decode("caf%C3%A9%20menu.png"), "caf\u{e9} menu.png");
705. assert_eq!(percent_decode("100%"), "100%");
706. assert_eq!(percent_decode("a%2"), "a%2");
707. }
709. #[test]
710. fn unique_names() {
711. let d = std::env::temp_dir().join(format!("cortex-u-{}", std::process::id()));
712. std::fs::create_dir_all(&d).unwrap();
713. std::fs::write(d.join("Chat.md"), "").unwrap();
714. assert_eq!(unique_path(&d, "Chat.md").file_name().unwrap(), "Chat 2.md");
715. std::fs::remove_dir_all(&d).unwrap();
716. }
717. }