agent-message 0.1.4 → 0.3.1

package/codex-message/src/codex.rs

@@ -1,278 +0,0 @@
-use std::collections::HashMap;
-use std::path::Path;
-use std::process::Stdio;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicU64, Ordering};
-
-use anyhow::{Context, Result, anyhow, bail};
-use serde_json::Value;
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
-use tokio::process::{Child, ChildStdin, ChildStdout, Command};
-use tokio::sync::{Mutex, mpsc, oneshot};
-
-#[derive(Debug)]
-pub(crate) enum IncomingMessage {
-    Request {
-        method: String,
-        id: Value,
-        params: Value,
-    },
-    Notification {
-        method: String,
-        params: Value,
-    },
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct RpcError {
-    pub(crate) code: Option<i64>,
-    pub(crate) message: String,
-}
-
-impl std::fmt::Display for RpcError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self.code {
-            Some(code) => write!(f, "rpc error {code}: {}", self.message),
-            None => write!(f, "rpc error: {}", self.message),
-        }
-    }
-}
-
-impl std::error::Error for RpcError {}
-
-pub(crate) struct CodexAppServer {
-    child: Child,
-    stdin: Arc<Mutex<ChildStdin>>,
-    next_request_id: AtomicU64,
-    pending: Arc<Mutex<HashMap<String, oneshot::Sender<Result<Value, RpcError>>>>>,
-    events_rx: mpsc::UnboundedReceiver<IncomingMessage>,
-}
-
-impl CodexAppServer {
-    pub(crate) async fn start(codex_bin: &Path, cwd: &Path) -> Result<Self> {
-        let mut child = Command::new(codex_bin)
-            .arg("app-server")
-            .current_dir(cwd)
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .kill_on_drop(true)
-            .spawn()
-            .with_context(|| format!("spawn `{}`", codex_bin.display()))?;
-
-        let stdin = child.stdin.take().context("capture codex stdin")?;
-        let stdout = child.stdout.take().context("capture codex stdout")?;
-        let stderr = child.stderr.take().context("capture codex stderr")?;
-
-        let pending = Arc::new(Mutex::new(HashMap::new()));
-        let (events_tx, events_rx) = mpsc::unbounded_channel();
-
-        spawn_stdout_pump(stdout, Arc::clone(&pending), events_tx);
-        spawn_stderr_pump(stderr);
-
-        Ok(Self {
-            child,
-            stdin: Arc::new(Mutex::new(stdin)),
-            next_request_id: AtomicU64::new(1),
-            pending,
-            events_rx,
-        })
-    }
-
-    pub(crate) async fn initialize(&self) -> Result<()> {
-        let initialize = serde_json::json!({
-            "clientInfo": {
-                "name": "codex_message",
-                "title": "Codex Message",
-                "version": env!("CARGO_PKG_VERSION"),
-            },
-            "capabilities": {
-                "experimentalApi": true,
-            }
-        });
-        self.request("initialize", initialize).await?;
-        self.notify("initialized", serde_json::json!({})).await
-    }
-
-    pub(crate) async fn request(&self, method: &str, params: Value) -> Result<Value> {
-        let id = self.next_request_id.fetch_add(1, Ordering::SeqCst);
-        let request_id = Value::from(id);
-        let key = id_key(&request_id)?;
-        let (tx, rx) = oneshot::channel();
-        self.pending.lock().await.insert(key, tx);
-        self.write_message(serde_json::json!({
-            "id": request_id,
-            "method": method,
-            "params": params,
-        }))
-        .await?;
-
-        match rx.await {
-            Ok(Ok(result)) => Ok(result),
-            Ok(Err(error)) => Err(error.into()),
-            Err(_) => bail!("rpc response channel dropped for method `{method}`"),
-        }
-    }
-
-    pub(crate) async fn notify(&self, method: &str, params: Value) -> Result<()> {
-        self.write_message(serde_json::json!({
-            "method": method,
-            "params": params,
-        }))
-        .await
-    }
-
-    pub(crate) async fn respond(&self, id: Value, result: Value) -> Result<()> {
-        self.write_message(serde_json::json!({
-            "id": id,
-            "result": result,
-        }))
-        .await
-    }
-
-    pub(crate) async fn next_event(&mut self) -> Result<IncomingMessage> {
-        self.events_rx
-            .recv()
-            .await
-            .ok_or_else(|| anyhow!("codex app-server event stream ended"))
-    }
-
-    pub(crate) async fn shutdown(&mut self) -> Result<()> {
-        if let Err(error) = self.child.start_kill() {
-            eprintln!("[codex] failed to signal shutdown: {error}");
-        }
-        let _ = self.child.wait().await;
-        Ok(())
-    }
-
-    async fn write_message(&self, message: Value) -> Result<()> {
-        let encoded = serde_json::to_vec(&message).context("encode rpc message")?;
-        let mut stdin = self.stdin.lock().await;
-        stdin
-            .write_all(&encoded)
-            .await
-            .context("write rpc payload to codex stdin")?;
-        stdin
-            .write_all(b"\n")
-            .await
-            .context("write rpc newline to codex stdin")?;
-        stdin.flush().await.context("flush codex stdin")
-    }
-}
-
-fn spawn_stdout_pump(
-    stdout: ChildStdout,
-    pending: Arc<Mutex<HashMap<String, oneshot::Sender<Result<Value, RpcError>>>>>,
-    events_tx: mpsc::UnboundedSender<IncomingMessage>,
-) {
-    tokio::spawn(async move {
-        let mut lines = BufReader::new(stdout).lines();
-        loop {
-            let next = lines.next_line().await;
-            let line = match next {
-                Ok(Some(line)) => line,
-                Ok(None) => break,
-                Err(error) => {
-                    eprintln!("[codex] failed to read stdout: {error}");
-                    break;
-                }
-            };
-            let trimmed = line.trim();
-            if trimmed.is_empty() {
-                continue;
-            }
-
-            let value: Value = match serde_json::from_str(trimmed) {
-                Ok(value) => value,
-                Err(error) => {
-                    eprintln!("[codex] invalid JSON from app-server: {error}: {trimmed}");
-                    continue;
-                }
-            };
-
-            if let Some(id) = value.get("id") {
-                if value.get("method").is_some() {
-                    let Some(method) = value.get("method").and_then(Value::as_str) else {
-                        eprintln!("[codex] request missing method string: {trimmed}");
-                        continue;
-                    };
-                    let params = value.get("params").cloned().unwrap_or(Value::Null);
-                    if events_tx
-                        .send(IncomingMessage::Request {
-                            method: method.to_string(),
-                            id: id.clone(),
-                            params,
-                        })
-                        .is_err()
-                    {
-                        break;
-                    }
-                    continue;
-                }
-
-                let key = match id_key(id) {
-                    Ok(key) => key,
-                    Err(error) => {
-                        eprintln!("[codex] invalid response id: {error:#}");
-                        continue;
-                    }
-                };
-                let sender = pending.lock().await.remove(&key);
-                let Some(sender) = sender else {
-                    eprintln!("[codex] dropped response for unknown request id: {trimmed}");
-                    continue;
-                };
-
-                if let Some(result) = value.get("result") {
-                    let _ = sender.send(Ok(result.clone()));
-                    continue;
-                }
-
-                let error = value.get("error").cloned().unwrap_or(Value::Null);
-                let rpc_error = RpcError {
-                    code: error.get("code").and_then(Value::as_i64),
-                    message: error
-                        .get("message")
-                        .and_then(Value::as_str)
-                        .unwrap_or("unknown rpc error")
-                        .to_string(),
-                };
-                let _ = sender.send(Err(rpc_error));
-                continue;
-            }
-
-            if let Some(method) = value.get("method").and_then(Value::as_str) {
-                let params = value.get("params").cloned().unwrap_or(Value::Null);
-                if events_tx
-                    .send(IncomingMessage::Notification {
-                        method: method.to_string(),
-                        params,
-                    })
-                    .is_err()
-                {
-                    break;
-                }
-            }
-        }
-    });
-}
-
-fn spawn_stderr_pump(stderr: tokio::process::ChildStderr) {
-    tokio::spawn(async move {
-        let mut lines = BufReader::new(stderr).lines();
-        loop {
-            match lines.next_line().await {
-                Ok(Some(line)) => eprintln!("[codex] {line}"),
-                Ok(None) => break,
-                Err(error) => {
-                    eprintln!("[codex] failed to read stderr: {error}");
-                    break;
-                }
-            }
-        }
-    });
-}
-
-fn id_key(id: &Value) -> Result<String> {
-    serde_json::to_string(id).context("serialize request id")
-}

package/codex-message/src/main.rs

@@ -1,101 +0,0 @@
-mod agent_message;
-mod app;
-mod codex;
-mod render;
-
-use std::path::PathBuf;
-
-use anyhow::Context;
-use app::App;
-use clap::Parser;
-
-#[derive(Debug, Clone, clap::ValueEnum)]
-enum ApprovalPolicyArg {
-    Untrusted,
-    OnFailure,
-    OnRequest,
-    Never,
-}
-
-impl ApprovalPolicyArg {
-    fn as_app_server_value(&self) -> &'static str {
-        match self {
-            Self::Untrusted => "untrusted",
-            Self::OnFailure => "on-failure",
-            Self::OnRequest => "on-request",
-            Self::Never => "never",
-        }
-    }
-}
-
-#[derive(Debug, Clone, clap::ValueEnum)]
-enum SandboxArg {
-    ReadOnly,
-    WorkspaceWrite,
-    DangerFullAccess,
-}
-
-#[derive(Debug, Clone, Parser)]
-#[command(author, version, about)]
-struct Cli {
-    #[arg(long = "to", env = "CODEX_MESSAGE_TO", default_value = "jay")]
-    to_username: String,
-
-    #[arg(long, env = "CODEX_MESSAGE_CODEX_BIN", default_value = "codex")]
-    codex_bin: PathBuf,
-
-    #[arg(long, env = "CODEX_MESSAGE_MODEL")]
-    model: Option<String>,
-
-    #[arg(long, env = "CODEX_MESSAGE_CWD")]
-    cwd: Option<PathBuf>,
-
-    #[arg(long, env = "CODEX_MESSAGE_APPROVAL_POLICY")]
-    approval_policy: Option<ApprovalPolicyArg>,
-
-    #[arg(long, env = "CODEX_MESSAGE_SANDBOX", default_value = "workspace-write")]
-    sandbox: SandboxArg,
-
-    #[arg(long, env = "CODEX_MESSAGE_NETWORK_ACCESS", default_value_t = false)]
-    network_access: bool,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct Config {
-    pub(crate) to_username: String,
-    pub(crate) codex_bin: PathBuf,
-    pub(crate) model: Option<String>,
-    pub(crate) cwd: PathBuf,
-    pub(crate) approval_policy: Option<String>,
-    pub(crate) sandbox: SandboxArg,
-    pub(crate) network_access: bool,
-}
-
-impl TryFrom<Cli> for Config {
-    type Error = anyhow::Error;
-
-    fn try_from(value: Cli) -> Result<Self, Self::Error> {
-        let cwd = match value.cwd {
-            Some(path) => path,
-            None => std::env::current_dir().context("resolve current working directory")?,
-        };
-
-        Ok(Self {
-            to_username: value.to_username,
-            codex_bin: value.codex_bin,
-            model: value.model,
-            cwd,
-            approval_policy: value
-                .approval_policy
-                .map(|policy| policy.as_app_server_value().to_string()),
-            sandbox: value.sandbox,
-            network_access: value.network_access,
-        })
-    }
-}
-
-#[tokio::main]
-async fn main() -> anyhow::Result<()> {
-    let config = Config::try_from(Cli::parse())?;
-    App::new(config).run().await
-}

package/codex-message/src/render.rs

@@ -1,125 +0,0 @@
-use serde_json::{Map, Value, json};
-
-pub(crate) fn report_spec(badge: &str, title: &str, lines: &[String], body: Option<&str>) -> Value {
-    let mut elements = Map::new();
-    let mut children = Vec::new();
-
-    push_badge(&mut elements, &mut children, "badge", badge);
-    push_text(&mut elements, &mut children, "title", title);
-    push_separator(&mut elements, &mut children, "sep-top");
-
-    for (index, line) in lines.iter().enumerate() {
-        let key = format!("line-{index}");
-        push_text(&mut elements, &mut children, &key, line);
-    }
-
-    if let Some(body) = body.and_then(non_empty) {
-        if !lines.is_empty() {
-            push_separator(&mut elements, &mut children, "sep-body");
-        }
-        for (index, paragraph) in paragraphs(body).into_iter().enumerate() {
-            let key = format!("body-{index}");
-            push_text(&mut elements, &mut children, &key, &paragraph);
-        }
-    }
-
-    elements.insert(
-        "root".to_string(),
-        json!({
-            "type": "Stack",
-            "children": children,
-        }),
-    );
-
-    json!({
-        "root": "root",
-        "elements": elements,
-    })
-}
-
-pub(crate) fn approval_spec(
-    badge: &str,
-    title: &str,
-    details: &[String],
-    reply_hint: &str,
-) -> Value {
-    let mut lines = details.to_vec();
-    lines.push(format!("Reply: {reply_hint}"));
-    report_spec(badge, title, &lines, None)
-}
-
-fn push_badge(
-    elements: &mut Map<String, Value>,
-    children: &mut Vec<String>,
-    key: &str,
-    text: &str,
-) {
-    children.push(key.to_string());
-    elements.insert(
-        key.to_string(),
-        json!({
-            "type": "Badge",
-            "props": { "text": text },
-        }),
-    );
-}
-
-fn push_text(elements: &mut Map<String, Value>, children: &mut Vec<String>, key: &str, text: &str) {
-    children.push(key.to_string());
-    elements.insert(
-        key.to_string(),
-        json!({
-            "type": "Text",
-            "props": { "text": text },
-        }),
-    );
-}
-
-fn push_separator(elements: &mut Map<String, Value>, children: &mut Vec<String>, key: &str) {
-    children.push(key.to_string());
-    elements.insert(
-        key.to_string(),
-        json!({
-            "type": "Separator",
-        }),
-    );
-}
-
-fn paragraphs(text: &str) -> Vec<String> {
-    text.split("\n\n")
-        .map(str::trim)
-        .filter(|part| !part.is_empty())
-        .map(ToOwned::to_owned)
-        .collect()
-}
-
-fn non_empty(value: &str) -> Option<&str> {
-    let trimmed = value.trim();
-    if trimmed.is_empty() {
-        None
-    } else {
-        Some(trimmed)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn report_spec_has_expected_shape() {
-        let spec = report_spec(
-            "Completed",
-            "Request finished",
-            &["Status: ok".to_string()],
-            Some("First paragraph\n\nSecond paragraph"),
-        );
-        assert_eq!(spec["root"], "root");
-        assert_eq!(spec["elements"]["badge"]["type"], "Badge");
-        assert_eq!(spec["elements"]["title"]["type"], "Text");
-        assert_eq!(
-            spec["elements"]["body-1"]["props"]["text"],
-            "Second paragraph"
-        );
-    }
-}

package/npm/bin/codex-message.mjs

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-
-import { spawnSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
-import { dirname, resolve } from 'node:path'
-import process from 'node:process'
-import { fileURLToPath } from 'node:url'
-
-const scriptDir = dirname(fileURLToPath(import.meta.url))
-const packageRoot = resolve(scriptDir, '..', '..')
-const crateDir = resolve(packageRoot, 'codex-message')
-const manifestPath = resolve(crateDir, 'Cargo.toml')
-const binaryPath = resolve(crateDir, 'target', 'debug', process.platform === 'win32' ? 'codex-message.exe' : 'codex-message')
-
-if (!existsSync(manifestPath)) {
-  console.error(`codex-message sources were not found at ${crateDir}`)
-  process.exit(1)
-}
-
-if (!existsSync(binaryPath)) {
-  const build = spawnSync('cargo', ['build', '--manifest-path', manifestPath], {
-    stdio: 'inherit',
-    cwd: packageRoot,
-  })
-  if (build.status !== 0) {
-    process.exit(build.status ?? 1)
-  }
-}
-
-const child = spawnSync(binaryPath, process.argv.slice(2), {
-  stdio: 'inherit',
-  cwd: process.cwd(),
-  env: process.env,
-})
-
-if (child.error) {
-  console.error(child.error.message)
-  process.exit(1)
-}
-
-process.exit(child.status ?? 0)