commit 368f616435c9e57b8d8a9f4dd4866f9ebaa8cf5d · dunkirk.sh/tangled-cli

Cargo.lock

···

       1981
       1981
        
        "anyhow",

     

       1982
       1982
        
        "atrium-api",

     

       1983
       1983
        
        "atrium-xrpc-client",

     

       1984
       1984
       +
        "chrono",

     

       1984
       1985
        
        "reqwest",

     

       1985
       1986
        
        "serde",

     

       1986
       1987
        
        "serde_json",

+1 -1

crates/tangled-api/Cargo.toml

···

       11
       11
        
       serde_json = { workspace = true }

     

       12
       12
        
       reqwest = { workspace = true }

     

       13
       13
        
       tokio = { workspace = true, features = ["full"] }

     

       14
       14
       +
       chrono = { workspace = true }

     

       14
       15
        
       

     

       15
       16
        
       # Optionally depend on ATrium (wired later as endpoints solidify)

     

       16
       17
        
       atrium-api = { workspace = true, optional = true }

     
···

       21
       22
        
       [features]

     

       22
       23
        
       default = []

     

       23
       24
        
       atrium = ["dep:atrium-api", "dep:atrium-xrpc-client"]

     

       24
       24
       -

+184 -32

crates/tangled-api/src/client.rs

···

       7
       7
        
           base_url: String,

     

       8
       8
        
       }

     

       9
       9
        
       

     

       10
       10
       +
       const REPO_CREATE: &str = "sh.tangled.repo.create";

     

       11
       11
       +
       

     

       12
       12
       +
       impl Default for TangledClient {

     

       13
       13
       +
           fn default() -> Self {

     

       14
       14
       +
               Self::new("https://tngl.sh")

     

       15
       15
       +
           }

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       10
       18
        
       impl TangledClient {

     

       11
       19
        
           pub fn new(base_url: impl Into<String>) -> Self {

     

       12
       12
       -
               Self { base_url: base_url.into() }

     

       13
       13
       -
           }

     

       14
       14
       -
       

     

       15
       15
       -
           pub fn default() -> Self {

     

       16
       16
       -
               Self::new("https://tangled.org")

     

       20
       20
       +
               Self {

     

       21
       21
       +
                   base_url: base_url.into(),

     

       22
       22
       +
               }

     

       17
       23
        
           }

     

       18
       24
        
       

     

       19
       25
        
           fn xrpc_url(&self, method: &str) -> String {

     

       20
       20
       -
               format!(

     

       21
       21
       -
                   "{}/xrpc/{}",

     

       22
       22
       -
                   self.base_url.trim_end_matches('/'),

     

       23
       23
       -
                   method

     

       24
       24
       -
               )

     

       26
       26
       +
               format!("{}/xrpc/{}", self.base_url.trim_end_matches('/'), method)

     

       25
       27
        
           }

     

       26
       28
        
       

     

       27
       29
        
           async fn post_json<TReq: Serialize, TRes: DeserializeOwned>(

     
···

       36
       38
        
                   .post(url)

     

       37
       39
        
                   .header(reqwest::header::CONTENT_TYPE, "application/json");

     

       38
       40
        
               if let Some(token) = bearer {

     

       39
       39
       -
                   reqb = reqb.header(

     

       40
       40
       -
                       reqwest::header::AUTHORIZATION,

     

       41
       41
       -
                       format!("Bearer {}", token),

     

       42
       42
       -
                   );

     

       41
       41
       +
                   reqb = reqb.header(reqwest::header::AUTHORIZATION, format!("Bearer {}", token));

     

       43
       42
        
               }

     

       44
       43
        
               let res = reqb.json(req).send().await?;

     

       45
       44
        
               let status = res.status();

     
···

       58
       57
        
           ) -> Result<TRes> {

     

       59
       58
        
               let url = self.xrpc_url(method);

     

       60
       59
        
               let client = reqwest::Client::new();

     

       61
       61
       -
               let mut reqb = client.get(url).query(&params);

     

       60
       60
       +
               let mut reqb = client

     

       61
       61
       +
                   .get(&url)

     

       62
       62
       +
                   .query(&params)

     

       63
       63
       +
                   .header(reqwest::header::ACCEPT, "application/json");

     

       62
       64
        
               if let Some(token) = bearer {

     

       63
       63
       -
                   reqb = reqb.header(

     

       64
       64
       -
                       reqwest::header::AUTHORIZATION,

     

       65
       65
       -
                       format!("Bearer {}", token),

     

       66
       66
       -
                   );

     

       65
       65
       +
                   reqb = reqb.header(reqwest::header::AUTHORIZATION, format!("Bearer {}", token));

     

       67
       66
        
               }

     

       68
       67
        
               let res = reqb.send().await?;

     

       69
       68
        
               let status = res.status();

     

       69
       69
       +
               let body = res.text().await.unwrap_or_default();

     

       70
       70
        
               if !status.is_success() {

     

       71
       71
       -
                   let body = res.text().await.unwrap_or_default();

     

       72
       72
       -
                   return Err(anyhow!("{}: {}", status, body));

     

       71
       71
       +
                   return Err(anyhow!("GET {} -> {}: {}", url, status, body));

     

       73
       72
        
               }

     

       74
       74
       -
               Ok(res.json::<TRes>().await?)

     

       73
       73
       +
               serde_json::from_str::<TRes>(&body).map_err(|e| {

     

       74
       74
       +
                   let snippet = body.chars().take(300).collect::<String>();

     

       75
       75
       +
                   anyhow!(

     

       76
       76
       +
                       "error decoding response from {}: {}\nBody (first 300 chars): {}",

     

       77
       77
       +
                       url,

     

       78
       78
       +
                       e,

     

       79
       79
       +
                       snippet

     

       80
       80
       +
                   )

     

       81
       81
       +
               })

     

       75
       82
        
           }

     

       76
       83
        
       

     

       77
       84
        
           pub async fn login_with_password(

     
···

       119
       126
        
               starred: bool,

     

       120
       127
        
               bearer: Option<&str>,

     

       121
       128
        
           ) -> Result<Vec<Repository>> {

     

       129
       129
       +
               // NOTE: Repo listing is done via the user's PDS using com.atproto.repo.listRecords

     

       130
       130
       +
               // for the collection "sh.tangled.repo". This does not go through the Tangled API base.

     

       131
       131
       +
               // Here, `self.base_url` must be the PDS base (e.g., https://bsky.social).

     

       132
       132
       +
               // Resolve handle to DID if needed

     

       133
       133
       +
               let did = match user {

     

       134
       134
       +
                   Some(u) if u.starts_with("did:") => u.to_string(),

     

       135
       135
       +
                   Some(handle) => {

     

       136
       136
       +
                       #[derive(Deserialize)]

     

       137
       137
       +
                       struct Res {

     

       138
       138
       +
                           did: String,

     

       139
       139
       +
                       }

     

       140
       140
       +
                       let params = [("handle", handle.to_string())];

     

       141
       141
       +
                       let res: Res = self

     

       142
       142
       +
                           .get_json("com.atproto.identity.resolveHandle", &params, bearer)

     

       143
       143
       +
                           .await?;

     

       144
       144
       +
                       res.did

     

       145
       145
       +
                   }

     

       146
       146
       +
                   None => {

     

       147
       147
       +
                       return Err(anyhow!(

     

       148
       148
       +
                           "missing user for list_repos; provide handle or DID"

     

       149
       149
       +
                       ));

     

       150
       150
       +
                   }

     

       151
       151
       +
               };

     

       152
       152
       +
       

     

       122
       153
        
               #[derive(Deserialize)]

     

       123
       123
       -
               struct Envelope {

     

       124
       124
       -
                   repos: Vec<Repository>,

     

       154
       154
       +
               struct RecordItem {

     

       155
       155
       +
                   value: Repository,

     

       125
       156
        
               }

     

       126
       126
       -
               let mut q = vec![];

     

       127
       127
       -
               if let Some(u) = user {

     

       128
       128
       -
                   q.push(("user", u.to_string()));

     

       157
       157
       +
               #[derive(Deserialize)]

     

       158
       158
       +
               struct ListRes {

     

       159
       159
       +
                   #[serde(default)]

     

       160
       160
       +
                   records: Vec<RecordItem>,

     

       129
       161
        
               }

     

       162
       162
       +
       

     

       163
       163
       +
               let params = vec![

     

       164
       164
       +
                   ("repo", did),

     

       165
       165
       +
                   ("collection", "sh.tangled.repo".to_string()),

     

       166
       166
       +
                   ("limit", "100".to_string()),

     

       167
       167
       +
               ];

     

       168
       168
       +
       

     

       169
       169
       +
               let res: ListRes = self

     

       170
       170
       +
                   .get_json("com.atproto.repo.listRecords", &params, bearer)

     

       171
       171
       +
                   .await?;

     

       172
       172
       +
               let mut repos: Vec<Repository> = res.records.into_iter().map(|r| r.value).collect();

     

       173
       173
       +
               // Apply optional filters client-side

     

       130
       174
        
               if let Some(k) = knot {

     

       131
       131
       -
                   q.push(("knot", k.to_string()));

     

       175
       175
       +
                   repos.retain(|r| r.knot.as_deref().unwrap_or("") == k);

     

       132
       176
        
               }

     

       133
       177
        
               if starred {

     

       134
       134
       -
                   q.push(("starred", true.to_string()));

     

       178
       178
       +
                   // TODO: implement starred filtering when API is available. For now, no-op.

     

       135
       179
        
               }

     

       136
       136
       -
               let env: Envelope = self

     

       137
       137
       -
                   .get_json("sh.tangled.repo.list", &q, bearer)

     

       180
       180
       +
               Ok(repos)

     

       181
       181
       +
           }

     

       182
       182
       +
       

     

       183
       183
       +
           pub async fn create_repo(&self, opts: CreateRepoOptions<'_>) -> Result<()> {

     

       184
       184
       +
               // 1) Create the sh.tangled.repo record on the user's PDS

     

       185
       185
       +
               #[derive(Serialize)]

     

       186
       186
       +
               struct Record<'a> {

     

       187
       187
       +
                   name: &'a str,

     

       188
       188
       +
                   knot: &'a str,

     

       189
       189
       +
                   #[serde(skip_serializing_if = "Option::is_none")]

     

       190
       190
       +
                   description: Option<&'a str>,

     

       191
       191
       +
                   #[serde(rename = "createdAt")]

     

       192
       192
       +
                   created_at: String,

     

       193
       193
       +
               }

     

       194
       194
       +
               #[derive(Serialize)]

     

       195
       195
       +
               struct CreateRecordReq<'a> {

     

       196
       196
       +
                   repo: &'a str,

     

       197
       197
       +
                   collection: &'a str,

     

       198
       198
       +
                   validate: bool,

     

       199
       199
       +
                   record: Record<'a>,

     

       200
       200
       +
               }

     

       201
       201
       +
               #[derive(Deserialize)]

     

       202
       202
       +
               struct CreateRecordRes {

     

       203
       203
       +
                   uri: String,

     

       204
       204
       +
               }

     

       205
       205
       +
       

     

       206
       206
       +
               let now = chrono::Utc::now().to_rfc3339();

     

       207
       207
       +
               let rec = Record {

     

       208
       208
       +
                   name: opts.name,

     

       209
       209
       +
                   knot: opts.knot,

     

       210
       210
       +
                   description: opts.description,

     

       211
       211
       +
                   created_at: now,

     

       212
       212
       +
               };

     

       213
       213
       +
               let create_req = CreateRecordReq {

     

       214
       214
       +
                   repo: opts.did,

     

       215
       215
       +
                   collection: "sh.tangled.repo",

     

       216
       216
       +
                   validate: true,

     

       217
       217
       +
                   record: rec,

     

       218
       218
       +
               };

     

       219
       219
       +
       

     

       220
       220
       +
               let pds_client = TangledClient::new(opts.pds_base);

     

       221
       221
       +
               let created: CreateRecordRes = pds_client

     

       222
       222
       +
                   .post_json(

     

       223
       223
       +
                       "com.atproto.repo.createRecord",

     

       224
       224
       +
                       &create_req,

     

       225
       225
       +
                       Some(opts.access_jwt),

     

       226
       226
       +
                   )

     

       138
       227
        
                   .await?;

     

       139
       139
       -
               Ok(env.repos)

     

       228
       228
       +
       

     

       229
       229
       +
               // Extract rkey from at-uri: at://did/collection/rkey

     

       230
       230
       +
               let rkey = created

     

       231
       231
       +
                   .uri

     

       232
       232
       +
                   .rsplit('/')

     

       233
       233
       +
                   .next()

     

       234
       234
       +
                   .ok_or_else(|| anyhow!("failed to parse rkey from uri"))?;

     

       235
       235
       +
       

     

       236
       236
       +
               // 2) Obtain a service auth token for the Tangled server (aud = did:web:<host>)

     

       237
       237
       +
               let host = self

     

       238
       238
       +
                   .base_url

     

       239
       239
       +
                   .trim_end_matches('/')

     

       240
       240
       +
                   .strip_prefix("https://")

     

       241
       241
       +
                   .or_else(|| self.base_url.trim_end_matches('/').strip_prefix("http://"))

     

       242
       242
       +
                   .ok_or_else(|| anyhow!("invalid base_url"))?;

     

       243
       243
       +
               let audience = format!("did:web:{}", host);

     

       244
       244
       +
       

     

       245
       245
       +
               #[derive(Deserialize)]

     

       246
       246
       +
               struct GetSARes {

     

       247
       247
       +
                   token: String,

     

       248
       248
       +
               }

     

       249
       249
       +
               let params = [

     

       250
       250
       +
                   ("aud", audience),

     

       251
       251
       +
                   ("exp", (chrono::Utc::now().timestamp() + 600).to_string()),

     

       252
       252
       +
               ];

     

       253
       253
       +
               let sa: GetSARes = pds_client

     

       254
       254
       +
                   .get_json(

     

       255
       255
       +
                       "com.atproto.server.getServiceAuth",

     

       256
       256
       +
                       &params,

     

       257
       257
       +
                       Some(opts.access_jwt),

     

       258
       258
       +
                   )

     

       259
       259
       +
                   .await?;

     

       260
       260
       +
       

     

       261
       261
       +
               // 3) Call sh.tangled.repo.create with the rkey

     

       262
       262
       +
               #[derive(Serialize)]

     

       263
       263
       +
               struct CreateRepoReq<'a> {

     

       264
       264
       +
                   rkey: &'a str,

     

       265
       265
       +
                   #[serde(skip_serializing_if = "Option::is_none")]

     

       266
       266
       +
                   #[serde(rename = "defaultBranch")]

     

       267
       267
       +
                   default_branch: Option<&'a str>,

     

       268
       268
       +
                   #[serde(skip_serializing_if = "Option::is_none")]

     

       269
       269
       +
                   source: Option<&'a str>,

     

       270
       270
       +
               }

     

       271
       271
       +
               let req = CreateRepoReq {

     

       272
       272
       +
                   rkey,

     

       273
       273
       +
                   default_branch: opts.default_branch,

     

       274
       274
       +
                   source: opts.source,

     

       275
       275
       +
               };

     

       276
       276
       +
               // No output expected on success

     

       277
       277
       +
               let _: serde_json::Value = self.post_json(REPO_CREATE, &req, Some(&sa.token)).await?;

     

       278
       278
       +
               Ok(())

     

       140
       279
        
           }

     

       141
       280
        
       }

     

       142
       281
        
       

     
···

       147
       286
        
           pub name: String,

     

       148
       287
        
           pub knot: Option<String>,

     

       149
       288
        
           pub description: Option<String>,

     

       289
       289
       +
           #[serde(default)]

     

       150
       290
        
           pub private: bool,

     

       151
       291
        
       }

     

       292
       292
       +
       

     

       293
       293
       +
       #[derive(Debug, Clone)]

     

       294
       294
       +
       pub struct CreateRepoOptions<'a> {

     

       295
       295
       +
           pub did: &'a str,

     

       296
       296
       +
           pub name: &'a str,

     

       297
       297
       +
           pub knot: &'a str,

     

       298
       298
       +
           pub description: Option<&'a str>,

     

       299
       299
       +
           pub default_branch: Option<&'a str>,

     

       300
       300
       +
           pub source: Option<&'a str>,

     

       301
       301
       +
           pub pds_base: &'a str,

     

       302
       302
       +
           pub access_jwt: &'a str,

     

       303
       303
       +
       }

-1

crates/tangled-api/src/lib.rs

···

       1
       1
        
       pub mod client;

     

       2
       2
        
       

     

       3
       3
        
       pub use client::TangledClient;

     

       4
       4
       -

crates/tangled-cli/src/cli.rs

···

       108
       108
        
           pub user: Option<String>,

     

       109
       109
        
           #[arg(long, default_value_t = false)]

     

       110
       110
        
           pub starred: bool,

     

       111
       111
       +
           /// Tangled API base URL (overrides env)

     

       112
       112
       +
           #[arg(long)]

     

       113
       113
       +
           pub base: Option<String>,

     

       111
       114
        
       }

     

       112
       115
        
       

     

       113
       116
        
       #[derive(Args, Debug, Clone)]

+5 -4

crates/tangled-cli/src/commands/auth.rs

···

       21
       21
        
               Some(p) => p,

     

       22
       22
        
               None => Password::new().with_prompt("Password").interact()?,

     

       23
       23
        
           };

     

       24
       24
       -
           let pds = args.pds.unwrap_or_else(|| "https://bsky.social".to_string());

     

       24
       24
       +
           let pds = args

     

       25
       25
       +
               .pds

     

       26
       26
       +
               .unwrap_or_else(|| "https://bsky.social".to_string());

     

       25
       27
        
       

     

       26
       28
        
           let client = tangled_api::TangledClient::new(&pds);

     

       27
       27
       -
           let session = client

     

       28
       28
       -
               .login_with_password(&handle, &password, &pds)

     

       29
       29
       -
               .await?;

     

       29
       29
       +
           let mut session = client.login_with_password(&handle, &password, &pds).await?;

     

       30
       30
       +
           session.pds = Some(pds.clone());

     

       30
       31
        
           SessionManager::default().save(&session)?;

     

       31
       32
        
           println!("Logged in as '{}' ({})", session.handle, session.did);

     

       32
       33
        
           Ok(())

+24 -10

crates/tangled-cli/src/commands/issue.rs

···

       1
       1
       +
       use crate::cli::{

     

       2
       2
       +
           Cli, IssueCommand, IssueCommentArgs, IssueCreateArgs, IssueEditArgs, IssueListArgs,

     

       3
       3
       +
           IssueShowArgs,

     

       4
       4
       +
       };

     

       1
       5
        
       use anyhow::Result;

     

       2
       2
       -
       use crate::cli::{Cli, IssueCommand, IssueListArgs, IssueCreateArgs, IssueShowArgs, IssueEditArgs, IssueCommentArgs};

     

       3
       6
        
       

     

       4
       7
        
       pub async fn run(_cli: &Cli, cmd: IssueCommand) -> Result<()> {

     

       5
       8
        
           match cmd {

     
···

       12
       15
        
       }

     

       13
       16
        
       

     

       14
       17
        
       async fn list(args: IssueListArgs) -> Result<()> {

     

       15
       15
       -
           println!("Issue list (stub) repo={:?} state={:?} author={:?} label={:?} assigned={:?}",

     

       16
       16
       -
               args.repo, args.state, args.author, args.label, args.assigned);

     

       18
       18
       +
           println!(

     

       19
       19
       +
               "Issue list (stub) repo={:?} state={:?} author={:?} label={:?} assigned={:?}",

     

       20
       20
       +
               args.repo, args.state, args.author, args.label, args.assigned

     

       21
       21
       +
           );

     

       17
       22
        
           Ok(())

     

       18
       23
        
       }

     

       19
       24
        
       

     

       20
       25
        
       async fn create(args: IssueCreateArgs) -> Result<()> {

     

       21
       21
       -
           println!("Issue create (stub) repo={:?} title={:?} body={:?} labels={:?} assign={:?}",

     

       22
       22
       -
               args.repo, args.title, args.body, args.label, args.assign);

     

       26
       26
       +
           println!(

     

       27
       27
       +
               "Issue create (stub) repo={:?} title={:?} body={:?} labels={:?} assign={:?}",

     

       28
       28
       +
               args.repo, args.title, args.body, args.label, args.assign

     

       29
       29
       +
           );

     

       23
       30
        
           Ok(())

     

       24
       31
        
       }

     

       25
       32
        
       

     

       26
       33
        
       async fn show(args: IssueShowArgs) -> Result<()> {

     

       27
       27
       -
           println!("Issue show (stub) id={} comments={} json={}", args.id, args.comments, args.json);

     

       34
       34
       +
           println!(

     

       35
       35
       +
               "Issue show (stub) id={} comments={} json={}",

     

       36
       36
       +
               args.id, args.comments, args.json

     

       37
       37
       +
           );

     

       28
       38
        
           Ok(())

     

       29
       39
        
       }

     

       30
       40
        
       

     

       31
       41
        
       async fn edit(args: IssueEditArgs) -> Result<()> {

     

       32
       32
       -
           println!("Issue edit (stub) id={} title={:?} body={:?} state={:?}",

     

       33
       33
       -
               args.id, args.title, args.body, args.state);

     

       42
       42
       +
           println!(

     

       43
       43
       +
               "Issue edit (stub) id={} title={:?} body={:?} state={:?}",

     

       44
       44
       +
               args.id, args.title, args.body, args.state

     

       45
       45
       +
           );

     

       34
       46
        
           Ok(())

     

       35
       47
        
       }

     

       36
       48
        
       

     

       37
       49
        
       async fn comment(args: IssueCommentArgs) -> Result<()> {

     

       38
       38
       -
           println!("Issue comment (stub) id={} close={} body={:?}", args.id, args.close, args.body);

     

       50
       50
       +
           println!(

     

       51
       51
       +
               "Issue comment (stub) id={} close={} body={:?}",

     

       52
       52
       +
               args.id, args.close, args.body

     

       53
       53
       +
           );

     

       39
       54
        
           Ok(())

     

       40
       55
        
       }

     

       41
       41
       -

+9 -4

crates/tangled-cli/src/commands/knot.rs

···

       1
       1
       +
       use crate::cli::{Cli, KnotAddArgs, KnotCommand, KnotListArgs, KnotRefArgs, KnotVerifyArgs};

     

       1
       2
        
       use anyhow::Result;

     

       2
       2
       -
       use crate::cli::{Cli, KnotCommand, KnotListArgs, KnotAddArgs, KnotVerifyArgs, KnotRefArgs};

     

       3
       3
        
       

     

       4
       4
        
       pub async fn run(_cli: &Cli, cmd: KnotCommand) -> Result<()> {

     

       5
       5
        
           match cmd {

     
···

       12
       12
        
       }

     

       13
       13
        
       

     

       14
       14
        
       async fn list(args: KnotListArgs) -> Result<()> {

     

       15
       15
       -
           println!("Knot list (stub) public={} owned={}", args.public, args.owned);

     

       15
       15
       +
           println!(

     

       16
       16
       +
               "Knot list (stub) public={} owned={}",

     

       17
       17
       +
               args.public, args.owned

     

       18
       18
       +
           );

     

       16
       19
        
           Ok(())

     

       17
       20
        
       }

     

       18
       21
        
       

     

       19
       22
        
       async fn add(args: KnotAddArgs) -> Result<()> {

     

       20
       20
       -
           println!("Knot add (stub) url={} did={:?} name={:?} verify={}", args.url, args.did, args.name, args.verify);

     

       23
       23
       +
           println!(

     

       24
       24
       +
               "Knot add (stub) url={} did={:?} name={:?} verify={}",

     

       25
       25
       +
               args.url, args.did, args.name, args.verify

     

       26
       26
       +
           );

     

       21
       27
        
           Ok(())

     

       22
       28
        
       }

     

       23
       29
        
       

     
···

       35
       41
        
           println!("Knot remove (stub) url={}", args.url);

     

       36
       42
        
           Ok(())

     

       37
       43
        
       }

     

       38
       38
       -

+3 -7

crates/tangled-cli/src/commands/mod.rs

···

       1
       1
        
       pub mod auth;

     

       2
       2
       -
       pub mod repo;

     

       3
       2
        
       pub mod issue;

     

       3
       3
       +
       pub mod knot;

     

       4
       4
        
       pub mod pr;

     

       5
       5
       -
       pub mod knot;

     

       5
       5
       +
       pub mod repo;

     

       6
       6
        
       pub mod spindle;

     

       7
       7
        
       

     

       8
       8
        
       use anyhow::Result;

     

       9
       9
       -
       use colored::Colorize;

     

       10
       9
        
       

     

       11
       10
        
       use crate::cli::{Cli, Command};

     

       12
       11
        
       

     
···

       21
       20
        
           }

     

       22
       21
        
       }

     

       23
       22
        
       

     

       24
       24
       -
       fn not_implemented(feature: &str) -> Result<()> {

     

       25
       25
       -
           eprintln!("{} {}", "[todo]".yellow().bold(), feature);

     

       26
       26
       -
           Ok(())

     

       27
       27
       -
       }

     

       23
       23
       +
       // All subcommands are currently implemented with stubs where needed.

+21 -11

crates/tangled-cli/src/commands/pr.rs

···

       1
       1
       +
       use crate::cli::{Cli, PrCommand, PrCreateArgs, PrListArgs, PrMergeArgs, PrReviewArgs, PrShowArgs};

     

       1
       2
        
       use anyhow::Result;

     

       2
       2
       -
       use crate::cli::{Cli, PrCommand, PrCreateArgs, PrListArgs, PrShowArgs, PrReviewArgs, PrMergeArgs};

     

       3
       3
        
       

     

       4
       4
        
       pub async fn run(_cli: &Cli, cmd: PrCommand) -> Result<()> {

     

       5
       5
        
           match cmd {

     
···

       12
       12
        
       }

     

       13
       13
        
       

     

       14
       14
        
       async fn list(args: PrListArgs) -> Result<()> {

     

       15
       15
       -
           println!("PR list (stub) repo={:?} state={:?} author={:?} reviewer={:?}",

     

       16
       16
       -
               args.repo, args.state, args.author, args.reviewer);

     

       15
       15
       +
           println!(

     

       16
       16
       +
               "PR list (stub) repo={:?} state={:?} author={:?} reviewer={:?}",

     

       17
       17
       +
               args.repo, args.state, args.author, args.reviewer

     

       18
       18
       +
           );

     

       17
       19
        
           Ok(())

     

       18
       20
        
       }

     

       19
       21
        
       

     

       20
       22
        
       async fn create(args: PrCreateArgs) -> Result<()> {

     

       21
       21
       -
           println!("PR create (stub) repo={:?} base={:?} head={:?} title={:?} draft={}",

     

       22
       22
       -
               args.repo, args.base, args.head, args.title, args.draft);

     

       23
       23
       +
           println!(

     

       24
       24
       +
               "PR create (stub) repo={:?} base={:?} head={:?} title={:?} draft={}",

     

       25
       25
       +
               args.repo, args.base, args.head, args.title, args.draft

     

       26
       26
       +
           );

     

       23
       27
        
           Ok(())

     

       24
       28
        
       }

     

       25
       29
        
       

     

       26
       30
        
       async fn show(args: PrShowArgs) -> Result<()> {

     

       27
       27
       -
           println!("PR show (stub) id={} diff={} comments={} checks={}", args.id, args.diff, args.comments, args.checks);

     

       31
       31
       +
           println!(

     

       32
       32
       +
               "PR show (stub) id={} diff={} comments={} checks={}",

     

       33
       33
       +
               args.id, args.diff, args.comments, args.checks

     

       34
       34
       +
           );

     

       28
       35
        
           Ok(())

     

       29
       36
        
       }

     

       30
       37
        
       

     

       31
       38
        
       async fn review(args: PrReviewArgs) -> Result<()> {

     

       32
       32
       -
           println!("PR review (stub) id={} approve={} request_changes={} comment={:?}",

     

       33
       33
       -
               args.id, args.approve, args.request_changes, args.comment);

     

       39
       39
       +
           println!(

     

       40
       40
       +
               "PR review (stub) id={} approve={} request_changes={} comment={:?}",

     

       41
       41
       +
               args.id, args.approve, args.request_changes, args.comment

     

       42
       42
       +
           );

     

       34
       43
        
           Ok(())

     

       35
       44
        
       }

     

       36
       45
        
       

     

       37
       46
        
       async fn merge(args: PrMergeArgs) -> Result<()> {

     

       38
       38
       -
           println!("PR merge (stub) id={} squash={} rebase={} no_ff={}",

     

       39
       39
       -
               args.id, args.squash, args.rebase, args.no_ff);

     

       47
       47
       +
           println!(

     

       48
       48
       +
               "PR merge (stub) id={} squash={} rebase={} no_ff={}",

     

       49
       49
       +
               args.id, args.squash, args.rebase, args.no_ff

     

       50
       50
       +
           );

     

       40
       51
        
           Ok(())

     

       41
       52
        
       }

     

       42
       42
       -

+82 -13

crates/tangled-cli/src/commands/repo.rs

···

       1
       1
       -
       use anyhow::Result;

     

       2
       2
       -
       use crate::cli::{Cli, RepoCommand, RepoCreateArgs, RepoInfoArgs, RepoListArgs, RepoCloneArgs, RepoDeleteArgs, RepoRefArgs};

     

       1
       1
       +
       use anyhow::{anyhow, Result};

     

       2
       2
       +
       use serde_json;

     

       3
       3
       +
       use tangled_config::session::SessionManager;

     

       3
       4
        
       

     

       4
       4
       -
       pub async fn run(_cli: &Cli, cmd: RepoCommand) -> Result<()> {

     

       5
       5
       +
       use crate::cli::{

     

       6
       6
       +
           Cli, OutputFormat, RepoCloneArgs, RepoCommand, RepoCreateArgs, RepoDeleteArgs, RepoInfoArgs,

     

       7
       7
       +
           RepoListArgs, RepoRefArgs,

     

       8
       8
       +
       };

     

       9
       9
       +
       

     

       10
       10
       +
       pub async fn run(cli: &Cli, cmd: RepoCommand) -> Result<()> {

     

       5
       11
        
           match cmd {

     

       6
       6
       -
               RepoCommand::List(args) => list(args).await,

     

       12
       12
       +
               RepoCommand::List(args) => list(cli, args).await,

     

       7
       13
        
               RepoCommand::Create(args) => create(args).await,

     

       8
       14
        
               RepoCommand::Clone(args) => clone(args).await,

     

       9
       15
        
               RepoCommand::Info(args) => info(args).await,

     
···

       13
       19
        
           }

     

       14
       20
        
       }

     

       15
       21
        
       

     

       16
       16
       -
       async fn list(args: RepoListArgs) -> Result<()> {

     

       17
       17
       -
           println!("Listing repositories (stub) knot={:?} user={:?} starred={}",

     

       18
       18
       -
               args.knot, args.user, args.starred);

     

       22
       22
       +
       async fn list(cli: &Cli, args: RepoListArgs) -> Result<()> {

     

       23
       23
       +
           let mgr = SessionManager::default();

     

       24
       24
       +
           let session = match mgr.load()? {

     

       25
       25
       +
               Some(s) => s,

     

       26
       26
       +
               None => return Err(anyhow!("Please login first: tangled auth login")),

     

       27
       27
       +
           };

     

       28
       28
       +
       

     

       29
       29
       +
           // Use the PDS to list repo records for the user

     

       30
       30
       +
           let pds = session

     

       31
       31
       +
               .pds

     

       32
       32
       +
               .clone()

     

       33
       33
       +
               .or_else(|| std::env::var("TANGLED_PDS_BASE").ok())

     

       34
       34
       +
               .unwrap_or_else(|| "https://bsky.social".into());

     

       35
       35
       +
           let pds_client = tangled_api::TangledClient::new(pds);

     

       36
       36
       +
           // Default to the logged-in user handle if --user is not provided

     

       37
       37
       +
           let effective_user = args.user.as_deref().unwrap_or(session.handle.as_str());

     

       38
       38
       +
           let repos = pds_client

     

       39
       39
       +
               .list_repos(

     

       40
       40
       +
                   Some(effective_user),

     

       41
       41
       +
                   args.knot.as_deref(),

     

       42
       42
       +
                   args.starred,

     

       43
       43
       +
                   Some(session.access_jwt.as_str()),

     

       44
       44
       +
               )

     

       45
       45
       +
               .await?;

     

       46
       46
       +
       

     

       47
       47
       +
           match cli.format {

     

       48
       48
       +
               OutputFormat::Json => {

     

       49
       49
       +
                   let json = serde_json::to_string_pretty(&repos)?;

     

       50
       50
       +
                   println!("{}", json);

     

       51
       51
       +
               }

     

       52
       52
       +
               OutputFormat::Table => {

     

       53
       53
       +
                   println!("NAME\tKNOT\tPRIVATE");

     

       54
       54
       +
                   for r in repos {

     

       55
       55
       +
                       println!("{}\t{}\t{}", r.name, r.knot.unwrap_or_default(), r.private);

     

       56
       56
       +
                   }

     

       57
       57
       +
               }

     

       58
       58
       +
           }

     

       59
       59
       +
       

     

       19
       60
        
           Ok(())

     

       20
       61
        
       }

     

       21
       62
        
       

     

       22
       63
        
       async fn create(args: RepoCreateArgs) -> Result<()> {

     

       23
       23
       -
           println!(

     

       24
       24
       -
               "Creating repo '{}' (stub) knot={:?} private={} init={} desc={:?}",

     

       25
       25
       -
               args.name, args.knot, args.private, args.init, args.description

     

       26
       26
       -
           );

     

       64
       64
       +
           let mgr = SessionManager::default();

     

       65
       65
       +
           let session = match mgr.load()? {

     

       66
       66
       +
               Some(s) => s,

     

       67
       67
       +
               None => return Err(anyhow!("Please login first: tangled auth login")),

     

       68
       68
       +
           };

     

       69
       69
       +
       

     

       70
       70
       +
           let base = std::env::var("TANGLED_API_BASE").unwrap_or_else(|_| "https://tngl.sh".into());

     

       71
       71
       +
           let client = tangled_api::TangledClient::new(base);

     

       72
       72
       +
       

     

       73
       73
       +
           // Determine PDS base and target knot hostname

     

       74
       74
       +
           let pds = session

     

       75
       75
       +
               .pds

     

       76
       76
       +
               .clone()

     

       77
       77
       +
               .or_else(|| std::env::var("TANGLED_PDS_BASE").ok())

     

       78
       78
       +
               .unwrap_or_else(|| "https://bsky.social".into());

     

       79
       79
       +
           let knot = args.knot.unwrap_or_else(|| "tngl.sh".to_string());

     

       80
       80
       +
       

     

       81
       81
       +
           let opts = tangled_api::client::CreateRepoOptions {

     

       82
       82
       +
               did: &session.did,

     

       83
       83
       +
               name: &args.name,

     

       84
       84
       +
               knot: &knot,

     

       85
       85
       +
               description: args.description.as_deref(),

     

       86
       86
       +
               default_branch: None,

     

       87
       87
       +
               source: None,

     

       88
       88
       +
               pds_base: &pds,

     

       89
       89
       +
               access_jwt: &session.access_jwt,

     

       90
       90
       +
           };

     

       91
       91
       +
           client.create_repo(opts).await?;

     

       92
       92
       +
       

     

       93
       93
       +
           println!("Created repo '{}' (knot: {})", args.name, knot);

     

       27
       94
        
           Ok(())

     

       28
       95
        
       }

     

       29
       96
        
       

     

       30
       97
        
       async fn clone(args: RepoCloneArgs) -> Result<()> {

     

       31
       31
       -
           println!("Cloning repo '{}' (stub) https={} depth={:?}", args.repo, args.https, args.depth);

     

       98
       98
       +
           println!(

     

       99
       99
       +
               "Cloning repo '{}' (stub) https={} depth={:?}",

     

       100
       100
       +
               args.repo, args.https, args.depth

     

       101
       101
       +
           );

     

       32
       102
        
           Ok(())

     

       33
       103
        
       }

     

       34
       104
        
       

     
···

       54
       124
        
           println!("Unstarring repo '{}' (stub)", args.repo);

     

       55
       125
        
           Ok(())

     

       56
       126
        
       }

     

       57
       57
       -

+11 -4

crates/tangled-cli/src/commands/spindle.rs

···

       1
       1
       +
       use crate::cli::{

     

       2
       2
       +
           Cli, SpindleCommand, SpindleConfigArgs, SpindleListArgs, SpindleLogsArgs, SpindleRunArgs,

     

       3
       3
       +
       };

     

       1
       4
        
       use anyhow::Result;

     

       2
       2
       -
       use crate::cli::{Cli, SpindleCommand, SpindleListArgs, SpindleConfigArgs, SpindleRunArgs, SpindleLogsArgs};

     

       3
       5
        
       

     

       4
       6
        
       pub async fn run(_cli: &Cli, cmd: SpindleCommand) -> Result<()> {

     

       5
       7
        
           match cmd {

     
···

       24
       26
        
       }

     

       25
       27
        
       

     

       26
       28
        
       async fn run_pipeline(args: SpindleRunArgs) -> Result<()> {

     

       27
       27
       -
           println!("Spindle run (stub) repo={:?} branch={:?} wait={}", args.repo, args.branch, args.wait);

     

       29
       29
       +
           println!(

     

       30
       30
       +
               "Spindle run (stub) repo={:?} branch={:?} wait={}",

     

       31
       31
       +
               args.repo, args.branch, args.wait

     

       32
       32
       +
           );

     

       28
       33
        
           Ok(())

     

       29
       34
        
       }

     

       30
       35
        
       

     

       31
       36
        
       async fn logs(args: SpindleLogsArgs) -> Result<()> {

     

       32
       32
       -
           println!("Spindle logs (stub) job_id={} follow={} lines={:?}", args.job_id, args.follow, args.lines);

     

       37
       37
       +
           println!(

     

       38
       38
       +
               "Spindle logs (stub) job_id={} follow={} lines={:?}",

     

       39
       39
       +
               args.job_id, args.follow, args.lines

     

       40
       40
       +
           );

     

       33
       41
        
           Ok(())

     

       34
       42
        
       }

     

       35
       35
       -

+1 -1

crates/tangled-cli/src/main.rs

···

       2
       2
        
       mod commands;

     

       3
       3
        
       

     

       4
       4
        
       use anyhow::Result;

     

       5
       5
       -
       use cli::Cli;

     

       6
       5
        
       use clap::Parser;

     

       6
       6
       +
       use cli::Cli;

     

       7
       7
        
       

     

       8
       8
        
       #[tokio::main]

     

       9
       9
        
       async fn main() -> Result<()> {

+7 -4

crates/tangled-config/src/config.rs

···

       22
       22
        
           pub knot: Option<String>,

     

       23
       23
        
           pub editor: Option<String>,

     

       24
       24
        
           pub pager: Option<String>,

     

       25
       25
       -
           #[serde(default = "default_format")] 

     

       25
       25
       +
           #[serde(default = "default_format")]

     

       26
       26
        
           pub format: String,

     

       27
       27
        
       }

     

       28
       28
        
       

     

       29
       29
       -
       fn default_format() -> String { "table".to_string() }

     

       29
       29
       +
       fn default_format() -> String {

     

       30
       30
       +
           "table".to_string()

     

       31
       31
       +
       }

     

       30
       32
        
       

     

       31
       33
        
       #[derive(Debug, Clone, Serialize, Deserialize, Default)]

     

       32
       34
        
       pub struct AuthSection {

     
···

       74
       76
        
           let path = path

     

       75
       77
        
               .map(|p| p.to_path_buf())

     

       76
       78
        
               .unwrap_or(default_config_path()?);

     

       77
       77
       -
           if let Some(parent) = path.parent() { std::fs::create_dir_all(parent)?; }

     

       79
       79
       +
           if let Some(parent) = path.parent() {

     

       80
       80
       +
               std::fs::create_dir_all(parent)?;

     

       81
       81
       +
           }

     

       78
       82
        
           let toml = toml::to_string_pretty(cfg)?;

     

       79
       83
        
           fs::write(&path, toml)

     

       80
       84
        
               .with_context(|| format!("Failed writing config file: {}", path.display()))?;

     

       81
       85
        
           Ok(())

     

       82
       86
        
       }

     

       83
       83
       -

+13 -4

crates/tangled-config/src/keychain.rs

···

       8
       8
        
       

     

       9
       9
        
       impl Keychain {

     

       10
       10
        
           pub fn new(service: &str, account: &str) -> Self {

     

       11
       11
       -
               Self { service: service.into(), account: account.into() }

     

       11
       11
       +
               Self {

     

       12
       12
       +
                   service: service.into(),

     

       13
       13
       +
                   account: account.into(),

     

       14
       14
       +
               }

     

       12
       15
        
           }

     

       13
       16
        
       

     

       14
       17
        
           fn entry(&self) -> Result<Entry> {

     
···

       16
       19
        
           }

     

       17
       20
        
       

     

       18
       21
        
           pub fn set_password(&self, secret: &str) -> Result<()> {

     

       19
       19
       -
               self.entry()?.set_password(secret).map_err(|e| anyhow!("keyring error: {e}"))

     

       22
       22
       +
               self.entry()?

     

       23
       23
       +
                   .set_password(secret)

     

       24
       24
       +
                   .map_err(|e| anyhow!("keyring error: {e}"))

     

       20
       25
        
           }

     

       21
       26
        
       

     

       22
       27
        
           pub fn get_password(&self) -> Result<String> {

     

       23
       23
       -
               self.entry()?.get_password().map_err(|e| anyhow!("keyring error: {e}"))

     

       28
       28
       +
               self.entry()?

     

       29
       29
       +
                   .get_password()

     

       30
       30
       +
                   .map_err(|e| anyhow!("keyring error: {e}"))

     

       24
       31
        
           }

     

       25
       32
        
       

     

       26
       33
        
           pub fn delete_password(&self) -> Result<()> {

     

       27
       27
       -
               self.entry()?.delete_credential().map_err(|e| anyhow!("keyring error: {e}"))

     

       34
       34
       +
               self.entry()?

     

       35
       35
       +
                   .delete_credential()

     

       36
       36
       +
                   .map_err(|e| anyhow!("keyring error: {e}"))

     

       28
       37
        
           }

     

       29
       38
        
       }

+1 -2

crates/tangled-config/src/lib.rs

···

       1
       1
        
       pub mod config;

     

       2
       2
       -
       pub mod session;

     

       3
       2
        
       pub mod keychain;

     

       4
       4
       -
       

     

       3
       3
       +
       pub mod session;

+13 -3

crates/tangled-config/src/session.rs

···

       11
       11
        
           pub did: String,

     

       12
       12
        
           pub handle: String,

     

       13
       13
        
           #[serde(default)]

     

       14
       14
       +
           pub pds: Option<String>,

     

       15
       15
       +
           #[serde(default)]

     

       14
       16
        
           pub created_at: DateTime<Utc>,

     

       15
       17
        
       }

     

       16
       18
        
       

     
···

       21
       23
        
                   refresh_jwt: String::new(),

     

       22
       24
        
                   did: String::new(),

     

       23
       25
        
                   handle: String::new(),

     

       26
       26
       +
                   pds: None,

     

       24
       27
        
                   created_at: Utc::now(),

     

       25
       28
        
               }

     

       26
       29
        
           }

     
···

       33
       36
        
       

     

       34
       37
        
       impl Default for SessionManager {

     

       35
       38
        
           fn default() -> Self {

     

       36
       36
       -
               Self { service: "tangled-cli".into(), account: "default".into() }

     

       39
       39
       +
               Self {

     

       40
       40
       +
                   service: "tangled-cli".into(),

     

       41
       41
       +
                   account: "default".into(),

     

       42
       42
       +
               }

     

       37
       43
        
           }

     

       38
       44
        
       }

     

       39
       45
        
       

     

       40
       46
        
       impl SessionManager {

     

       41
       41
       -
           pub fn new(service: &str, account: &str) -> Self { Self { service: service.into(), account: account.into() } }

     

       47
       47
       +
           pub fn new(service: &str, account: &str) -> Self {

     

       48
       48
       +
               Self {

     

       49
       49
       +
                   service: service.into(),

     

       50
       50
       +
                   account: account.into(),

     

       51
       51
       +
               }

     

       52
       52
       +
           }

     

       42
       53
        
       

     

       43
       54
        
           pub fn save(&self, session: &Session) -> Result<()> {

     

       44
       55
        
               let keychain = Keychain::new(&self.service, &self.account);

     
···

       59
       70
        
               keychain.delete_password()

     

       60
       71
        
           }

     

       61
       72
        
       }

     

       62
       62
       -

-1

crates/tangled-git/src/lib.rs

···

       1
       1
        
       pub mod operations;

     

       2
       2
       -

-1

crates/tangled-git/src/operations.rs

···

       5
       5
        
           // TODO: support ssh/https and depth

     

       6
       6
        
           bail!("clone_repo not implemented")

     

       7
       7
        
       }

     

       8
       8
       -