Feat/webCaseCenter

.gitignore

@@ -33,6 +33,14 @@ examples/openai-agents-example/.scratch/
 examples/openai-agents-code-interpreter/__pycache__/
 examples/openai-agents-code-interpreter/output/
 examples/openai-agents-code-interpreter/.scratch/
+examples/code-sandbox-quickstart/__pycache__/
+examples/browser-sandbox/__pycache__/
+examples/host-mount/__pycache__/
+examples/network-policy/__pycache__/
+examples/snapshot-rollback-clone/__pycache__/
+
+# Auto-generated pip install fingerprints (local cache, do not commit)
+examples/*/.requirements_installed
 
 pvm-guest-build/
 pvm-host-build/

CubeAPI/src/config/mod.rs

@@ -71,6 +71,52 @@ pub struct ServerConfig {
     /// Example: mysql://cube:cube_pass@127.0.0.1:3306/cube_mvp
     #[serde(default = "default_database_url")]
     pub database_url: Option<String>,
+
+    /// Default template ID used by the Examples runner.
+    /// Env var: CUBE_TEMPLATE_ID
+    #[serde(default = "default_template_id")]
+    pub default_template_id: Option<String>,
+
+    /// CubeAPI URL used by the Examples runner (passed as CUBE_API_URL to scripts).
+    /// Env var: CUBE_API_URL (default "http://127.0.0.1:3000")
+    #[serde(default = "default_cube_api_url")]
+    pub cube_api_url: Option<String>,
+
+    /// CubeProxy node IP for bypassing DNS resolution (passed as CUBE_PROXY_NODE_IP).
+    /// Env var: CUBE_PROXY_NODE_IP
+    #[serde(default)]
+    pub cube_proxy_node_ip: Option<String>,
+
+    /// CubeProxy HTTP port (passed as CUBE_PROXY_PORT_HTTP).
+    /// Env var: CUBE_PROXY_PORT_HTTP (no default; omitted when unset)
+    #[serde(default = "default_cube_proxy_port_http")]
+    pub cube_proxy_port_http: Option<u16>,
+
+    /// Base URL of the sandbox proxy used to reach in-sandbox services
+    /// (envd / Jupyter). Env var: AGENTHUB_SANDBOX_PROXY_URL (default
+    /// "http://127.0.0.1").
+    #[serde(default = "default_sandbox_proxy_url")]
+    pub sandbox_proxy_url: String,
+
+    /// `Authorization` header value used for internal service-to-service auth
+    /// with the in-sandbox envd / Jupyter endpoints.
+    ///
+    /// **Security**: this is a credential and must never be hardcoded in
+    /// business logic. It is sourced from the environment so deployments can
+    /// rotate it without code changes. Env var: CUBE_API_ENVD_AUTH (default
+    /// `Basic cm9vdDo=`, i.e. the envd built-in `root:` with an empty
+    /// password — override it in any non-local environment).
+    #[serde(default = "default_envd_auth")]
+    pub envd_auth: String,
+
+    /// Fallback CUBE_API_KEY injected into example subprocesses when the
+    /// parent process does not export CUBE_API_KEY.
+    ///
+    /// Intended for sandbox/demo deployments to provide an out-of-the-box
+    /// experience. In production, leave this unset and export CUBE_API_KEY
+    /// directly. Env var: CUBE_API_DEFAULT_KEY
+    #[serde(default = "default_api_key")]
+    pub default_api_key: Option<String>,
 }
 
 fn default_bind() -> String {
@@ -109,6 +155,35 @@ fn default_database_url() -> Option<String> {
         .ok()
         .or_else(default_cube_sandbox_mysql_url)
 }
+fn default_template_id() -> Option<String> {
+    std::env::var("CUBE_TEMPLATE_ID")
+        .ok()
+        .filter(|s| !s.is_empty())
+}
+fn default_cube_api_url() -> Option<String> {
+    std::env::var("CUBE_API_URL")
+        .ok()
+        .filter(|s| !s.is_empty())
+        .or_else(|| Some("http://127.0.0.1:3000".to_string()))
+}
+
+fn default_cube_proxy_port_http() -> Option<u16> {
+    std::env::var("CUBE_PROXY_PORT_HTTP")
+        .ok()
+        .and_then(|s| s.parse().ok())
+}
+fn default_sandbox_proxy_url() -> String {
+    std::env::var("AGENTHUB_SANDBOX_PROXY_URL").unwrap_or_else(|_| "http://127.0.0.1".to_string())
+}
+fn default_envd_auth() -> String {
+    std::env::var("CUBE_API_ENVD_AUTH").unwrap_or_else(|_| "Basic cm9vdDo=".to_string())
+}
+fn default_api_key() -> Option<String> {
+    std::env::var("CUBE_API_DEFAULT_KEY")
+        .ok()
+        .filter(|s| !s.is_empty())
+        .or_else(|| Some("cube_0000000000000000000000000000000000000000".to_string()))
+}
 
 fn default_cube_sandbox_mysql_url() -> Option<String> {
     let host = std::env::var("CUBE_SANDBOX_MYSQL_HOST").ok()?;
@@ -148,6 +223,13 @@ impl Default for ServerConfig {
             log_prefix: default_log_prefix(),
             auth_callback_url: None,
             database_url: default_database_url(),
+            default_template_id: default_template_id(),
+            cube_api_url: default_cube_api_url(),
+            cube_proxy_node_ip: None,
+            cube_proxy_port_http: default_cube_proxy_port_http(),
+            sandbox_proxy_url: default_sandbox_proxy_url(),
+            envd_auth: default_envd_auth(),
+            default_api_key: default_api_key(),
         }
     }
 }

CubeAPI/src/db.rs

@@ -84,6 +84,27 @@ pub struct AgentHubOperationRecord {
     pub updated_at: Option<String>,
 }
 
+// ── Store Template records ──────────────────────────────────────────────────
+
+pub struct StoreTemplateRecord {
+    pub item_id: String,
+    pub name_key: String,
+    pub description_key: String,
+    pub image_cn: String,
+    pub image_intl: String,
+    pub digest: Option<String>,
+    pub tags: Vec<String>,
+    pub category: String,
+    pub size_mb: i32,
+    pub expose_ports: Vec<i32>,
+    pub probe_port: i32,
+    pub probe_path: String,
+    pub writable_layer_size: String,
+    pub official: bool,
+    pub dns: Vec<String>,
+    pub sort_order: i32,
+}
+
 impl AgentHubStore {
     pub async fn connect(database_url: &str) -> anyhow::Result<Self> {
         let pool = MySqlPoolOptions::new()
@@ -1248,6 +1269,156 @@ LIMIT 1
             .await?;
         Ok(())
     }
+
+    // ── Store Template CRUD ──────────────────────────────────────────────────
+
+    pub async fn list_store_templates(&self) -> anyhow::Result<Vec<StoreTemplateRecord>> {
+        let rows = sqlx::query(
+            r#"
+SELECT item_id, name_key, description_key, image_cn, image_intl, digest,
+       tags, category, size_mb, expose_ports, probe_port, probe_path,
+       writable_layer_size, official, dns, sort_order
+FROM t_store_template
+WHERE deleted_at IS NULL
+ORDER BY sort_order, id
+"#,
+        )
+        .fetch_all(&self.pool)
+        .await?;
+
+        rows.into_iter()
+            .map(|row| {
+                let tags_value: Option<Value> = row.try_get("tags")?;
+                let ports_value: Option<Value> = row.try_get("expose_ports")?;
+                let dns_value: Option<Value> = row.try_get("dns")?;
+                Ok::<StoreTemplateRecord, sqlx::Error>(StoreTemplateRecord {
+                    item_id: row.try_get("item_id")?,
+                    name_key: row.try_get("name_key")?,
+                    description_key: row.try_get("description_key")?,
+                    image_cn: row.try_get("image_cn")?,
+                    image_intl: row.try_get("image_intl")?,
+                    digest: row.try_get("digest")?,
+                    tags: tags_value
+                        .and_then(|v| serde_json::from_value(v).ok())
+                        .unwrap_or_default(),
+                    category: row.try_get("category")?,
+                    size_mb: row.try_get("size_mb")?,
+                    expose_ports: ports_value
+                        .and_then(|v| serde_json::from_value(v).ok())
+                        .unwrap_or_default(),
+                    probe_port: row.try_get("probe_port")?,
+                    probe_path: row.try_get("probe_path")?,
+                    writable_layer_size: row.try_get("writable_layer_size")?,
+                    official: row.try_get::<i8, _>("official")? != 0,
+                    dns: dns_value
+                        .and_then(|v| serde_json::from_value(v).ok())
+                        .unwrap_or_default(),
+                    sort_order: row.try_get("sort_order")?,
+                })
+            })
+            .collect::<Result<Vec<_>, sqlx::Error>>()
+            .map_err(anyhow::Error::from)
+    }
+
+    pub async fn create_store_template(&self, record: &StoreTemplateRecord) -> anyhow::Result<()> {
+        let tags = serde_json::to_value(&record.tags)?;
+        let ports = serde_json::to_value(&record.expose_ports)?;
+        let dns = serde_json::to_value(&record.dns)?;
+        sqlx::query(
+            r#"
+INSERT INTO t_store_template (
+  item_id, name_key, description_key, image_cn, image_intl, digest,
+  tags, category, size_mb, expose_ports, probe_port, probe_path,
+  writable_layer_size, official, dns, sort_order, deleted_at
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
+ON DUPLICATE KEY UPDATE
+  name_key = VALUES(name_key),
+  description_key = VALUES(description_key),
+  image_cn = VALUES(image_cn),
+  image_intl = VALUES(image_intl),
+  digest = VALUES(digest),
+  tags = VALUES(tags),
+  category = VALUES(category),
+  size_mb = VALUES(size_mb),
+  expose_ports = VALUES(expose_ports),
+  probe_port = VALUES(probe_port),
+  probe_path = VALUES(probe_path),
+  writable_layer_size = VALUES(writable_layer_size),
+  official = VALUES(official),
+  dns = VALUES(dns),
+  sort_order = VALUES(sort_order),
+  deleted_at = NULL
+"#,
+        )
+        .bind(&record.item_id)
+        .bind(&record.name_key)
+        .bind(&record.description_key)
+        .bind(&record.image_cn)
+        .bind(&record.image_intl)
+        .bind(&record.digest)
+        .bind(tags)
+        .bind(&record.category)
+        .bind(record.size_mb)
+        .bind(ports)
+        .bind(record.probe_port)
+        .bind(&record.probe_path)
+        .bind(&record.writable_layer_size)
+        .bind(record.official)
+        .bind(dns)
+        .bind(record.sort_order)
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+
+    pub async fn update_store_template(&self, record: &StoreTemplateRecord) -> anyhow::Result<()> {
+        let tags = serde_json::to_value(&record.tags)?;
+        let ports = serde_json::to_value(&record.expose_ports)?;
+        let dns = serde_json::to_value(&record.dns)?;
+        sqlx::query(
+            r#"
+UPDATE t_store_template SET
+  name_key = ?, description_key = ?, image_cn = ?, image_intl = ?,
+  digest = ?, tags = ?, category = ?, size_mb = ?, expose_ports = ?,
+  probe_port = ?, probe_path = ?, writable_layer_size = ?,
+  official = ?, dns = ?, sort_order = ?
+WHERE item_id = ? AND deleted_at IS NULL
+"#,
+        )
+        .bind(&record.name_key)
+        .bind(&record.description_key)
+        .bind(&record.image_cn)
+        .bind(&record.image_intl)
+        .bind(&record.digest)
+        .bind(tags)
+        .bind(&record.category)
+        .bind(record.size_mb)
+        .bind(ports)
+        .bind(record.probe_port)
+        .bind(&record.probe_path)
+        .bind(&record.writable_layer_size)
+        .bind(record.official)
+        .bind(dns)
+        .bind(record.sort_order)
+        .bind(&record.item_id)
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+
+    pub async fn soft_delete_store_template(&self, item_id: &str) -> anyhow::Result<()> {
+        sqlx::query(
+            r#"
+UPDATE t_store_template
+SET deleted_at = CURRENT_TIMESTAMP
+WHERE item_id = ? AND deleted_at IS NULL
+"#,
+        )
+        .bind(item_id)
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
 }
 
 impl AgentHubInstanceRecord {

CubeAPI/src/examples/mod.rs

@@ -0,0 +1,13 @@
+// Copyright (c) 2024 Tencent Inc.
+// SPDX-License-Identifier: Apache-2.0
+//
+//! Example registry and topology templates.
+//!
+//! Pure-data modules with no async dependencies; they are consumed by
+//! [`crate::services::examples::ExampleService`].
+
+pub mod registry;
+pub mod topology;
+
+pub use registry::{file_languages, scenario_registry, FileSpec, ScenarioSpec};
+pub use topology::{topology_with_status, TopologyGraph};