feat: mothership working e2e

Author: elibosley

.claude/settings.local.json

@@ -17,7 +17,9 @@
       "Bash(pnpm --filter \"*connect*\" test connect-status-writer.service.spec)",
       "Bash(npx tsc:*)",
       "Bash(npx eslint:*)",
-      "Bash(rm:*)"
+      "Bash(rm:*)",
+      "Bash(pnpm --filter ./packages/unraid-api-plugin-connect build)",
+      "Bash(pnpm tsc:*)"
     ]
   },
   "enableAllProjectMcpServers": false

api/dev/configs/connect.json

@@ -2,7 +2,7 @@
   "wanaccess": true,
   "wanport": 8443,
   "upnpEnabled": false,
-  "apikey": "test-key-123",
+  "apikey": "test-api-key-12345",
   "localApiKey": "_______________________LOCAL_API_KEY_HERE_________________________",
   "email": "[email protected]",
   "username": "zspearmint",

api/dev/keys/7789353b-40f4-4f3b-a230-b1f22909abff.json

@@ -0,0 +1,11 @@
+{
+  "createdAt": "2025-07-19T22:29:38.790Z",
+  "description": "Internal API Key Used By Unraid Connect to access your server resources for the connect.myunraid.net dashboard",
+  "id": "7789353b-40f4-4f3b-a230-b1f22909abff",
+  "key": "e6e0212193fa1cb468194dd5a4e41196305bc3b5e38532c2f86935bbde317bd0",
+  "name": "ConnectInternal",
+  "permissions": [],
+  "roles": [
+    "CONNECT"
+  ]
+}

api/dev/keys/b5b4aa3d-8e40-4c92-bc40-d50182071886.json

@@ -0,0 +1,156 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { gql } from '@apollo/client/core/index.js';
+import { parse, print, visit } from 'graphql';
+
+import { InternalClientService } from '../internal-rpc/internal.client.js';
+
+interface GraphQLExecutor {
+  execute(params: {
+    query: string
+    variables?: Record<string, any>
+    operationName?: string
+    operationType?: 'query' | 'mutation' | 'subscription'
+  }): Promise<any>
+  stopSubscription?(operationId: string): Promise<void>
+}
+
+/**
+ * Local GraphQL executor that maps remote queries to local API calls
+ */
+@Injectable()
+export class LocalGraphQLExecutor implements GraphQLExecutor {
+  private logger = new Logger('LocalGraphQLExecutor');
+
+  constructor(private readonly internalClient: InternalClientService) {}
+
+  async execute(params: {
+    query: string
+    variables?: Record<string, any>
+    operationName?: string
+    operationType?: 'query' | 'mutation' | 'subscription'
+  }): Promise<any> {
+    const { query, variables, operationName, operationType } = params;
+
+    try {
+      this.logger.debug(`Executing ${operationType} operation: ${operationName || 'unnamed'}`);
+      this.logger.verbose(`Query: ${query}`);
+      this.logger.verbose(`Variables: ${JSON.stringify(variables)}`);
+
+      // Transform remote query to local query by removing "remote" prefixes
+      const localQuery = this.transformRemoteQueryToLocal(query);
+
+      // Execute the transformed query against local API
+      const client = await this.internalClient.getClient();
+      const result = await client.query({
+        query: gql`${localQuery}`,
+        variables,
+      });
+
+      return {
+        data: result.data,
+      };
+    } catch (error: any) {
+      this.logger.error(`GraphQL execution error: ${error?.message}`);
+      return {
+        errors: [
+          {
+            message: error?.message || 'Unknown error',
+            extensions: { code: 'EXECUTION_ERROR' },
+          },
+        ],
+      };
+    }
+  }
+
+  /**
+   * Transform remote GraphQL query to local query by removing "remote" prefixes
+   */
+  private transformRemoteQueryToLocal(query: string): string {
+    try {
+      // Parse the GraphQL query
+      const document = parse(query);
+
+      // Transform the document by removing "remote" prefixes
+      const transformedDocument = visit(document, {
+        // Transform operation names (e.g., remoteGetDockerInfo -> getDockerInfo)
+        OperationDefinition: (node) => {
+          if (node.name?.value.startsWith('remote')) {
+            return {
+              ...node,
+              name: {
+                ...node.name,
+                value: this.removeRemotePrefix(node.name.value),
+              },
+            };
+          }
+          return node;
+        },
+        // Transform field names (e.g., remoteGetDockerInfo -> docker, remoteGetVms -> vms)
+        Field: (node) => {
+          if (node.name.value.startsWith('remote')) {
+            return {
+              ...node,
+              name: {
+                ...node.name,
+                value: this.transformRemoteFieldName(node.name.value),
+              },
+            };
+          }
+          return node;
+        },
+      });
+
+      // Convert back to string
+      return print(transformedDocument);
+    } catch (error) {
+      this.logger.error(`Failed to parse/transform GraphQL query: ${error}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Remove "remote" prefix from operation names
+   */
+  private removeRemotePrefix(name: string): string {
+    if (name.startsWith('remote')) {
+      // remoteGetDockerInfo -> getDockerInfo
+      return name.slice(6); // Remove "remote"
+    }
+    return name;
+  }
+
+  /**
+   * Transform remote field names to local equivalents
+   */
+  private transformRemoteFieldName(fieldName: string): string {
+    // Handle common patterns
+    if (fieldName === 'remoteGetDockerInfo') {
+      return 'docker';
+    }
+    if (fieldName === 'remoteGetVms') {
+      return 'vms';
+    }
+    if (fieldName === 'remoteGetSystemInfo') {
+      return 'system';
+    }
+    
+    // Generic transformation: remove "remoteGet" and convert to camelCase
+    if (fieldName.startsWith('remoteGet')) {
+      const baseName = fieldName.slice(9); // Remove "remoteGet"
+      return baseName.charAt(0).toLowerCase() + baseName.slice(1);
+    }
+    
+    // Remove "remote" prefix as fallback
+    if (fieldName.startsWith('remote')) {
+      const baseName = fieldName.slice(6); // Remove "remote"
+      return baseName.charAt(0).toLowerCase() + baseName.slice(1);
+    }
+    
+    return fieldName;
+  }
+
+  async stopSubscription(operationId: string): Promise<void> {
+    this.logger.debug(`Stopping subscription: ${operationId}`);
+    // Subscription cleanup logic would go here
+  }
+}

api/dev/states/connectStatus.json

@@ -4,6 +4,13 @@ import { InternalClientService } from '../internal-rpc/internal.client.js';
 import { MothershipConnectionService } from './connection.service.js';
 import { UnraidServerClientService } from './unraid-server-client.service.js';
 
+interface SubscriptionInfo {
+    sha256: string;
+    createdAt: number;
+    lastPing: number;
+    operationId?: string;
+}
+
 @Injectable()
 export class MothershipSubscriptionHandler {
     constructor(
@@ -13,21 +20,85 @@ export class MothershipSubscriptionHandler {
     ) {}
 
     private readonly logger = new Logger(MothershipSubscriptionHandler.name);
+    private readonly activeSubscriptions = new Map<string, SubscriptionInfo>();
 
     removeSubscription(sha256: string) {
-        this.logger.debug(`Request to remove subscription ${sha256} (not implemented yet)`);
+        const subscription = this.activeSubscriptions.get(sha256);
+        if (subscription) {
+            this.logger.debug(`Removing subscription ${sha256}`);
+            this.activeSubscriptions.delete(sha256);
+            
+            // Stop the subscription via the UnraidServerClient if it has an operationId
+            const client = this.mothershipClient.getClient();
+            if (client && subscription.operationId) {
+                // Note: We can't directly call stopSubscription on the client since it's private
+                // This would need to be exposed or handled differently in a real implementation
+                this.logger.debug(`Should stop subscription with operationId: ${subscription.operationId}`);
+            }
+        } else {
+            this.logger.debug(`Subscription ${sha256} not found`);
+        }
     }
 
     clearAllSubscriptions() {
-        this.logger.verbose('Request to clear all active subscriptions (not implemented yet)');
+        this.logger.verbose(`Clearing ${this.activeSubscriptions.size} active subscriptions`);
+        
+        // Stop all subscriptions via the UnraidServerClient
+        const client = this.mothershipClient.getClient();
+        if (client) {
+            for (const [sha256, subscription] of this.activeSubscriptions.entries()) {
+                if (subscription.operationId) {
+                    this.logger.debug(`Should stop subscription with operationId: ${subscription.operationId}`);
+                }
+            }
+        }
+        
+        this.activeSubscriptions.clear();
     }
 
     clearStaleSubscriptions({ maxAgeMs }: { maxAgeMs: number }) {
-        this.logger.verbose(`Request to clear stale subscriptions older than ${maxAgeMs}ms (not implemented yet)`);
+        const now = Date.now();
+        const staleSubscriptions: string[] = [];
+        
+        for (const [sha256, subscription] of this.activeSubscriptions.entries()) {
+            const age = now - subscription.lastPing;
+            if (age > maxAgeMs) {
+                staleSubscriptions.push(sha256);
+            }
+        }
+        
+        if (staleSubscriptions.length > 0) {
+            this.logger.verbose(`Clearing ${staleSubscriptions.length} stale subscriptions older than ${maxAgeMs}ms`);
+            
+            for (const sha256 of staleSubscriptions) {
+                this.removeSubscription(sha256);
+            }
+        } else {
+            this.logger.verbose(`No stale subscriptions found (${this.activeSubscriptions.size} active)`);
+        }
     }
 
     pingSubscription(sha256: string) {
-        this.logger.verbose(`Ping subscription ${sha256} (not implemented yet)`);
+        const subscription = this.activeSubscriptions.get(sha256);
+        if (subscription) {
+            subscription.lastPing = Date.now();
+            this.logger.verbose(`Updated ping for subscription ${sha256}`);
+        } else {
+            this.logger.verbose(`Ping for unknown subscription ${sha256}`);
+        }
+    }
+
+    addSubscription(sha256: string, operationId?: string) {
+        const now = Date.now();
+        const subscription: SubscriptionInfo = {
+            sha256,
+            createdAt: now,
+            lastPing: now,
+            operationId
+        };
+        
+        this.activeSubscriptions.set(sha256, subscription);
+        this.logger.debug(`Added subscription ${sha256} ${operationId ? `with operationId: ${operationId}` : ''}`);
     }
 
     stopMothershipSubscription() {

packages/unraid-api-plugin-connect/src/mothership-proxy/local-graphql-executor.service.ts

@@ -8,6 +8,7 @@ import { TimeoutCheckerJob } from '../connection-status/timeout-checker.job.js';
 import { InternalClientService } from '../internal-rpc/internal.client.js';
 import { RemoteAccessModule } from '../remote-access/remote-access.module.js';
 import { MothershipConnectionService } from './connection.service.js';
+import { LocalGraphQLExecutor } from './local-graphql-executor.service.js';
 import { MothershipSubscriptionHandler } from './mothership-subscription.handler.js';
 import { MothershipController } from './mothership.controller.js';
 import { MothershipHandler } from './mothership.events.js';
@@ -21,6 +22,7 @@ import { UnraidServerClientService } from './unraid-server-client.service.js';
         MothershipConnectionService,
         UnraidServerClientService,
         InternalClientService,
+        LocalGraphQLExecutor,
         MothershipHandler,
         MothershipSubscriptionHandler,
         TimeoutCheckerJob,