ExbytePublicServices/exbyte-depot-viewer-perforce
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 19 Wiki Activity
Files
fdaf126c00ac388451425f25a31bbb8884f0d720
exbyte-depot-viewer-perforce/src-tauri/src/lib.rs
Bonchellon fdaf126c00 Integrate / Merge / Copy between branches 
- Tools -> Integrate / Merge / Copy: pick op + source/target paths, runs into a
  new pending changelist; resolve (if needed) via the Resolve UI and submit
- Backend p4 merge/copy/integrate -c

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-08 11:53:12 +03:00

2137 lines
80 KiB
Rust
Raw Blame History

// Exbyte Depot — Perforce client backend.
// Thin wrappers around the `p4` CLI that return JSON (`-Mj`) to the frontend.
use serde_json::Value;
use std::io::{BufRead, BufReader, Write};
use std::process::{Command, Stdio};
use std::sync::{Mutex, OnceLock};
use std::time::{Duration, Instant};
use tauri::{AppHandle, Emitter, Manager, State};
/// App handle stashed at startup so the low-level p4 helpers can emit a live
/// command log to the frontend (a Perforce-style "Log" panel).
static APP: OnceLock<AppHandle> = OnceLock::new();
/// Emit one p4-log entry to the UI: the command line, how many items/lines it
/// returned, whether it succeeded, and any error text.
fn log_p4(args: &[&str], count: i64, ok: bool, err: Option<&str>) {
if let Some(app) = APP.get() {
let _ = app.emit(
"p4-log",
serde_json::json!({
"cmd": format!("p4 {}", args.join(" ")),
"count": count,
"ok": ok,
"err": err,
}),
);
}
}
#[derive(Default, Clone)]
struct Conn {
port: String,
user: String,
client: String,
root: String, // local client root (populated after login/restore/switch)
}
#[derive(Default)]
struct AppState(Mutex<Conn>);
/// Decode p4 output bytes: strict UTF-8 first, else the Windows ANSI codepage
/// (cp1251 on Russian systems) so Cyrillic file paths survive round-trips
/// instead of turning into U+FFFD and breaking later revert/submit calls.
fn decode(bytes: &[u8]) -> String {
match std::str::from_utf8(bytes) {
Ok(s) => s.to_string(),
Err(_) => encoding_rs::WINDOWS_1251.decode(bytes).0.into_owned(),
}
}
/// Preview/transfer size limit: reads above this are rejected instead of
/// buffering a multi-GB .pak/.uasset in memory and shipping it over IPC.
const MAX_READ_BYTES: u64 = 64 * 1024 * 1024;
fn check_local_size(path: &str) -> Result<(), String> {
if let Ok(m) = std::fs::metadata(path) {
if m.len() > MAX_READ_BYTES {
return Err(format!(
"File is too large to preview ({} MB, limit {} MB)",
m.len() / (1024 * 1024),
MAX_READ_BYTES / (1024 * 1024)
));
}
}
Ok(())
}
/// Reject local paths outside the client root (workspace confinement for
/// filesystem-touching IPC commands).
fn ensure_under_root(conn: &Conn, path: &str) -> Result<(), String> {
if conn.root.is_empty() {
return Err("No workspace root known for this connection".into());
}
let canon_root = std::fs::canonicalize(&conn.root)
.map_err(|e| format!("Workspace root not accessible: {e}"))?;
let canon = std::fs::canonicalize(path).map_err(|e| format!("File not found: {e}"))?;
if !canon.starts_with(&canon_root) {
return Err("Path is outside the workspace".into());
}
Ok(())
}
/// Build a `p4` command with the connection's global flags applied.
/// On Windows we set CREATE_NO_WINDOW so no console flashes on every call.
/// stdin defaults to null so a command that unexpectedly prompts (expired
/// ticket, interactive subcommand) errors out instead of hanging forever;
/// commands that feed stdin (login, change -i) override it with piped().
fn p4_cmd(conn: &Conn, tagged: bool) -> Command {
let mut c = Command::new("p4");
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
c.creation_flags(0x0800_0000); // CREATE_NO_WINDOW
}
c.stdin(Stdio::null());
if !conn.port.is_empty() {
c.args(["-p", &conn.port]);
}
if !conn.user.is_empty() {
c.args(["-u", &conn.user]);
}
if !conn.client.is_empty() {
c.args(["-c", &conn.client]);
}
if tagged {
c.arg("-ztag").arg("-Mj"); // tagged, JSON-marshalled fields (one object per line)
}
c
}
/// Run a tagged (JSON) p4 command and collect the objects it prints.
fn run_json(conn: &Conn, args: &[&str]) -> Result<Vec<Value>, String> {
let out = match p4_cmd(conn, true).args(args).output() {
Ok(o) => o,
Err(e) => {
let m = format!("Failed to start p4: {e}");
log_p4(args, 0, false, Some(&m));
return Err(m);
}
};
let text = decode(&out.stdout);
let mut items = Vec::new();
for line in text.lines() {
let t = line.trim();
if t.is_empty() {
continue;
}
let v: Value = match serde_json::from_str(t) {
Ok(v) => v,
Err(_) => continue,
};
// real error: code=="error" or severity >= 3 (E_FAILED / E_FATAL)
let is_error = v.get("code").and_then(|c| c.as_str()) == Some("error")
|| v.get("severity").and_then(|s| s.as_i64()).map_or(false, |s| s >= 3);
if is_error {
let msg = v
.get("data")
.and_then(|d| d.as_str())
.unwrap_or("unknown p4 error")
.trim()
.to_string();
log_p4(args, 0, false, Some(&msg));
return Err(msg);
}
// informational message (e.g. "File(s) not opened."), not a data record — skip
let is_message = v.get("data").is_some()
&& (v.get("generic").is_some() || v.get("severity").is_some() || v.get("level").is_some());
if is_message {
continue;
}
items.push(v);
}
if items.is_empty() && !out.status.success() {
let e = decode(&out.stderr).trim().to_string();
if !e.is_empty() {
log_p4(args, 0, false, Some(&e));
return Err(e);
}
}
log_p4(args, items.len() as i64, true, None);
Ok(items)
}
/// Trust the SSL fingerprint on FIRST connect only (no `-f`): if the server's
/// fingerprint later CHANGES — the signature of a MITM/substituted server —
/// p4 refuses and we surface that instead of silently re-trusting and then
/// sending the user's password to the impostor.
fn trust(port: &str) -> Result<(), String> {
let mut c = Command::new("p4");
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
c.creation_flags(0x0800_0000);
}
c.stdin(Stdio::null());
let out = match c.args(["-p", port, "trust", "-y"]).output() {
Ok(o) => o,
Err(_) => return Ok(()), // p4 missing → the next real command reports it properly
};
if !out.status.success() {
let e = decode(&out.stderr);
let el = e.to_lowercase();
// only a fingerprint MISMATCH is fatal; "not an SSL connection" etc. is fine
if el.contains("has changed") || el.contains("mismatch") {
return Err(format!(
"SECURITY: the server's SSL fingerprint has CHANGED — possible man-in-the-middle. \
Verify the server before connecting.\n{}",
e.trim()
));
}
}
Ok(())
}
/// List workspaces (clients) for a user — used to populate the connect screen.
#[tauri::command]
async fn p4_clients(port: String, user: String) -> Result<Vec<Value>, String> {
trust(&port)?;
let conn = Conn {
port,
user: user.clone(),
..Default::default()
};
run_json(&conn, &["clients", "-u", &user])
}
/// Authenticate. Runs `p4 login` feeding the password on stdin, then stores
/// the connection and returns `p4 info`.
#[tauri::command]
async fn p4_login(
state: State<'_, AppState>,
port: String,
user: String,
password: String,
client: String,
) -> Result<Value, String> {
trust(&port)?;
let mut conn = Conn {
port: port.clone(),
user: user.clone(),
client: client.clone(),
..Default::default()
};
let mut child = p4_cmd(&conn, false)
.arg("login")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| format!("Failed to start p4: {e}"))?;
if let Some(si) = child.stdin.as_mut() {
si.write_all(format!("{password}\n").as_bytes())
.map_err(|e| e.to_string())?;
}
let out = child.wait_with_output().map_err(|e| e.to_string())?;
if !out.status.success() {
let err = decode(&out.stderr);
let err = if err.trim().is_empty() {
decode(&out.stdout).trim().to_string()
} else {
err.trim().to_string()
};
return Err(if err.is_empty() {
"Login failed (wrong user or password)".into()
} else {
err
});
}
let info = run_json(&conn, &["info"])?;
let info = info.into_iter().next().unwrap_or(Value::Null);
conn.root = info.get("clientRoot").and_then(|r| r.as_str()).unwrap_or("").to_string();
*state.0.lock().unwrap_or_else(|e| e.into_inner()) = conn;
Ok(info)
}
/// Restore a saved session using the on-disk p4 ticket (no password).
/// Fails if the ticket has expired — the UI then falls back to the login form.
#[tauri::command]
async fn p4_restore(
state: State<'_, AppState>,
port: String,
user: String,
client: String,
) -> Result<Value, String> {
trust(&port)?;
let mut conn = Conn { port, user, client, ..Default::default() };
// `p4 login -s` reports ticket status; errors if not authenticated.
run_json(&conn, &["login", "-s"])?;
let info = run_json(&conn, &["info"])?;
let info = info.into_iter().next().unwrap_or(Value::Null);
conn.root = info.get("clientRoot").and_then(|r| r.as_str()).unwrap_or("").to_string();
*state.0.lock().unwrap_or_else(|e| e.into_inner()) = conn;
Ok(info)
}
fn current(state: &State<AppState>) -> Result<Conn, String> {
let c = state.0.lock().unwrap_or_else(|e| e.into_inner()).clone();
if c.port.is_empty() {
return Err("No active connection".into());
}
Ok(c)
}
#[tauri::command]
async fn p4_info(state: State<'_, AppState>) -> Result<Value, String> {
let conn = current(&state)?;
let info = run_json(&conn, &["info"])?;
Ok(info.into_iter().next().unwrap_or(Value::Null))
}
/// Build a `path/...` spec from a scope depot folder (empty = whole workspace).
fn scope_spec(scope: &str) -> String {
if scope.is_empty() {
"//...".to_string()
} else {
format!("{}/...", scope.trim_end_matches(['/', '\\']))
}
}
/// Files currently open, optionally scoped to a depot folder.
#[tauri::command]
async fn p4_opened(state: State<'_, AppState>, scope: String) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
if scope.is_empty() {
run_json(&conn, &["opened"])
} else {
run_json(&conn, &["opened", &scope_spec(&scope)])
}
}
/// List sub-directories of a depot path (for the working-folder picker).
#[tauri::command]
async fn p4_dirs(state: State<'_, AppState>, path: String) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
let spec = if path.is_empty() {
"//*".to_string()
} else {
format!("{}/*", path.trim_end_matches(['/', '\\']))
};
run_json(&conn, &["dirs", &spec])
}
/// Pending changelists for the current user that actually contain files.
/// Empty pending changelists (leftovers from a reverted/aborted commit) are
/// cleaned up so they never show a phantom "ready to Submit" or fail submit.
#[tauri::command]
async fn p4_changes(state: State<'_, AppState>) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
let changes = run_json(
&conn,
&["changes", "-s", "pending", "-u", &conn.user, "-c", &conn.client],
)?;
// which pending changelists hold at least one opened file?
let opened = run_json(&conn, &["opened"]).unwrap_or_default();
let mut with_files = std::collections::HashSet::new();
for o in &opened {
if let Some(ch) = o.get("change").and_then(|c| c.as_str()) {
with_files.insert(ch.to_string());
}
}
let mut result = Vec::new();
for c in changes {
let num = c
.get("change")
.and_then(|c| c.as_str())
.unwrap_or("")
.to_string();
if num.is_empty() {
continue;
}
if with_files.contains(&num) {
result.push(c);
} else {
// no opened files — but NEVER delete a changelist that holds shelved
// files: it looks "empty" here yet carries real work
let shelved = run_json(&conn, &["describe", "-s", "-S", &num])
.ok()
.and_then(|v| v.into_iter().next())
.map_or(false, |d| d.get("depotFile0").is_some());
if shelved {
result.push(c);
} else {
let _ = run_text(&conn, &["change", "-d", &num]);
}
}
}
Ok(result)
}
/// Submitted history for a depot path (History tab).
#[tauri::command]
async fn p4_history(state: State<'_, AppState>, path: String) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
let spec = if path.is_empty() { "//...".to_string() } else { path };
run_json(&conn, &["changes", "-s", "submitted", "-m", "50", &spec])
}
#[tauri::command]
async fn p4_disconnect(state: State<'_, AppState>) -> Result<(), String> {
*state.0.lock().unwrap_or_else(|e| e.into_inner()) = Conn::default();
Ok(())
}
/// Run a non-tagged p4 command (raw text out). Errors carry stderr.
fn run_text(conn: &Conn, args: &[&str]) -> Result<String, String> {
let out = match p4_cmd(conn, false).args(args).output() {
Ok(o) => o,
Err(e) => {
let m = format!("Failed to start p4: {e}");
log_p4(args, 0, false, Some(&m));
return Err(m);
}
};
let stdout = decode(&out.stdout).trim().to_string();
let stderr = decode(&out.stderr).trim().to_string();
if !out.status.success() && !stderr.is_empty() {
log_p4(args, 0, false, Some(&stderr));
return Err(stderr);
}
log_p4(args, stdout.lines().count() as i64, true, None);
Ok(if stdout.is_empty() { stderr } else { stdout })
}
/// Pull a short file name out of a p4 sync/submit progress line, e.g.
/// "//depot/Proj/Foo.uasset#3 - added as C:\..." -> "Foo.uasset".
fn progress_file(line: &str) -> String {
let head = line.split(" - ").next().unwrap_or(line);
let head = head.split('#').next().unwrap_or(head);
head.rsplit(['/', '\\']).next().unwrap_or(head).trim().to_string()
}
/// Run a p4 command streaming its stdout line-by-line, emitting a `p4-transfer`
/// event as files move so the UI can show a live P4V-style progress dialog.
/// `op` labels the operation ("sync" | "submit"). Returns the full stdout.
fn run_stream(conn: &Conn, args: &[&str], op: &str) -> Result<String, String> {
let mut child = match p4_cmd(conn, false)
.args(args)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
{
Ok(c) => c,
Err(e) => {
let m = format!("Failed to start p4: {e}");
log_p4(args, 0, false, Some(&m));
return Err(m);
}
};
let mut collected = String::new();
let mut count: i64 = 0;
let mut last = Instant::now();
if let Some(out) = child.stdout.take() {
for line in BufReader::new(out).lines().map_while(Result::ok) {
count += 1;
// throttle to ~25 fps regardless of file count, but always send the first few
if count <= 5 || last.elapsed().as_millis() >= 40 {
if let Some(app) = APP.get() {
let _ = app.emit(
"p4-transfer",
serde_json::json!({ "op": op, "count": count, "file": progress_file(&line), "done": false }),
);
}
last = Instant::now();
}
collected.push_str(&line);
collected.push('\n');
}
}
let status = child.wait().map_err(|e| e.to_string())?;
let stderr = child
.stderr
.take()
.map(|mut s| {
let mut buf = String::new();
let _ = std::io::Read::read_to_string(&mut s, &mut buf);
buf.trim().to_string()
})
.unwrap_or_default();
// tell the UI the transfer is finished
if let Some(app) = APP.get() {
let _ = app.emit(
"p4-transfer",
serde_json::json!({ "op": op, "count": count, "done": true }),
);
}
if !status.success() && !stderr.is_empty() {
log_p4(args, 0, false, Some(&stderr));
return Err(stderr);
}
log_p4(args, count, true, None);
Ok(collected.trim().to_string())
}
/// Get Latest — sync to head, optionally scoped to a depot folder.
#[tauri::command]
async fn p4_sync(state: State<'_, AppState>, scope: String) -> Result<String, String> {
let conn = current(&state)?;
let msg = run_stream(&conn, &["sync", &scope_spec(&scope)], "sync")?;
Ok(if msg.is_empty() { "Already up to date — nothing to sync.".into() } else { msg })
}
/// List labels on the server (most-recently-updated first).
#[tauri::command]
async fn p4_labels(state: State<'_, AppState>) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
run_json(&conn, &["labels", "-m", "300"])
}
/// Tag revisions with a label (auto-creates the label if new). `rev` optional:
/// a changelist, another label, or a date; empty = head. Scope confines it.
#[tauri::command]
async fn p4_label_tag(state: State<'_, AppState>, label: String, scope: String, rev: String) -> Result<String, String> {
let conn = current(&state)?;
let label = label.trim();
if label.is_empty() {
return Err("No label name".into());
}
let mut spec = scope_spec(&scope);
let rev = rev.trim().trim_start_matches(['@', '#']);
if !rev.is_empty() {
spec = format!("{spec}@{rev}");
}
run_text(&conn, &["tag", "-l", label, &spec])
}
/// Sync the workspace to an exact revision: a changelist number, a label name,
/// or a date (`YYYY/MM/DD`). `rev` is appended to the scope spec as `@rev`.
#[tauri::command]
async fn p4_sync_to(state: State<'_, AppState>, scope: String, rev: String) -> Result<String, String> {
let conn = current(&state)?;
let rev = rev.trim();
if rev.is_empty() {
return Err("No revision specified".into());
}
// strip a leading @ or # if the user typed one
let rev = rev.trim_start_matches(['@', '#']);
let spec = format!("{}@{}", scope_spec(&scope), rev);
let msg = run_stream(&conn, &["sync", &spec], "sync")?;
Ok(if msg.is_empty() { "Already at that revision — nothing to sync.".into() } else { msg })
}
/// Unified diff of an opened file vs. the have revision.
#[tauri::command]
async fn p4_diff(state: State<'_, AppState>, file: String) -> Result<String, String> {
let conn = current(&state)?;
run_text(&conn, &["diff", "-du", &file])
}
/// Revert the given depot files (discard local edits).
#[tauri::command]
async fn p4_revert(state: State<'_, AppState>, files: Vec<String>) -> Result<String, String> {
let conn = current(&state)?;
let mut args: Vec<&str> = vec!["revert"];
for f in &files {
args.push(f.as_str());
}
run_text(&conn, &args)
}
/// Create an empty numbered changelist with a description; returns its number.
/// (`p4 submit` accepts only one file arg, so partial submits go through a
/// numbered changelist: create → reopen selected files into it → submit -c.)
fn create_changelist(conn: &Conn, desc: &str) -> Result<String, String> {
let body = desc.trim().replace('\n', "\n\t");
let spec = format!("Change:\tnew\nStatus:\tnew\nDescription:\n\t{body}\n");
let mut child = p4_cmd(conn, false)
.args(["change", "-i"])
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| format!("Failed to start p4: {e}"))?;
if let Some(si) = child.stdin.as_mut() {
si.write_all(spec.as_bytes()).map_err(|e| e.to_string())?;
}
let out = child.wait_with_output().map_err(|e| e.to_string())?;
if !out.status.success() {
return Err(decode(&out.stderr).trim().to_string());
}
// stdout: "Change 23 created."
let s = decode(&out.stdout);
s.split_whitespace()
.find(|w| w.chars().all(|c| c.is_ascii_digit()) && !w.is_empty())
.map(|n| n.to_string())
.ok_or_else(|| format!("Failed to create changelist: {}", s.trim()))
}
/// "Commit" (local): create a pending numbered changelist with a description and
/// move the selected files into it. Nothing goes to the server yet — this is
/// revertable. Returns the changelist number.
#[tauri::command]
async fn p4_commit(
state: State<'_, AppState>,
description: String,
files: Vec<String>,
) -> Result<String, String> {
let conn = current(&state)?;
if files.is_empty() {
return Err("No files to commit".into());
}
let cl = create_changelist(&conn, &description)?;
let mut reopen: Vec<&str> = vec!["reopen", "-c", &cl];
for f in &files {
reopen.push(f.as_str());
}
run_text(&conn, &reopen)?;
Ok(cl)
}
/// Submit a numbered pending changelist to the server (the "push").
#[tauri::command]
async fn p4_submit_change(state: State<'_, AppState>, change: String) -> Result<String, String> {
let conn = current(&state)?;
run_stream(&conn, &["submit", "-c", &change], "submit")
}
/// "Uncommit": move files back into the default changelist (like `git reset`).
/// The now-empty numbered changelist is cleaned up on the next `p4_changes`.
#[tauri::command]
async fn p4_reopen_default(state: State<'_, AppState>, files: Vec<String>) -> Result<String, String> {
let conn = current(&state)?;
if files.is_empty() {
return Ok(String::new());
}
let mut args: Vec<&str> = vec!["reopen", "-c", "default"];
for f in &files {
args.push(f.as_str());
}
run_text(&conn, &args)
}
/// Edit the description of a pending changelist, preserving its file list.
#[tauri::command]
async fn p4_set_desc(state: State<'_, AppState>, change: String, description: String) -> Result<String, String> {
let conn = current(&state)?;
let spec = run_text(&conn, &["change", "-o", &change])?;
// rebuild the spec, replacing only the Description field's indented body
let mut out = String::new();
let mut lines = spec.lines().peekable();
let mut replaced = false;
while let Some(line) = lines.next() {
if !replaced && line.starts_with("Description:") {
out.push_str("Description:\n");
for dl in description.trim().lines() {
out.push('\t');
out.push_str(dl);
out.push('\n');
}
// consume the old (indented / blank) description body
while let Some(p) = lines.peek() {
if p.starts_with('\t') || p.starts_with(' ') || p.is_empty() {
lines.next();
} else {
break;
}
}
replaced = true;
} else {
out.push_str(line);
out.push('\n');
}
}
let mut child = p4_cmd(&conn, false)
.args(["change", "-i"])
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| format!("Failed to start p4: {e}"))?;
if let Some(si) = child.stdin.as_mut() {
si.write_all(out.as_bytes()).map_err(|e| e.to_string())?;
}
let res = child.wait_with_output().map_err(|e| e.to_string())?;
if !res.status.success() {
return Err(decode(&res.stderr).trim().to_string());
}
Ok(decode(&res.stdout).trim().to_string())
}
/// Submit the selected files with a description.
#[tauri::command]
async fn p4_submit(
state: State<'_, AppState>,
description: String,
files: Vec<String>,
) -> Result<String, String> {
let conn = current(&state)?;
if files.is_empty() {
return Err("No files selected to submit".into());
}
let total = run_json(&conn, &["opened"])?.len();
// all opened files selected → submit the whole default changelist in one go
if files.len() >= total {
return run_stream(&conn, &["submit", "-d", &description], "submit");
}
// partial submit → dedicated numbered changelist
let cl = create_changelist(&conn, &description)?;
let mut reopen: Vec<&str> = vec!["reopen", "-c", &cl];
for f in &files {
reopen.push(f.as_str());
}
run_text(&conn, &reopen)?;
run_stream(&conn, &["submit", "-c", &cl], "submit")
}
/// Run a p4 command over a list of file paths, returning the opened records.
fn files_cmd(conn: &Conn, cmd: &str, files: &[String]) -> Result<Vec<Value>, String> {
let mut args: Vec<&str> = vec![cmd];
for f in files {
args.push(f.as_str());
}
run_json(conn, &args)
}
/// Mark files for add.
#[tauri::command]
async fn p4_add(state: State<'_, AppState>, files: Vec<String>) -> Result<Vec<Value>, String> {
files_cmd(&current(&state)?, "add", &files)
}
/// Open files for edit (check out).
#[tauri::command]
async fn p4_edit(state: State<'_, AppState>, files: Vec<String>) -> Result<Vec<Value>, String> {
files_cmd(&current(&state)?, "edit", &files)
}
/// Mark files for delete.
#[tauri::command]
async fn p4_delete(state: State<'_, AppState>, files: Vec<String>) -> Result<Vec<Value>, String> {
files_cmd(&current(&state)?, "delete", &files)
}
/// Reconcile a path — auto-detect adds/edits/deletes vs. the depot.
/// This is what a drag-drop of files/folders uses.
#[tauri::command]
async fn p4_reconcile(state: State<'_, AppState>, path: String) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
// depot spec (//...) → recurse; local folder → recurse; local file → as-is
let spec = if path.starts_with("//") {
if path.ends_with("...") { path.clone() } else { format!("{}/...", path.trim_end_matches('/')) }
} else if std::path::Path::new(&path).is_dir() {
format!("{}/...", path.trim_end_matches(['/', '\\']))
} else {
path.clone()
};
run_json(&conn, &["reconcile", "-e", "-a", "-d", &spec])
}
/// Scan the working scope for new / changed / deleted files and open them
/// (reconcile). This is what surfaces assets created outside the client —
/// e.g. new .uasset files that Unreal wrote straight to disk but that were
/// never `p4 add`-ed, so they don't yet show up in `p4 opened`.
#[tauri::command]
async fn p4_scan(state: State<'_, AppState>, scope: String) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
run_json(&conn, &["reconcile", "-e", "-a", "-d", &scope_spec(&scope)])
}
/// Undo (roll back) an already-submitted changelist. Perforce (2019.1+) does this
/// with `p4 undo`: it opens the reverting revisions, which we drop into a fresh
/// numbered changelist and submit — so the rollback is itself a new change, exactly
/// like GitHub Desktop's "Revert this commit". Returns the submit output.
#[tauri::command]
async fn p4_undo_change(state: State<'_, AppState>, change: String) -> Result<String, String> {
let conn = current(&state)?;
if change.is_empty() || !change.chars().all(|c| c.is_ascii_digit()) {
return Err(format!("Invalid changelist number: {change}"));
}
let cl = create_changelist(&conn, &format!("Revert change {change}"))?;
let spec = format!("//...@={change}");
// -c keeps the undone files isolated in our changelist (won't touch other open work)
run_text(&conn, &["undo", "-c", &cl, &spec])?;
run_text(&conn, &["submit", "-c", &cl])
}
/// Reveal a depot folder/file (or a raw local path) in the OS file explorer.
/// Depot paths are resolved to the local working copy via `p4 where`.
#[tauri::command]
async fn open_in_explorer(state: State<'_, AppState>, target: String) -> Result<(), String> {
let local = if target.starts_with("//") {
let conn = current(&state)?;
let spec = format!("{}/...", target.trim_end_matches(['/', '.']));
let p = run_json(&conn, &["where", &spec])?
.into_iter()
.next()
.and_then(|v| v.get("path").and_then(|x| x.as_str()).map(String::from))
.ok_or_else(|| "Could not resolve the local path".to_string())?;
// strip the trailing "..." wildcard and separators → the folder itself
p.trim_end_matches(['.', '/', '\\']).to_string()
} else {
target
};
let path = std::path::Path::new(&local);
if !path.exists() {
return Err(format!("Path not synced to disk yet: {local}"));
}
let mut c = Command::new("explorer");
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
c.creation_flags(0x0800_0000);
}
// reveal-and-select for files, open-folder for directories
if path.is_file() {
c.arg(format!("/select,{local}"));
} else {
c.arg(&local);
}
c.spawn().map_err(|e| format!("Could not open Explorer: {e}"))?;
Ok(())
}
/// A code editor / IDE detected on this machine.
#[derive(serde::Serialize, Clone)]
struct Editor {
id: String, // stable key ("vscode", "cursor", "vs", …)
name: String, // display name
exe: String, // resolved absolute .exe (empty → system-default association)
args: Vec<String>, // args inserted before the file path (e.g. ["/edit"] for VS)
}
/// First path in `cands` that exists on disk.
fn first_existing(cands: &[String]) -> Option<String> {
cands.iter().find(|p| std::path::Path::new(p).exists()).cloned()
}
/// Bounded recursive search for a file named `target` (case-insensitive) under `root`.
fn find_file_named(root: &std::path::Path, target: &str, depth: usize) -> Option<String> {
if depth == 0 || !root.is_dir() {
return None;
}
let entries = std::fs::read_dir(root).ok()?;
let mut dirs = Vec::new();
for e in entries.flatten() {
let p = e.path();
if p.is_file() {
if p.file_name().and_then(|n| n.to_str()).map_or(false, |n| n.eq_ignore_ascii_case(target)) {
return Some(p.to_string_lossy().to_string());
}
} else if p.is_dir() {
dirs.push(p);
}
}
for d in dirs {
if let Some(f) = find_file_named(&d, target, depth - 1) {
return Some(f);
}
}
None
}
/// Locate Visual Studio's devenv.exe via vswhere (latest install).
fn find_devenv() -> Option<String> {
let pf86 = std::env::var("ProgramFiles(x86)").ok()?;
let vswhere = format!("{pf86}\\Microsoft Visual Studio\\Installer\\vswhere.exe");
if !std::path::Path::new(&vswhere).exists() {
return None;
}
let mut c = Command::new(&vswhere);
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
c.creation_flags(0x0800_0000);
}
let out = c.args(["-latest", "-property", "productPath"]).output().ok()?;
let s = decode(&out.stdout).trim().to_string();
if s.is_empty() || !std::path::Path::new(&s).exists() { None } else { Some(s) }
}
fn add_editor(out: &mut Vec<Editor>, id: &str, name: &str, exe: Option<String>, args: &[&str]) {
if let Some(exe) = exe {
out.push(Editor { id: id.into(), name: name.into(), exe, args: args.iter().map(|s| s.to_string()).collect() });
}
}
/// Scan for installed code editors / IDEs (Windows). Only installed ones are
/// returned; "System default" (open with the associated app) is always last.
fn detect_editors() -> Vec<Editor> {
let la = std::env::var("LOCALAPPDATA").unwrap_or_default();
let pf = std::env::var("ProgramFiles").unwrap_or_default();
let pf86 = std::env::var("ProgramFiles(x86)").unwrap_or_default();
let mut out: Vec<Editor> = Vec::new();
add_editor(&mut out, "vscode", "VS Code", first_existing(&[
format!("{la}\\Programs\\Microsoft VS Code\\Code.exe"),
format!("{pf}\\Microsoft VS Code\\Code.exe"),
format!("{pf86}\\Microsoft VS Code\\Code.exe"),
]), &[]);
add_editor(&mut out, "cursor", "Cursor", first_existing(&[
format!("{la}\\Programs\\cursor\\Cursor.exe"),
]), &[]);
add_editor(&mut out, "windsurf", "Windsurf", first_existing(&[
format!("{la}\\Programs\\Windsurf\\Windsurf.exe"),
]), &[]);
add_editor(&mut out, "vscode-insiders", "VS Code Insiders", first_existing(&[
format!("{la}\\Programs\\Microsoft VS Code Insiders\\Code - Insiders.exe"),
format!("{pf}\\Microsoft VS Code Insiders\\Code - Insiders.exe"),
]), &[]);
add_editor(&mut out, "vs", "Visual Studio", find_devenv(), &["/edit"]);
let jb_pf = format!("{pf}\\JetBrains");
let jb_tb = format!("{la}\\JetBrains\\Toolbox\\apps");
add_editor(&mut out, "rider", "JetBrains Rider",
find_file_named(std::path::Path::new(&jb_pf), "rider64.exe", 3)
.or_else(|| find_file_named(std::path::Path::new(&jb_tb), "rider64.exe", 6)), &[]);
add_editor(&mut out, "clion", "JetBrains CLion",
find_file_named(std::path::Path::new(&jb_pf), "clion64.exe", 3)
.or_else(|| find_file_named(std::path::Path::new(&jb_tb), "clion64.exe", 6)), &[]);
add_editor(&mut out, "idea", "IntelliJ IDEA",
find_file_named(std::path::Path::new(&jb_pf), "idea64.exe", 3)
.or_else(|| find_file_named(std::path::Path::new(&jb_tb), "idea64.exe", 6)), &[]);
add_editor(&mut out, "sublime", "Sublime Text", first_existing(&[
format!("{pf}\\Sublime Text\\sublime_text.exe"),
format!("{pf}\\Sublime Text 3\\sublime_text.exe"),
format!("{pf86}\\Sublime Text 3\\sublime_text.exe"),
]), &[]);
add_editor(&mut out, "npp", "Notepad++", first_existing(&[
format!("{pf}\\Notepad++\\notepad++.exe"),
format!("{pf86}\\Notepad++\\notepad++.exe"),
]), &[]);
add_editor(&mut out, "zed", "Zed", first_existing(&[
format!("{la}\\Programs\\Zed\\Zed.exe"),
format!("{la}\\Zed\\Zed.exe"),
]), &[]);
// always available: open with the OS-associated application
out.push(Editor { id: "default".into(), name: "System default".into(), exe: String::new(), args: vec![] });
out
}
/// List installed code editors for the Settings picker.
#[tauri::command]
async fn list_editors() -> Result<Vec<Editor>, String> {
Ok(detect_editors())
}
/// Open a depot file's local working copy in the chosen editor (by id).
#[tauri::command]
async fn open_in_editor(state: State<'_, AppState>, depot: String, editor: String) -> Result<(), String> {
let conn = current(&state)?;
let local = run_json(&conn, &["where", &depot])?
.into_iter()
.next()
.and_then(|v| v.get("path").and_then(|p| p.as_str()).map(String::from))
.ok_or_else(|| "Could not resolve the file path".to_string())?;
if !std::path::Path::new(&local).exists() {
return Err(format!("File is not on disk yet (not synced): {local}"));
}
let editors = detect_editors();
let ed = editors
.iter()
.find(|e| e.id == editor)
.or_else(|| editors.iter().find(|e| e.id == "default"))
.cloned()
.ok_or_else(|| "No editor available".to_string())?;
if ed.exe.is_empty() {
// system-default association via `start`
let mut c = Command::new("cmd");
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
c.creation_flags(0x0800_0000);
}
c.args(["/C", "start", "", &local])
.spawn()
.map_err(|e| format!("Could not launch: {e}"))?;
} else {
let mut c = Command::new(&ed.exe);
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
c.creation_flags(0x0800_0000);
}
for a in &ed.args {
c.arg(a);
}
// pass the path as a separate arg so Rust quotes only it
c.arg(&local)
.spawn()
.map_err(|e| format!("Could not open in {}: {e}", ed.name))?;
}
Ok(())
}
/// Open a local file with its associated application (e.g. launch Unreal for a
/// `.uproject`). Confined to the workspace root — the webview cannot use this
/// to execute arbitrary files elsewhere on disk.
#[tauri::command]
async fn launch_file(state: State<'_, AppState>, path: String) -> Result<(), String> {
let conn = current(&state)?;
ensure_under_root(&conn, &path)?;
if !std::path::Path::new(&path).exists() {
return Err(format!("File not found: {path}"));
}
let mut c = Command::new("cmd");
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
c.creation_flags(0x0800_0000);
}
c.args(["/C", "start", "", &path])
.spawn()
.map_err(|e| format!("Could not launch: {e}"))?;
Ok(())
}
/// Resolve a working-folder scope to a local directory via `p4 where`.
fn scope_local_dir(conn: &Conn, scope: &str) -> Option<String> {
if scope.is_empty() {
return None;
}
let spec = format!("{}/...", scope.trim_end_matches(['/', '.']));
run_json(conn, &["where", &spec])
.ok()?
.into_iter()
.next()
.and_then(|v| v.get("path").and_then(|p| p.as_str()).map(String::from))
.map(|p| p.trim_end_matches(['.', '/', '\\']).to_string())
}
/// First file with the given extension in `dir` (checked, then one level of subdirs).
fn find_ext(dir: &str, ext: &str) -> String {
let matches = |p: &std::path::Path| p.extension().map_or(false, |x| x.eq_ignore_ascii_case(ext));
if let Ok(entries) = std::fs::read_dir(dir) {
let mut subdirs = Vec::new();
for e in entries.flatten() {
let p = e.path();
if matches(&p) {
return p.to_string_lossy().to_string();
}
if p.is_dir() {
subdirs.push(p);
}
}
for sd in subdirs {
if let Ok(inner) = std::fs::read_dir(&sd) {
for e in inner.flatten() {
let p = e.path();
if matches(&p) {
return p.to_string_lossy().to_string();
}
}
}
}
}
String::new()
}
/// Local path of a `.uproject` in the scope (or "" if not a UE project).
#[tauri::command]
async fn find_uproject(state: State<'_, AppState>, scope: String) -> Result<String, String> {
let conn = current(&state)?;
Ok(scope_local_dir(&conn, &scope).map(|d| find_ext(&d, "uproject")).unwrap_or_default())
}
/// Local path of a Visual Studio `.sln` in the scope (or "" if none).
#[tauri::command]
async fn find_sln(state: State<'_, AppState>, scope: String) -> Result<String, String> {
let conn = current(&state)?;
Ok(scope_local_dir(&conn, &scope).map(|d| find_ext(&d, "sln")).unwrap_or_default())
}
/// Build a Visual Studio solution with MSBuild (located via vswhere), streaming
/// its output line-by-line as `build-log` events. Uses the solution's default
/// configuration — for an Unreal project that compiles the game module.
#[tauri::command]
async fn build_sln(path: String, config: String) -> Result<String, String> {
if !std::path::Path::new(&path).exists() {
return Err(format!("Solution not found: {path}"));
}
let emit = |line: String, done: bool, ok: bool| {
if let Some(app) = APP.get() {
let _ = app.emit(
"build-log",
serde_json::json!({ "line": line, "done": done, "ok": ok }),
);
}
};
// locate MSBuild.exe via vswhere (falls back to PATH)
let pf86 = std::env::var("ProgramFiles(x86)").unwrap_or_else(|_| "C:\\Program Files (x86)".into());
let vswhere = format!("{pf86}\\Microsoft Visual Studio\\Installer\\vswhere.exe");
let msbuild = {
let mut vc = Command::new(&vswhere);
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
vc.creation_flags(0x0800_0000);
}
vc.args(["-latest", "-requires", "Microsoft.Component.MSBuild", "-find", "MSBuild\\**\\Bin\\MSBuild.exe"]);
match vc.output() {
Ok(o) => decode(&o.stdout).lines().next().unwrap_or("").trim().to_string(),
Err(_) => String::new(),
}
};
let msbuild = if msbuild.is_empty() { "MSBuild.exe".to_string() } else { msbuild };
emit(format!("MSBuild: {msbuild}"), false, false);
emit(
format!("Building {path}{} …", if config.is_empty() { String::new() } else { format!(" [{config} | Win64]") }),
false,
false,
);
let mut cmd = Command::new(&msbuild);
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(0x0800_0000);
}
// build args; a specific UE configuration ("Development Editor", "Shipping", …) → Win64
let mut args: Vec<String> = vec![
path.clone(),
"/m".into(),
"/nologo".into(),
"/v:minimal".into(),
"/clp:NoSummary".into(),
];
if !config.is_empty() {
args.push(format!("/p:Configuration={config}"));
args.push("/p:Platform=Win64".into());
}
cmd.args(&args).stdout(Stdio::piped()).stderr(Stdio::piped());
let mut child = match cmd.spawn() {
Ok(c) => c,
Err(e) => {
let m = format!("Could not start MSBuild (Visual Studio C++ tools installed?): {e}");
emit(m.clone(), true, false);
return Err(m);
}
};
// For Unreal, the .sln drives UnrealBuildTool; MSBuild can return non-zero for a
// side project even when UBT reports the game module built fine. So trust UBT's
// "Result: Succeeded" (and the absence of real compile errors) over the exit code.
let mut ubt_result = false;
let mut ubt_success = false;
let mut compile_error = false;
let mut scan = |line: &str| {
let l = line.to_ascii_lowercase();
if l.contains("result: succeeded") { ubt_result = true; ubt_success = true; }
if l.contains("result: failed") { ubt_result = true; }
if l.contains(": error ") || l.contains(") error ") || l.contains("error msb") {
compile_error = true;
}
};
if let Some(out) = child.stdout.take() {
for line in BufReader::new(out).lines().map_while(Result::ok) {
if !line.trim().is_empty() {
scan(&line);
emit(line, false, false);
}
}
}
let status = child.wait().map_err(|e| e.to_string())?;
if let Some(mut se) = child.stderr.take() {
let mut buf = String::new();
let _ = std::io::Read::read_to_string(&mut se, &mut buf);
for line in buf.lines() {
if !line.trim().is_empty() {
scan(line);
emit(line.to_string(), false, false);
}
}
}
// UBT verdict wins when present; otherwise fall back to MSBuild's exit code
let ok = if ubt_result {
ubt_success && !compile_error
} else {
status.success()
};
emit(if ok { "✓ Build succeeded.".into() } else { "✗ Build FAILED.".into() }, true, ok);
if ok {
Ok("ok".into())
} else {
Err("Build failed".into())
}
}
/// Files and metadata of a submitted changelist (History detail).
#[tauri::command]
async fn p4_describe(state: State<'_, AppState>, change: String) -> Result<Value, String> {
let conn = current(&state)?;
let v = run_json(&conn, &["describe", "-s", &change])?;
Ok(v.into_iter().next().unwrap_or(Value::Null))
}
/// Read raw bytes of a local file — used by the 3D model / texture viewer.
/// Confined to the workspace root and size-capped.
#[tauri::command]
async fn read_file(state: State<'_, AppState>, path: String) -> Result<tauri::ipc::Response, String> {
let conn = current(&state)?;
ensure_under_root(&conn, &path)?;
check_local_size(&path)?;
std::fs::read(&path)
.map(tauri::ipc::Response::new)
.map_err(|e| format!("Could not read file: {e}"))
}
/// Write UTF-8 text back to a depot file's local working copy (built-in editor).
/// Opens the file for edit first (so the change is tracked and the read-only bit
/// is cleared), then writes. Confined to the workspace root.
#[tauri::command]
async fn write_depot(state: State<'_, AppState>, depot: String, content: String) -> Result<(), String> {
let conn = current(&state)?;
let local = run_json(&conn, &["where", &depot])?
.into_iter()
.next()
.and_then(|v| v.get("path").and_then(|p| p.as_str()).map(String::from))
.ok_or_else(|| "Could not resolve the file path".to_string())?;
ensure_under_root(&conn, &local)?;
// ensure the file is open for edit (ignored for a not-yet-submitted add, or
// if it is already open); this also clears the read-only attribute
let _ = run_text(&conn, &["edit", &depot]);
// belt-and-suspenders: clear read-only in case `p4 edit` didn't apply
if let Ok(md) = std::fs::metadata(&local) {
let mut perms = md.permissions();
#[allow(clippy::permissions_set_readonly_false)]
perms.set_readonly(false);
let _ = std::fs::set_permissions(&local, perms);
}
std::fs::write(&local, content.as_bytes()).map_err(|e| format!("Could not write file: {e}"))?;
Ok(())
}
/// Read the local working-copy bytes of a depot file (resolves via `p4 where`).
#[tauri::command]
async fn read_depot(state: State<'_, AppState>, depot: String) -> Result<tauri::ipc::Response, String> {
let conn = current(&state)?;
let local = run_json(&conn, &["where", &depot])?
.into_iter()
.next()
.and_then(|v| v.get("path").and_then(|p| p.as_str()).map(String::from))
.ok_or_else(|| "Could not resolve the file path".to_string())?;
check_local_size(&local)?;
std::fs::read(&local)
.map(tauri::ipc::Response::new)
.map_err(|e| format!("Could not read file: {e}"))
}
/// Read raw file bytes at an exact revision via `p4 print` (works for
/// submitted / historical revisions that may not be synced locally).
/// `spec` is a depot path optionally suffixed with a revision, e.g.
/// `//depot/foo.cpp#7`. `-q` suppresses the leading file header line.
#[tauri::command]
async fn print_depot(state: State<'_, AppState>, spec: String) -> Result<tauri::ipc::Response, String> {
let conn = current(&state)?;
// size guard: reject huge revisions before buffering them via `p4 print`
if let Ok(sizes) = run_json(&conn, &["sizes", &spec]) {
if let Some(sz) = sizes.first().and_then(|v| v.get("fileSize")).and_then(|s| s.as_str()).and_then(|s| s.parse::<u64>().ok()) {
if sz > MAX_READ_BYTES {
return Err(format!(
"File is too large to preview ({} MB, limit {} MB)",
sz / (1024 * 1024),
MAX_READ_BYTES / (1024 * 1024)
));
}
}
}
let out = p4_cmd(&conn, false)
.args(["print", "-q", &spec])
.output()
.map_err(|e| format!("Failed to start p4: {e}"))?;
if !out.status.success() && out.stdout.is_empty() {
let e = decode(&out.stderr).trim().to_string();
log_p4(&["print", "-q", &spec], 0, false, Some(&e));
return Err(if e.is_empty() { "p4 print failed".into() } else { e });
}
if out.stdout.len() as u64 > MAX_READ_BYTES {
return Err("File is too large to preview".into());
}
log_p4(&["print", "-q", &spec], out.stdout.len() as i64, true, None);
Ok(tauri::ipc::Response::new(out.stdout))
}
/// Run an arbitrary `p4` command for the built-in terminal and return combined
/// stdout+stderr as text. Never errors on a non-zero exit — the terminal shows
/// the error text just like a real console would.
#[tauri::command]
async fn p4_console(state: State<'_, AppState>, args: Vec<String>) -> Result<String, String> {
let conn = current(&state)?;
let refs: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
// stdin is null (p4_cmd default) so prompting commands fail fast instead of
// hanging; a failing P4EDITOR aborts editor-spawning forms (change, submit
// without -d, client, …) the same way.
let out = p4_cmd(&conn, false)
.env("P4EDITOR", "cmd /c exit 1")
.args(&refs)
.output()
.map_err(|e| format!("Failed to start p4: {e}"))?;
let mut s = decode(&out.stdout);
let err = decode(&out.stderr);
if !err.trim().is_empty() {
if !s.is_empty() && !s.ends_with('\n') { s.push('\n'); }
s.push_str(&err);
}
let ok = out.status.success();
log_p4(&refs, s.lines().count() as i64, ok, if ok { None } else { Some(err.trim()) });
Ok(s)
}
/// Tail the newest Unreal log for a project. `uproject` is the local path of the
/// `.uproject`; the log lives at `<ProjectDir>/Saved/Logs/*.log`. Returns the
/// last `tail_bytes` bytes (empty string if no log yet — e.g. UE not running).
#[tauri::command]
async fn ue_log(state: State<'_, AppState>, uproject: String, tail_bytes: u64) -> Result<String, String> {
use std::path::Path;
let conn = current(&state)?;
ensure_under_root(&conn, &uproject)?;
let dir = Path::new(&uproject)
.parent()
.ok_or("bad uproject path")?
.join("Saved")
.join("Logs");
if !dir.is_dir() {
return Ok(String::new());
}
let mut newest: Option<(std::time::SystemTime, std::path::PathBuf)> = None;
for e in std::fs::read_dir(&dir).map_err(|e| e.to_string())?.flatten() {
let p = e.path();
if p.extension().and_then(|x| x.to_str()) == Some("log") {
if let Ok(m) = e.metadata().and_then(|m| m.modified()) {
if newest.as_ref().map_or(true, |(t, _)| m > *t) {
newest = Some((m, p));
}
}
}
}
let Some((_, path)) = newest else { return Ok(String::new()) };
let data = std::fs::read(&path).map_err(|e| e.to_string())?;
let start = data.len().saturating_sub(tail_bytes as usize);
Ok(decode(&data[start..]))
}
/// Files opened by ANYONE in the scope (`p4 opened -a`) — powers the
/// "who is holding this file" indicators and exclusive-checkout awareness.
#[tauri::command]
async fn p4_opened_all(state: State<'_, AppState>, scope: String) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
if scope.is_empty() {
run_json(&conn, &["opened", "-a"])
} else {
run_json(&conn, &["opened", "-a", &scope_spec(&scope)])
}
}
/// Lock opened files so nobody else can submit them (binary-asset safety).
#[tauri::command]
async fn p4_lock(state: State<'_, AppState>, files: Vec<String>) -> Result<String, String> {
let conn = current(&state)?;
let mut args: Vec<&str> = vec!["lock"];
for f in &files {
args.push(f.as_str());
}
run_text(&conn, &args)
}
/// Release locks.
#[tauri::command]
async fn p4_unlock(state: State<'_, AppState>, files: Vec<String>) -> Result<String, String> {
let conn = current(&state)?;
let mut args: Vec<&str> = vec!["unlock"];
for f in &files {
args.push(f.as_str());
}
run_text(&conn, &args)
}
/// Read the server typemap as a list of "TYPE PATTERN" entries.
/// (Empty list if the typemap is unset. Requires admin to *change*, not to read.)
#[tauri::command]
async fn p4_typemap_get(state: State<'_, AppState>) -> Result<Vec<String>, String> {
let conn = current(&state)?;
let spec = run_text(&conn, &["typemap", "-o"])?;
let mut entries = Vec::new();
let mut in_map = false;
for line in spec.lines() {
if line.starts_with("TypeMap:") {
in_map = true;
continue;
}
if in_map {
if line.starts_with('\t') || line.starts_with(' ') {
let e = line.trim();
if !e.is_empty() && !e.starts_with('#') {
entries.push(e.to_string());
}
} else if !line.trim().is_empty() {
break; // reached the next spec field
}
}
}
Ok(entries)
}
/// Replace the server typemap with the given "TYPE PATTERN" entries.
/// Requires admin rights on the server.
#[tauri::command]
async fn p4_typemap_set(state: State<'_, AppState>, entries: Vec<String>) -> Result<String, String> {
let conn = current(&state)?;
let mut spec = String::from("TypeMap:\n");
for e in &entries {
let e = e.trim();
if !e.is_empty() {
spec.push('\t');
spec.push_str(e);
spec.push('\n');
}
}
let mut child = p4_cmd(&conn, false)
.args(["typemap", "-i"])
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| format!("Failed to start p4: {e}"))?;
if let Some(si) = child.stdin.as_mut() {
si.write_all(spec.as_bytes()).map_err(|e| e.to_string())?;
}
let out = child.wait_with_output().map_err(|e| e.to_string())?;
if !out.status.success() {
let err = decode(&out.stderr);
let msg = if err.trim().is_empty() { decode(&out.stdout) } else { err };
let low = msg.to_lowercase();
return Err(if low.contains("permission") || low.contains("protect") || low.contains("admin") || low.contains("not allowed") {
"You need admin rights on the server to change the typemap.".to_string()
} else {
msg.trim().to_string()
});
}
Ok(decode(&out.stdout).trim().to_string())
}
/// Change the Perforce file type of opened files (e.g. add "+l" exclusive lock).
/// `filetype` is passed to `p4 reopen -t`, so "+l" adds the modifier and
/// "binary+l" sets the full type.
#[tauri::command]
async fn p4_reopen_type(state: State<'_, AppState>, files: Vec<String>, filetype: String) -> Result<String, String> {
let conn = current(&state)?;
if files.is_empty() {
return Ok(String::new());
}
let mut args: Vec<&str> = vec!["reopen", "-t", &filetype];
for f in &files {
args.push(f.as_str());
}
run_text(&conn, &args)
}
/// Extract the largest embedded PNG from a byte blob — this is how an uncooked
/// Unreal `.uasset` stores its Content-Browser thumbnail (PNG-compressed in the
/// package thumbnail table). We scan for the PNG signature → IEND and keep the
/// biggest hit (the real thumbnail, not some tiny incidental chunk). No engine,
/// no CUE4Parse — exactly the approach Anchorpoint uses for its previews.
fn extract_png(b: &[u8]) -> Option<Vec<u8>> {
const SIG: [u8; 8] = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
let mut best: Option<(usize, usize)> = None; // (start, end)
let mut i = 0usize;
while i + 8 < b.len() {
if b[i..i + 8] == SIG {
// find the IEND chunk that closes this PNG
let mut j = i + 8;
let mut end = None;
while j + 8 <= b.len() {
if &b[j..j + 4] == b"IEND" {
end = Some(j + 8); // IEND + 4-byte CRC
break;
}
j += 1;
}
let e = end.unwrap_or(b.len());
if best.map_or(true, |(s0, e0)| (e - i) > (e0 - s0)) {
best = Some((i, e));
}
i = e; // continue scanning after this PNG
} else {
i += 1;
}
}
best.map(|(s, e)| b[s..e].to_vec())
}
/// Read the bytes of a `.uasset` (working copy or an exact submitted revision)
/// and return ONLY its embedded thumbnail PNG. Reading happens server-side so a
/// huge asset never crosses the IPC bridge — just the small thumbnail does, and
/// the 64 MB preview cap does not apply here.
#[tauri::command]
async fn uasset_thumbnail(state: State<'_, AppState>, spec: String, historical: bool) -> Result<tauri::ipc::Response, String> {
let conn = current(&state)?;
// avoid buffering absurdly large assets just to grab a thumbnail
const MAX_UASSET: u64 = 400 * 1024 * 1024;
let bytes: Vec<u8> = if historical {
// exact revision → p4 print
if let Ok(sizes) = run_json(&conn, &["sizes", &spec]) {
if let Some(sz) = sizes.first().and_then(|v| v.get("fileSize")).and_then(|s| s.as_str()).and_then(|s| s.parse::<u64>().ok()) {
if sz > MAX_UASSET {
return Err("Asset too large for a thumbnail".into());
}
}
}
let out = p4_cmd(&conn, false)
.args(["print", "-q", &spec])
.output()
.map_err(|e| format!("Failed to start p4: {e}"))?;
if !out.status.success() && out.stdout.is_empty() {
return Err(decode(&out.stderr).trim().to_string());
}
out.stdout
} else {
// working copy → resolve local path and read it
let local = run_json(&conn, &["where", &spec])?
.into_iter()
.next()
.and_then(|v| v.get("path").and_then(|p| p.as_str()).map(String::from))
.ok_or_else(|| "Could not resolve the file path".to_string())?;
if let Ok(m) = std::fs::metadata(&local) {
if m.len() > MAX_UASSET {
return Err("Asset too large for a thumbnail".into());
}
}
std::fs::read(&local).map_err(|e| format!("Could not read file: {e}"))?
};
match extract_png(&bytes) {
Some(png) => Ok(tauri::ipc::Response::new(png)),
None => Err("No embedded thumbnail".into()),
}
}
/// Python run inside a headless Unreal editor to export one mesh asset to FBX.
/// Args come via env vars (EXD_ASSET = /Game path, EXD_OUT = output .fbx).
const EXPORT_PY: &str = r#"
import unreal, os
def log(m): unreal.log("EXD_EXPORT: " + str(m))
ap = os.environ.get("EXD_ASSET", "")
op = os.environ.get("EXD_OUT", "")
if not ap or not op:
log("missing env"); raise SystemExit(1)
asset = unreal.EditorAssetLibrary.load_asset(ap)
if asset is None:
log("asset not found: " + ap); raise SystemExit(2)
task = unreal.AssetExportTask()
task.set_editor_property("object", asset)
task.set_editor_property("filename", op)
task.set_editor_property("automated", True)
task.set_editor_property("prompt", False)
task.set_editor_property("replace_identical", True)
if isinstance(asset, unreal.StaticMesh):
opt = unreal.FbxExportOption(); opt.set_editor_property("collision", False); opt.set_editor_property("level_of_detail", False)
task.set_editor_property("options", opt); task.set_editor_property("exporter", unreal.StaticMeshExporterFBX())
elif isinstance(asset, unreal.SkeletalMesh):
opt = unreal.FbxExportOption(); opt.set_editor_property("collision", False); opt.set_editor_property("level_of_detail", False)
task.set_editor_property("options", opt); task.set_editor_property("exporter", unreal.SkeletalMeshExporterFBX())
else:
log("unsupported type: " + asset.get_class().get_name()); raise SystemExit(3)
ok = unreal.Exporter.run_asset_export_task(task)
log("result " + str(ok))
raise SystemExit(0 if ok else 4)
"#;
/// Query a Windows registry value (returns the REG_SZ string, if any).
fn reg_query(key: &str, value: &str) -> Option<String> {
let mut c = Command::new("reg");
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
c.creation_flags(0x0800_0000);
}
let out = c.stdin(Stdio::null()).args(["query", key, "/v", value]).output().ok()?;
if !out.status.success() {
return None;
}
let s = decode(&out.stdout);
for line in s.lines() {
if let Some(idx) = line.find("REG_SZ") {
let val = line[idx + 6..].trim();
if !val.is_empty() {
return Some(val.to_string());
}
}
}
None
}
/// Locate UnrealEditor-Cmd.exe for a project's engine (version or source-build GUID).
fn unreal_editor_cmd(uproject: &str) -> Option<String> {
let assoc = std::fs::read_to_string(uproject)
.ok()
.and_then(|s| serde_json::from_str::<Value>(&s).ok())
.and_then(|v| v.get("EngineAssociation").and_then(|e| e.as_str()).map(String::from))
.unwrap_or_default();
let bin = |root: &str| -> Option<String> {
for name in ["UnrealEditor-Cmd.exe", "UE4Editor-Cmd.exe"] {
let p = format!("{root}\\Engine\\Binaries\\Win64\\{name}");
if std::path::Path::new(&p).exists() {
return Some(p);
}
}
None
};
let pf = std::env::var("ProgramFiles").unwrap_or_else(|_| "C:\\Program Files".into());
// launcher install "UE_5.x" by version, else registry, else source-build GUID
if assoc.chars().next().map_or(false, |c| c.is_ascii_digit()) {
if let Some(b) = bin(&format!("{pf}\\Epic Games\\UE_{assoc}")) {
return Some(b);
}
if let Some(dir) = reg_query(&format!("HKLM\\SOFTWARE\\EpicGames\\Unreal Engine\\{assoc}"), "InstalledDirectory") {
if let Some(b) = bin(dir.trim()) {
return Some(b);
}
}
} else if !assoc.is_empty() {
if let Some(dir) = reg_query("HKCU\\SOFTWARE\\Epic Games\\Unreal Engine\\Builds", &assoc) {
if let Some(b) = bin(dir.trim()) {
return Some(b);
}
}
}
// fallback: any UE_* under Program Files\Epic Games
if let Ok(rd) = std::fs::read_dir(format!("{pf}\\Epic Games")) {
for e in rd.flatten() {
let p = e.path();
if p.is_dir() && p.file_name().and_then(|n| n.to_str()).map_or(false, |n| n.starts_with("UE_")) {
if let Some(b) = bin(&p.to_string_lossy()) {
return Some(b);
}
}
}
}
None
}
/// Map a local `.uasset` path to its Unreal object path:
/// <Project>/Content/Foo.uasset → /Game/Foo
/// <Project>/Plugins/<Name>/Content/Bar… → /<Name>/Bar (plugin mount point)
fn content_to_game(uproject: &str, local: &str) -> Option<String> {
let strip_ext = |s: &str| -> String {
for ext in [".uasset", ".umap"] {
if let Some(x) = s.strip_suffix(ext) {
return x.to_string();
}
}
s.to_string()
};
let proj_dir = std::path::Path::new(uproject).parent()?;
let norm = local.replace('\\', "/");
// project Content → /Game/
let content = proj_dir.join("Content");
if let Ok(rel) = std::path::Path::new(local).strip_prefix(&content) {
return Some(format!("/Game/{}", strip_ext(&rel.to_string_lossy().replace('\\', "/"))));
}
// plugin Content → /<PluginName>/ (…/Plugins/…/<Name>/Content/<rest>)
if let Some(pidx) = norm.find("/Plugins/") {
let after = &norm[pidx + "/Plugins/".len()..];
if let Some(cidx) = after.find("/Content/") {
let plugin_path = &after[..cidx]; // may be nested, e.g. "GameFeatures/GASPALS"
let mount = plugin_path.rsplit('/').next().unwrap_or(plugin_path);
let rest = &after[cidx + "/Content/".len()..];
return Some(format!("/{mount}/{}", strip_ext(rest)));
}
}
None
}
/// Export a `.uasset` mesh to FBX by driving a headless Unreal editor, so the
/// app's 3D viewport can show a real, rotatable model. The FBX is written to a
/// temp file that is deleted immediately after reading — nothing is left on disk;
/// the model exists only in the preview's memory while it is open.
#[tauri::command]
async fn uasset_export_3d(state: State<'_, AppState>, depot: String, uproject: String) -> Result<tauri::ipc::Response, String> {
let conn = current(&state)?;
if uproject.is_empty() {
return Err("Not an Unreal project — pick the project working folder first.".into());
}
let local = run_json(&conn, &["where", &depot])?
.into_iter()
.next()
.and_then(|v| v.get("path").and_then(|p| p.as_str()).map(String::from))
.ok_or_else(|| "Could not resolve the file path".to_string())?;
if !std::path::Path::new(&local).exists() {
return Err("Asset is not synced to disk yet — Get Latest first.".into());
}
ensure_under_root(&conn, &local)?;
let game = content_to_game(&uproject, &local)
.ok_or_else(|| "Asset is outside the project's Content folder (3D export supports /Game assets).".to_string())?;
let editor = unreal_editor_cmd(&uproject)
.ok_or_else(|| "UnrealEditor-Cmd.exe not found — is Unreal Engine installed for this project's version?".to_string())?;
// export to a temp file that is deleted the moment we've read it — nothing is
// cached on disk; the model lives only in the preview's memory while open
let safe: String = game.chars().map(|c| if c.is_alphanumeric() { c } else { '_' }).collect();
let out_fbx = std::env::temp_dir().join(format!("exd_preview_{safe}.fbx"));
let _ = std::fs::remove_file(&out_fbx); // clear any stale leftover
let script = std::env::temp_dir().join("exd_uasset_export.py");
std::fs::write(&script, EXPORT_PY).map_err(|e| e.to_string())?;
let mut c = Command::new(&editor);
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
c.creation_flags(0x0800_0000);
}
// commandlet mode (-run=pythonscript) + -nullrhi → no editor window appears
c.arg(&uproject)
.arg("-run=pythonscript")
.arg(format!("-script={}", script.to_string_lossy()))
.args(["-unattended", "-nosplash", "-nullrhi", "-nop4", "-NoLogTimes", "-NoLoadStartupPackages"])
.env("EXD_ASSET", &game)
.env("EXD_OUT", out_fbx.to_string_lossy().to_string())
.stdin(Stdio::null())
.stdout(Stdio::null()) // Unreal logs a lot; ignore it to avoid a full-pipe deadlock
.stderr(Stdio::null());
let mut child = c.spawn().map_err(|e| format!("Failed to launch Unreal: {e}"))?;
// poll with a hard timeout so a stuck editor never wedges the backend
let deadline = Instant::now() + Duration::from_secs(360);
loop {
match child.try_wait() {
Ok(Some(_)) => break,
Ok(None) => {
if Instant::now() > deadline {
let _ = child.kill();
return Err("Unreal export timed out (6 min).".into());
}
std::thread::sleep(Duration::from_millis(400));
}
Err(e) => return Err(e.to_string()),
}
}
if !out_fbx.exists() {
return Err("Unreal produced no file — the asset may not be a Static/Skeletal Mesh, or the editor failed to start.".into());
}
let data = std::fs::read(&out_fbx).map_err(|e| e.to_string())?;
let _ = std::fs::remove_file(&out_fbx); // delete right away — leave nothing behind
if data.is_empty() {
return Err("Exported model is empty.".into());
}
Ok(tauri::ipc::Response::new(data))
}
/// Shelve a pending changelist's files on the server (share work-in-progress).
#[tauri::command]
async fn p4_shelve(state: State<'_, AppState>, change: String) -> Result<String, String> {
let conn = current(&state)?;
run_text(&conn, &["shelve", "-f", "-c", &change])
}
/// Unshelve files from a shelved changelist into the workspace.
#[tauri::command]
async fn p4_unshelve(state: State<'_, AppState>, change: String) -> Result<String, String> {
let conn = current(&state)?;
run_text(&conn, &["unshelve", "-s", &change, "-f"])
}
/// Delete the shelved files of a changelist.
#[tauri::command]
async fn p4_delete_shelf(state: State<'_, AppState>, change: String) -> Result<String, String> {
let conn = current(&state)?;
run_text(&conn, &["shelve", "-d", "-c", &change])
}
/// Shelved files of a changelist (describe -S).
#[tauri::command]
async fn p4_shelved_files(state: State<'_, AppState>, change: String) -> Result<Value, String> {
let conn = current(&state)?;
let v = run_json(&conn, &["describe", "-s", "-S", &change])?;
Ok(v.into_iter().next().unwrap_or(Value::Null))
}
/// Files that need conflict resolution after a sync (`p4 resolve -n`).
#[tauri::command]
async fn p4_resolve_list(state: State<'_, AppState>) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
// -n = preview only; never prompts
run_json(&conn, &["resolve", "-n"]).or_else(|e| {
// "no file(s) to resolve" is not an error — just an empty list
if e.to_lowercase().contains("no file") { Ok(Vec::new()) } else { Err(e) }
})
}
/// Resolve one file (or everything when `file` is empty).
/// mode: "am" auto-merge · "ay" accept yours · "at" accept theirs.
#[tauri::command]
async fn p4_resolve_file(state: State<'_, AppState>, file: String, mode: String) -> Result<String, String> {
let conn = current(&state)?;
let flag = match mode.as_str() {
"ay" => "-ay",
"at" => "-at",
_ => "-am",
};
if file.is_empty() {
run_text(&conn, &["resolve", flag])
} else {
run_text(&conn, &["resolve", flag, &file])
}
}
/// Propagate changes between branches/streams: op is "merge" (with resolve),
/// "copy" (overwrite target), or "integrate" (classic). Opens the affected files
/// into a fresh numbered changelist; the user then resolves (if needed) and
/// submits via the normal pending-changelist flow. Returns the changelist number.
#[tauri::command]
async fn p4_branch_op(state: State<'_, AppState>, op: String, source: String, target: String) -> Result<String, String> {
let conn = current(&state)?;
let cmd = match op.as_str() {
"merge" => "merge",
"copy" => "copy",
_ => "integrate",
};
let src = source.trim();
let tgt = target.trim();
if src.is_empty() || tgt.is_empty() {
return Err("Source and target paths are required".into());
}
let cl = create_changelist(&conn, &format!("{cmd} {src} -> {tgt}"))?;
let out = run_text(&conn, &[cmd, "-c", &cl, src, tgt]).unwrap_or_default();
Ok(format!("CL {cl}\n{}", out.trim()))
}
/// Unified diff between two exact revisions (`p4 diff2 -du`).
#[tauri::command]
async fn p4_diff2(state: State<'_, AppState>, spec1: String, spec2: String) -> Result<String, String> {
let conn = current(&state)?;
run_text(&conn, &["diff2", "-du", &spec1, &spec2])
}
/// Per-line blame: `p4 annotate -c -u -q` (changelist + user per line).
#[tauri::command]
async fn p4_annotate(state: State<'_, AppState>, spec: String) -> Result<String, String> {
let conn = current(&state)?;
let mut s = run_text(&conn, &["annotate", "-c", "-u", "-q", &spec])?;
if s.len() > 2_000_000 {
s.truncate(2_000_000);
s.push_str("\n… (truncated)");
}
Ok(s)
}
/// Depot file search by name fragment (case-preserving p4 wildcards).
#[tauri::command]
async fn p4_search_files(state: State<'_, AppState>, query: String, scope: String) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
let q = query.trim();
if q.is_empty() {
return Ok(Vec::new());
}
let base = if scope.is_empty() {
"//".to_string()
} else {
format!("{}/", scope.trim_end_matches(['/', '\\']))
};
// `...` spans directories; `*` stays within a segment → "name contains q"
let spec = format!("{base}...{q}*");
run_json(&conn, &["files", "-e", "-m", "200", &spec]).or_else(|e| {
if e.to_lowercase().contains("no such file") { Ok(Vec::new()) } else { Err(e) }
})
}
/// Move opened files into another pending changelist ("default" allowed).
#[tauri::command]
async fn p4_reopen_to(state: State<'_, AppState>, change: String, files: Vec<String>) -> Result<String, String> {
let conn = current(&state)?;
if files.is_empty() {
return Ok(String::new());
}
let mut args: Vec<&str> = vec!["reopen", "-c", &change];
for f in &files {
args.push(f.as_str());
}
run_text(&conn, &args)
}
/// Newest submitted changelist in the scope — cheap poll for "new submit" toasts.
#[tauri::command]
async fn p4_latest_change(state: State<'_, AppState>, scope: String) -> Result<Value, String> {
let conn = current(&state)?;
let spec = if scope.is_empty() { "//...".to_string() } else { scope_spec(&scope) };
let v = run_json(&conn, &["changes", "-s", "submitted", "-m", "1", &spec])?;
Ok(v.into_iter().next().unwrap_or(Value::Null))
}
/// Get a workspace (client) spec as editable text. An unknown name returns a
/// fresh template — used to create a new workspace.
#[tauri::command]
async fn p4_client_spec(state: State<'_, AppState>, client: String) -> Result<String, String> {
let conn = current(&state)?;
if client.trim().is_empty() {
return Err("No workspace name".into());
}
run_text(&conn, &["client", "-o", client.trim()])
}
/// Save a workspace (client) spec (`p4 client -i`). Creates it if new.
#[tauri::command]
async fn p4_client_save(state: State<'_, AppState>, spec: String) -> Result<String, String> {
let conn = current(&state)?;
let mut child = p4_cmd(&conn, false)
.args(["client", "-i"])
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| format!("Failed to start p4: {e}"))?;
if let Some(si) = child.stdin.as_mut() {
si.write_all(spec.as_bytes()).map_err(|e| e.to_string())?;
}
let out = child.wait_with_output().map_err(|e| e.to_string())?;
if !out.status.success() {
let err = decode(&out.stderr);
return Err(if err.trim().is_empty() { decode(&out.stdout).trim().to_string() } else { err.trim().to_string() });
}
Ok(decode(&out.stdout).trim().to_string())
}
/// Switch the active workspace (client) without re-authenticating.
#[tauri::command]
async fn p4_switch_client(state: State<'_, AppState>, client: String) -> Result<Value, String> {
let conn = {
let mut c = state.0.lock().unwrap_or_else(|e| e.into_inner());
if c.port.is_empty() {
return Err("No active connection".into());
}
c.client = client;
c.clone()
};
let info = run_json(&conn, &["info"])?;
let info = info.into_iter().next().unwrap_or(Value::Null);
// refresh the cached client root for the new workspace
let root = info.get("clientRoot").and_then(|r| r.as_str()).unwrap_or("").to_string();
state.0.lock().unwrap_or_else(|e| e.into_inner()).root = root;
Ok(info)
}
/// List depots on the server (for the Depot-path picker).
#[tauri::command]
async fn p4_depots(state: State<'_, AppState>) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
run_json(&conn, &["depots"])
}
/// All Perforce users (with last-access time → activity indicator).
#[tauri::command]
async fn p4_users(state: State<'_, AppState>) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
run_json(&conn, &["users"])
}
/// All groups on the server, or the groups a given user belongs to.
#[tauri::command]
async fn p4_groups(state: State<'_, AppState>, user: String) -> Result<Vec<Value>, String> {
let conn = current(&state)?;
if user.is_empty() {
run_json(&conn, &["groups"])
} else {
run_json(&conn, &["groups", "-u", &user])
}
}
/// Add or remove a user from a group (role assignment). Requires admin/super.
/// Edits the group spec's Users list and pipes it back via `group -i`.
#[tauri::command]
async fn p4_group_member(
state: State<'_, AppState>,
group: String,
user: String,
add: bool,
) -> Result<String, String> {
let conn = current(&state)?;
let spec = run_text(&conn, &["group", "-o", &group])?;
// collect existing Users: entries (indented under the "Users:" field)
let mut users: Vec<String> = Vec::new();
let mut in_users = false;
let mut head = String::new();
for line in spec.lines() {
if line.starts_with("Users:") {
in_users = true;
continue;
}
if in_users {
if line.starts_with('\t') || line.starts_with(' ') {
let u = line.trim().to_string();
if !u.is_empty() {
users.push(u);
}
continue;
} else if line.trim().is_empty() {
continue;
} else {
in_users = false; // next field — stop collecting
}
}
if !in_users {
head.push_str(line);
head.push('\n');
}
}
users.retain(|u| !u.eq_ignore_ascii_case(&user));
if add {
users.push(user.clone());
}
// rebuild spec: head (everything except Users:) + fresh Users section
let mut out = head.trim_end().to_string();
out.push_str("\n\nUsers:\n");
for u in &users {
out.push('\t');
out.push_str(u);
out.push('\n');
}
let mut child = p4_cmd(&conn, false)
.args(["group", "-i"])
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| format!("Failed to start p4: {e}"))?;
if let Some(si) = child.stdin.as_mut() {
si.write_all(out.as_bytes()).map_err(|e| e.to_string())?;
}
let res = child.wait_with_output().map_err(|e| e.to_string())?;
if !res.status.success() {
return Err(decode(&res.stderr).trim().to_string());
}
Ok(decode(&res.stdout).trim().to_string())
}
/// OpenRouter API key baked into the binary at compile time from the
/// git-ignored file src-tauri/openrouter.key.
const BAKED_AI_KEY: &str = include_str!("../openrouter.key");
/// Path to the (git-ignored) OpenRouter API key, stored in the app config dir.
/// Kept as a fallback/override location for builds without a baked key.
fn ai_key_path() -> Option<std::path::PathBuf> {
let app = APP.get()?;
let dir = app.path().app_config_dir().ok()?;
Some(dir.join("openrouter.key"))
}
#[tauri::command]
async fn read_ai_key() -> Result<String, String> {
let baked = BAKED_AI_KEY.trim();
if !baked.is_empty() {
return Ok(baked.to_string());
}
Ok(ai_key_path()
.and_then(|p| std::fs::read_to_string(p).ok())
.map(|s| s.trim().to_string())
.unwrap_or_default())
}
#[tauri::command]
async fn save_ai_key(key: String) -> Result<(), String> {
let p = ai_key_path().ok_or("No config dir")?;
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
std::fs::write(&p, key.trim()).map_err(|e| e.to_string())
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
let mut builder = tauri::Builder::default()
.plugin(tauri_plugin_opener::init())
.plugin(tauri_plugin_dialog::init());
#[cfg(desktop)]
{
builder = builder
.plugin(tauri_plugin_updater::Builder::new().build())
.plugin(tauri_plugin_process::init());
}
builder
.setup(|app| {
// stash the app handle so p4 helpers can emit the live command log
let _ = APP.set(app.handle().clone());
Ok(())
})
.manage(AppState::default())
.invoke_handler(tauri::generate_handler![
p4_clients,
p4_login,
p4_restore,
p4_info,
p4_opened,
p4_changes,
p4_history,
p4_disconnect,
p4_sync,
p4_diff,
p4_revert,
p4_submit,
p4_commit,
p4_submit_change,
p4_reopen_default,
p4_set_desc,
p4_add,
p4_edit,
p4_delete,
p4_reconcile,
p4_scan,
p4_undo_change,
open_in_explorer,
find_uproject,
find_sln,
build_sln,
launch_file,
list_editors,
open_in_editor,
p4_describe,
read_file,
write_depot,
read_depot,
print_depot,
p4_console,
ue_log,
p4_opened_all,
p4_lock,
p4_unlock,
p4_typemap_get,
p4_typemap_set,
p4_reopen_type,
p4_sync_to,
p4_labels,
p4_label_tag,
p4_branch_op,
p4_client_spec,
p4_client_save,
uasset_thumbnail,
uasset_export_3d,
p4_shelve,
p4_unshelve,
p4_delete_shelf,
p4_shelved_files,
p4_resolve_list,
p4_resolve_file,
p4_diff2,
p4_annotate,
p4_search_files,
p4_reopen_to,
p4_latest_change,
p4_switch_client,
p4_depots,
p4_users,
p4_groups,
p4_group_member,
read_ai_key,
save_ai_key,
p4_dirs,
])
.run(tauri::generate_context!())
.expect("error while running tauri application");
}
Reference in New Issue View Git Blame Copy Permalink