feat: add main features

Agents for developpement added + frontend add + backend added. Git viewer created + agent and template creator + layout and project creator

crates/application/src/terminal/usecases.rs

@@ -0,0 +1,250 @@
+//! The four terminal use cases (ARCHITECTURE §6, L3).
+
+use std::sync::Arc;
+
+use domain::ports::{EventBus, PtyPort, SpawnSpec};
+use domain::{
+    DomainEvent, NodeId, ProjectPath, PtySize, SessionId, SessionKind, SessionStatus,
+    TerminalSession,
+};
+
+use crate::error::AppError;
+
+use super::registry::TerminalSessions;
+
+/// Input for [`OpenTerminal::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct OpenTerminalInput {
+    /// Working directory for the shell (absolute path; defaults applied by the
+    /// caller — typically the project root).
+    pub cwd: String,
+    /// Initial terminal height in rows.
+    pub rows: u16,
+    /// Initial terminal width in columns.
+    pub cols: u16,
+    /// Command to run. `None` ⇒ the platform default login shell.
+    pub command: Option<String>,
+    /// Arguments for the command.
+    pub args: Vec<String>,
+    /// The layout leaf hosting this session. `None` ⇒ a fresh node id (L4 will
+    /// thread the real layout node through here).
+    pub node_id: Option<NodeId>,
+}
+
+/// Output of [`OpenTerminal::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct OpenTerminalOutput {
+    /// The created terminal session (its `id` is the [`SessionId`] minted by the
+    /// PTY layer and reused everywhere — write/resize/close, the output channel).
+    pub session: TerminalSession,
+}
+
+/// Opens a PTY in a cwd, creates a [`TerminalSession`], registers the handle.
+pub struct OpenTerminal {
+    pty: Arc<dyn PtyPort>,
+    sessions: Arc<TerminalSessions>,
+    events: Arc<dyn EventBus>,
+}
+
+impl OpenTerminal {
+    /// Builds the use case from its injected ports/services.
+    #[must_use]
+    pub fn new(
+        pty: Arc<dyn PtyPort>,
+        sessions: Arc<TerminalSessions>,
+        events: Arc<dyn EventBus>,
+    ) -> Self {
+        Self {
+            pty,
+            sessions,
+            events,
+        }
+    }
+
+    /// Executes the open: validate cwd + size, spawn the PTY, snapshot the
+    /// session, register the live handle, publish [`DomainEvent::LayoutChanged`].
+    ///
+    /// # Errors
+    /// - [`AppError::Invalid`] for a non-absolute cwd or a zero-sized terminal,
+    /// - [`AppError::Process`] if the PTY fails to spawn.
+    pub async fn execute(
+        &self,
+        input: OpenTerminalInput,
+    ) -> Result<OpenTerminalOutput, AppError> {
+        let cwd = ProjectPath::new(input.cwd).map_err(|e| AppError::Invalid(e.to_string()))?;
+        let size =
+            PtySize::new(input.rows, input.cols).map_err(|e| AppError::Invalid(e.to_string()))?;
+
+        let command = input.command.unwrap_or_else(default_shell);
+        let spec = SpawnSpec {
+            command,
+            args: input.args,
+            cwd: cwd.clone(),
+            env: Vec::new(),
+            context_plan: None,
+        };
+
+        // The PTY layer owns the session identity; we adopt the returned handle's
+        // id as the `TerminalSession.id` (single source of truth, ARCHITECTURE §4).
+        let handle = self.pty.spawn(spec, size).await?;
+        let session_id = handle.session_id;
+        let node_id = input.node_id.unwrap_or_else(NodeId::new_random);
+
+        let mut session =
+            TerminalSession::starting(session_id, node_id, cwd, SessionKind::Plain, size);
+        session.status = SessionStatus::Running;
+
+        self.sessions.insert(handle, session.clone());
+
+        // Output streaming + per-session Channel wiring happens in the presentation
+        // layer (it owns the transport). Announce so the UI can react.
+        self.events.publish(DomainEvent::PtyOutput {
+            session_id,
+            bytes: Vec::new(),
+        });
+
+        Ok(OpenTerminalOutput { session })
+    }
+}
+
+/// Input for [`WriteToTerminal::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WriteToTerminalInput {
+    /// Target session.
+    pub session_id: SessionId,
+    /// Bytes to write (typically keystrokes from xterm.js).
+    pub data: Vec<u8>,
+}
+
+/// Forwards bytes (keystrokes) to a live PTY.
+pub struct WriteToTerminal {
+    pty: Arc<dyn PtyPort>,
+    sessions: Arc<TerminalSessions>,
+}
+
+impl WriteToTerminal {
+    /// Builds the use case.
+    #[must_use]
+    pub fn new(pty: Arc<dyn PtyPort>, sessions: Arc<TerminalSessions>) -> Self {
+        Self { pty, sessions }
+    }
+
+    /// Writes to the session's PTY.
+    ///
+    /// # Errors
+    /// - [`AppError::NotFound`] if the session is unknown,
+    /// - [`AppError::Process`] on PTY I/O failure.
+    pub fn execute(&self, input: WriteToTerminalInput) -> Result<(), AppError> {
+        let handle = self
+            .sessions
+            .handle(&input.session_id)
+            .ok_or_else(|| AppError::NotFound(format!("terminal session {}", input.session_id)))?;
+        self.pty.write(&handle, &input.data)?;
+        Ok(())
+    }
+}
+
+/// Input for [`ResizeTerminal::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResizeTerminalInput {
+    /// Target session.
+    pub session_id: SessionId,
+    /// New height in rows.
+    pub rows: u16,
+    /// New width in columns.
+    pub cols: u16,
+}
+
+/// Resizes a live PTY.
+pub struct ResizeTerminal {
+    pty: Arc<dyn PtyPort>,
+    sessions: Arc<TerminalSessions>,
+}
+
+impl ResizeTerminal {
+    /// Builds the use case.
+    #[must_use]
+    pub fn new(pty: Arc<dyn PtyPort>, sessions: Arc<TerminalSessions>) -> Self {
+        Self { pty, sessions }
+    }
+
+    /// Resizes the session's PTY.
+    ///
+    /// # Errors
+    /// - [`AppError::Invalid`] for a zero-sized terminal,
+    /// - [`AppError::NotFound`] if the session is unknown,
+    /// - [`AppError::Process`] on PTY failure.
+    pub fn execute(&self, input: ResizeTerminalInput) -> Result<(), AppError> {
+        let size =
+            PtySize::new(input.rows, input.cols).map_err(|e| AppError::Invalid(e.to_string()))?;
+        let handle = self
+            .sessions
+            .handle(&input.session_id)
+            .ok_or_else(|| AppError::NotFound(format!("terminal session {}", input.session_id)))?;
+        self.pty.resize(&handle, size)?;
+        Ok(())
+    }
+}
+
+/// Input for [`CloseTerminal::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CloseTerminalInput {
+    /// Target session.
+    pub session_id: SessionId,
+}
+
+/// Output of [`CloseTerminal::execute`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CloseTerminalOutput {
+    /// Exit code reported by the killed process (`None` if signalled).
+    pub code: Option<i32>,
+}
+
+/// Kills a live PTY and forgets its handle.
+pub struct CloseTerminal {
+    pty: Arc<dyn PtyPort>,
+    sessions: Arc<TerminalSessions>,
+}
+
+impl CloseTerminal {
+    /// Builds the use case.
+    #[must_use]
+    pub fn new(pty: Arc<dyn PtyPort>, sessions: Arc<TerminalSessions>) -> Self {
+        Self { pty, sessions }
+    }
+
+    /// Kills the session's PTY and removes it from the registry. Idempotent on
+    /// the registry side (removing an unknown session is a no-op error).
+    ///
+    /// # Errors
+    /// - [`AppError::NotFound`] if the session is unknown,
+    /// - [`AppError::Process`] if the kill fails.
+    pub async fn execute(
+        &self,
+        input: CloseTerminalInput,
+    ) -> Result<CloseTerminalOutput, AppError> {
+        let handle = self
+            .sessions
+            .remove(&input.session_id)
+            .ok_or_else(|| AppError::NotFound(format!("terminal session {}", input.session_id)))?;
+        let status = self.pty.kill(&handle).await?;
+        Ok(CloseTerminalOutput { code: status.code })
+    }
+}
+
+/// The platform default interactive shell.
+///
+/// Resolution policy lives in the application layer (a metier default), not the
+/// adapter, so it is uniform and testable. On Unix we honour `$SHELL`, falling
+/// back to `/bin/sh`; on Windows we use `cmd.exe` (a ConPTY spike point — PowerShell
+/// could become the default, ARCHITECTURE §13.1).
+fn default_shell() -> String {
+    #[cfg(windows)]
+    {
+        std::env::var("COMSPEC").unwrap_or_else(|_| "cmd.exe".to_owned())
+    }
+    #[cfg(not(windows))]
+    {
+        std::env::var("SHELL").unwrap_or_else(|_| "/bin/sh".to_owned())
+    }
+}