feat(billing, team): add billing and team management RPC functionality (tinyhumansai#159)

* feat(billing, team): add billing and team management RPC functionality

- Introduced billing module with methods for fetching current plans, purchasing plans, creating portal sessions, and topping up credits.
- Added team management module with methods for listing team members, creating invites, listing invites, removing members, and changing member roles.
- Updated core registry to include new billing and team controllers and schemas, enhancing the overall functionality of the application.
- Implemented comprehensive tests for billing and team RPC methods to ensure reliability and correctness.

These additions improve the application's capabilities in managing billing and team functionalities, providing a more robust user experience.

* refactor(billing, team): improve code readability and structure

* fix(billing, team): enhance error handling and response structure

- Improved error handling in  to provide clearer error messages when reading response bodies.
- Updated validation in  to ensure  is a finite number greater than zero.
- Refined output schemas for billing and team functions to include more descriptive fields, enhancing API clarity.
- Introduced a new  function to standardize URL path construction, improving code maintainability.
- Added tests to verify the correctness of new output structures and API path building.

These changes enhance the robustness and usability of the billing and team management functionalities.

* feat(billing, team): add gateway normalization and route redaction functionality

- Introduced  function to standardize payment gateway inputs, ensuring only valid options (stripe, coinbase) are accepted, with defaults and error handling.
- Enhanced  function to utilize the new gateway normalization logic, improving input validation.
- Added  function to obscure sensitive identifiers in API route paths, enhancing security in logging.
- Implemented unit tests for both  and  to ensure correctness and reliability of the new features.

These changes improve the robustness of billing operations and enhance security in route handling.

Author: YellowSnnowmann

src/core/all.rs

@@ -63,6 +63,8 @@ fn build_registered_controllers() -> Vec<RegisteredController> {
     controllers.extend(crate::openhuman::workspace::all_workspace_registered_controllers());
     controllers.extend(crate::openhuman::tools::all_tools_registered_controllers());
     controllers.extend(crate::openhuman::memory::all_memory_registered_controllers());
+    controllers.extend(crate::openhuman::billing::all_billing_registered_controllers());
+    controllers.extend(crate::openhuman::team::all_team_registered_controllers());
     controllers
 }
 
@@ -91,6 +93,8 @@ fn build_declared_controller_schemas() -> Vec<ControllerSchema> {
     schemas.extend(crate::openhuman::workspace::all_workspace_controller_schemas());
     schemas.extend(crate::openhuman::tools::all_tools_controller_schemas());
     schemas.extend(crate::openhuman::memory::all_memory_controller_schemas());
+    schemas.extend(crate::openhuman::billing::all_billing_controller_schemas());
+    schemas.extend(crate::openhuman::team::all_team_controller_schemas());
     schemas
 }
 
@@ -125,6 +129,8 @@ pub fn namespace_description(namespace: &str) -> Option<&'static str> {
         "skills" => Some("Skill registry, runtime lifecycle, setup, tools, and sync."),
         "socket" => Some("Skills runtime socket bridge controls."),
         "memory" => Some("Document storage, vector search, key-value store, and knowledge graph."),
+        "billing" => Some("Subscription plan, payment links, and credit top-up via the backend."),
+        "team" => Some("Team member management, invites, and role changes via the backend."),
         _ => None,
     }
 }

src/core/jsonrpc.rs

@@ -732,5 +732,215 @@ mod tests {
                 .any(|m| m.method == "openhuman.health_snapshot"),
             "schema dump should include migrated openhuman methods"
         );
+
+        assert!(
+            methods
+                .iter()
+                .any(|m| m.method == "openhuman.billing_get_current_plan"),
+            "schema dump should include billing methods"
+        );
+
+        assert!(
+            methods
+                .iter()
+                .any(|m| m.method == "openhuman.team_list_members"),
+            "schema dump should include team methods"
+        );
+    }
+
+    #[tokio::test]
+    async fn billing_get_current_plan_rejects_unknown_param() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.billing_get_current_plan",
+            json!({ "extra": true }),
+        )
+        .await
+        .expect_err("unknown param should fail");
+        assert!(err.contains("unknown param 'extra'"));
+    }
+
+    #[tokio::test]
+    async fn billing_purchase_plan_missing_plan_fails_validation() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.billing_purchase_plan",
+            json!({}),
+        )
+        .await
+        .expect_err("missing plan should fail");
+        assert!(err.contains("missing required param 'plan'"));
+    }
+
+    #[tokio::test]
+    async fn billing_top_up_missing_amount_fails_validation() {
+        let err = invoke_method(default_state(), "openhuman.billing_top_up", json!({}))
+            .await
+            .expect_err("missing amountUsd should fail");
+        assert!(err.contains("missing required param 'amountUsd'"));
+    }
+
+    #[tokio::test]
+    async fn billing_top_up_rejects_unknown_param() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.billing_top_up",
+            json!({ "amountUsd": 10.0, "unknownField": true }),
+        )
+        .await
+        .expect_err("unknown param should fail");
+        assert!(err.contains("unknown param 'unknownField'"));
+    }
+
+    #[tokio::test]
+    async fn billing_create_portal_session_rejects_unknown_param() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.billing_create_portal_session",
+            json!({ "x": 1 }),
+        )
+        .await
+        .expect_err("unknown param should fail");
+        assert!(err.contains("unknown param 'x'"));
+    }
+
+    #[tokio::test]
+    async fn team_list_members_missing_team_id_fails_validation() {
+        let err = invoke_method(default_state(), "openhuman.team_list_members", json!({}))
+            .await
+            .expect_err("missing teamId should fail");
+        assert!(err.contains("missing required param 'teamId'"));
+    }
+
+    #[tokio::test]
+    async fn team_list_members_rejects_unknown_param() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.team_list_members",
+            json!({ "teamId": "t1", "extra": true }),
+        )
+        .await
+        .expect_err("unknown param should fail");
+        assert!(err.contains("unknown param 'extra'"));
+    }
+
+    #[tokio::test]
+    async fn team_create_invite_missing_team_id_fails_validation() {
+        let err = invoke_method(default_state(), "openhuman.team_create_invite", json!({}))
+            .await
+            .expect_err("missing teamId should fail");
+        assert!(err.contains("missing required param 'teamId'"));
+    }
+
+    #[tokio::test]
+    async fn team_remove_member_missing_required_params_fails_validation() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.team_remove_member",
+            json!({ "teamId": "t1" }),
+        )
+        .await
+        .expect_err("missing userId should fail");
+        assert!(err.contains("missing required param 'userId'"));
+    }
+
+    #[tokio::test]
+    async fn team_change_member_role_missing_role_fails_validation() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.team_change_member_role",
+            json!({ "teamId": "t1", "userId": "u1" }),
+        )
+        .await
+        .expect_err("missing role should fail");
+        assert!(err.contains("missing required param 'role'"));
+    }
+
+    #[tokio::test]
+    async fn billing_create_coinbase_charge_missing_plan_fails_validation() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.billing_create_coinbase_charge",
+            json!({}),
+        )
+        .await
+        .expect_err("missing plan should fail");
+        assert!(err.contains("missing required param 'plan'"));
+    }
+
+    #[tokio::test]
+    async fn billing_create_coinbase_charge_rejects_unknown_param() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.billing_create_coinbase_charge",
+            json!({ "plan": "pro", "extra": true }),
+        )
+        .await
+        .expect_err("unknown param should fail");
+        assert!(err.contains("unknown param 'extra'"));
+    }
+
+    #[tokio::test]
+    async fn team_list_invites_missing_team_id_fails_validation() {
+        let err = invoke_method(default_state(), "openhuman.team_list_invites", json!({}))
+            .await
+            .expect_err("missing teamId should fail");
+        assert!(err.contains("missing required param 'teamId'"));
+    }
+
+    #[tokio::test]
+    async fn team_list_invites_rejects_unknown_param() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.team_list_invites",
+            json!({ "teamId": "t1", "extra": true }),
+        )
+        .await
+        .expect_err("unknown param should fail");
+        assert!(err.contains("unknown param 'extra'"));
+    }
+
+    #[tokio::test]
+    async fn team_revoke_invite_missing_team_id_fails_validation() {
+        let err = invoke_method(default_state(), "openhuman.team_revoke_invite", json!({}))
+            .await
+            .expect_err("missing teamId should fail");
+        assert!(err.contains("missing required param 'teamId'"));
+    }
+
+    #[tokio::test]
+    async fn team_revoke_invite_missing_invite_id_fails_validation() {
+        let err = invoke_method(
+            default_state(),
+            "openhuman.team_revoke_invite",
+            json!({ "teamId": "t1" }),
+        )
+        .await
+        .expect_err("missing inviteId should fail");
+        assert!(err.contains("missing required param 'inviteId'"));
+    }
+
+    #[tokio::test]
+    async fn schema_dump_includes_new_billing_and_team_methods() {
+        let dump = build_http_schema_dump();
+        let methods: Vec<&str> = dump.methods.iter().map(|m| m.method.as_str()).collect();
+        for expected in &[
+            "openhuman.billing_get_current_plan",
+            "openhuman.billing_purchase_plan",
+            "openhuman.billing_create_portal_session",
+            "openhuman.billing_top_up",
+            "openhuman.billing_create_coinbase_charge",
+            "openhuman.team_list_members",
+            "openhuman.team_create_invite",
+            "openhuman.team_list_invites",
+            "openhuman.team_revoke_invite",
+            "openhuman.team_remove_member",
+            "openhuman.team_change_member_role",
+        ] {
+            assert!(
+                methods.contains(expected),
+                "schema dump missing expected method: {expected}"
+            );
+        }
     }
 }

src/openhuman/billing/mod.rs

@@ -0,0 +1,12 @@
+//! Billing and payment RPC adapters that thin-wrap the hosted API.
+//!
+//! Exposes plan lookup, purchase flows, and credit top-ups through the
+//! standard controller registry (`openhuman.billing_*`).
+
+mod ops;
+mod schemas;
+
+pub use ops::*;
+pub use schemas::{
+    all_billing_controller_schemas, all_billing_registered_controllers, billing_schemas,
+};