Add apps support

AppxManifest.xml

@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package
+  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
+  xmlns:desktop="http://schemas.microsoft.com/appx/manifest/desktop/windows10"
+  xmlns:desktop4="http://schemas.microsoft.com/appx/manifest/desktop/windows10/4"
+  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
+  xmlns:uap5="http://schemas.microsoft.com/appx/manifest/uap/windows10/5"
+  xmlns:uap10="http://schemas.microsoft.com/appx/manifest/uap/windows10/10"
+  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
+  IgnorableNamespaces="uap uap10 rescap build"
+  xmlns:build="http://schemas.microsoft.com/developer/appx/2015/build">
+
+  <Identity Name="StringBuildersManifest"
+    Publisher="CN=Julialang, OID.2.25.311729368913984317654407730594956997722=1"
+    Version="1.0.0.6" />
+
+    <Properties>
+        <DisplayName>Number Guesser (Manifest)</DisplayName>
+        <PublisherDisplayName>AppModelSamples</PublisherDisplayName>
+        <Logo>Images\StoreLogo.png</Logo>
+    </Properties>
+
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.19041.0" MaxVersionTested="10.0.19041.0" />
+    <uap10:HostRuntimeDependency Name="JuliaHubInc.JuliaDev" Publisher="CN=&quot;JuliaHub, Inc.&quot;, O=&quot;JuliaHub, Inc.&quot;, L=CAMBRIDGE, S=Massachusetts, C=US" MinVersion="1.0.0.0"/>
+  </Dependencies>
+
+  <Applications>
+    <Application Id="StringBuildersApp"  
+      uap10:HostId="JuliaHost"
+      uap10:Parameters="--project=C:\Users\david\.julia\dev\StringBuilders\app">
+      <uap:VisualElements
+        DisplayName="Stringbuilders"
+        Description="Stringbuilders is a high-level, high-performance, dynamic programming language"
+        BackgroundColor="transparent"
+        Square150x150Logo="Images\Square150x150Logo.png"
+        Square44x44Logo="Images\Square44x44Logo.png">
+        <uap:DefaultTile
+          Wide310x150Logo="Images\Wide310x150Logo.png"
+          ShortName="Julia"
+          Square71x71Logo="Images\SmallTile.png"
+          Square310x310Logo="Images\LargeTile.png">
+          <uap:ShowNameOnTiles>
+            <uap:ShowOn Tile="square150x150Logo"/>
+            <uap:ShowOn Tile="wide310x150Logo"/>
+            <uap:ShowOn Tile="square310x310Logo"/>
+          </uap:ShowNameOnTiles>
+        </uap:DefaultTile >
+        <uap:SplashScreen Image="Images\SplashScreen.png" />
+      </uap:VisualElements>
+      <Extensions>
+        <uap5:Extension Category="windows.appExecutionAlias">
+          <uap5:AppExecutionAlias>
+            <uap5:ExecutionAlias Alias="foobarasdf.exe" />
+          </uap5:AppExecutionAlias>
+        </uap5:Extension>
+      </Extensions>
+    </Application>
+
+  </Applications>
+
+<Capabilities>
+        <rescap:Capability Name="runFullTrust" />
+        <rescap:Capability Name="unvirtualizedResources"/>
+    </Capabilities>
+</Package>

Cargo.toml

@@ -59,6 +59,7 @@ indoc = "2.0.3"
 is-terminal = "0.4.9"
 path-absolutize = "3.1.0"
 human-sort = "0.2.2"
+toml_edit = "0.22"
 regex = "1.10.5"
 
 [target.'cfg(windows)'.dependencies]

deploy/winpkgidentityext/create-msix.ps1

@@ -22,3 +22,5 @@ $params = @{
     }
 
 Invoke-TrustedSigning @params
+
+Move-Item .\juliaup.msix ..\..\target\debug\ -Force

deploy/winpkgidentityext/msix/appxmanifest.xml

@@ -12,7 +12,7 @@
   xmlns:desktop6="http://schemas.microsoft.com/appx/manifest/desktop/windows10/6"
   xmlns:iot2="http://schemas.microsoft.com/appx/manifest/iot/windows10/2" IgnorableNamespaces="mp uap uap3 uap5 rescap desktop desktop4 desktop6 iot2">
 
-  <Identity Name="JuliaHubInc.JuliaDev" Publisher="CN=&quot;JuliaHub, Inc.&quot;, O=&quot;JuliaHub, Inc.&quot;, L=CAMBRIDGE, S=Massachusetts, C=US" Version="1.0.0.0" ProcessorArchitecture="x64"/>
+  <Identity Name="JuliaHubInc.JuliaDev" Publisher="CN=&quot;JuliaHub, Inc.&quot;, O=&quot;JuliaHub, Inc.&quot;, L=CAMBRIDGE, S=Massachusetts, C=US" Version="1.0.0.3" ProcessorArchitecture="x64"/>
 
   <Properties>
     <DisplayName>Julia Dev</DisplayName>
@@ -78,13 +78,22 @@
         </uap:DefaultTile >
         <uap:SplashScreen Image="Images\SplashScreen.png" />
       </uap:VisualElements>
-      <Extensions>
-      </Extensions>
+
     </Application>
   </Applications>
 
+<Extensions>
+      <uap10:Extension Category="windows.hostRuntime"
+          Executable="julialauncher.exe"
+          uap10:RuntimeBehavior="win32App"
+          uap10:TrustLevel="mediumIL">
+      <uap10:HostRuntime Id="JuliaHost"/>
+    </uap10:Extension>
+      </Extensions>
+
   <Capabilities>
     <rescap:Capability Name="runFullTrust" />
     <rescap:Capability Name="unvirtualizedResources"/>
+    <rescap:Capability Name="packageManagement" />
   </Capabilities>
 </Package>

src/bin/juliaup.rs

@@ -1,7 +1,10 @@
 use anyhow::{Context, Result};
 use clap::Parser;
-use juliaup::cli::{ConfigSubCmd, Juliaup, OverrideSubCmd, SelfSubCmd};
+use juliaup::cli::{ApplicationSubCmd, ConfigSubCmd, Juliaup, OverrideSubCmd, SelfSubCmd};
 use juliaup::command_api::run_command_api;
+use juliaup::command_app_add::run_command_app_add;
+use juliaup::command_app_run::run_command_app_run;
+use juliaup::command_app_remove::run_command_app_remove;
 use juliaup::command_completions::run_command_completions;
 #[cfg(not(windows))]
 use juliaup::command_config_symlinks::run_command_config_symlinks;
@@ -147,7 +150,16 @@
             SelfSubCmd::Uninstall {} => run_command_selfuninstall(&paths),
             #[cfg(not(feature = "selfupdate"))]
             SelfSubCmd::Uninstall {} => run_command_selfuninstall_unavailable(),
         },
         Juliaup::Completions { shell } => run_command_completions(shell),
+        Juliaup::Application(subcmd) => match subcmd {
+            ApplicationSubCmd::Add { value } => {
+                run_command_app_add(&value, &paths)
+            },
+            ApplicationSubCmd::Run { name, args } => {
+                run_command_app_run(&name, &args, &paths)
+            },
+            ApplicationSubCmd::Remove { name } => run_command_app_remove(&name, &paths)
+        },
     }
 }

src/cli.rs

@@ -54,6 +54,9 @@
     #[cfg(feature = "selfupdate")]
     #[clap(name = "4c79c12db1d34bbbab1f6c6f838f423f", hide = true)]
     SecretSelfUpdate {},
+    #[clap(subcommand, name = "app")]
+    /// Juliaup applications
+    Application(ApplicationSubCmd),
 }
 
 #[derive(Parser)]
@@ -154,3 +157,23 @@
         value: Option<i64>,
     },
 }
+
+#[derive(Parser)]
+pub enum ApplicationSubCmd {
+    #[clap(name = "add")]
+    /// Add a Julia application
+    Add {
+        value: String
+    },
+    #[clap(name = "run")]
+    /// Run a Julia application
+    Run {
+        name: String,
+        args: Vec<String>
+    },
+    #[clap(name = "remove", alias = "rm")]
+    /// Remove a Julia application
+    Remove {
+        name: String
+    }
+}

src/command_app_add.rs

@@ -0,0 +1,108 @@
+use std::fs;
+use std::path::PathBuf;
+use std::str::FromStr;
+
+use crate::config_file::{load_mut_config_db, save_config_db, JuliaupConfigApplication, JuliaupConfigExcutionAlias};
+use crate::global_paths::GlobalPaths;
+use crate::operations::install_version;
+use crate::versions_file::load_versions_db;
+use anyhow::{Context, Result};
+use bstr::ByteVec;
+use normpath::PathExt;
+
+pub fn run_command_app_add(path: &str, paths: &GlobalPaths) -> Result<()> {
+    let app_folder_path = PathBuf::from(path);
+
+    let project_path = app_folder_path.join("Project.toml");
+    let manifest_path = app_folder_path.join("Manifest.toml");
+
+    let project_content = fs::read_to_string(project_path).unwrap();
+    let project_parsed = toml_edit::DocumentMut::from_str(&project_content).unwrap();
+
+    let manifest_content = fs::read_to_string(&manifest_path).unwrap();
+    let manifest_parsed = toml_edit::DocumentMut::from_str(&manifest_content).unwrap();
+
+    let app_name = project_parsed.as_table().get_key_value("name").unwrap().1.as_str().unwrap();
+    let julia_version = manifest_parsed.as_table().get_key_value("julia_version").unwrap().1.as_str().unwrap();
+
+    let exec_aliases: Vec<(String, String)> = project_parsed
+        .as_table()
+        .get_key_value("executionaliases")
+        .unwrap()
+        .1
+        .clone()
+        .into_table()
+        .unwrap()
+        .iter()
+        .map(|i| (i.0.to_string(), i.1.clone().into_value().unwrap().as_str().unwrap().to_string()))
+        .collect();
+
+    let version_db =
+        load_versions_db(paths).with_context(|| "`add app` command failed to load versions db.")?;
+
+    let asdf = version_db.available_channels.get(julia_version).unwrap();
+
+    let mut config_file = load_mut_config_db(paths)
+        .with_context(|| "`app add` command failed to load configuration data.")?;
+
+    install_version(&asdf.version, &mut config_file.data, &version_db, paths).unwrap();
+
+    let julia_binary_path = &paths.juliaupconfig
+        .parent()
+        .unwrap() // unwrap OK because there should always be a parent
+        .join(config_file.data.installed_versions.get(&asdf.version).unwrap().path.clone())
+        .join("bin")
+        .join(format!("julia{}", std::env::consts::EXE_SUFFIX))
+        .normalize().unwrap();
+
+    let depot_detection_output = std::process::Command::new(julia_binary_path)
+        .arg("-e")
+        .arg("println(Base.DEPOT_PATH[1])")
+        .output()
+        .unwrap();
+
+    let depot_detection_output = depot_detection_output.stdout.into_string().unwrap().trim().to_string();
+
+    config_file.data.installed_apps.insert(
+        app_name.to_string(),
+        JuliaupConfigApplication::DevedApplication { 
+            path: app_folder_path.to_str().unwrap().to_string(),
+            julia_version: asdf.version.to_string(),
+            julia_depot: depot_detection_output,
+            execution_aliases: exec_aliases.iter().map(|i| (i.0.clone(), JuliaupConfigExcutionAlias { target: i.1.to_string() })).collect()
+        }
+    );
+
+    save_config_db(&mut config_file).unwrap();
+
+    std::process::Command::new(julia_binary_path)
+        .env("JULIA_PROJECT", &app_folder_path)
+        .arg("-e")
+        .arg("using Pkg; Pkg.instantiate()")
+        .status()
+        .unwrap();
+
+    // #[cfg(feature = "winpkgidentityext")]
+    {
+        use windows::Management::Deployment::{RegisterPackageOptions, PackageManager};
+
+        let package_manager = PackageManager::new().unwrap();
+        let register_package_options = RegisterPackageOptions::new().unwrap();
+        register_package_options.SetAllowUnsigned(true)?;
+
+        let self_location = std::env::current_exe().unwrap();
+        let self_location = self_location.parent().unwrap().parent().unwrap().parent().unwrap().join("stringbuislders.xml");
+
+        println!("WE ARE AT {:?}", self_location);
+
+        let external_loc =
+            windows::Foundation::Uri::CreateUri(&windows::core::HSTRING::from("C:\\Users\\david\\source\\juliaup\\AppxManifest.xml"))
+                .unwrap();
+
+        let asdf = package_manager.RegisterPackageByUriAsync(&external_loc, &register_package_options).unwrap().get().unwrap();
+
+        println!("DEPLOY WAS {:?} with {:?}", asdf.IsRegistered().unwrap(), asdf.ErrorText().unwrap());
+    }
+
+    return Ok(())
+}

src/command_app_remove.rs

@@ -0,0 +1,21 @@
+use anyhow::{Context,Result};
+
+use crate::{config_file::{load_mut_config_db, save_config_db}, global_paths::GlobalPaths, operations::garbage_collect_versions};
+
+pub fn run_command_app_remove(name: &str, paths: &GlobalPaths) -> Result<()> {
+    let mut config_file = load_mut_config_db(paths)
+        .with_context(|| "`app remove` command failed to load configuration data.")?;
+
+    if !config_file.data.installed_apps.contains_key(name) {
+        println!("Unknown app {}.", name);
+    }
+    else {
+        config_file.data.installed_apps.remove(name).unwrap();
+
+        garbage_collect_versions(&mut config_file.data, paths).unwrap();
+
+        save_config_db(&mut config_file).unwrap();
+    }
+
+    return Ok(())
+}

src/command_app_run.rs

@@ -0,0 +1,54 @@
+use std::collections::HashMap;
+
+use crate::{config_file::{load_config_db, JuliaupConfigApplication}, global_paths::GlobalPaths};
+use anyhow::{Context,Result};
+use normpath::PathExt;
+
+pub fn run_command_app_run(name: &str, args: &Vec<String>, paths: &GlobalPaths) -> Result<()> {
+
+    let config_file = load_config_db(paths)
+        .with_context(|| "`app run` command failed to load configuration data.")?;
+
+    let target: HashMap<String,(String,String,String,String)> = config_file
+        .data
+        .installed_apps
+        .iter()
+        .flat_map(|i| match&i.1 {
+            JuliaupConfigApplication::DevedApplication { path, julia_version, julia_depot, execution_aliases } => execution_aliases.iter().map(|j| (j.0.clone(), (j.1.target.clone(), path.clone(), julia_version.clone(), julia_depot.clone())))
+        })
+        .map(|i| (i.0.clone(), (i.1.0.clone(), i.1.1.clone(), i.1.2.clone(), i.1.3.clone())))
+        .collect();
+
+    if target.contains_key(name) {
+        let foo = target.get(name).unwrap();
+
+        let parts: Vec<&str> = foo.0.split(".").collect();
+
+        // println!("First arg {}, second arg {}", foo.0, foo.1)
+
+        let target_path = foo.1.clone();
+
+        let julia_binary_path = &paths.juliaupconfig
+            .parent()
+            .unwrap() // unwrap OK because there should always be a parent
+            .join(config_file.data.installed_versions.get(&foo.2).unwrap().path.clone())
+            .join("bin")
+            .join(format!("julia{}", std::env::consts::EXE_SUFFIX))
+            .normalize().unwrap();
+
+        std::process::Command::new(julia_binary_path)
+            .arg(format!("--project={}", target_path))
+            // .env("JULIA_PROJECT", target_path)
+            .env("JULIA_DEPOT_PATH", foo.3.clone())
+            .arg("-e")
+            .arg(format!("import {}; {}(ARGS)", parts[0], foo.0))
+            .args(args)
+            .status()
+            .unwrap();
+
+    }
+    else {
+        println!("Could not find app.");
+    }
+    return Ok(())    
+}