248 lines
9.4 KiB
Rust
248 lines
9.4 KiB
Rust
//! Reconcile externally edited files against committed snapshots, never against UI read caches.
|
|
use crate::workspace::{hash, HostError, Result, Workspace};
|
|
use rusqlite::{params, OptionalExtension};
|
|
use std::{collections::HashSet, fs, io::Read, path::Path};
|
|
use uuid::Uuid;
|
|
/// File transport only. Logical records receive their own versioned whitelist separately.
|
|
pub fn allowed(path: &str) -> bool {
|
|
let parts: Vec<_> = path.split('/').collect();
|
|
if parts.iter().any(|part| {
|
|
part.starts_with('.')
|
|
|| matches!(
|
|
part.to_ascii_lowercase().as_str(),
|
|
"node_modules" | "target" | "__pycache__" | "cache" | "logs" | "models"
|
|
)
|
|
}) {
|
|
return false;
|
|
}
|
|
let extension = Path::new(path)
|
|
.extension()
|
|
.and_then(|v| v.to_str())
|
|
.unwrap_or("")
|
|
.to_ascii_lowercase();
|
|
extension == "md"
|
|
|| (parts
|
|
.first()
|
|
.is_some_and(|v| v.eq_ignore_ascii_case("attachments"))
|
|
&& matches!(
|
|
extension.as_str(),
|
|
"png"
|
|
| "jpg"
|
|
| "jpeg"
|
|
| "gif"
|
|
| "webp"
|
|
| "svg"
|
|
| "pdf"
|
|
| "mp3"
|
|
| "wav"
|
|
| "m4a"
|
|
| "ogg"
|
|
| "flac"
|
|
| "mp4"
|
|
| "webm"
|
|
| "mov"
|
|
| "txt"
|
|
| "csv"
|
|
| "docx"
|
|
| "xlsx"
|
|
| "pptx"
|
|
| "bin"
|
|
))
|
|
}
|
|
impl Workspace {
|
|
pub(crate) fn sync_paths(&self) -> Result<Vec<String>> {
|
|
fn walk(ws: &Workspace, directory: &Path, paths: &mut Vec<String>) -> Result<()> {
|
|
for item in fs::read_dir(directory)? {
|
|
let item = item?;
|
|
let name = item.file_name().to_string_lossy().into_owned();
|
|
if name.starts_with('.')
|
|
|| matches!(
|
|
name.to_ascii_lowercase().as_str(),
|
|
"node_modules" | "target" | "__pycache__" | "cache" | "logs" | "models"
|
|
)
|
|
{
|
|
continue;
|
|
}
|
|
let path = item
|
|
.path()
|
|
.strip_prefix(&ws.root)
|
|
.map_err(|_| HostError::new("UNSAFE_PATH"))?
|
|
.to_string_lossy()
|
|
.replace('\\', "/");
|
|
let resolved = ws.resolve(&path)?;
|
|
if item.file_type()?.is_dir() {
|
|
walk(ws, &resolved, paths)?;
|
|
} else if allowed(&path) && item.file_type()?.is_file() {
|
|
paths.push(path);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
let mut paths = Vec::new();
|
|
walk(self, &self.root, &mut paths)?;
|
|
paths.sort();
|
|
Ok(paths)
|
|
}
|
|
pub fn sync_discover(&mut self, binding: &str) -> Result<usize> {
|
|
self.check_binding(binding)?;
|
|
let paths = self.sync_paths()?;
|
|
let mut seen = HashSet::new();
|
|
let mut changes = 0;
|
|
for path in paths {
|
|
let target = self.resolve(&path)?;
|
|
if fs::metadata(&target)?.len() > 104857600 {
|
|
return Err(HostError::new("FILE_TOO_LARGE"));
|
|
}
|
|
let mut bytes = Vec::new();
|
|
fs::File::open(&target)?
|
|
.take(104857601)
|
|
.read_to_end(&mut bytes)?;
|
|
if bytes.len() > 104857600 {
|
|
return Err(HostError::new("FILE_TOO_LARGE"));
|
|
}
|
|
let digest = hash(&bytes);
|
|
let previous = self.entry(&path)?;
|
|
let observed: Option<(String, String, bool)> = if let Some(entry) = &previous {
|
|
self.db
|
|
.query_row(
|
|
"SELECT path,hash,deleted FROM sync_observed WHERE file_id=?1",
|
|
[&entry.file_id],
|
|
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
|
|
)
|
|
.optional()?
|
|
} else {
|
|
None
|
|
};
|
|
if let Some(entry) = &previous {
|
|
seen.insert(entry.file_id.clone());
|
|
}
|
|
if observed
|
|
.as_ref()
|
|
.is_some_and(|v| v == &(path.clone(), digest.clone(), false))
|
|
{
|
|
continue;
|
|
}
|
|
// Confirm the snapshot without writing back over an external editor.
|
|
crate::payloads::verify(&target, &digest, bytes.len() as u64)?;
|
|
let operation = Uuid::new_v4().to_string();
|
|
self.store_payload(&operation, &bytes)?;
|
|
let file_id = previous.map_or_else(|| Uuid::new_v4().to_string(), |e| e.file_id);
|
|
let tx = self.db.transaction()?;
|
|
tx.execute("INSERT INTO files VALUES (?1,?2,?3,1,0) ON CONFLICT(path) DO UPDATE SET hash=excluded.hash,revision=files.revision+1,deleted=0",params![file_id,path,digest])?;
|
|
tx.execute("INSERT INTO outbox SELECT ?1,id,revision,path,hash,'put',X'','pending' FROM files WHERE id=?2",params![operation,file_id])?;
|
|
tx.execute("INSERT INTO sync_observed VALUES (?1,?2,?3,0) ON CONFLICT(file_id) DO UPDATE SET path=excluded.path,hash=excluded.hash,deleted=0",params![file_id,path,digest])?;
|
|
tx.commit()?;
|
|
seen.insert(file_id);
|
|
changes += 1;
|
|
}
|
|
let previous = {
|
|
let mut statement = self
|
|
.db
|
|
.prepare("SELECT file_id,path FROM sync_observed WHERE deleted=0")?;
|
|
let rows = statement
|
|
.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))?
|
|
.collect::<std::result::Result<Vec<_>, _>>()?;
|
|
rows
|
|
};
|
|
for (file_id, path) in previous {
|
|
if seen.contains(&file_id) || !allowed(&path) || self.resolve(&path)?.exists() {
|
|
continue;
|
|
}
|
|
let operation = Uuid::new_v4().to_string();
|
|
let tx = self.db.transaction()?;
|
|
tx.execute(
|
|
"UPDATE files SET deleted=1,revision=revision+1 WHERE id=?1",
|
|
[&file_id],
|
|
)?;
|
|
tx.execute("INSERT INTO outbox SELECT ?1,id,revision,path,'','delete',X'','pending' FROM files WHERE id=?2",params![operation,file_id])?;
|
|
tx.execute(
|
|
"UPDATE sync_observed SET deleted=1 WHERE file_id=?1",
|
|
[&file_id],
|
|
)?;
|
|
tx.commit()?;
|
|
changes += 1;
|
|
}
|
|
Ok(changes)
|
|
}
|
|
}
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn external_edits_after_ui_reads_are_queued_once_and_deletions_survive_restart() {
|
|
let root = tempfile::tempdir().unwrap();
|
|
let mut ws = Workspace::open(root.path()).unwrap();
|
|
let binding = ws
|
|
.sync_bind_empty("https://sync.example", "remote", "account")
|
|
.unwrap();
|
|
fs::write(root.path().join("a.md"), b"one").unwrap();
|
|
ws.read("a.md").unwrap();
|
|
ws.scan().unwrap();
|
|
assert_eq!(ws.sync_discover(&binding.id).unwrap(), 1);
|
|
assert_eq!(ws.sync_discover(&binding.id).unwrap(), 0);
|
|
fs::write(root.path().join("a.md"), b"two").unwrap();
|
|
ws.read("a.md").unwrap();
|
|
assert_eq!(ws.sync_discover(&binding.id).unwrap(), 1);
|
|
fs::remove_file(root.path().join("a.md")).unwrap();
|
|
drop(ws);
|
|
let mut ws = Workspace::open(root.path()).unwrap();
|
|
assert_eq!(ws.sync_discover(&binding.id).unwrap(), 1);
|
|
assert_eq!(ws.sync_discover(&binding.id).unwrap(), 0);
|
|
assert_eq!(ws.pending_count().unwrap(), 3);
|
|
let inline: i64 = ws
|
|
.db
|
|
.query_row(
|
|
"SELECT COALESCE(SUM(length(content)),0) FROM outbox",
|
|
[],
|
|
|r| r.get(0),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(inline, 0);
|
|
}
|
|
#[test]
|
|
fn file_classification_excludes_credentials_caches_and_executable_packages() {
|
|
for path in [
|
|
".env",
|
|
".ainote/credentials.md",
|
|
".git/readme.md",
|
|
"models/model.md",
|
|
"logs/trace.md",
|
|
"node_modules/package/readme.md",
|
|
"attachments/tool.exe",
|
|
"attachments/plugin.zip",
|
|
"settings.json",
|
|
] {
|
|
assert!(!allowed(path), "{path}");
|
|
}
|
|
for path in [
|
|
"notes/a.md",
|
|
"attachments/movie.mp4",
|
|
"attachments/image.png",
|
|
"attachments/fixture.bin",
|
|
] {
|
|
assert!(allowed(path), "{path}");
|
|
}
|
|
}
|
|
#[test]
|
|
fn prohibited_workspace_outbox_is_retained_but_never_sent() {
|
|
let root = tempfile::tempdir().unwrap();
|
|
let mut ws = Workspace::open(root.path()).unwrap();
|
|
ws.write("provider-settings.json", "", b"fixture-secret", "local")
|
|
.unwrap();
|
|
let binding = ws
|
|
.sync_bind_empty("https://sync.example", "remote", "account")
|
|
.unwrap();
|
|
assert!(ws.sync_next(&binding.id).unwrap().is_none());
|
|
assert_eq!(ws.pending_count().unwrap(), 0);
|
|
assert_eq!(
|
|
ws.read("provider-settings.json").unwrap().content,
|
|
"fixture-secret"
|
|
);
|
|
let state: String = ws
|
|
.db
|
|
.query_row("SELECT state FROM outbox", [], |r| r.get(0))
|
|
.unwrap();
|
|
assert_eq!(state, "excluded");
|
|
}
|
|
}
|