Merge pull request #33 from 100monkeys-ai/feat/delegate-foundry-client-publish-7078516248368222698

feat(cli): delegate forge publish to foundry-client

Author: Theaxiom

Cargo.lock

@@ -2,6 +2,7 @@
 
 use anyhow::Result;
 use clap::Args;
+use crate::config::CliConfig;
 
 #[derive(Debug, Args)]
 pub struct PublishArgs {
@@ -11,12 +12,17 @@ pub struct PublishArgs {
 }
 
 pub async fn run(args: PublishArgs) -> Result<()> {
-    use foundry_client::publish::{publish_package, PublishOptions};
+    let config = CliConfig::load();
+    let registry_url = config.registry_url.unwrap_or_else(|| "https://registry.forgejs.com".to_string());
 
-    publish_package(PublishOptions {
+    let options = foundry_client::publish::PublishOptions {
+        dir: camino::Utf8PathBuf::from("."),
         dry_run: args.dry_run,
-    })
-    .await?;
+        registry_url,
+        auth_token: config.auth_token,
+    };
+
+    foundry_client::publish::publish_package(options).await?;
 
     Ok(())
 }

cli/src/commands/publish.rs

@@ -16,7 +16,7 @@ thiserror = { workspace = true }
 anyhow = { workspace = true }
 tracing = { workspace = true }
 camino = { workspace = true }
-reqwest = { workspace = true }
+reqwest = { workspace = true, features = ["multipart"] }
 blake3 = { workspace = true }
 indexmap = { workspace = true }
 tokio = { workspace = true }
@@ -27,6 +27,7 @@ oxc_ast = { workspace = true }
 oxc_span = { workspace = true }
 oxc_allocator = { workspace = true }
 chrono = { workspace = true }
+walkdir = "2.5.0"
 
 [dev-dependencies]
 serial_test = "3.4.0"

foundry/client/Cargo.toml

@@ -40,3 +40,4 @@ pub mod migrate;
 pub mod publish;
 pub mod registry_client;
 pub mod resolver;
+pub mod publish;

foundry/client/src/lib.rs

@@ -1,29 +1,76 @@
-//! Publishing logic for the Foundry registry.
-
 use crate::error::FoundryError;
+use crate::manifest::foundry_toml::parse_foundry_toml;
+use crate::registry_client::RegistryClient;
+use flate2::write::GzEncoder;
+use flate2::Compression;
+use std::fs;
 use tracing::info;
 
-/// Options for the publish command.
-#[derive(Debug, Clone)]
 pub struct PublishOptions {
-    /// Perform a dry run without actually publishing.
+    pub dir: camino::Utf8PathBuf,
     pub dry_run: bool,
+    pub registry_url: String,
+    pub auth_token: Option<String>,
 }
 
-/// Publish a package to the Foundry registry.
 pub async fn publish_package(options: PublishOptions) -> Result<(), FoundryError> {
-    // TODO: Implementation of package publishing:
-    // 1. Read foundry.toml
-    // 2. Validate package
-    // 3. Create tarball
-    // 4. Sign package
-    // 5. Upload to registry
+    let manifest_path = options.dir.join("foundry.toml");
+    let manifest = parse_foundry_toml(&manifest_path)?;
+
+    let name_parts: Vec<&str> = manifest.package.name.split('/').collect();
+    if name_parts.len() != 2 {
+        return Err(FoundryError::ManifestParse {
+            path: manifest_path.to_string(),
+            message: "package name must be in the format 'author/name'".to_string(),
+        });
+    }
+    let author = name_parts[0];
+    let name = name_parts[1];
+
+    info!("Publishing {}@{}...", manifest.package.name, manifest.package.version);
 
     if options.dry_run {
-        info!("Dry run: would publish package to registry");
-    } else {
-        info!("Publishing package to registry...");
+        info!("Dry run complete. No package published.");
+        return Ok(());
     }
 
+    let auth_token = options.auth_token.ok_or(FoundryError::AuthRequired)?;
+
+    let mut tar_gz = Vec::new();
+    let enc = GzEncoder::new(&mut tar_gz, Compression::default());
+    let mut tar = tar::Builder::new(enc);
+
+    // Pack the directory
+    for entry in walkdir::WalkDir::new(&options.dir).into_iter().filter_map(|e: Result<walkdir::DirEntry, walkdir::Error>| e.ok()) {
+        let path = entry.path();
+        if path.is_file() {
+            let relative_path = path.strip_prefix(&options.dir).unwrap();
+
+            let should_skip = relative_path.components().any(|c| {
+                if let std::path::Component::Normal(os_str) = c {
+                    let s = os_str.to_string_lossy();
+                    s == ".git" || s == ".forge" || s == "node_modules"
+                } else {
+                    false
+                }
+            });
+
+            if should_skip {
+                continue;
+            }
+
+            let mut file = fs::File::open(path)?;
+            tar.append_file(relative_path, &mut file)?;
+        }
+    }
+    let enc = tar.into_inner()?;
+    enc.finish()?;
+
+    let manifest_content = fs::read_to_string(&manifest_path)?;
+
+    let client = RegistryClient::new(options.registry_url, Some(auth_token));
+    client.publish(author, name, manifest_content, tar_gz).await?;
+
+    info!("Successfully published {}@{}", manifest.package.name, manifest.package.version);
     Ok(())
 }

foundry/client/src/publish.rs

@@ -107,4 +107,35 @@ impl RegistryClient {
 
         Ok(bytes.to_vec())
     }
+
+    pub async fn publish(&self, author: &str, name: &str, manifest: String, tarball: Vec<u8>) -> Result<(), FoundryError> {
+        let url = format!("{}/packages/{}/{}", self.base_url, author, name);
+
+        let token = self.auth_token.as_ref().ok_or(FoundryError::AuthRequired)?;
+
+        let manifest_part = reqwest::multipart::Part::text(manifest)
+            .mime_str("text/plain;charset=utf-8")
+            .map_err(|_| FoundryError::Registry("Invalid mime type for manifest".to_string()))?;
+
+        let tarball_part = reqwest::multipart::Part::bytes(tarball)
+            .mime_str("application/x-tar")
+            .map_err(|_| FoundryError::Registry("Invalid mime type for tarball".to_string()))?;
+
+        let form = reqwest::multipart::Form::new()
+            .part("manifest", manifest_part)
+            .part("tarball", tarball_part);
+
+        let response: reqwest::Response = self.http.post(&url)
+            .bearer_auth(token)
+            .multipart(form)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            return Err(FoundryError::Registry(format!("Failed to publish package: {}", error_text)));
+        }
+
+        Ok(())
+    }
 }