feat(gateway): implement automatic device registration during login

Lasim · Lasim · commit a647196ebad9 · 2025-08-20T22:45:42.000+02:00
diff --git a/services/gateway/src/commands/login.ts b/services/gateway/src/commands/login.ts
@@ -7,6 +7,7 @@ import { DeployStackAPI } from '../core/auth/api-client';
 import { MCPConfigService } from '../core/mcp';
 import { AuthenticationError } from '../types/auth';
 import { ServerStartService } from '../services/server-start-service';
+import { detectDeviceInfo } from '../utils/device-detection';
 
 export function registerLoginCommand(program: Command) {
   program
@@ -43,10 +44,33 @@ export function registerLoginCommand(program: Command) {
           timeout: 120000 // 2 minutes
         });
 
-        spinner = ora('Storing credentials securely...').start();
+        spinner = ora('Registering device...').start();
 
-        // Store credentials
-        await storage.storeCredentials(authResult.credentials);
+        // NEW: Automatic device registration
+        try {
+          const api = new DeployStackAPI(authResult.credentials, options.url);
+          const deviceInfo = await detectDeviceInfo();
+          const device = await api.registerOrUpdateDevice(deviceInfo);
+          
+          spinner.text = 'Storing credentials securely...';
+          
+          // Store credentials with device context
+          await storage.storeCredentials({
+            ...authResult.credentials,
+            deviceId: device.id
+          });
+
+          console.log(chalk.green(`📱 Device registered: ${device.device_name}`));
+        } catch (deviceError) {
+          // If device registration fails, continue without it
+          spinner.text = 'Storing credentials securely...';
+          await storage.storeCredentials(authResult.credentials);
+          
+          console.log(chalk.yellow('⚠️  Device registration failed - continuing without device context'));
+          if (deviceError instanceof Error) {
+            console.log(chalk.gray(`   Device Error: ${deviceError.message}`));
+          }
+        }
 
         // Set default team as selected team and download MCP config
         spinner.text = 'Setting up default team...';
diff --git a/services/gateway/src/core/auth/api-client.ts b/services/gateway/src/core/auth/api-client.ts
@@ -3,6 +3,7 @@ import fetch from 'node-fetch';
 import { StoredCredentials, UserInfo, TokenInfo, Team, AuthError, AuthenticationError } from '../../types/auth';
 import { MCPInstallationsResponse } from '../../types/mcp';
 import { buildAuthConfig } from '../../utils/auth-config';
+import { Device, DeviceInfo } from '../../utils/device-detection';
 
 export class DeployStackAPI {
   private credentials: StoredCredentials;
@@ -98,6 +99,162 @@ export class DeployStackAPI {
     return response;
   }
 
+  /**
+   * Get device by hardware ID
+   * @param hardwareId Hardware fingerprint
+   * @returns Device if found, null otherwise
+   */
+  async getDeviceByHardwareId(hardwareId: string): Promise<Device | null> {
+    try {
+      const endpoint = `${this.baseUrl}/api/users/me/devices`;
+      const response = await this.makeRequest(endpoint);
+      
+      if (response.success && response.devices) {
+        const device = response.devices.find((d: Device) => d.hardware_id === hardwareId);
+        return device || null;
+      }
+      
+      return null;
+    } catch {
+      // If we get a 404 or other error, assume no device found
+      return null;
+    }
+  }
+
+  /**
+   * Create a new device
+   * @param deviceInfo Device information
+   * @returns Created device
+   */
+  async createDevice(deviceInfo: DeviceInfo): Promise<Device> {
+    const endpoint = `${this.baseUrl}/api/users/me/devices`;
+    const deviceData = {
+      device_name: deviceInfo.hostname, // Default to hostname
+      hostname: deviceInfo.hostname,
+      hardware_id: deviceInfo.hardware_id,
+      os_type: deviceInfo.os_type,
+      os_version: deviceInfo.os_version,
+      arch: deviceInfo.arch,
+      node_version: deviceInfo.node_version,
+      user_agent: deviceInfo.user_agent,
+      last_login_at: new Date().toISOString(),
+      last_activity_at: new Date().toISOString()
+    };
+
+    const response = await this.makeRequest(endpoint, {
+      method: 'POST',
+      body: JSON.stringify(deviceData)
+    });
+
+    if (response.success && response.device) {
+      return response.device;
+    }
+
+    throw new AuthenticationError(
+      AuthError.NETWORK_ERROR,
+      'Failed to create device'
+    );
+  }
+
+  /**
+   * Update an existing device
+   * @param deviceId Device ID
+   * @param updates Device updates
+   * @returns Updated device
+   */
+  async updateDevice(deviceId: string, updates: { device_name?: string }): Promise<Device> {
+    const endpoint = `${this.baseUrl}/api/users/me/devices/${deviceId}`;
+    
+    // The backend only accepts device_name updates via PUT
+    const updateData = {
+      device_name: updates.device_name || 'Updated Device'
+    };
+
+    const response = await this.makeRequest(endpoint, {
+      method: 'PUT',
+      body: JSON.stringify(updateData)
+    });
+
+    if (response.success && response.device) {
+      return response.device;
+    }
+
+    throw new AuthenticationError(
+      AuthError.NETWORK_ERROR,
+      'Failed to update device'
+    );
+  }
+  /**
+   * Update device activity (internal method)
+   * This would be called during login to update last_login_at
+   * For now, we'll just update the device name to trigger an update
+   * @param deviceId Device ID
+   * @returns Updated device
+   */
+  async updateDeviceActivity(deviceId: string): Promise<Device> {
+    // Since the backend only supports device_name updates,
+    // we'll just update with the current name to trigger last update timestamp
+    const endpoint = `${this.baseUrl}/api/users/me/devices/${deviceId}`;
+    
+    // Get current device first to preserve the name
+    const currentDevice = await this.getDeviceById(deviceId);
+    
+    const updateData = {
+      device_name: currentDevice.device_name
+    };
+
+    const response = await this.makeRequest(endpoint, {
+      method: 'PUT',
+      body: JSON.stringify(updateData)
+    });
+
+    if (response.success && response.device) {
+      return response.device;
+    }
+
+    throw new AuthenticationError(
+      AuthError.NETWORK_ERROR,
+      'Failed to update device activity'
+    );
+  }
+
+  /**
+   * Get device by ID
+   * @param deviceId Device ID
+   * @returns Device
+   */
+  async getDeviceById(deviceId: string): Promise<Device> {
+    const endpoint = `${this.baseUrl}/api/users/me/devices/${deviceId}`;
+    const response = await this.makeRequest(endpoint);
+    
+    if (response.success && response.device) {
+      return response.device;
+    }
+
+    throw new AuthenticationError(
+      AuthError.NETWORK_ERROR,
+      'Device not found'
+    );
+  }
+
+  /**
+   * Register or update a device (convenience method)
+   * @param deviceInfo Device information
+   * @returns Device (created or updated)
+   */
+  async registerOrUpdateDevice(deviceInfo: DeviceInfo): Promise<Device> {
+    // First, try to find existing device by hardware ID
+    const existingDevice = await this.getDeviceByHardwareId(deviceInfo.hardware_id);
+    
+    if (existingDevice) {
+      // Update existing device activity (this will update the timestamp)
+      return await this.updateDeviceActivity(existingDevice.id);
+    } else {
+      // Create new device
+      return await this.createDevice(deviceInfo);
+    }
+  }
+
   /**
    * Make an authenticated API request
    * @param endpoint API endpoint URL
diff --git a/services/gateway/src/types/auth.ts b/services/gateway/src/types/auth.ts
@@ -13,6 +13,8 @@ export interface StoredCredentials {
     id: string;
     name: string;
   };
+  // Device information
+  deviceId?: string;
 }
 
 export interface UserInfo {
diff --git a/services/gateway/src/utils/device-detection.ts b/services/gateway/src/utils/device-detection.ts
@@ -0,0 +1,121 @@
+import os from 'os';
+import crypto from 'crypto';
+
+export interface DeviceInfo {
+  hostname: string;
+  os_type: string;
+  os_version: string;
+  arch: string;
+  node_version: string;
+  hardware_id: string;
+  user_agent: string;
+}
+
+export interface Device {
+  id: string;
+  user_id: string;
+  device_name: string;
+  hostname: string | null;
+  hardware_id: string | null;
+  os_type: string | null;
+  os_version: string | null;
+  arch: string | null;
+  node_version: string | null;
+  last_ip: string | null;
+  user_agent: string | null;
+  is_active: boolean;
+  is_trusted: boolean;
+  last_login_at: string | null;
+  last_activity_at: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+/**
+ * Get platform name in a user-friendly format
+ */
+function getPlatformName(platform: string): string {
+  switch (platform) {
+    case 'darwin':
+      return 'macOS';
+    case 'win32':
+      return 'Windows';
+    case 'linux':
+      return 'Linux';
+    default:
+      return platform;
+  }
+}
+
+/**
+ * Generate a stable hardware fingerprint for device identification
+ */
+export async function generateHardwareFingerprint(): Promise<string> {
+  try {
+    // Get network interfaces for MAC addresses
+    const networkInterfaces = os.networkInterfaces();
+    const macAddresses = Object.values(networkInterfaces)
+      .flat()
+      .filter(iface => !iface?.internal && iface?.mac !== '00:00:00:00:00:00')
+      .map(iface => iface?.mac)
+      .filter(Boolean)
+      .sort();
+
+    // Get CPU information
+    const cpus = os.cpus();
+    const cpuModel = cpus.length > 0 ? cpus[0].model : 'unknown';
+
+    // Create fingerprint data
+    const fingerprintData = {
+      macs: macAddresses,
+      hostname: os.hostname(),
+      platform: os.platform(),
+      arch: os.arch(),
+      cpuModel: cpuModel,
+      // Add some entropy from system info
+      totalmem: os.totalmem(),
+      homedir: os.homedir()
+    };
+
+    // Generate SHA256 hash
+    const fingerprint = crypto
+      .createHash('sha256')
+      .update(JSON.stringify(fingerprintData))
+      .digest('hex');
+
+    // Return first 32 characters for consistency
+    return fingerprint.substring(0, 32);
+  } catch {
+    // Fallback fingerprint if hardware detection fails
+    const fallbackData = {
+      hostname: os.hostname(),
+      platform: os.platform(),
+      arch: os.arch(),
+      timestamp: Date.now()
+    };
+
+    const fallbackFingerprint = crypto
+      .createHash('sha256')
+      .update(JSON.stringify(fallbackData))
+      .digest('hex');
+
+    return fallbackFingerprint.substring(0, 32);
+  }
+}
+
+/**
+ * Detect current device information
+ */
+export async function detectDeviceInfo(): Promise<DeviceInfo> {
+  const packageVersion = process.env.npm_package_version || '1.0.0';
+  
+  return {
+    hostname: os.hostname(),
+    os_type: getPlatformName(os.platform()),
+    os_version: os.release(),
+    arch: os.arch(),
+    node_version: process.version,
+    hardware_id: await generateHardwareFingerprint(),
+    user_agent: `DeployStack-CLI/${packageVersion} (${os.platform()}; ${os.arch()})`
+  };
+}

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,8 @@ export interface StoredCredentials {`
`13`	`13`	`id: string;`
`14`	`14`	`name: string;`
`15`	`15`	`};`
	`16`	`+ // Device information`
	`17`	`+ deviceId?: string;`
`16`	`18`	`}`
`17`	`19`
`18`	`20`	`export interface UserInfo {`