everruns-cli 0.18.0

Command-line interface for Everruns — run and manage agents from your terminal
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

// File sync CLI commands
//
// TODO(sdk): Replace RemoteClient (raw reqwest) with SDK session_files() methods.
// SDK v0.1.5 ships session filesystem support (https://github.com/everruns/sdk/issues/60 resolved).
// Migration is tracked separately — involves adapting to SDK's FileInfo/SessionFile types.
//
// Design Decision: All file operations grouped under `everruns files` subcommand.

pub mod ls;
pub mod pull;
pub mod push;
pub mod remote;
pub mod state;
pub mod sync_cmd;
pub mod sync_engine;

use crate::output::OutputFormat;
use anyhow::Result;
use clap::Subcommand;

#[derive(Subcommand)]
pub enum FilesCommand {
    /// Bidirectional live sync between local directory and session workspace
    Sync {
        /// Session ID (e.g. ses_xxx)
        #[arg(long, short)]
        session: String,

        /// Local directory to sync (default: current directory)
        #[arg(default_value = ".")]
        local_dir: String,

        /// Remote poll interval in seconds
        #[arg(long, default_value = "3")]
        interval: u64,

        /// Conflict strategy
        #[arg(long, default_value = "last-write-wins", value_parser = ["last-write-wins", "local-wins", "remote-wins"])]
        conflict: String,

        /// Additional exclude patterns (repeatable)
        #[arg(long)]
        exclude: Vec<String>,

        /// Don't read .gitignore
        #[arg(long)]
        no_gitignore: bool,

        /// Show what would sync without making changes
        #[arg(long)]
        dry_run: bool,

        /// Delete files on one side when deleted on the other
        #[arg(long)]
        delete: bool,

        /// Show every file operation
        #[arg(long, short)]
        verbose: bool,
    },

    /// One-shot push local files to session workspace
    Push {
        /// Session ID (e.g. ses_xxx)
        #[arg(long, short)]
        session: String,

        /// Local directory to push from (default: current directory)
        #[arg(default_value = ".")]
        local_dir: String,

        /// Delete remote files not present locally
        #[arg(long)]
        delete: bool,

        /// Show what would be pushed
        #[arg(long)]
        dry_run: bool,
    },

    /// One-shot pull session workspace files to local directory
    Pull {
        /// Session ID (e.g. ses_xxx)
        #[arg(long, short)]
        session: String,

        /// Local directory to pull into (default: current directory)
        #[arg(default_value = ".")]
        local_dir: String,

        /// Delete local files not present remotely
        #[arg(long)]
        delete: bool,

        /// Show what would be pulled
        #[arg(long)]
        dry_run: bool,
    },

    /// List files in session workspace
    Ls {
        /// Session ID (e.g. ses_xxx)
        #[arg(long, short)]
        session: String,

        /// Remote path to list (default: root)
        #[arg(default_value = "/")]
        path: String,

        /// List recursively
        #[arg(long, short)]
        recursive: bool,

        /// Show size and dates
        #[arg(long, short)]
        long: bool,
    },
}

pub async fn run(
    command: FilesCommand,
    api_url: &str,
    api_key: &str,
    org_id: Option<&str>,
    output: OutputFormat,
    quiet: bool,
) -> Result<()> {
    match command {
        FilesCommand::Sync {
            session,
            local_dir,
            interval,
            conflict,
            exclude,
            no_gitignore,
            dry_run,
            delete,
            verbose,
        } => {
            sync_cmd::run(
                api_url,
                api_key,
                org_id,
                quiet,
                session,
                local_dir,
                interval,
                conflict,
                exclude,
                no_gitignore,
                dry_run,
                delete,
                verbose,
            )
            .await
        }
        FilesCommand::Push {
            session,
            local_dir,
            delete,
            dry_run,
        } => {
            push::run(
                api_url, api_key, org_id, output, quiet, session, local_dir, delete, dry_run,
            )
            .await
        }
        FilesCommand::Pull {
            session,
            local_dir,
            delete,
            dry_run,
        } => {
            pull::run(
                api_url, api_key, org_id, output, quiet, session, local_dir, delete, dry_run,
            )
            .await
        }
        FilesCommand::Ls {
            session,
            path,
            recursive,
            long,
        } => {
            ls::run(
                api_url, api_key, org_id, output, session, path, recursive, long,
            )
            .await
        }
    }
}