App Packing

Author: nab138

src-tauri/Cargo.lock

@@ -37,6 +37,7 @@ tar = "0.4.44"
 reqwest = "0.12.20"
 flate2 = "1.1.2"
 regex = "1"
+toml = "0.9.2"
 
 [features]
 # This feature is used for production builds or when a dev server is not specified, DO NOT REMOVE!!

src-tauri/Cargo.toml

@@ -0,0 +1,117 @@
+use std::{path::PathBuf, process::Command};
+
+use serde::{Deserialize, Serialize};
+
+use crate::builder::swift::swift_bin;
+
+pub const FORMAT_VERSION: u32 = 1;
+
+pub struct BuildSettings {
+    pub debug: bool,
+}
+
+// TODO: Min ios version, etc.
+pub struct ProjectConfig {
+    pub product: String,
+    pub version_num: String,
+    pub version_string: String,
+    pub bundle_id: String,
+    pub project_path: PathBuf,
+}
+
+#[derive(Deserialize, Serialize)]
+struct TomlConfig {
+    pub format_version: u32,
+    pub project: ProjectTomlConfig,
+}
+
+#[derive(Deserialize, Serialize)]
+struct ProjectTomlConfig {
+    pub version_num: String,
+    pub version_string: String,
+    pub bundle_id: String,
+}
+
+// TODO: Check platforms
+#[derive(Deserialize)]
+struct SwiftPackageDump {
+    name: String,
+    targets: Vec<SwiftPackageTarget>,
+}
+
+// TODO: Resources
+#[derive(Deserialize)]
+struct SwiftPackageTarget {
+    name: String,
+}
+
+impl ProjectConfig {
+    pub fn load(project_path: PathBuf, toolchain_path: &str) -> Result<Self, String> {
+        let toml_config = TomlConfig::load_or_default(project_path.clone())?;
+        let swift = swift_bin(toolchain_path)?;
+        let raw_package = Command::new(swift)
+            .arg("package")
+            .arg("dump-package")
+            .current_dir(&project_path)
+            .output()
+            .map_err(|e| format!("Failed to execute swift command: {}", e))?;
+        if !raw_package.status.success() {
+            return Err(format!(
+                "Failed to dump package: {}",
+                String::from_utf8_lossy(&raw_package.stderr)
+            ));
+        }
+        let package: SwiftPackageDump = serde_json::from_slice(&raw_package.stdout)
+            .map_err(|e| format!("Failed to parse package dump: {}", e))?;
+
+        Ok(ProjectConfig {
+            product: package.name,
+            version_num: toml_config.project.version_num,
+            version_string: toml_config.project.version_string,
+            bundle_id: toml_config.project.bundle_id,
+            project_path,
+        })
+    }
+}
+
+impl TomlConfig {
+    pub fn default(bundle_id: &str) -> Self {
+        TomlConfig {
+            format_version: FORMAT_VERSION,
+            project: ProjectTomlConfig {
+                version_num: "1".to_string(),
+                version_string: "1.0.0".to_string(),
+                bundle_id: bundle_id.to_string(),
+            },
+        }
+    }
+
+    pub fn load_or_default(project_path: PathBuf) -> Result<Self, String> {
+        if project_path.exists() {
+            Self::load(project_path)
+        } else {
+            let config = Self::default("com.example.myapp");
+            config.save(project_path)?;
+            Ok(config)
+        }
+    }
+
+    fn load(project_path: PathBuf) -> Result<Self, String> {
+        let content =
+            std::fs::read_to_string(project_path.join("ycode.toml")).map_err(|e| e.to_string())?;
+        let config: TomlConfig = toml::from_str(&content).map_err(|e| e.to_string())?;
+        if config.format_version != FORMAT_VERSION {
+            return Err(format!(
+                "Unsupported format version: {}, expected: {}",
+                config.format_version, FORMAT_VERSION
+            ));
+        }
+        Ok(config)
+    }
+
+    pub fn save(&self, project_path: PathBuf) -> Result<(), String> {
+        let content = toml::to_string(self).map_err(|e| e.to_string())?;
+        std::fs::write(project_path.join("ycode.toml"), content).map_err(|e| e.to_string())?;
+        Ok(())
+    }
+}

src-tauri/src/builder/config.rs

@@ -1,2 +1,4 @@
+pub mod config;
+pub mod packer;
 pub mod sdk;
 pub mod swift;

src-tauri/src/builder/mod.rs

@@ -0,0 +1,69 @@
+use std::{fs, path::PathBuf};
+
+use dircpy::CopyBuilder;
+
+use crate::builder::config::{BuildSettings, ProjectConfig};
+
+pub fn pack(
+    project_path: PathBuf,
+    config: &ProjectConfig,
+    build_settings: &BuildSettings,
+) -> Result<(), String> {
+    let workdir = project_path.join(".ycode");
+    if !workdir.exists() {
+        std::fs::create_dir_all(&workdir)
+            .map_err(|e| format!("Failed to create work directory: {}", e))?;
+    }
+    let app_path = workdir.join(format!("{}.app", config.product));
+    if app_path.exists() {
+        std::fs::remove_dir_all(&app_path)
+            .map_err(|e| format!("Failed to remove existing app directory: {}", e))?;
+    }
+    std::fs::create_dir_all(&app_path)
+        .map_err(|e| format!("Failed to create app directory: {}", e))?;
+
+    let exec = project_path
+        .join(".build")
+        .join("arm64-apple-ios")
+        .join(if build_settings.debug {
+            "debug"
+        } else {
+            "release"
+        })
+        .join(&config.product);
+
+    if !exec.exists() {
+        return Err(format!("Executable not found at: {}", exec.display()));
+    }
+
+    fs::copy(exec, app_path.join(&config.product))
+        .map_err(|e| format!("Failed to copy executable: {}", e))?;
+
+    // TODO: Create default Info.plist if it doesn't exist
+    let info_plist = project_path.join("Info.plist");
+    if !info_plist.exists() {
+        return Err(format!("Info.plist not found at: {}", info_plist.display()));
+    }
+
+    let info_content = fs::read_to_string(&info_plist)
+        .map_err(|e| format!("Failed to read Info.plist: {}", e))?
+        .replace("[[bundle_id]]", &config.bundle_id)
+        .replace("[[product]]", &config.product)
+        .replace("[[version_num]]", &config.version_num)
+        .replace("[[version_string]]", &config.version_string);
+    fs::write(&app_path.join("Info.plist"), info_content)
+        .map_err(|e| format!("Failed to write Info.plist: {}", e))?;
+
+    let resources = project_path.join("Resources");
+
+    if !resources.exists() {
+        std::fs::create_dir_all(&resources)
+            .map_err(|e| format!("Failed to create Resources directory: {}", e))?;
+    }
+
+    CopyBuilder::new(&resources, &app_path)
+        .run()
+        .map_err(|e| format!("Failed to copy resources: {}", e))?;
+
+    Ok(())
+}