1#![cfg_attr(target_os = "windows", allow(unused, dead_code))]
 2
 3use fs::RealFs;
 4use futures::channel::mpsc;
 5use gpui::Context as _;
 6use remote::{
 7    json_log::LogRecord,
 8    protocol::{read_message, write_message},
 9    SshSession,
10};
11use remote_server::HeadlessProject;
12use smol::{io::AsyncWriteExt, stream::StreamExt as _, Async};
13use std::{
14    env,
15    io::{self, Write},
16    mem, process,
17    sync::Arc,
18};
19
20#[cfg(windows)]
21fn main() {
22    unimplemented!()
23}
24
25#[cfg(not(windows))]
26fn main() {
27    env::set_var("RUST_BACKTRACE", "1");
28    env_logger::builder()
29        .format(|buf, record| {
30            serde_json::to_writer(&mut *buf, &LogRecord::new(&record))?;
31            buf.write_all(b"\n")?;
32            Ok(())
33        })
34        .init();
35
36    let subcommand = std::env::args().nth(1);
37    match subcommand.as_deref() {
38        Some("run") => {}
39        Some("version") => {
40            println!("{}", env!("ZED_PKG_VERSION"));
41            return;
42        }
43        _ => {
44            eprintln!("usage: remote <run|version>");
45            process::exit(1);
46        }
47    }
48
49    gpui::App::headless().run(move |cx| {
50        HeadlessProject::init(cx);
51
52        let (incoming_tx, incoming_rx) = mpsc::unbounded();
53        let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded();
54
55        let mut stdin = Async::new(io::stdin()).unwrap();
56        let mut stdout = Async::new(io::stdout()).unwrap();
57
58        let session = SshSession::server(incoming_rx, outgoing_tx, cx);
59        let project = cx.new_model(|cx| {
60            HeadlessProject::new(
61                session.clone(),
62                Arc::new(RealFs::new(Default::default(), None)),
63                cx,
64            )
65        });
66
67        cx.background_executor()
68            .spawn(async move {
69                let mut output_buffer = Vec::new();
70                while let Some(message) = outgoing_rx.next().await {
71                    write_message(&mut stdout, &mut output_buffer, message).await?;
72                    stdout.flush().await?;
73                }
74                anyhow::Ok(())
75            })
76            .detach();
77
78        cx.background_executor()
79            .spawn(async move {
80                let mut input_buffer = Vec::new();
81                loop {
82                    let message = match read_message(&mut stdin, &mut input_buffer).await {
83                        Ok(message) => message,
84                        Err(error) => {
85                            log::warn!("error reading message: {:?}", error);
86                            process::exit(0);
87                        }
88                    };
89                    incoming_tx.unbounded_send(message).ok();
90                }
91            })
92            .detach();
93
94        mem::forget(project);
95    });
96}