claudy 0.2.2

Modern multi-provider launcher for Claude CLI
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::process::Stdio;

use anyhow::Context as _;

use crate::config::layout::AppPaths;
use crate::config::registry::AppRegistry;
use crate::config::vault::SecretVault;
use crate::providers::index::ProviderIndex;

pub struct ClaudeProcess {
    child: tokio::process::Child,
    stdin: Option<tokio::process::ChildStdin>,
    stdout: tokio::process::ChildStdout,
    stderr: Option<tokio::process::ChildStderr>,
}

impl ClaudeProcess {
    pub fn child_id(&self) -> Option<u32> {
        self.child.id()
    }

    pub fn take_stdin(&mut self) -> Option<tokio::process::ChildStdin> {
        self.stdin.take()
    }

    pub fn stdout(&mut self) -> &mut tokio::process::ChildStdout {
        &mut self.stdout
    }

    pub fn take_stderr(&mut self) -> Option<tokio::process::ChildStderr> {
        self.stderr.take()
    }

    pub async fn wait(&mut self) -> anyhow::Result<i32> {
        let status = self.child.wait().await?;
        Ok(status.code().unwrap_or(1))
    }

    pub async fn kill(&mut self) -> anyhow::Result<()> {
        Ok(self.child.kill().await?)
    }
}

/// Session-specific parameters for launching a Claude process.
pub struct SessionConfig<'a> {
    pub profile: &'a str,
    pub mode: Option<&'a str>,
    pub resume_session: Option<&'a str>,
    pub working_dir: Option<&'a str>,
    pub model: Option<&'a str>,
    pub yolo: bool,
}

pub fn start_claude_session(
    paths: &AppPaths,
    config: &AppRegistry,
    secrets: &SecretVault,
    catalog: &ProviderIndex,
    session: &SessionConfig<'_>,
) -> anyhow::Result<ClaudeProcess> {
    let target = crate::routing::resolver::route_profile(session.profile, catalog, config)
        .context(format!("Failed to resolve profile '{}'", session.profile))?;
    let env = crate::launcher::envkit::build_auth_environment(&target, secrets)?;
    let claude_bin = crate::launcher::binary::find_claude_cli()?;

    let mut cmd = tokio::process::Command::new(claude_bin);
    cmd.args(["--output-format", "stream-json", "--print", "--verbose"])
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());

    if session.yolo {
        cmd.arg("--dangerously-skip-permissions");
    }

    if let Some(session_id) = session.resume_session {
        cmd.arg("--resume").arg(session_id);
    }

    if let Some(dir) = session.working_dir {
        let path = std::path::Path::new(dir);
        anyhow::ensure!(
            path.is_absolute(),
            "working_dir must be an absolute path: {dir}"
        );
        anyhow::ensure!(
            path.is_dir(),
            "working_dir does not exist or is not a directory: {dir}"
        );
        cmd.current_dir(path);
    }

    if let Some(model_name) = session.model {
        cmd.arg("--model").arg(model_name);
    }

    for env_str in &env {
        if let Some((key, value)) = env_str.split_once('=') {
            cmd.env(key, value);
        }
    }

    if let Some(mode_name) = session.mode {
        let mode_dir = std::path::Path::new(&paths.modes_dir).join(mode_name);
        cmd.env("CLAUDE_CONFIG_DIR", mode_dir);
    } else {
        cmd.env_remove("CLAUDE_CONFIG_DIR");
    }
    cmd.env_remove("CLAUDECODE");
    cmd.env_remove("CLAUDE_CODE_ENTRYPOINT");
    cmd.env_remove("CLAUDE_CODE_OAUTH_TOKEN");
    cmd.env_remove("CLAUDE_CODE_EXECPATH");

    let mut child = cmd.spawn().context("Failed to spawn Claude process")?;
    let stdin = child.stdin.take();
    let stdout = child.stdout.take().context("No stdout on Claude process")?;
    let stderr = child.stderr.take();

    Ok(ClaudeProcess {
        child,
        stdin,
        stdout,
        stderr,
    })
}