@ahqstore/cli 0.3.4 → 0.4.1

package/src/app/shared/platforms.rs

@@ -1,69 +1,45 @@
-use ahqstore_types::{InstallType, InstallerFormat, Win32Deps};
+use ahqstore_types::InstallerFormat;
 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>,
+  pub winAmd64Platform: Option<InstallerFormat>,
+  pub winArm64Platform: Option<InstallerFormat>,
+  pub linuxAmd64Platform: Option<InstallerFormat>,
+  pub linuxArm64Platform: Option<InstallerFormat>,
+  pub linuxArm32Platform: Option<InstallerFormat>,
+  pub androidUniversal: Option<InstallerFormat>,
   #[serde(borrow)]
-  pub win32Options: Option<IOWin32<'a>>,
-  pub linuxOptions: Option<IOLinux>,
+  pub winAmd64Options: Option<IOWin<'a>>,
+  #[serde(borrow)]
+  pub winArm64Options: Option<IOWin<'a>>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct IOWin32<'a> {
-  pub deps: Vec<Win32Deps>,
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct IOWin<'a> {
   #[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)),
-    );
+  pub fn new() -> Self {
+    let io_win = IOWin {
+      exe_installer_args: Some(vec![]),
+      zip_file_exec: None,
+    };
 
     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 {  }),
+      winAmd64Platform: None,
+      winArm64Platform: None,
+      linuxAmd64Platform: None,
+      linuxArm32Platform: None,
+      linuxArm64Platform: None,
+      androidUniversal: None,
+      winAmd64Options: Some(io_win.clone()),
+      winArm64Options: Some(io_win)
     }
   }
-}
-
-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/cli-rs/Cargo.toml

@@ -1,45 +0,0 @@
-[package]
-name = "ahqstore_cli_rs"
-version = "0.2.8"
-edition = "2021"
-description = "AHQ Store CLI"
-repository = "https://github.com/ahqstore/cli"
-homepage = "https://github.com/ahqstore/cli"
-license = "MIT"
-exclude = ["dist/**", ".ahqstore/**", "finalize.js", "tslink.toml"]
-readme = "README.md"
-
-[lib]
-name = "ahqstore_cli_rs"
-crate-type = ["cdylib"]
-path = "src/lib.rs"
-
-[[bin]]
-name = "ahqstore"
-path = "src/main.rs"
-
-[dependencies]
-node-bindgen = { version = "6.0.1", optional = true }
-tslink = { version = "0.1.3", optional = true }
-inquire = { version = "0.7.5", features = ["editor"] }
-chalk_rs = "1.0.1"
-lazy_static = "1.4.0"
-serde = { version = "1.0.203", features = ["derive"] }
-serde_json = "1.0.117"
-ahqstore-types = "2.0.0"
-reqwest = { version = "0.12", features = ["json", "blocking"] }
-sha2 = "0.10.8"
-base64 = "0.22.1"
-image = "0.25"
-rand = "0.8.5"
-
-[target.aarch64-unknown-linux-gnu.dependencies]
-openssl = { version = "0.10.64", features = ["vendored"] }
-
-[build-dependencies]
-node-bindgen = { version = "6.0.1", default-features = false, features = [
-  "build",
-], optional = true }
-
-[features]
-node = ["dep:node-bindgen", "dep:tslink"]

package/cli-rs/README.md

@@ -1,41 +0,0 @@
-# AHQ Store CLI
-
-The CLI for devs making AHQ Store Apps
-
-This version: CARGO
-
-Install
-
-```sh
-$ cargo install ahqstore_cli_rs
-```
-
-## Help Command
-
-The help command shows all available commands
-
-```sh
-$ ahqstore --help
-```
-
-## Create .ahqstore config
-
-Creates the .ahqstore/\* config files to make your app ready to be built
-
-```sh
-$ ahqstore --create {--force}
-```
-
-## Build a project
-
-Builds your app based on the config files and environment variables
-ENV:
-
-> `APP_ID` (Optional) Application Id (only required if your config has more than 1 appIds)
-> `RELEASE_ID` GitHub Release Id
-> `GH_TOKEN` GitHub Personal Access Token / GitHub Actions Token
-> `GITHUB_REPOSITORY` GitHub owner & repo name, eg ahqstore/app
-
-```sh
-$ ahqstore build
-```

package/cli-rs/build.rs

@@ -1,4 +0,0 @@
-fn main() {
-  #[cfg(feature = "node")]
-  node_bindgen::build::configure();
-}

package/cli-rs/finalize.js

@@ -1,25 +0,0 @@
-const { writeFileSync, readFileSync } = require("fs");
-const { join } = require("path");
-let arch = process.env.arch || require("process").arch;
-
-if (arch == "arm64" && process.platform == "win32") {
-  arch = "ia32";
-}
-
-const packageJson = join(__dirname, "dist", "package.json");
-
-let json = JSON.parse(readFileSync(packageJson));
-
-json.name = `@ahqstore/cli-rs-${process.platform}-${arch}`;
-
-json.description = `AHQ Store CLI Binaries for ${process.platform}-${arch}`;
-json.repository = {
-  type: "git",
-  url: "git+https://github.com/ahqstore/cli.git",
-};
-json.bugs = {
-  url: "https://github.com/ahqstore/cli/issues",
-};
-json.homepage = "https://github.com/ahqstore/cli#readme";
-
-writeFileSync(packageJson, JSON.stringify(json, null, 2));

package/cli-rs/rust-toolchain.toml

@@ -1,2 +0,0 @@
-[toolchain]
-channel = "nightly"

package/cli-rs/src/app/build/config.rs

@@ -1,54 +0,0 @@
-use std::{env, fs, process};
-
-use serde_json::from_str;
-
-use crate::app::{
-  shared::{Config, Finder, IMetadata},
-  ERR,
-};
-
-use super::{GHAsset, GHRelease};
-
-pub fn get_config<'a>() -> IMetadata<'a> {
-  let Ok(config) = fs::read_to_string("./.ahqstore/config.json") else {
-    ERR.println(&"Unable to read config file!");
-    process::exit(1);
-  };
-  let config = config.leak();
-  let Ok(mut config) = from_str::<'a, Config>(config) else {
-    ERR.println(&"Unable to read config file!");
-    process::exit(1);
-  };
-
-  if let Ok(app_id) = env::var("APP_ID") {
-    config.remove(&app_id).expect("Key not present in JSON")
-  } else {
-    config.into_values().nth(0).expect("No Key present in JSON")
-  }
-}
-
-pub fn find_assets<'a>(gh_r: &'a GHRelease, finder: &'a Finder) -> Vec<&'a GHAsset> {
-  gh_r
-    .assets
-    .iter()
-    .filter(|a| {
-      if let Some(x) = finder.startsWith {
-        if !a.name.starts_with(&x) {
-          return false;
-        }
-      }
-      if let Some(x) = finder.contains {
-        if !a.name.contains(&x) {
-          return false;
-        }
-      }
-      if let Some(x) = finder.endsWith {
-        if !a.name.ends_with(&x) {
-          return false;
-        }
-      }
-
-      true
-    })
-    .collect::<Vec<_>>()
-}

package/cli-rs/src/app/build/icon.rs

@@ -1,48 +0,0 @@
-use crate::app::ERR;
-use base64::engine::{general_purpose::STANDARD, Engine};
-use image::{load_from_memory_with_format as load_img, ImageFormat};
-use std::fs;
-use std::process;
-
-pub fn get_icon(uid: &str) -> String {
-  let base_img = format!("./.ahqstore/images/{uid}/icon.png");
-
-  let Ok(icon) = fs::read(&base_img) else {
-    ERR.println(&"Unable to read icon file!");
-    process::exit(1);
-  };
-
-  validate_png(&icon);
-
-  STANDARD.encode(&icon)
-}
-
-pub fn get_images(uid: &str) -> Vec<String> {
-  let base_img = format!("./.ahqstore/images/{uid}");
-
-  let Ok(image_dir) = fs::read_dir(&base_img) else {
-    ERR.println(&"Unable to read image dir!");
-    process::exit(1);
-  };
-
-  let mut entries = image_dir
-    .map(|res| res.expect("Unable to unwrap dir entry").path())
-    .filter(|f| !f.ends_with("icon.png"))
-    .map(|res| fs::read(res).expect("Unable to read bytes"))
-    .map(|img| {
-      validate_png(&img);
-      return STANDARD.encode(&img);
-    })
-    .collect::<Vec<_>>();
-
-  entries.truncate(10);
-
-  entries
-}
-
-pub fn validate_png(data: &Vec<u8>) {
-  let Ok(_) = load_img(&data, ImageFormat::Png) else {
-    ERR.println(&"Invalid PNG");
-    process::exit(1);
-  };
-}

package/cli-rs/src/app/build/mod.rs

@@ -1,217 +0,0 @@
-use ahqstore_types::{
-  AHQStoreApplication, DownloadUrl, InstallType, InstallerFormat, InstallerOptions,
-  InstallerOptionsLinux, InstallerOptionsWin32, Str,
-};
-use lazy_static::lazy_static;
-use reqwest::blocking::{Client, ClientBuilder};
-use serde::{Deserialize, Serialize};
-use serde_json::{from_str, to_string, to_string_pretty};
-use std::{collections::HashMap, env, fs, process};
-
-use crate::app::{ERR, WARN};
-
-use super::INFO;
-
-mod config;
-mod icon;
-mod release;
-use config::*;
-use icon::*;
-use release::*;
-
-lazy_static! {
-  pub static ref CLIENT: Client = ClientBuilder::new()
-    .user_agent("AHQ Store / App Builder")
-    .build()
-    .unwrap();
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct GHRelease {
-  pub upload_url: String,
-  pub assets: Vec<GHAsset>,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct GHAsset {
-  pub name: String,
-  pub browser_download_url: String,
-}
-pub fn build_config(upload: bool, gh_action: bool) {
-  let Some(_) = fs::read_dir("./.ahqstore").ok() else {
-    ERR.println(&".ahqstore dir couldn't be accessed!");
-    process::exit(1);
-  };
-  if !gh_action {
-    INFO.print(&"INFO ");
-    println!("Checking .ahqstore");
-  }
-
-  let config = get_config();
-
-  let repo = env::var("GITHUB_REPOSITORY").unwrap_or("%NUL".into());
-
-  if &repo == "%NUL" {
-    ERR.println(&"GITHUB_REPOSITORY not set");
-    process::exit(1);
-  }
-
-  let r_id = env::var("RELEASE_ID").unwrap_or("latest".into());
-
-  if &r_id == "latest" && upload {
-    ERR.println(&"RELEASE_ID variable not present");
-    process::exit(1);
-  };
-  if &r_id == "latest" {
-    INFO.print(&"INFO ");
-    println!("Getting latest release");
-  }
-
-  let gh_token = env::var("GH_TOKEN").unwrap_or("".into());
-
-  if &gh_token == "" && upload {
-    ERR.println(&"GH_TOKEN variable not present");
-    process::exit(1);
-  };
-
-  let (version, gh_r) = fetch_release(&repo, &r_id, &gh_token);
-
-  let icon = get_icon(&config.appId);
-  #[allow(non_snake_case)]
-  let displayImages = get_images(&config.appId);
-
-  let app_id = config.appId.clone();
-
-  let mut final_config: AHQStoreApplication = AHQStoreApplication {
-    appDisplayName: config.appDisplayName,
-    appId: config.appId,
-    appShortcutName: config.appShortcutName,
-    authorId: config.authorId,
-    description: config.description,
-    downloadUrls: HashMap::default(),
-    icon,
-    displayImages,
-    install: InstallerOptions {
-      installType: config.platform.installType,
-      linux: None,
-      win32: None,
-    },
-    repo: config.repo,
-    version,
-    site: None,
-    source: None
-  };
-
-  if let Some(platform) = config.platform.win32Platform {
-    match (&platform, &final_config.install.installType) {
-      (&InstallerFormat::WindowsZip, _) => {}
-      (_, &InstallType::PerUser | &InstallType::Computer) => {
-        WARN.println(
-          &"Setting PerUser or Computer in a non WindowsZip install type does not have any effect",
-        );
-        process::exit(1);
-      }
-      _ => {}
-    };
-    let Some(options) = config.platform.win32Options else {
-      ERR.println(&"Win32 Options not found!");
-      process::exit(1);
-    };
-    let Some(finder) = config.finder.windowsFinder else {
-      ERR.println(&"Win32 Finder Config not found!");
-      process::exit(1);
-    };
-
-    let assets = find_assets(&gh_r, &finder);
-
-    if assets.len() > 1 {
-      ERR.println(&"Multiple assets found");
-      process::exit(1);
-    }
-    if assets.len() == 0 {
-      ERR.println(&"No assets found");
-      process::exit(1);
-    }
-
-    final_config.downloadUrls.insert(
-      1,
-      DownloadUrl {
-        installerType: platform,
-        url: assets[0].browser_download_url.clone(),
-      },
-    );
-
-    final_config.install.win32 = Some(InstallerOptionsWin32 {
-      assetId: 1,
-      deps: Some(options.deps),
-      exec: options.zip_file_exec.map_or(None, |a| Some(a.to_string())),
-      installerArgs: options
-        .exe_installer_args
-        .map_or(None, |a| Some(a.iter().map(|x| x.to_string()).collect())),
-    });
-  }
-
-  if let Some(platform) = config.platform.linuxPlatform {
-    let Some(finder) = config.finder.linuxFinder else {
-      ERR.println(&"Linux Finder Config not found!");
-      process::exit(1);
-    };
-
-    let assets = find_assets(&gh_r, &finder);
-
-    if assets.len() > 1 {
-      ERR.println(&"Multiple assets found");
-      process::exit(1);
-    }
-
-    final_config.downloadUrls.insert(
-      2,
-      DownloadUrl {
-        installerType: platform,
-        url: assets[0].browser_download_url.clone(),
-      },
-    );
-
-    final_config.install.linux = Some(InstallerOptionsLinux {
-      assetId: 2
-    });
-  }
-
-  final_config.site = config.site;
-  final_config.source = config.redistributed;
-
-  let config_file = to_string_pretty(&final_config).unwrap();
-  let config_file = to_string(config_file.as_bytes()).unwrap();
-
-  if !gh_action {
-    println!("Bytes: ahqstore.json");
-    println!("{}", &config_file);
-  }
-
-  if upload {
-    let uup = gh_r
-      .upload_url
-      .replace("{?name,label}", &format!("?name={app_id}.txt"));
-
-    let resp = CLIENT
-      .post(uup)
-      .header("Content-Length", config_file.len())
-      .header("Content-Type", "text/plain")
-      .header("Accept", "application/json")
-      .body(config_file)
-      .bearer_auth(&gh_token)
-      .send()
-      .unwrap()
-      .text()
-      .unwrap();
-
-    if gh_action {
-      let val: GHAsset = from_str(&resp).unwrap();
-
-      println!("AHQ_STORE_FILE_URL={}", &val.browser_download_url);
-    } else {
-      INFO.println(&"GitHub Response");
-      println!("{resp}");
-    }
-  }
-}

package/cli-rs/src/app/build/release.rs

@@ -1,50 +0,0 @@
-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)
-}