Method create_session

crates/opencode-server/src/pty.rs:62–176

(
        &self,
        command: &str,
        cwd: Option<&str>,
        env: Option<HashMap<String, String>>,
    )

    }

    pub async fn create_session(
        &self,
        command: &str,
        cwd: Option<&str>,
        env: Option<HashMap<String, String>>,
    ) -> Result<PtySession, PtyError> {
        let id = format!("pty_{}", uuid::Uuid::new_v4().simple());
        let env_map = env.unwrap_or_default();
        let cwd_str = cwd.unwrap_or(".").to_string();

        let cmd_string = command.to_string();
        let cwd_clone = cwd_str.clone();
        let env_clone = env_map.clone();

        // Spawn the PTY on a blocking thread since portable-pty is synchronous
        let (master, child, reader) = tokio::task::spawn_blocking(move || {
            let pty_system = native_pty_system();
            let pair = pty_system
                .openpty(PtySize {
                    rows: 24,
                    cols: 80,
                    pixel_width: 0,
                    pixel_height: 0,
                })
                .map_err(|e| PtyError::SpawnFailed(e.to_string()))?;

            let mut cmd = CommandBuilder::new(&cmd_string);
            cmd.cwd(&cwd_clone);
            for (k, v) in &env_clone {
                cmd.env(k, v);
            }

            let child = pair
                .slave
                .spawn_command(cmd)
                .map_err(|e| PtyError::SpawnFailed(e.to_string()))?;

            let reader = pair
                .master
                .try_clone_reader()
                .map_err(|e| PtyError::IoError(e.to_string()))?;

            Ok::<_, PtyError>((pair.master, child, reader))
        })
        .await
        .map_err(|e| PtyError::SpawnFailed(e.to_string()))??;

        let writer = master
            .take_writer()
            .map_err(|e| PtyError::IoError(e.to_string()))?;
        let writer = Arc::new(Mutex::new(writer));

        let output_buffer: Arc<Mutex<Vec<u8>>> = Arc::new(Mutex::new(Vec::new()));
        let cursor: Arc<Mutex<usize>> = Arc::new(Mutex::new(0));
        let (output_tx, _) = broadcast::channel::<Vec<u8>>(256);

        let buffer_clone = output_buffer.clone();
        let cursor_clone = cursor.clone();