ort-openrouter-cli 0.4.1

Open Router CLI
Documentation 
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

//! ort: Open Router CLI
//! https://github.com/grahamking/ort
//!
//! MIT License
//! Copyright (c) 2025 Graham King

extern crate alloc;
use alloc::string::String;
use alloc::vec::Vec;
use core::ffi::CStr;

use crate::{ErrorKind, OrtResult, PromptOpts, common::utils, ort_error};

const DEFAULT_SAVE_TO_FILE: bool = true;

pub fn load_config(filename: &'static str) -> OrtResult<ConfigFile> {
    let mut config_dir = xdg_dir(c"XDG_CONFIG_HOME", ".config")?;
    config_dir.push('/');
    config_dir.push_str(filename);
    let config_file = config_dir;
    match utils::filename_read_to_string(&config_file) {
        Ok(cfg_str) => {
            ConfigFile::from_json(&cfg_str).map_err(|_| ort_error(ErrorKind::ConfigParseFailed, ""))
        }
        Err("NOT FOUND") => Ok(ConfigFile::default()),
        Err(_e) => Err(ort_error(ErrorKind::ConfigReadFailed, "")),
    }
}

#[derive(Default)]
pub struct ConfigFile {
    pub settings: Option<Settings>,
    pub keys: Vec<ApiKey>,
    pub prompt_opts: Option<PromptOpts>,
}

impl ConfigFile {
    /// Get the API key. There should only be one.
    pub fn get_api_key(&self) -> Option<String> {
        self.keys.first().as_ref().map(|k| k.value.clone())
    }
    pub fn _save_to_file(&self) -> bool {
        self.settings
            .as_ref()
            .map(|s| s.save_to_file)
            .unwrap_or(DEFAULT_SAVE_TO_FILE)
    }
}

#[derive(Debug)]
pub struct Settings {
    /// Yes to persist to a file in ~/.cache/ort to allow `-c` flag (continue)
    pub save_to_file: bool,
    /// IP addresses of openrouter.ai or integrate.api.nvidia.com.
    /// Saves time resolving them.
    pub dns: Vec<String>,
}

impl Default for Settings {
    fn default() -> Self {
        Settings {
            save_to_file: DEFAULT_SAVE_TO_FILE,
            dns: Vec::new(),
        }
    }
}

// The unit tests in output/from_json.rs need PartialEq
#[derive(Debug, PartialEq)]
pub struct ApiKey {
    name: String,
    value: String,
}

impl ApiKey {
    pub fn new(name: String, value: String) -> Self {
        ApiKey { name, value }
    }
}

pub fn cache_dir() -> OrtResult<String> {
    let mut cache_dir = xdg_dir(c"XDG_CACHE_HOME", ".cache")?;
    cache_dir.push('/');
    cache_dir.push_str("ort");
    utils::ensure_dir_exists(&cache_dir);
    Ok(cache_dir)
}

/// A standard XDG directory based on environment variable, or default
pub fn xdg_dir(var_name: &CStr, default: &'static str) -> OrtResult<String> {
    let dir = utils::get_env(var_name);
    if !dir.is_empty() {
        // If it's in the env var, we assume the dir exists
        return Ok(dir);
    }

    let mut home_dir = utils::get_env(c"HOME");
    if !home_dir.is_empty() {
        home_dir.push('/');
        home_dir.push_str(default);
        utils::ensure_dir_exists(&home_dir);
        Ok(home_dir)
    } else {
        Err(ort_error(
            ErrorKind::MissingHomeDir,
            "Could not get home dir. Is $HOME set?",
        ))
    }
}