@ahqstore/cli 0.2.5 → 0.3.4

package/src/app/build/release.rs

@@ -0,0 +1,50 @@
+use std::process;
+
+use serde_json::{from_str, to_string};
+use sha2::{Digest, Sha256};
+
+use crate::app::{
+  build::{GHRelease, Str},
+  ERR, WARN,
+};
+
+use super::CLIENT;
+
+pub fn fetch_release(repo: &str, r_id: &str, gh_token: &str) -> (Str, GHRelease) {
+  let Ok(resp) = ({
+    let mut resp = CLIENT.get(format!(
+      "https://api.github.com/repos/{repo}/releases/{r_id}"
+    ));
+
+    if gh_token != "" {
+      resp = resp.bearer_auth(gh_token);
+    } else {
+      WARN.println(&"You may set GH_TOKEN environment variable to load private repos");
+    }
+
+    resp.send()
+  }) else {
+    ERR.println(&"Unable to fetch release");
+    process::exit(1)
+  };
+
+  let Ok(release) = resp.text() else {
+    ERR.println(&"Unable to read release");
+    process::exit(1);
+  };
+
+  let Ok(resp) = from_str::<GHRelease>(&release) else {
+    ERR.println(&"Unable to parse release");
+    process::exit(1);
+  };
+
+  let mut hasher = Sha256::new();
+
+  hasher.update(release.as_bytes());
+
+  let hashed = hasher.finalize();
+  let hashed = hashed.to_vec();
+  let version = to_string(&hashed).unwrap_or("**UNKNOWN**".to_string());
+
+  (version, resp)
+}

package/src/app/create/inquire.rs

@@ -0,0 +1,189 @@
+use std::process;
+
+use ahqstore_types::{AppRepo, InstallerFormat};
+use inquire::{
+  list_option::ListOption,
+  validator::{ErrorMessage, Validation},
+  Editor, MultiSelect, Text,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::app::{
+  build::CLIENT,
+  shared::{Config, IMetadata, IPlatform},
+  ERR, INFO,
+};
+
+#[derive(Serialize, Deserialize)]
+struct ServerUserResp {
+  pub linked_acc: Vec<String>,
+}
+
+pub fn inquire<'a>() -> (String, Config<'a>) {
+  INFO.println(&"Generating a random Application ID");
+  let Ok(app_id) = Text::new("Application ID:")
+    .with_default(&gen_appid())
+    .prompt()
+  else {
+    ERR.println(&"Must Enter an ID");
+    process::exit(1);
+  };
+
+  let Ok(app_name) = Text::new("Start menu entry name:")
+    .with_default("Application")
+    .prompt()
+  else {
+    ERR.println(&"Must Enter a name");
+    process::exit(1);
+  };
+
+  let Ok(display_name) = Text::new("Application Display Name:")
+    .with_default("My Cool App")
+    .prompt()
+  else {
+    ERR.println(&"Must Enter a name");
+    process::exit(1);
+  };
+
+  let Ok(user_id) = Text::new("Your AHQ Store Author ID:").prompt() else {
+    ERR.println(&"Must Enter an ID");
+    process::exit(1);
+  };
+
+  let Ok(desc) = Editor::new("Enter your app description").prompt() else {
+    ERR.println(&"Must Enter a description");
+    process::exit(1);
+  };
+
+  let Ok(repo) = Text::new("Enter your app repository:")
+    .with_default("owner/repoName")
+    .with_validator(|string: &str| {
+      if string.split("/").collect::<Vec<_>>().len() == 2 {
+        Ok(Validation::Valid)
+      } else {
+        Ok(Validation::Invalid(ErrorMessage::Custom(
+          "Must be in the format owner/repoName".into(),
+        )))
+      }
+    })
+    .prompt()
+  else {
+    ERR.println(&"Must Enter a repository");
+    process::exit(1);
+  };
+
+  let [owner, repo] = repo.split("/").collect::<Vec<_>>()[..] else {
+    panic!("Repo Parsing Failed")
+  };
+
+  INFO.println(&"Validating author id & repo");
+
+  let val: Option<()> = (|| {
+    let data: ServerUserResp = CLIENT
+      .get(format!(
+        "https://ahqstore-server.onrender.com/users/{}",
+        &user_id
+      ))
+      .send()
+      .ok()?
+      .json()
+      .ok()?;
+
+    if data.linked_acc.contains(&owner.into()) {
+      return Some(());
+    }
+    None
+  })();
+
+  if let None = val {
+    ERR.println(
+      &r#"Could not validate author id with github username. It may be because:
+- The account id provided is not valid
+- The account id has developer mode disabled
+- The GitHub repo owner doesn't seem to be in the list of linked_accounts
+- The GitHub repo is invalid"#,
+    );
+    process::exit(1);
+  }
+
+  let validator = |input: &[ListOption<&InstallerFormat>]| {
+    if input.len() == 0 {
+      return Ok(Validation::Invalid(
+        "You must select at least one target".into(),
+      ));
+    }
+    if input.len() > 2 {
+      return Ok(Validation::Invalid(
+        "You can only select two targets".into(),
+      ));
+    }
+
+    let flagged = vec![0, 1, 2, 3];
+    if input
+      .iter()
+      .filter(|a| flagged.contains(&a.index))
+      .collect::<Vec<_>>()
+      .len()
+      > 1
+    {
+      return Ok(Validation::Invalid(
+        "You can only select one bundle target for a platform".into(),
+      ));
+    }
+
+    Ok(Validation::Valid)
+  };
+
+  let Ok(platforms) = MultiSelect::new(
+    "Which platforms do you intend to support?",
+    vec![
+      InstallerFormat::WindowsZip,
+      InstallerFormat::WindowsInstallerMsi,
+      InstallerFormat::WindowsInstallerExe,
+      InstallerFormat::WindowsUWPMsix,
+      InstallerFormat::LinuxAppImage,
+    ],
+  )
+  .with_default(&[0])
+  .with_validator(validator)
+  .prompt() else {
+    ERR.println(&"Must Select a platform");
+    process::exit(1);
+  };
+
+  (
+    app_id.clone(),
+    IMetadata::new(
+      app_id,
+      app_name,
+      display_name,
+      user_id,
+      desc,
+      AppRepo {
+        author: owner.into(),
+        repo: repo.into(),
+      },
+      IPlatform::new(platforms),
+    ),
+  )
+}
+
+fn gen_appid() -> String {
+  let mut string = String::new();
+
+  use rand::seq::SliceRandom;
+
+  let val = vec![
+    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
+    "t", "u", "v", "w", "s", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
+    "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "S", "Y", "Z", "0", "1", "2", "3", "4",
+    "5", "6", "7", "8", "9"
+  ];
+
+  for _ in 0..40 {
+    let val = val.choose(&mut rand::thread_rng()).unwrap();
+    string.push_str(val);
+  }
+
+  string
+}

package/src/app/create/mod.rs

@@ -0,0 +1,74 @@
+mod inquire;
+use std::{fs, process};
+
+use inquire::*;
+use serde_json::to_string_pretty;
+
+use super::{ERR, INFO, WARN};
+
+pub fn create(force: bool) {
+  let (id, config) = inquire();
+
+  create_dir(force);
+
+  let succ = (|| {
+    let config_file = to_string_pretty(&config).ok()?;
+    fs::write("./.ahqstore/config.json", config_file).ok()?;
+
+    let base_img = format!("./.ahqstore/images/{}", &id);
+
+    fs::create_dir_all(&base_img).ok()?;
+
+    let icon = include_bytes!("./icon.png");
+    fs::write(format!("{}/icon.png", &base_img), icon).ok()?;
+
+    let readme = include_str!("./readme.md");
+    fs::write("./.ahqstore/README.md", readme).ok()
+  })()
+  .is_some();
+
+  if !succ {
+    ERR.println(&"Failed to populate .ahqstore");
+    process::exit(1);
+  } else {
+    println!("🇩​​​​​🇴​​​​​🇳​​​​​🇪​​​​​");
+    println!(
+      r#"████████████████████████████████████████████████████████████████▀█
+█─█─██▀▄─██▄─▄▄─█▄─▄▄─█▄─█─▄███─▄▄▄─█─▄▄─█▄─▄▄▀█▄─▄█▄─▀█▄─▄█─▄▄▄▄█
+█─▄─██─▀─███─▄▄▄██─▄▄▄██▄─▄████─███▀█─██─██─██─██─███─█▄▀─██─██▄─█
+▀▄▀▄▀▄▄▀▄▄▀▄▄▄▀▀▀▄▄▄▀▀▀▀▄▄▄▀▀▀▀▄▄▄▄▄▀▄▄▄▄▀▄▄▄▄▀▀▄▄▄▀▄▄▄▀▀▄▄▀▄▄▄▄▄▀
+"#
+    );
+    INFO.println(&"Do not forget to edit config.json and finder.json\nMore details about all the files is present in README.md");
+  }
+}
+
+pub fn create_dir(force: bool) {
+  if let Err(_) = fs::create_dir("./.ahqstore") {
+    if force {
+      WARN.println(&"--force detected\nRemoving dir .ahqstore");
+
+      let succ = (|| {
+        fs::remove_dir_all("./.ahqstore").ok()?;
+        fs::create_dir_all("./.ahqstore").ok()?;
+
+        Some(())
+      })()
+      .is_some();
+
+      if succ {
+        INFO.println(&".ahqstore directory created, initializing data...");
+      } else {
+        ERR.println(&"Failed to create .ahqstore directory");
+        process::exit(1);
+      }
+    } else {
+      ERR.println(
+        &"Failed to create .ahqstore directory\nHint: Use --force option to ignore this error",
+      );
+      process::exit(1);
+    }
+  } else {
+    INFO.println(&"Created .ahqstore directory, initializing data...");
+  }
+}

package/src/app/create/readme.md

@@ -0,0 +1,71 @@
+# AHQ Store Cli
+
+Do edit the config.json
+
+The schema has been shown below
+
+## config.json
+
+```ts
+type Platform =
+  // Windows Platforms + Updater & UnInstaller Support
+  | "WindowsZip"
+  | "WindowsInstallerMsi"
+
+  // Not Implemented
+  | "WindowsInstallerExe"
+  | "WindowsUWPMsix"
+
+  // Linux Platform + Updater & UnInstaller Support
+  | "LinuxAppImage";
+
+type Win32Deps = "AHQStoreAPI" | "Node21" | "Node18";
+
+interface ConfigJSON {
+  [key: string]: {
+    appId: string; //application id provided by AHQ Store DEVS
+    appInstalledName: string; //App Start Menu Entry + Desktop Shortcut Name
+    appDisplayName: string; //App display name
+    authorId: string; //Your User ID
+    shortDesc: string; //Short Description (max 48words)
+    description: string; //MultiLine App Description
+    repo: {
+      author: string; //Your GitHub username
+      repo: string; //Repo URL
+    };
+    finder: {
+      windowsFinder?: {
+        startsWith?: string; // The Windows Bundled app should startWith?
+        contains?: string; // The Windows Bundled app should include?
+        endsWith?: string; // The Windows Bundled app should endWith?
+      };
+      linuxFinder?: {
+        startsWith?: string; // The Linux Bundled app should startWith?
+        contains?: string; // The Linux Bundled app should include?
+        endsWith?: string; // The Linux Bundled app should endWith?
+      };
+    };
+    platform: {
+      installType: "Both" | "PerUser" | "Computer"; // Install Type
+      win32Platform?: Platform; // What type of binary does your app provide to AHQ Store
+      linuxPlatform?: Platform; // <-- Same as win32Platform -->
+      win32Options?: {
+        deps: Win32Deps[]; // Win32 Custom Deps
+        zip_file_exec?: string; // Exe to Link via our installer (WindowsZIP)
+        exe_installer_args?: string[]; // Args to run to your custom installer (WindowsInstallerExe)
+      };
+      linuxOptions?: {};
+    };
+    site?: string; // Your app's website
+    redistributed?: string; // Redistributed page (not for public)
+  };
+}
+```
+
+## icon.png
+
+Your application icon that'll be bundled in the app metadata file
+
+## images/<app-id>/\*
+
+Place any image(s) [upto 10] that will be placed in the app modal in AHQ Store

package/src/app/help.rs

@@ -0,0 +1,77 @@
+use chalk_rs::Chalk;
+
+pub fn main_help() -> String {
+  let mut chalk = Chalk::new();
+
+  let cli = chalk.blue().bold().string(&"AHQ Store CLI");
+
+  let usage = chalk.green().bold().string(&"Usage:");
+
+  let cmds = chalk.green().bold().string(&"Commands:");
+  let help = chalk.cyan().bold().string(&"help");
+  let create = chalk.cyan().bold().string(&"create");
+  let build = chalk.cyan().bold().string(&"build");
+  let upload = chalk.cyan().bold().string(&"build");
+
+  let opt = chalk.yellow().bold().string(&"Options:");
+  let force = chalk.cyan().bold().string(&"--force, -f");
+
+  let env = chalk.yellow().bold().string(&"Required ENV:");
+  let app_id = chalk.cyan().bold().string(&"APP_ID");
+  let gh_token = chalk.cyan().bold().string(&"GH_TOKEN");
+  let gh_repo = chalk.cyan().bold().string(&"GITHUB_REPOSITORY");
+  let gh_action = chalk.cyan().bold().string(&"GITHUB_ACTION");
+  let r_id = chalk.cyan().bold().string(&"RELEASE_ID");
+
+  let optional = chalk.yellow().bold().string(&"(Optional)");
+
+  format!(
+    r#"{cli}
+Ship your apps to the ahq store quickly and efficiently
+
+{usage}
+  ahqstore (command) [options]
+{cmds}
+  {help}
+    Shows the help menu
+  {create}
+    Generates AHQ Store config files required to ship your apps
+    {opt}
+      {force} Override Existing contents if .ahqstore dir isn't empty
+  {upload}
+    Build & Upload ahqstore config file
+    {env}
+    {app_id} {optional} Application Id (required if your config has more than 1 appIds)
+    {r_id} GitHub Release Id
+    {gh_token} GitHub Token
+    {gh_repo} GitHub owner & repo name, eg ahqstore/app
+                      (Equivalent to GITHUB_REPOSITORY variable in GitHub actions)
+    {gh_action} {optional} Set this env to anything to specify that it is running in an GitHub Action
+                      (Outputs AHQ_STORE_FILE_URL=<url>)
+  {build}
+    Build the ahqstore config file
+    {env}
+      {app_id} {optional} Application Id (required if your config has more than 1 appIds)
+      {r_id} GitHub Release Id
+      {gh_token} GitHub Token
+      {gh_repo} GitHub owner & repo name, eg ahqstore/app
+                        (Equivalent to GITHUB_REPOSITORY variable in GitHub actions)
+      {gh_action} {optional} Set this env to anything to specify that it is running in an GitHub Action
+                        (Outputs AHQ_STORE_FILE_URL=<url>)"#
+  )
+}
+
+pub fn not_found(name: &str) -> String {
+  let mut chalk = Chalk::new();
+
+  let cmd = chalk.red().bold().string(&"Command not found:");
+  let tip = chalk.green().bold().string(&"Tip:");
+  let astore = chalk.cyan().bold().string(&"ahqstore");
+
+  format!(
+    r#"{cmd} {name}
+
+{tip}
+  Write {astore} to view the help menu"#
+  )
+}

package/src/app/mod.rs

@@ -0,0 +1,39 @@
+use chalk_rs::Chalk;
+use lazy_static::lazy_static;
+
+mod build;
+mod create;
+mod help;
+pub mod shared;
+
+lazy_static! {
+  static ref INFO: Chalk = {
+    let mut chalk = Chalk::new();
+    chalk.blue().bold();
+    chalk
+  };
+  static ref WARN: Chalk = {
+    let mut chalk = Chalk::new();
+    chalk.yellow().bold();
+    chalk
+  };
+  static ref ERR: Chalk = {
+    let mut chalk = Chalk::new();
+    chalk.red().bold();
+    chalk
+  };
+}
+
+pub fn start(args: Vec<String>, gh: bool) {
+  if args.len() >= 1 {
+    match args[0].as_str() {
+      "create" => create::create(args.len() > 1 && (&args[1] == "--force" || &args[1] == "-f")),
+      "build" => build::build_config(false, false),
+      "upload" => build::build_config(true, gh),
+      "help" => println!("{}", help::main_help()),
+      a => println!("{}", help::not_found(a)),
+    }
+  } else {
+    println!("{}", help::main_help());
+  }
+}

package/src/app/shared/file_sorter.rs

@@ -0,0 +1,34 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+#[allow(non_snake_case)]
+pub struct FileFinder<'a> {
+  #[serde(borrow)]
+  pub windowsFinder: Option<Finder<'a>>,
+  #[serde(borrow)]
+  pub linuxFinder: Option<Finder<'a>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[allow(non_snake_case)]
+pub struct Finder<'a> {
+  #[serde(borrow)]
+  pub startsWith: Option<&'a str>,
+  #[serde(borrow)]
+  pub contains: Option<&'a str>,
+  #[serde(borrow)]
+  pub endsWith: Option<&'a str>,
+}
+
+impl<'a> FileFinder<'a> {
+  pub fn new() -> Self {
+    Self {
+      windowsFinder: Some(Finder {
+        startsWith: Some("This-is"),
+        contains: Some("an"),
+        endsWith: Some(".example"),
+      }),
+      linuxFinder: None,
+    }
+  }
+}

package/src/app/shared/mod.rs

@@ -0,0 +1,62 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+use ahqstore_types::AppRepo;
+
+pub type Str = String;
+pub type Config<'a> = HashMap<String, IMetadata<'a>>;
+
+mod file_sorter;
+mod platforms;
+pub use file_sorter::*;
+pub use platforms::*;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[allow(non_snake_case)]
+pub struct IMetadata<'a> {
+  pub appId: Str,
+  pub appShortcutName: Str,
+  pub appDisplayName: Str,
+  pub authorId: Str,
+  pub description: Str,
+  pub repo: AppRepo,
+  #[serde[borrow]]
+  pub platform: IPlatform<'a>,
+  #[serde[borrow]]
+  pub finder: FileFinder<'a>,
+  pub site: Option<Str>,
+  pub redistributed: Option<Str>,
+}
+
+impl<'a> IMetadata<'a> {
+  #[allow(non_snake_case)]
+  pub fn new(
+    appId: Str,
+    appShortcutName: Str,
+    appDisplayName: Str,
+    authorId: Str,
+    description: Str,
+    repo: AppRepo,
+    platform: IPlatform<'a>,
+  ) -> Config {
+    let mut config = Config::new();
+
+    config.insert(
+      appId.clone(),
+      Self {
+        appId,
+        appShortcutName,
+        appDisplayName,
+        authorId,
+        description,
+        repo,
+        platform,
+        finder: FileFinder::new(),
+        site: None,
+        redistributed: None
+      },
+    );
+
+    config
+  }
+}

package/src/app/shared/platforms.rs

@@ -0,0 +1,69 @@
+use ahqstore_types::{InstallType, InstallerFormat, Win32Deps};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+#[allow(non_snake_case)]
+pub struct IPlatform<'a> {
+  pub installType: InstallType,
+  pub win32Platform: Option<InstallerFormat>,
+  pub linuxPlatform: Option<InstallerFormat>,
+  #[serde(borrow)]
+  pub win32Options: Option<IOWin32<'a>>,
+  pub linuxOptions: Option<IOLinux>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct IOWin32<'a> {
+  pub deps: Vec<Win32Deps>,
+  #[serde(borrow)]
+  pub zip_file_exec: Option<&'a str>,
+  #[serde(borrow)]
+  pub exe_installer_args: Option<Vec<&'a str>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct IOLinux {
+  
+}
+
+impl<'a> IPlatform<'a> {
+  pub fn new(platforms: Vec<InstallerFormat>) -> Self {
+    let win32 = own(
+      platforms
+        .iter()
+        .find(|p| !matches!(&p, &&&InstallerFormat::LinuxAppImage)),
+    );
+
+    let linux = own(
+      platforms
+        .iter()
+        .find(|p| matches!(&p, &&&InstallerFormat::LinuxAppImage)),
+    );
+
+    Self {
+      installType: InstallType::Computer,
+      win32Platform: win32,
+      linuxPlatform: linux,
+      win32Options: Some(IOWin32 {
+        deps: vec![],
+        exe_installer_args: Some(vec![]),
+        zip_file_exec: None,
+      }),
+      linuxOptions: Some(IOLinux {  }),
+    }
+  }
+}
+
+fn own(val: Option<&InstallerFormat>) -> Option<InstallerFormat> {
+  if let Some(v) = val {
+    Some(match &v {
+      &&InstallerFormat::LinuxAppImage => InstallerFormat::LinuxAppImage,
+      &&InstallerFormat::WindowsInstallerExe => InstallerFormat::WindowsInstallerExe,
+      &&InstallerFormat::WindowsZip => InstallerFormat::WindowsZip,
+      &&InstallerFormat::WindowsInstallerMsi => InstallerFormat::WindowsInstallerMsi,
+      &&InstallerFormat::WindowsUWPMsix => InstallerFormat::WindowsUWPMsix,
+    })
+  } else {
+    None
+  }
+}

package/src/lib.rs

@@ -0,0 +1,12 @@
+#[cfg(feature = "node")]
+mod app;
+
+#[cfg(feature = "node")]
+#[macro_use]
+extern crate napi_derive;
+
+#[cfg(feature = "node")]
+#[napi]
+pub fn node_entrypoint(args: Vec<String>, gh: bool) {
+  app::start(args, gh);
+}

package/src/main.rs

@@ -0,0 +1,10 @@
+use std::env::args;
+
+mod app;
+
+fn main() {
+  let mut arg = args().collect::<Vec<String>>();
+  arg.remove(0);
+
+  app::start(arg, std::env::var("GH_ACTION").is_ok());
+}