n8n-nodes-dominusnode 1.0.1 → 1.2.0

package/src/nodes/DominusNodeTeams/DominusNodeTeams.node.ts

@@ -0,0 +1,351 @@
+/**
+ * Dominus Node Teams n8n community node.
+ *
+ * Operations (9 tools):
+ * - Delete Team: Delete a team
+ * - Revoke Team Key: Revoke a team API key
+ * - List Team Keys: List all API keys for a team
+ * - List Team Members: List all members of a team
+ * - Add Team Member: Add a user to a team
+ * - Remove Team Member: Remove a user from a team
+ * - Invite Team Member: Send an email invitation to join a team
+ * - List Team Invites: List pending invitations for a team
+ * - Cancel Team Invite: Cancel a pending team invitation
+ *
+ * Security:
+ * - UUID validation for team/user/key/invite IDs
+ * - Email validation for invitations
+ * - Control character rejection
+ * - Credential sanitization in error messages
+ *
+ * @module
+ */
+
+import {
+  IDataObject,
+  IExecuteFunctions,
+  INodeExecutionData,
+  INodeType,
+  INodeTypeDescription,
+  NodeOperationError,
+} from "n8n-workflow";
+
+import { DominusNodeAuth, sanitizeError } from "../../shared/auth";
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+export class DominusNodeTeams implements INodeType {
+  description: INodeTypeDescription = {
+    displayName: "Dominus Node Teams",
+    name: "dominusNodeTeams",
+    icon: "file:dominusnode.svg",
+    group: ["transform"],
+    version: 1,
+    subtitle: '={{$parameter["operation"]}}',
+    description: "Manage Dominus Node team members, keys, and invitations",
+    defaults: { name: "Dominus Node Teams" },
+    inputs: ["main"],
+    outputs: ["main"],
+    credentials: [{ name: "dominusNodeApi", required: true }],
+    properties: [
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        options: [
+          { name: "Delete Team", value: "teamDelete", description: "Delete a team", action: "Delete team" },
+          { name: "Revoke Team Key", value: "teamRevokeKey", description: "Revoke a team API key", action: "Revoke team key" },
+          { name: "List Team Keys", value: "teamListKeys", description: "List all API keys for a team", action: "List team keys" },
+          { name: "List Team Members", value: "teamListMembers", description: "List all members of a team", action: "List team members" },
+          { name: "Add Team Member", value: "teamAddMember", description: "Add a user to a team", action: "Add team member" },
+          { name: "Remove Team Member", value: "teamRemoveMember", description: "Remove a user from a team", action: "Remove team member" },
+          { name: "Invite Team Member", value: "teamInviteMember", description: "Send an email invitation to join a team", action: "Invite team member" },
+          { name: "List Team Invites", value: "teamListInvites", description: "List pending invitations for a team", action: "List team invites" },
+          { name: "Cancel Team Invite", value: "teamCancelInvite", description: "Cancel a pending team invitation", action: "Cancel team invite" },
+        ],
+        default: "teamListMembers",
+      },
+
+      // --- Team ID (shared) ---
+      {
+        displayName: "Team ID",
+        name: "teamId",
+        type: "string",
+        default: "",
+        required: true,
+        description: "Team UUID",
+        displayOptions: {
+          show: {
+            operation: [
+              "teamDelete",
+              "teamRevokeKey",
+              "teamListKeys",
+              "teamListMembers",
+              "teamAddMember",
+              "teamRemoveMember",
+              "teamInviteMember",
+              "teamListInvites",
+              "teamCancelInvite",
+            ],
+          },
+        },
+      },
+
+      // --- Key ID for revoke ---
+      {
+        displayName: "Key ID",
+        name: "keyId",
+        type: "string",
+        default: "",
+        required: true,
+        description: "UUID of the team API key to revoke",
+        displayOptions: { show: { operation: ["teamRevokeKey"] } },
+      },
+
+      // --- User ID for add/remove member ---
+      {
+        displayName: "User ID",
+        name: "userId",
+        type: "string",
+        default: "",
+        required: true,
+        description: "UUID of the user to add or remove",
+        displayOptions: { show: { operation: ["teamAddMember", "teamRemoveMember"] } },
+      },
+
+      // --- Role for add member / invite ---
+      {
+        displayName: "Role",
+        name: "role",
+        type: "options",
+        options: [
+          { name: "Admin", value: "admin" },
+          { name: "Member", value: "member" },
+        ],
+        default: "member",
+        description: "Role for the team member",
+        displayOptions: { show: { operation: ["teamAddMember", "teamInviteMember"] } },
+      },
+
+      // --- Invite email ---
+      {
+        displayName: "Email",
+        name: "inviteEmail",
+        type: "string",
+        default: "",
+        required: true,
+        description: "Email address to send the invitation to",
+        displayOptions: { show: { operation: ["teamInviteMember"] } },
+      },
+
+      // --- Invite ID for cancel ---
+      {
+        displayName: "Invite ID",
+        name: "inviteId",
+        type: "string",
+        default: "",
+        required: true,
+        description: "UUID of the invitation to cancel",
+        displayOptions: { show: { operation: ["teamCancelInvite"] } },
+      },
+    ],
+  };
+
+  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+    const items = this.getInputData();
+    const returnData: INodeExecutionData[] = [];
+    const credentials = await this.getCredentials("dominusNodeApi");
+
+    const apiKey = credentials.apiKey as string;
+    const baseUrl = (credentials.baseUrl as string) || "https://api.dominusnode.com";
+
+    if (!apiKey) {
+      throw new NodeOperationError(this.getNode(), "API Key is required");
+    }
+
+    const agentSecret = (credentials.agentSecret as string) || undefined;
+    const auth = new DominusNodeAuth(apiKey, baseUrl, 30000, agentSecret);
+    const operation = this.getNodeParameter("operation", 0) as string;
+
+    for (let i = 0; i < items.length; i++) {
+      try {
+        let result: unknown;
+
+        // All operations require teamId
+        const teamId = this.getNodeParameter("teamId", i) as string;
+        validateUuid(this, teamId, "teamId", i);
+
+        switch (operation) {
+          case "teamDelete": {
+            result = await auth.apiRequest(
+              "DELETE",
+              `/api/teams/${encodeURIComponent(teamId)}`,
+            );
+            break;
+          }
+
+          case "teamRevokeKey": {
+            const keyId = this.getNodeParameter("keyId", i) as string;
+            validateUuid(this, keyId, "keyId", i);
+            result = await auth.apiRequest(
+              "DELETE",
+              `/api/teams/${encodeURIComponent(teamId)}/keys/${encodeURIComponent(keyId)}`,
+            );
+            break;
+          }
+
+          case "teamListKeys": {
+            result = await auth.apiRequest(
+              "GET",
+              `/api/teams/${encodeURIComponent(teamId)}/keys`,
+            );
+            break;
+          }
+
+          case "teamListMembers": {
+            result = await auth.apiRequest(
+              "GET",
+              `/api/teams/${encodeURIComponent(teamId)}/members`,
+            );
+            break;
+          }
+
+          case "teamAddMember": {
+            const userId = this.getNodeParameter("userId", i) as string;
+            const role = this.getNodeParameter("role", i, "member") as string;
+            validateUuid(this, userId, "userId", i);
+            if (role !== "member" && role !== "admin") {
+              throw new NodeOperationError(
+                this.getNode(),
+                "Role must be 'member' or 'admin'",
+                { itemIndex: i },
+              );
+            }
+            result = await auth.apiRequest(
+              "POST",
+              `/api/teams/${encodeURIComponent(teamId)}/members`,
+              { userId, role },
+            );
+            break;
+          }
+
+          case "teamRemoveMember": {
+            const userId = this.getNodeParameter("userId", i) as string;
+            validateUuid(this, userId, "userId", i);
+            result = await auth.apiRequest(
+              "DELETE",
+              `/api/teams/${encodeURIComponent(teamId)}/members/${encodeURIComponent(userId)}`,
+            );
+            break;
+          }
+
+          case "teamInviteMember": {
+            const email = this.getNodeParameter("inviteEmail", i) as string;
+            const role = this.getNodeParameter("role", i, "member") as string;
+            const safeEmail = validateEmail(this, email, i);
+            if (role !== "member" && role !== "admin") {
+              throw new NodeOperationError(
+                this.getNode(),
+                "Role must be 'member' or 'admin'",
+                { itemIndex: i },
+              );
+            }
+            result = await auth.apiRequest(
+              "POST",
+              `/api/teams/${encodeURIComponent(teamId)}/invites`,
+              { email: safeEmail, role },
+            );
+            break;
+          }
+
+          case "teamListInvites": {
+            result = await auth.apiRequest(
+              "GET",
+              `/api/teams/${encodeURIComponent(teamId)}/invites`,
+            );
+            break;
+          }
+
+          case "teamCancelInvite": {
+            const inviteId = this.getNodeParameter("inviteId", i) as string;
+            validateUuid(this, inviteId, "inviteId", i);
+            result = await auth.apiRequest(
+              "DELETE",
+              `/api/teams/${encodeURIComponent(teamId)}/invites/${encodeURIComponent(inviteId)}`,
+            );
+            break;
+          }
+
+          default:
+            throw new NodeOperationError(
+              this.getNode(),
+              `Unknown operation: ${operation}`,
+              { itemIndex: i },
+            );
+        }
+
+        returnData.push({ json: (result ?? {}) as IDataObject });
+      } catch (err) {
+        if (this.continueOnFail()) {
+          returnData.push({
+            json: {
+              error: sanitizeError(err instanceof Error ? err.message : String(err)),
+            },
+          });
+          continue;
+        }
+        if (err instanceof NodeOperationError) throw err;
+        throw new NodeOperationError(
+          this.getNode(),
+          sanitizeError(err instanceof Error ? err.message : String(err)),
+          { itemIndex: i },
+        );
+      }
+    }
+
+    return [returnData];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Validation helpers
+// ---------------------------------------------------------------------------
+
+function validateUuid(
+  ctx: IExecuteFunctions,
+  value: string,
+  fieldName: string,
+  itemIndex: number,
+): void {
+  if (!value || typeof value !== "string") {
+    throw new NodeOperationError(ctx.getNode(), `${fieldName} is required`, { itemIndex });
+  }
+  if (!UUID_RE.test(value)) {
+    throw new NodeOperationError(ctx.getNode(), `${fieldName} must be a valid UUID`, { itemIndex });
+  }
+}
+
+function validateEmail(
+  ctx: IExecuteFunctions,
+  email: string,
+  itemIndex: number,
+): string {
+  const trimmed = (email ?? "").trim();
+  if (!trimmed || !EMAIL_RE.test(trimmed)) {
+    throw new NodeOperationError(
+      ctx.getNode(),
+      "A valid email address is required",
+      { itemIndex },
+    );
+  }
+  if (trimmed.length > 254) {
+    throw new NodeOperationError(
+      ctx.getNode(),
+      "Email address too long (max 254 characters)",
+      { itemIndex },
+    );
+  }
+  return trimmed;
+}

package/src/nodes/DominusNodeUsage/DominusNodeUsage.node.ts

@@ -1,8 +1,10 @@
 /**
  * Dominus Node Usage n8n community node.
  *
- * Operations:
+ * Operations (3 tools):
  * - Check Usage: Get proxy usage statistics for a given period
+ * - Get Daily Usage: Get daily usage breakdown for the last N days
+ * - Get Top Hosts: Get top accessed hosts by bandwidth
  *
  * @module
  */
@@ -46,6 +48,18 @@ export class DominusNodeUsage implements INodeType {
             description: "Get proxy usage statistics for a given period",
             action: "Check usage",
           },
+          {
+            name: "Get Daily Usage",
+            value: "getDailyUsage",
+            description: "Get daily usage breakdown for the last N days",
+            action: "Get daily usage",
+          },
+          {
+            name: "Get Top Hosts",
+            value: "getTopHosts",
+            description: "Get top accessed hosts by bandwidth",
+            action: "Get top hosts",
+          },
         ],
         default: "checkUsage",
       },
@@ -62,6 +76,22 @@ export class DominusNodeUsage implements INodeType {
         description: "Time period for usage statistics",
         displayOptions: { show: { operation: ["checkUsage"] } },
       },
+      {
+        displayName: "Days",
+        name: "days",
+        type: "number",
+        default: 7,
+        description: "Number of days of daily usage to return (1-365)",
+        displayOptions: { show: { operation: ["getDailyUsage"] } },
+      },
+      {
+        displayName: "Limit",
+        name: "topHostsLimit",
+        type: "number",
+        default: 10,
+        description: "Number of top hosts to return (1-100)",
+        displayOptions: { show: { operation: ["getTopHosts"] } },
+      },
     ],
   };
 
@@ -77,7 +107,8 @@ export class DominusNodeUsage implements INodeType {
       throw new NodeOperationError(this.getNode(), "API Key is required");
     }
 
-    const auth = new DominusNodeAuth(apiKey, baseUrl);
+    const agentSecret = (credentials.agentSecret as string) || undefined;
+    const auth = new DominusNodeAuth(apiKey, baseUrl, 30000, agentSecret);
 
     for (let i = 0; i < items.length; i++) {
       try {
@@ -99,6 +130,28 @@ export class DominusNodeUsage implements INodeType {
           const params = new URLSearchParams({ since, until });
           const result = await auth.apiRequest("GET", `/api/usage?${params.toString()}`);
 
+          returnData.push({ json: (result ?? {}) as IDataObject });
+        } else if (operation === "getDailyUsage") {
+          const days = this.getNodeParameter("days", i, 7) as number;
+          if (!Number.isInteger(days) || days < 1 || days > 365) {
+            throw new NodeOperationError(
+              this.getNode(),
+              "Days must be an integer between 1 and 365",
+              { itemIndex: i },
+            );
+          }
+          const result = await auth.apiRequest("GET", `/api/usage/daily?days=${days}`);
+          returnData.push({ json: (result ?? {}) as IDataObject });
+        } else if (operation === "getTopHosts") {
+          const limit = this.getNodeParameter("topHostsLimit", i, 10) as number;
+          if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+            throw new NodeOperationError(
+              this.getNode(),
+              "Limit must be an integer between 1 and 100",
+              { itemIndex: i },
+            );
+          }
+          const result = await auth.apiRequest("GET", `/api/usage/top-hosts?limit=${limit}`);
           returnData.push({ json: (result ?? {}) as IDataObject });
         } else {
           throw new NodeOperationError(

package/src/nodes/DominusNodeWallet/DominusNodeWallet.node.ts

@@ -1,11 +1,14 @@
 /**
  * Dominus Node Wallet n8n community node.
  *
- * Operations:
+ * Operations (25 tools):
  * - Check Balance: Get current wallet balance
  * - Top Up (Stripe): Create a Stripe checkout session
  * - Top Up (Crypto): Create a crypto payment invoice
  * - Top Up (PayPal): Create a PayPal checkout session via Stripe
+ * - Get Transactions: Get wallet transaction history
+ * - Get Forecast: Get wallet spend forecast
+ * - Check Payment: Check crypto payment invoice status
  * - Create Agentic Wallet: Create a sub-wallet with spending limits
  * - Fund Agentic Wallet: Transfer funds to an agentic wallet
  * - Get Agentic Wallet Balance: Check an agentic wallet's balance
@@ -23,6 +26,7 @@
  * - Team Usage: Get team wallet transaction history
  * - Update Team: Update team name/max members
  * - Update Team Member Role: Update a team member's role
+ * - x402 Info: Get x402 micropayment protocol information
  *
  * @module
  */
@@ -70,6 +74,9 @@ export class DominusNodeWallet implements INodeType {
           { name: "Top Up (Stripe)", value: "topUpStripe", description: "Create a Stripe checkout session", action: "Top up stripe" },
           { name: "Top Up (Crypto)", value: "topUpCrypto", description: "Create a crypto payment invoice", action: "Top up crypto" },
           { name: "Top Up (PayPal)", value: "topUpPaypal", description: "Create a PayPal checkout session", action: "Top up paypal" },
+          { name: "Get Transactions", value: "getTransactions", description: "Get wallet transaction history", action: "Get transactions" },
+          { name: "Get Forecast", value: "getForecast", description: "Get wallet spend forecast", action: "Get forecast" },
+          { name: "Check Payment", value: "checkPayment", description: "Check crypto payment invoice status", action: "Check payment" },
           // Agentic Wallets
           { name: "Create Agentic Wallet", value: "createAgenticWallet", description: "Create a sub-wallet with spending limits", action: "Create agentic wallet" },
           { name: "Fund Agentic Wallet", value: "fundAgenticWallet", description: "Transfer funds to an agentic wallet", action: "Fund agentic wallet" },
@@ -137,6 +144,25 @@ export class DominusNodeWallet implements INodeType {
         displayOptions: { show: { operation: ["topUpCrypto"] } },
       },
 
+      // --- Transaction / payment params ---
+      {
+        displayName: "Limit",
+        name: "walletTransactionLimit",
+        type: "number",
+        default: 20,
+        description: "Number of transactions to return (1-100)",
+        displayOptions: { show: { operation: ["getTransactions"] } },
+      },
+      {
+        displayName: "Invoice ID",
+        name: "invoiceId",
+        type: "string",
+        default: "",
+        required: true,
+        description: "Crypto payment invoice UUID to check status",
+        displayOptions: { show: { operation: ["checkPayment"] } },
+      },
+
       // --- Agentic wallet params ---
       {
         displayName: "Label",
@@ -343,7 +369,8 @@ export class DominusNodeWallet implements INodeType {
       throw new NodeOperationError(this.getNode(), "API Key is required");
     }
 
-    const auth = new DominusNodeAuth(apiKey, baseUrl);
+    const agentSecret = (credentials.agentSecret as string) || undefined;
+    const auth = new DominusNodeAuth(apiKey, baseUrl, 30000, agentSecret);
     const operation = this.getNodeParameter("operation", 0) as string;
 
     for (let i = 0; i < items.length; i++) {
@@ -410,6 +437,31 @@ export class DominusNodeWallet implements INodeType {
             break;
           }
 
+          case "getTransactions": {
+            const limit = this.getNodeParameter("walletTransactionLimit", i, 20) as number;
+            validateLimit(this, limit, i);
+
+            const params = new URLSearchParams();
+            params.set("limit", String(limit));
+            result = await auth.apiRequest("GET", `/api/wallet/transactions?${params.toString()}`);
+            break;
+          }
+
+          case "getForecast": {
+            result = await auth.apiRequest("GET", "/api/wallet/forecast");
+            break;
+          }
+
+          case "checkPayment": {
+            const invoiceId = this.getNodeParameter("invoiceId", i) as string;
+            validateUuid(this, invoiceId, "invoiceId", i);
+            result = await auth.apiRequest(
+              "GET",
+              `/api/wallet/topup/crypto/${encodeURIComponent(invoiceId)}/status`,
+            );
+            break;
+          }
+
           // ----- Agentic Wallets -----
           case "createAgenticWallet": {
             const label = this.getNodeParameter("agenticLabel", i) as string;

package/src/shared/auth.ts

@@ -156,14 +156,18 @@ export class DominusNodeAuth {
   private token: string | null = null;
   private authPromise: Promise<void> | null = null;
 
+  private agentSecret?: string;
+
   constructor(
     private apiKey: string,
     private baseUrl: string,
     private timeoutMs: number = 30000,
+    agentSecret?: string,
   ) {
     if (!apiKey || typeof apiKey !== "string") {
       throw new Error("apiKey is required and must be a non-empty string");
     }
+    this.agentSecret = agentSecret || process.env.DOMINUSNODE_AGENT_SECRET;
   }
 
   /**
@@ -202,6 +206,11 @@ export class DominusNodeAuth {
       Authorization: `Bearer ${this.token}`,
     };
 
+    if (this.agentSecret) {
+      headers["X-DominusNode-Agent"] = "mcp";
+      headers["X-DominusNode-Agent-Secret"] = this.agentSecret;
+    }
+
     const response = await fetch(url, {
       method,
       headers,
@@ -247,12 +256,18 @@ export class DominusNodeAuth {
   }
 
   private async authenticate(): Promise<void> {
+    const authHeaders: Record<string, string> = {
+      "User-Agent": "n8n-nodes-dominusnode/1.0.0",
+      "Content-Type": "application/json",
+    };
+    if (this.agentSecret) {
+      authHeaders["X-DominusNode-Agent"] = "mcp";
+      authHeaders["X-DominusNode-Agent-Secret"] = this.agentSecret;
+    }
+
     const response = await fetch(`${this.baseUrl}/api/auth/verify-key`, {
       method: "POST",
-      headers: {
-        "User-Agent": "n8n-nodes-dominusnode/1.0.0",
-        "Content-Type": "application/json",
-      },
+      headers: authHeaders,
       body: JSON.stringify({ apiKey: this.apiKey }),
       signal: AbortSignal.timeout(this.timeoutMs),
       redirect: "error",

package/tests/DominusNodeProxy.test.ts

@@ -76,10 +76,10 @@ describe("DominusNodeProxy", () => {
     ]);
   });
 
-  it("has three operations", () => {
+  it("has four operations", () => {
     const opProp = node.description.properties.find((p) => p.name === "operation");
     expect(opProp).toBeDefined();
-    expect((opProp as any).options).toHaveLength(3);
+    expect((opProp as any).options).toHaveLength(4);
   });
 });
 

package/tests/DominusNodeUsage.test.ts

@@ -95,11 +95,11 @@ describe("DominusNodeUsage - metadata", () => {
     ]);
   });
 
-  it("has one operation", () => {
+  it("has three operations", () => {
     const node = new DominusNodeUsage();
     const opProp = node.description.properties.find((p) => p.name === "operation");
     expect(opProp).toBeDefined();
-    expect((opProp as any).options).toHaveLength(1);
+    expect((opProp as any).options).toHaveLength(3);
   });
 
   it("has period options: day, week, month", () => {

package/tests/DominusNodeWallet.test.ts

@@ -93,11 +93,11 @@ describe("DominusNodeWallet - metadata", () => {
     ]);
   });
 
-  it("has 22 operations", () => {
+  it("has 25 operations", () => {
     const node = new DominusNodeWallet();
     const opProp = node.description.properties.find((p) => p.name === "operation");
     expect(opProp).toBeDefined();
-    expect((opProp as any).options).toHaveLength(22);
+    expect((opProp as any).options).toHaveLength(25);
   });
 });