@mmmbuto/masix 0.3.8 → 0.4.1

package/packages/plugin-base/codex-backend/source/src/lib.rs

@@ -0,0 +1,328 @@
+pub mod error;
+pub mod exec;
+pub mod http_backend;
+pub mod patch;
+pub mod policy;
+pub mod tools;
+pub mod workspace;
+
+pub use error::{CodingError, ExitStatus};
+pub use exec::{
+    CommandExecutor, ExecRequest, ExecResult, DEFAULT_COMMAND_ALLOWLIST, DEFAULT_EXEC_TIMEOUT_SECS,
+    DEFAULT_MAX_OUTPUT_BYTES as EXEC_DEFAULT_MAX_OUTPUT_BYTES, MAX_EXEC_TIMEOUT_SECS,
+};
+pub use http_backend::HttpBackend;
+pub use patch::{
+    apply_patch, preview_patch, rollback_patch, BackupEntry, BackupManifest, PatchApplyResult,
+    PatchPreview,
+};
+pub use policy::{AdminPolicy, PermissionLevel, PolicyContext};
+pub use tools::{
+    get_read_tools, get_write_tools, tools_to_anthropic_format, tools_to_openai_format,
+};
+pub use workspace::{
+    default_workspace_root, resolve_relative_path, resolve_workspace, ExecutionProfile,
+    ResolvedWorkspace, WorkspaceConfig, WorkspaceSource,
+};
+
+use async_trait::async_trait;
+use std::path::PathBuf;
+use std::time::Duration;
+
+pub const DEFAULT_TIMEOUT_SECS: u64 = 300;
+pub const DEFAULT_MAX_OUTPUT_BYTES: usize = 1024 * 1024;
+pub const DEFAULT_MAX_TOKENS: u32 = 4096;
+pub const MAX_LOG_ENTRIES: usize = 1000;
+
+/// Module metadata for plugin registry
+pub const MODULE_ID: &str = "codex-backend";
+pub const MODULE_VERSION: &str = env!("CARGO_PKG_VERSION");
+pub const MODULE_REQUIRES_ADMIN: bool = true;
+
+/// Returns true if this module requires admin privileges
+pub fn requires_admin() -> bool {
+    MODULE_REQUIRES_ADMIN
+}
+
+/// Returns module metadata as JSON
+pub fn module_info() -> serde_json::Value {
+    serde_json::json!({
+        "id": MODULE_ID,
+        "version": MODULE_VERSION,
+        "requires_admin": MODULE_REQUIRES_ADMIN,
+        "capabilities": ["http_client", "file_read", "file_write", "command_exec", "patch_apply"],
+        "trait": "CodingBackend"
+    })
+}
+
+#[derive(Debug, Clone)]
+pub struct CodingTask {
+    pub repo_path: PathBuf,
+    pub instructions: String,
+    pub mode: CodingMode,
+    pub timeout: Option<Duration>,
+    pub max_steps: Option<u32>,
+    /// Policy context for admin checks (optional for backward compatibility)
+    pub policy: Option<PolicyContext>,
+}
+
+impl Default for CodingTask {
+    fn default() -> Self {
+        Self {
+            repo_path: PathBuf::new(),
+            instructions: String::new(),
+            mode: CodingMode::default(),
+            timeout: None,
+            max_steps: None,
+            policy: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub enum CodingMode {
+    #[default]
+    ReadOnly,
+    WorkspaceWrite,
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct CodingResult {
+    pub patch: Option<String>,
+    pub summary: String,
+    pub logs: Vec<String>,
+    pub exit_status: ExitStatus,
+    /// Structured event traces for machine-readable output
+    pub events: Vec<CodingEvent>,
+}
+
+/// Structured event for runtime tracing
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct CodingEvent {
+    /// Event type: start, tool_call, tool_result, iteration, final
+    pub event: String,
+    /// Iteration number (when applicable)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub iteration: Option<u32>,
+    /// Tool name (for tool_call/tool_result)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool: Option<String>,
+    /// Tool call ID
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_call_id: Option<String>,
+    /// Result status
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    /// Timestamp (ISO 8601)
+    pub timestamp: String,
+    /// Additional data
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<serde_json::Value>,
+}
+
+impl CodingEvent {
+    pub fn start(repo_path: &std::path::Path) -> Self {
+        Self {
+            event: "start".into(),
+            iteration: None,
+            tool: None,
+            tool_call_id: None,
+            status: None,
+            timestamp: chrono_like_timestamp(),
+            data: Some(serde_json::json!({ "repo_path": repo_path.display().to_string() })),
+        }
+    }
+
+    pub fn iteration(n: u32) -> Self {
+        Self {
+            event: "iteration".into(),
+            iteration: Some(n),
+            tool: None,
+            tool_call_id: None,
+            status: None,
+            timestamp: chrono_like_timestamp(),
+            data: None,
+        }
+    }
+
+    pub fn tool_call(id: &str, name: &str, args: &str) -> Self {
+        Self {
+            event: "tool_call".into(),
+            iteration: None,
+            tool: Some(name.into()),
+            tool_call_id: Some(id.into()),
+            status: None,
+            timestamp: chrono_like_timestamp(),
+            data: Some(
+                serde_json::json!({ "args_preview": args.chars().take(200).collect::<String>() }),
+            ),
+        }
+    }
+
+    pub fn tool_result(id: &str, name: &str, success: bool, output_preview: &str) -> Self {
+        Self {
+            event: "tool_result".into(),
+            iteration: None,
+            tool: Some(name.into()),
+            tool_call_id: Some(id.into()),
+            status: Some(if success { "success" } else { "error" }.into()),
+            timestamp: chrono_like_timestamp(),
+            data: Some(
+                serde_json::json!({ "output_preview": output_preview.chars().take(200).collect::<String>() }),
+            ),
+        }
+    }
+
+    pub fn final_event(status: &str, summary: &str) -> Self {
+        Self {
+            event: "final".into(),
+            iteration: None,
+            tool: None,
+            tool_call_id: None,
+            status: Some(status.into()),
+            timestamp: chrono_like_timestamp(),
+            data: Some(serde_json::json!({ "summary": summary })),
+        }
+    }
+}
+
+fn chrono_like_timestamp() -> String {
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default();
+    let secs = now.as_secs();
+    let datetime = time_to_iso8601(secs);
+    datetime
+}
+
+fn time_to_iso8601(secs: u64) -> String {
+    // Simple ISO 8601 format without chrono dependency
+    let days = secs / 86400;
+    let rem = secs % 86400;
+    let hours = rem / 3600;
+    let minutes = (rem % 3600) / 60;
+    let seconds = rem % 60;
+
+    // Calculate year/month/day (simplified, good enough for timestamps)
+    let (year, month, day) = days_to_ymd(days);
+    format!(
+        "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}Z",
+        year, month, day, hours, minutes, seconds
+    )
+}
+
+fn days_to_ymd(days: u64) -> (u64, u64, u64) {
+    // Howard Hinnant's civil_from_days algorithm (public domain)
+    // Handles all edge cases including leap years correctly
+    let z = days as i64 + 719468;
+    let era = if z >= 0 { z } else { z - 146096 } / 146097;
+    let doe = (z - era * 146097) as u64; // day of era [0, 146096]
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; // year of era [0, 399]
+    let y = (yoe as i64) + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // day of year [0, 365]
+    let mp = (5 * doy + 2) / 153; // month offset [0, 11]
+    let d = doy - (153 * mp + 2) / 5 + 1; // day [1, 31]
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+    let y = if m <= 2 { y + 1 } else { y };
+    (y as u64, m, d)
+}
+
+#[async_trait]
+pub trait CodingBackend: Send + Sync {
+    /// Execute a coding task. Returns error if policy check fails.
+    async fn run(&self, task: CodingTask) -> Result<CodingResult, CodingError>;
+
+    /// Preview task execution without making changes.
+    fn dry_run(&self, task: &CodingTask) -> DryRunInfo;
+
+    /// Check if task is allowed by policy
+    fn check_policy(&self, task: &CodingTask) -> Result<(), CodingError>;
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct DryRunInfo {
+    pub backend: &'static str,
+    pub provider_type: &'static str,
+    pub base_url: Option<String>,
+    pub model: Option<String>,
+    pub timeout_secs: u64,
+    pub mode: &'static str,
+    pub repo_path: PathBuf,
+    pub policy_allowed: bool,
+    pub requires_admin: bool,
+}
+
+#[derive(Debug, Clone)]
+pub enum ProviderType {
+    OpenAI,
+    Anthropic,
+    OpenAICompatible,
+}
+
+impl ProviderType {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            ProviderType::OpenAI => "openai",
+            ProviderType::Anthropic => "anthropic",
+            ProviderType::OpenAICompatible => "openai-compatible",
+        }
+    }
+
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s {
+            "openai" => Some(ProviderType::OpenAI),
+            "anthropic" => Some(ProviderType::Anthropic),
+            "openai-compatible" => Some(ProviderType::OpenAICompatible),
+            _ => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_module_metadata() {
+        assert_eq!(MODULE_ID, "codex-backend");
+        assert!(requires_admin());
+        let info = module_info();
+        assert_eq!(info["id"], "codex-backend");
+        assert_eq!(info["requires_admin"], true);
+    }
+
+    #[test]
+    fn test_coding_task_default() {
+        let task = CodingTask::default();
+        assert!(task.policy.is_none());
+        assert!(task.repo_path.as_os_str().is_empty());
+    }
+
+    #[test]
+    fn test_days_to_ymd_epoch() {
+        let (y, m, d) = days_to_ymd(0);
+        assert_eq!((y, m, d), (1970, 1, 1));
+    }
+
+    #[test]
+    fn test_days_to_ymd_leap_year() {
+        // 2000-02-29 is day 11016 since epoch
+        // 2000-01-01 = day 10957, plus 31 (Jan) + 28 (Feb 1-28) = 10957+59 = 11016
+        let (y, m, d) = days_to_ymd(11016);
+        assert_eq!((y, m, d), (2000, 2, 29));
+    }
+
+    #[test]
+    fn test_days_to_ymd_2026() {
+        // 2026-03-02: days since epoch
+        // Using known value: 2026-01-01 = 20454 days, +31 (Jan) +28 (Feb) +1 = 20514
+        let (y, m, d) = days_to_ymd(20514);
+        assert_eq!((y, m, d), (2026, 3, 2));
+    }
+
+    #[test]
+    fn test_time_to_iso8601() {
+        let ts = time_to_iso8601(0);
+        assert_eq!(ts, "1970-01-01T00:00:00Z");
+    }
+}