gnd: Implement publish command matching graph-cli behavior

The publish command now:
- Builds the subgraph and uploads to IPFS (reusing build command)
- Opens browser to cli.thegraph.com/publish with query params
- Supports --ipfs-hash to skip build and use existing hash
- Supports --subgraph-id and --api-key for updating existing subgraphs
- Supports --protocol-network (arbitrum-one, arbitrum-sepolia)
- Prompts user before opening browser

This matches graph-cli's approach of delegating wallet/GRT handling
to the web UI rather than implementing it in the CLI.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: lutter

Cargo.lock

@@ -61,6 +61,9 @@ which = "7"
 # Interactive prompts
 inquire = "0.7"
 
+# Browser opening for publish command
+open = "5"
+
 [target.'cfg(unix)'.dependencies]
 pgtemp = { git = "https://github.com/graphprotocol/pgtemp", branch = "initdb-args" }
 

gnd/Cargo.toml

@@ -1,102 +1,244 @@
 //! Publish command for publishing subgraphs to The Graph's decentralized network.
 //!
-//! This command publishes a subgraph to The Graph's decentralized network,
-//! which requires GRT tokens for indexer rewards and query fees.
+//! This command builds a subgraph, uploads it to IPFS, and opens a browser
+//! to complete the publishing process on The Graph Network.
 
 use std::path::PathBuf;
 
 use anyhow::{anyhow, Result};
 use clap::Parser;
+use inquire::Confirm;
 
+use crate::commands::build::{run_build, BuildOpt};
 use crate::output::{step, Step};
 
+/// Default IPFS URL for The Graph's hosted IPFS node.
+const DEFAULT_IPFS_URL: &str = "https://api.thegraph.com/ipfs/api/v0";
+
+/// Default webapp URL for publishing.
+const DEFAULT_WEBAPP_URL: &str = "https://cli.thegraph.com/publish";
+
 #[derive(Clone, Debug, Parser)]
 #[clap(about = "Publish a subgraph to The Graph's decentralized network")]
 pub struct PublishOpt {
-    /// Subgraph deployment ID (IPFS hash)
-    #[clap()]
-    pub deployment_id: Option<String>,
-
     /// Path to the subgraph manifest
-    #[clap(short = 'm', long, default_value = "subgraph.yaml")]
+    #[clap(default_value = "subgraph.yaml")]
     pub manifest: PathBuf,
 
-    /// IPFS node URL
-    #[clap(short = 'i', long)]
-    pub ipfs: Option<String>,
+    /// IPFS node URL to upload build results to
+    #[clap(short = 'i', long, default_value = DEFAULT_IPFS_URL)]
+    pub ipfs: String,
 
-    /// Subgraph Studio deploy key
+    /// IPFS hash of the subgraph manifest to deploy (skips build)
     #[clap(long)]
-    pub deploy_key: Option<String>,
+    pub ipfs_hash: Option<String>,
 
-    /// Network to publish to (mainnet, arbitrum-one, etc.)
+    /// Subgraph ID to publish to (for updating existing subgraphs)
     #[clap(long)]
-    pub network: Option<String>,
+    pub subgraph_id: Option<String>,
+
+    /// The network to use for the subgraph deployment
+    #[clap(long, default_value = "arbitrum-one")]
+    pub protocol_network: String,
 
-    /// Version label for the deployment
-    #[clap(short = 'l', long)]
-    pub version_label: Option<String>,
+    /// The API key for Subgraph queries (required when updating existing subgraph)
+    #[clap(long)]
+    pub api_key: Option<String>,
+
+    /// URL of the web UI to use for publishing
+    #[clap(long, default_value = DEFAULT_WEBAPP_URL)]
+    pub webapp_url: String,
+
+    /// Output directory for build results
+    #[clap(short = 'o', long, default_value = "build/")]
+    pub output_dir: PathBuf,
+
+    /// Skip subgraph migrations
+    #[clap(long)]
+    pub skip_migrations: bool,
 
-    /// Skip confirmation prompt
+    /// Network configuration to use from the networks config file
     #[clap(long)]
-    pub skip_confirmation: bool,
+    pub network: Option<String>,
+
+    /// Networks config file path
+    #[clap(long, default_value = "networks.json")]
+    pub network_file: PathBuf,
 }
 
 /// Run the publish command.
-pub fn run_publish(opt: PublishOpt) -> Result<()> {
-    step(
-        Step::Generate,
-        "Publishing to The Graph's decentralized network",
-    );
+pub async fn run_publish(opt: PublishOpt) -> Result<()> {
+    // Validate: if subgraph_id is provided, api_key is required
+    if opt.subgraph_id.is_some() && opt.api_key.is_none() {
+        return Err(anyhow!(
+            "API key is required to publish to an existing subgraph (--api-key).\n\
+             See https://thegraph.com/docs/en/deploying/subgraph-studio-faqs/#2-how-do-i-create-an-api-key"
+        ));
+    }
 
-    // Validate we have a deployment ID or manifest
-    if opt.deployment_id.is_none() && !opt.manifest.exists() {
+    // Validate protocol network
+    if opt.protocol_network != "arbitrum-one" && opt.protocol_network != "arbitrum-sepolia" {
         return Err(anyhow!(
-            "No deployment ID provided and manifest '{}' not found.\n\
-             Please provide either:\n\
-             - A deployment ID (IPFS hash): gnd publish <deployment-id>\n\
-             - A valid manifest path: gnd publish -m <path>",
-            opt.manifest.display()
+            "Invalid protocol network '{}'. Must be 'arbitrum-one' or 'arbitrum-sepolia'",
+            opt.protocol_network
         ));
     }
 
-    Err(anyhow!(
-        "Publish command is not yet implemented.\n\
-         This feature requires:\n\
-         - Integration with The Graph Network subgraph\n\
-         - Wallet connection for signing transactions\n\
-         - GRT token handling for indexer rewards\n\n\
-         To publish your subgraph:\n\
-         1. Visit https://thegraph.com/studio\n\
-         2. Create your subgraph in the Studio\n\
-         3. Deploy using: gnd deploy --studio <subgraph-name>\n\
-         4. Use the Studio UI to publish to the network\n\n\
-         Or use the TypeScript graph-cli:\n\
-         graph publish"
-    ))
+    // Extract URL-related fields before potentially moving opt fields into BuildOpt
+    let webapp_url = opt.webapp_url.clone();
+    let subgraph_id = opt.subgraph_id.clone();
+    let protocol_network = opt.protocol_network.clone();
+    let api_key = opt.api_key.clone();
+
+    // Get the IPFS hash - either from flag or by building
+    let ipfs_hash = if let Some(hash) = opt.ipfs_hash {
+        step(Step::Skip, "Using provided IPFS hash");
+        hash
+    } else {
+        // Build the subgraph and upload to IPFS
+        step(Step::Load, "Building subgraph for publishing");
+
+        // Validate manifest exists
+        if !opt.manifest.exists() {
+            return Err(anyhow!(
+                "Manifest '{}' not found.\n\
+                 Please provide either:\n\
+                 - A valid manifest path: gnd publish <manifest>\n\
+                 - An IPFS hash: gnd publish --ipfs-hash <hash>",
+                opt.manifest.display()
+            ));
+        }
+
+        let build_opt = BuildOpt {
+            manifest: opt.manifest,
+            output_dir: opt.output_dir,
+            output_format: "wasm".to_string(),
+            skip_migrations: opt.skip_migrations,
+            watch: false,
+            ipfs: Some(opt.ipfs),
+            network: opt.network,
+            network_file: opt.network_file,
+        };
+
+        match run_build(build_opt).await? {
+            Some(hash) => hash,
+            None => {
+                return Err(anyhow!(
+                    "Build completed but IPFS upload failed. Cannot proceed with publish."
+                ));
+            }
+        }
+    };
+
+    // Prompt user to open browser
+    step(Step::Generate, "Ready to publish to The Graph Network");
+
+    let open_browser = Confirm::new("Open browser to continue publishing?")
+        .with_default(true)
+        .prompt()?;
+
+    if !open_browser {
+        println!("\nTo publish manually, visit:");
+        println!(
+            "  {}",
+            build_publish_url(
+                &webapp_url,
+                &ipfs_hash,
+                &subgraph_id,
+                &protocol_network,
+                &api_key
+            )
+        );
+        return Ok(());
+    }
+
+    // Build the URL with query parameters
+    let url = build_publish_url(
+        &webapp_url,
+        &ipfs_hash,
+        &subgraph_id,
+        &protocol_network,
+        &api_key,
+    );
+
+    step(Step::Done, "Opening browser to complete publishing");
+    println!("\n  {}\n", url);
+
+    // Open the browser
+    open::that(&url).map_err(|e| anyhow!("Failed to open browser: {}", e))?;
+
+    Ok(())
+}
+
+/// Build the publish URL with query parameters.
+fn build_publish_url(
+    base_url: &str,
+    ipfs_hash: &str,
+    subgraph_id: &Option<String>,
+    protocol_network: &str,
+    api_key: &Option<String>,
+) -> String {
+    let mut params = vec![format!("id={}", ipfs_hash)];
+
+    if let Some(id) = subgraph_id {
+        params.push(format!("subgraphId={}", id));
+    }
+
+    params.push(format!("network={}", protocol_network));
+
+    if let Some(key) = api_key {
+        params.push(format!("apiKey={}", key));
+    }
+
+    format!("{}?{}", base_url, params.join("&"))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
-    fn test_publish_not_implemented() {
-        let opt = PublishOpt {
-            deployment_id: Some("QmTest".to_string()),
-            manifest: PathBuf::from("subgraph.yaml"),
-            ipfs: None,
-            deploy_key: None,
-            network: None,
-            version_label: None,
-            skip_confirmation: false,
-        };
+    fn test_build_publish_url_basic() {
+        let url = build_publish_url(
+            DEFAULT_WEBAPP_URL,
+            "QmTest123",
+            &None,
+            "arbitrum-one",
+            &None,
+        );
+        assert_eq!(
+            url,
+            "https://cli.thegraph.com/publish?id=QmTest123&network=arbitrum-one"
+        );
+    }
 
-        let result = run_publish(opt);
-        assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("not yet implemented"));
+    #[test]
+    fn test_build_publish_url_with_subgraph_id() {
+        let url = build_publish_url(
+            DEFAULT_WEBAPP_URL,
+            "QmTest456",
+            &Some("my-subgraph".to_string()),
+            "arbitrum-sepolia",
+            &Some("abc123".to_string()),
+        );
+        assert_eq!(
+            url,
+            "https://cli.thegraph.com/publish?id=QmTest456&subgraphId=my-subgraph&network=arbitrum-sepolia&apiKey=abc123"
+        );
+    }
+
+    #[test]
+    fn test_build_publish_url_custom_webapp() {
+        let url = build_publish_url(
+            "https://custom.example.com/publish",
+            "QmCustom",
+            &None,
+            "arbitrum-one",
+            &None,
+        );
+        assert_eq!(
+            url,
+            "https://custom.example.com/publish?id=QmCustom&network=arbitrum-one"
+        );
     }
 }

gnd/src/commands/publish.rs

@@ -204,7 +204,7 @@ async fn main() -> Result<()> {
             }
         }
         Commands::Publish(publish_opt) => {
-            if let Err(e) = run_publish(publish_opt) {
+            if let Err(e) = run_publish(publish_opt).await {
                 eprintln!("Error: {}", e);
                 std::process::exit(1);
             }