143 lines
4.1 KiB
Rust
143 lines
4.1 KiB
Rust
use anyhow::{anyhow, Result};
|
||
use clap::Parser;
|
||
use cli::{CliRequest, CliResponse, IpcHandshake};
|
||
use core_foundation::{
|
||
array::{CFArray, CFIndex},
|
||
string::kCFStringEncodingUTF8,
|
||
url::{CFURLCreateWithBytes, CFURL},
|
||
};
|
||
use core_services::{kLSLaunchDefaults, LSLaunchURLSpec, LSOpenFromURLSpec, TCFType};
|
||
use ipc_channel::ipc::{IpcOneShotServer, IpcReceiver, IpcSender};
|
||
use serde::Deserialize;
|
||
use std::{
|
||
ffi::OsStr,
|
||
fs::{self, OpenOptions},
|
||
io,
|
||
path::{Path, PathBuf},
|
||
ptr,
|
||
};
|
||
|
||
#[derive(Parser)]
|
||
#[clap(name = "zed", global_setting(clap::AppSettings::NoAutoVersion))]
|
||
struct Args {
|
||
/// Wait for all of the given paths to be closed before exiting.
|
||
#[clap(short, long)]
|
||
wait: bool,
|
||
/// A sequence of space-separated paths that you want to open.
|
||
#[clap()]
|
||
paths: Vec<PathBuf>,
|
||
/// Print Zed's version and the app path.
|
||
#[clap(short, long)]
|
||
version: bool,
|
||
/// Custom Zed.app path
|
||
#[clap(short, long)]
|
||
bundle_path: Option<PathBuf>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize)]
|
||
struct InfoPlist {
|
||
#[serde(rename = "CFBundleShortVersionString")]
|
||
bundle_short_version_string: String,
|
||
}
|
||
|
||
fn main() -> Result<()> {
|
||
let args = Args::parse();
|
||
|
||
let bundle_path = if let Some(bundle_path) = args.bundle_path {
|
||
bundle_path.canonicalize()?
|
||
} else {
|
||
locate_bundle()?
|
||
};
|
||
|
||
if args.version {
|
||
let plist_path = bundle_path.join("Contents/Info.plist");
|
||
let plist = plist::from_file::<_, InfoPlist>(plist_path)?;
|
||
println!(
|
||
"Zed {} – {}",
|
||
plist.bundle_short_version_string,
|
||
bundle_path.to_string_lossy()
|
||
);
|
||
return Ok(());
|
||
}
|
||
|
||
for path in args.paths.iter() {
|
||
if !path.exists() {
|
||
touch(path.as_path())?;
|
||
}
|
||
}
|
||
|
||
let (tx, rx) = launch_app(bundle_path)?;
|
||
|
||
tx.send(CliRequest::Open {
|
||
paths: args
|
||
.paths
|
||
.into_iter()
|
||
.map(|path| fs::canonicalize(path).map_err(|error| anyhow!(error)))
|
||
.collect::<Result<Vec<PathBuf>>>()?,
|
||
wait: args.wait,
|
||
})?;
|
||
|
||
while let Ok(response) = rx.recv() {
|
||
match response {
|
||
CliResponse::Ping => {}
|
||
CliResponse::Stdout { message } => println!("{message}"),
|
||
CliResponse::Stderr { message } => eprintln!("{message}"),
|
||
CliResponse::Exit { status } => std::process::exit(status),
|
||
}
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn touch(path: &Path) -> io::Result<()> {
|
||
match OpenOptions::new().create(true).write(true).open(path) {
|
||
Ok(_) => Ok(()),
|
||
Err(e) => Err(e),
|
||
}
|
||
}
|
||
|
||
fn locate_bundle() -> Result<PathBuf> {
|
||
let cli_path = std::env::current_exe()?.canonicalize()?;
|
||
let mut app_path = cli_path.clone();
|
||
while app_path.extension() != Some(OsStr::new("app")) {
|
||
if !app_path.pop() {
|
||
return Err(anyhow!("cannot find app bundle containing {:?}", cli_path));
|
||
}
|
||
}
|
||
Ok(app_path)
|
||
}
|
||
|
||
fn launch_app(app_path: PathBuf) -> Result<(IpcSender<CliRequest>, IpcReceiver<CliResponse>)> {
|
||
let (server, server_name) = IpcOneShotServer::<IpcHandshake>::new()?;
|
||
let url = format!("zed-cli://{server_name}");
|
||
|
||
let status = unsafe {
|
||
let app_url =
|
||
CFURL::from_path(&app_path, true).ok_or_else(|| anyhow!("invalid app path"))?;
|
||
let url_to_open = CFURL::wrap_under_create_rule(CFURLCreateWithBytes(
|
||
ptr::null(),
|
||
url.as_ptr(),
|
||
url.len() as CFIndex,
|
||
kCFStringEncodingUTF8,
|
||
ptr::null(),
|
||
));
|
||
let urls_to_open = CFArray::from_copyable(&[url_to_open.as_concrete_TypeRef()]);
|
||
LSOpenFromURLSpec(
|
||
&LSLaunchURLSpec {
|
||
appURL: app_url.as_concrete_TypeRef(),
|
||
itemURLs: urls_to_open.as_concrete_TypeRef(),
|
||
passThruParams: ptr::null(),
|
||
launchFlags: kLSLaunchDefaults,
|
||
asyncRefCon: ptr::null_mut(),
|
||
},
|
||
ptr::null_mut(),
|
||
)
|
||
};
|
||
|
||
if status == 0 {
|
||
let (_, handshake) = server.accept()?;
|
||
Ok((handshake.requests, handshake.responses))
|
||
} else {
|
||
Err(anyhow!("cannot start {:?}", app_path))
|
||
}
|
||
}
|