wepub 0.6.0

CLI to publish browser extensions to Chrome Web Store, Firefox Add-ons, and Edge Add-ons
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

use anyhow::{Context, Result, bail};
use wepub_core::chrome::{Client, Credentials, PublishOptions, PublishType};

use crate::cli::{ChromeArgs, ChromePublishTypeArg};

pub async fn run(args: ChromeArgs) -> Result<()> {
    let client = build_client(&args)?;

    let zip = tokio::fs::read(&args.zip)
        .await
        .with_context(|| format!("failed to read archive from {}", args.zip.display()))?;

    let options = PublishOptions {
        publish_type: args.publish_type.map(Into::into),
        skip_review: args.skip_review,
        deploy_percentage: args.deploy_percentage,
    };

    client
        .publish(zip, options)
        .await
        .context("Chrome Web Store publish failed")?;
    Ok(())
}

fn build_client(args: &ChromeArgs) -> Result<Client> {
    let client_set = (
        args.client_id.as_deref(),
        args.client_secret.as_deref(),
        args.refresh_token.as_deref(),
    );
    let any_client_field =
        client_set.0.is_some() || client_set.1.is_some() || client_set.2.is_some();

    match (any_client_field, args.access_token.as_deref()) {
        (true, Some(_)) => bail!(
            "--access-token cannot be combined with --client-id / --client-secret / --refresh-token; \
             choose one authentication mode"
        ),
        (false, None) => bail!(
            "missing Chrome Web Store credentials: pass either --access-token or the trio \
             --client-id / --client-secret / --refresh-token"
        ),
        (true, None) => {
            let (Some(client_id), Some(client_secret), Some(refresh_token)) = client_set else {
                bail!(
                    "--client-id, --client-secret and --refresh-token must all be provided together"
                );
            };
            Ok(Client::new(
                args.publisher_id.clone(),
                args.item_id.clone(),
                Credentials::RefreshToken {
                    client_id: client_id.to_string(),
                    client_secret: client_secret.to_string(),
                    refresh_token: refresh_token.to_string(),
                },
            )?)
        }
        (false, Some(access_token)) => Ok(Client::new(
            args.publisher_id.clone(),
            args.item_id.clone(),
            Credentials::AccessToken(access_token.to_string()),
        )?),
    }
}

impl From<ChromePublishTypeArg> for PublishType {
    fn from(value: ChromePublishTypeArg) -> Self {
        match value {
            ChromePublishTypeArg::Default => PublishType::DefaultPublish,
            ChromePublishTypeArg::Staged => PublishType::StagedPublish,
        }
    }
}