feat: Implement Canister Build Adapter Framework and Script Adapter

.github/workflows/test.yml

@@ -12,7 +12,7 @@ env:
   # Use the local .curlrc
   CURL_HOME: .
   # Disable DFX telemetry
-  DFX_TELEMETRY: 'off'
+  DFX_TELEMETRY: "off"
 
 jobs:
   discover:
@@ -24,6 +24,31 @@ jobs:
       - id: set-matrix
         run: echo "matrix=$(python3 .github/scripts/test-matrix.py)" >> $GITHUB_OUTPUT
 
+  unit-tests:
+    name: Unit tests on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Show Rust toolchain version
+        run: rustup show
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ matrix.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}-test-1
+
+      - name: Run unit tests
+        run: cargo test --workspace --lib --bins
+
   test:
     name: ${{ matrix.test }} on ${{ matrix.os }}
     needs: discover
@@ -61,8 +86,8 @@ jobs:
     name: test:required
     if: ${{ always() }}
     runs-on: ubuntu-latest
-    needs: [test]
+    needs: [unit-tests, test]
     steps:
       - name: check result
-        if: ${{ needs.test.result != 'success' }}
+        if: ${{ needs.unit-tests.result != 'success' || needs.test.result != 'success' }}
         run: exit 1

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
     "bin/icp-cli",
+    "lib/icp-adapter",
     "lib/icp-canister",
     "lib/icp-dirs",
     "lib/icp-fs",
@@ -12,18 +13,22 @@ members = [
 resolver = "3"
 
 [workspace.dependencies]
+async-trait = "0.1.88"
 bip32 = "0.5.0"
 camino = { version = "1.1.9", features = ["serde1"] }
+camino-tempfile = "1"
 candid = "0.10.14"
 clap = { version = "4.5.3", features = ["derive"] }
 dialoguer = "0.11.0"
 directories = "6.0.0"
+dunce = "1.0.5"
 ed25519-consensus = "2.1.0"
 elliptic-curve = { version = "0.13.8", features = ["sec1", "std", "pkcs8"] }
 fd-lock = "4.0.4"
 glob = "0.3.2"
 hex = "0.4.3"
 ic-agent = { version = "0.40.1" }
+icp-adapter = { path = "lib/icp-adapter" }
 icp-canister = { path = "lib/icp-canister" }
 icp-dirs = { path = "lib/icp-dirs" }
 icp-fs = { path = "lib/icp-fs" }
@@ -37,13 +42,11 @@ pem = "3.0.5"
 pkcs8 = { version = "0.10.2", features = ["encryption", "std"] }
 pocket-ic = "9.0.0"
 rand = "0.9.1"
-reqwest = { version = "0.12.15", default-features = false, features = [
-    "rustls-tls",
-] }
 sec1 = { version = "0.7.3", features = ["pkcs8"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_yaml = "0.9.34"
+shellwords = "1.1.0"
 snafu = "0.8.5"
 strum = { version = "0.27", features = ["derive"] }
 tempfile = "3"
@@ -53,6 +56,11 @@ tokio = { version = "1.45.0", features = ["macros", "rt-multi-thread"] }
 uuid = { version = "1.16.0", features = ["serde", "v4"] }
 zeroize = "1.8.1"
 
+[workspace.dependencies.reqwest]
+version = "0.12.15"
+default-features = false
+features = ["rustls-tls"]
+
 [workspace.lints.rust]
 missing_debug_implementations = "warn"
 

bin/icp-cli/Cargo.toml

@@ -16,6 +16,7 @@ dialoguer.workspace = true
 elliptic-curve.workspace = true
 hex.workspace = true
 ic-agent.workspace = true
+icp-adapter.workspace = true
 icp-canister.workspace = true
 icp-dirs.workspace = true
 icp-fs.workspace = true

bin/icp-cli/src/commands/build.rs

@@ -1,13 +1,16 @@
 use clap::Parser;
-use icp_canister::model::{CanisterManifest, LoadCanisterManifestError};
-use icp_project::directory::{FindProjectError, ProjectDirectory};
-use icp_project::model::{LoadProjectManifestError, ProjectManifest};
+use icp_adapter::{Adapter as _, AdapterCompileError};
+use icp_canister::model::{Adapter, CanisterManifest, LoadCanisterManifestError};
+use icp_project::{
+    directory::{FindProjectError, ProjectDirectory},
+    model::{LoadProjectManifestError, ProjectManifest},
+};
 use snafu::Snafu;
 
 #[derive(Parser, Debug)]
 pub struct Cmd;
 
-pub async fn exec(_cmd: Cmd) -> Result<(), BuildCommandError> {
+pub async fn exec(_: Cmd) -> Result<(), BuildCommandError> {
     // Project
     let pd = ProjectDirectory::find()?.ok_or(BuildCommandError::ProjectNotFound)?;
 
@@ -21,12 +24,27 @@ pub async fn exec(_cmd: Cmd) -> Result<(), BuildCommandError> {
     let mut cs = Vec::new();
 
     for c in pm.canisters {
-        let cm = CanisterManifest::from_file(pds.canister_yaml_path(&c))?;
-        cs.push(cm);
+        let mpath = pds.canister_yaml_path(&c);
+        let cm = CanisterManifest::from_file(&mpath)?;
+        cs.push((c, cm));
     }
 
     // Build canisters
-    println!("{cs:?}");
+    for (path, c) in cs {
+        match c.build.adapter {
+            Adapter::Script(adapter) => {
+                adapter.compile(&path).await?;
+            }
+
+            Adapter::Motoko(adapter) => {
+                adapter.compile(&path).await?;
+            }
+
+            Adapter::Rust(adapter) => {
+                adapter.compile(&path).await?;
+            }
+        }
+    }
 
     Ok(())
 }
@@ -44,4 +62,7 @@ pub enum BuildCommandError {
 
     #[snafu(transparent)]
     CanisterLoad { source: LoadCanisterManifestError },
+
+    #[snafu(transparent)]
+    BuildAdapter { source: AdapterCompileError },
 }

bin/icp-cli/tests/build_tests.rs

@@ -0,0 +1,50 @@
+use crate::common::TestEnv;
+use icp_fs::fs::{create_dir_all, write};
+use predicates::{ord::eq, str::PredicateStrExt};
+
+mod common;
+
+#[test]
+fn build_adapter_script_simple() {
+    let env = TestEnv::new();
+
+    // Setup project
+    let project_dir = env.create_project_dir("icp");
+
+    // Project manifest
+    let pm = r#"
+    canisters:
+      - my-canister
+    "#;
+
+    write(
+        project_dir.join("icp.yaml"), // path
+        pm,                           // contents
+    )
+    .expect("failed to write project manifest");
+
+    // Canister manifest
+    let cm = r#"
+    name: my-canister
+    build:
+      adapter:
+        type: script
+        command: echo hi
+    "#;
+
+    create_dir_all(project_dir.join("my-canister")).expect("failed to create canister directory");
+
+    write(
+        project_dir.join("my-canister/canister.yaml"), // path
+        cm,                                            // contents
+    )
+    .expect("failed to write project manifest");
+
+    // Invoke build
+    env.icp()
+        .current_dir(project_dir)
+        .args(["build"])
+        .assert()
+        .success()
+        .stdout(eq("hi").trim());
+}

lib/icp-adapter/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "icp-adapter"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+async-trait = { workspace = true }
+camino = { workspace = true }
+dunce = { workspace = true }
+serde = { workspace = true }
+shellwords = { workspace = true }
+snafu = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true }
+camino-tempfile = { workspace = true }

lib/icp-adapter/src/lib.rs

@@ -0,0 +1,27 @@
+use async_trait::async_trait;
+use camino::Utf8Path;
+use motoko::MotokoAdapterCompileError;
+use rust::RustAdapterCompileError;
+use script::ScriptAdapterCompileError;
+use snafu::Snafu;
+
+pub mod motoko;
+pub mod rust;
+pub mod script;
+
+#[async_trait]
+pub trait Adapter {
+    async fn compile(&self, path: &Utf8Path) -> Result<(), AdapterCompileError>;
+}
+
+#[derive(Debug, Snafu)]
+pub enum AdapterCompileError {
+    #[snafu(transparent)]
+    Rust { source: RustAdapterCompileError },
+
+    #[snafu(transparent)]
+    Motoko { source: MotokoAdapterCompileError },
+
+    #[snafu(transparent)]
+    Script { source: ScriptAdapterCompileError },
+}

lib/icp-adapter/src/motoko.rs

@@ -0,0 +1,27 @@
+use crate::{Adapter, AdapterCompileError};
+use async_trait::async_trait;
+use camino::Utf8Path;
+use serde::Deserialize;
+use snafu::Snafu;
+
+/// Configuration for a Motoko-based canister build adapter.
+#[derive(Debug, Deserialize)]
+pub struct MotokoAdapter {
+    /// Optional path to the main Motoko source file.
+    /// If omitted, a default like `main.mo` may be assumed.
+    #[serde(default)]
+    pub main: Option<String>,
+}
+
+#[async_trait]
+impl Adapter for MotokoAdapter {
+    async fn compile(&self, _path: &Utf8Path) -> Result<(), AdapterCompileError> {
+        Ok(())
+    }
+}
+
+#[derive(Debug, Snafu)]
+pub enum MotokoAdapterCompileError {
+    #[snafu(display("an unexpected build error occurred"))]
+    Unexpected,
+}

lib/icp-adapter/src/rust.rs

@@ -0,0 +1,25 @@
+use crate::{Adapter, AdapterCompileError};
+use async_trait::async_trait;
+use camino::Utf8Path;
+use serde::Deserialize;
+use snafu::Snafu;
+
+/// Configuration for a Rust-based canister build adapter.
+#[derive(Debug, Deserialize)]
+pub struct RustAdapter {
+    /// The name of the Cargo package to build.
+    pub package: String,
+}
+
+#[async_trait]
+impl Adapter for RustAdapter {
+    async fn compile(&self, _path: &Utf8Path) -> Result<(), AdapterCompileError> {
+        Ok(())
+    }
+}
+
+#[derive(Debug, Snafu)]
+pub enum RustAdapterCompileError {
+    #[snafu(display("an unexpected build error occurred"))]
+    Unexpected,
+}