@build-astron-co/nimbus 0.2.0

package/src/clients/core-engine-client.ts

@@ -0,0 +1,227 @@
+/**
+ * Core Engine Client
+ *
+ * Client for interacting with the Core Engine Service
+ */
+
+import type { DriftReport, DriftRemediationResult, DriftProvider } from '../types';
+
+export interface DriftDetectParams {
+  provider: DriftProvider;
+  directory: string;
+  namespace?: string;
+  release?: string;
+}
+
+export interface DriftFixParams {
+  provider: DriftProvider;
+  directory: string;
+  dryRun?: boolean;
+  namespace?: string;
+  release?: string;
+}
+
+export interface RollbackParams {
+  taskId: string;
+  force?: boolean;
+}
+
+export interface RollbackResult {
+  success: boolean;
+  message: string;
+  details?: string;
+}
+
+export interface ResumeResult {
+  success: boolean;
+  data?: any;
+  error?: string;
+}
+
+export class CoreEngineClient {
+  private baseUrl: string;
+
+  constructor(baseUrl?: string) {
+    this.baseUrl = baseUrl || process.env.CORE_ENGINE_URL || 'http://localhost:3010';
+  }
+
+  /**
+   * Detect drift in infrastructure
+   */
+  async detectDrift(params: DriftDetectParams): Promise<DriftReport> {
+    const response = await fetch(`${this.baseUrl}/api/drift/detect`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(params),
+    });
+
+    if (!response.ok) {
+      const error = (await response.json().catch(() => ({ message: 'Unknown error' }))) as {
+        message?: string;
+      };
+      throw new Error(error.message || `Failed to detect drift: ${response.status}`);
+    }
+
+    const data = (await response.json()) as { report: DriftReport };
+    return data.report;
+  }
+
+  /**
+   * Create a remediation plan for detected drift
+   */
+  async createRemediationPlan(params: DriftDetectParams): Promise<any> {
+    const response = await fetch(`${this.baseUrl}/api/drift/plan`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(params),
+    });
+
+    if (!response.ok) {
+      const error = (await response.json().catch(() => ({ message: 'Unknown error' }))) as {
+        message?: string;
+      };
+      throw new Error(error.message || `Failed to create remediation plan: ${response.status}`);
+    }
+
+    return response.json() as Promise<any>;
+  }
+
+  /**
+   * Fix detected drift
+   */
+  async fixDrift(params: DriftFixParams): Promise<DriftRemediationResult> {
+    const response = await fetch(`${this.baseUrl}/api/drift/fix`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(params),
+    });
+
+    if (!response.ok) {
+      const error = (await response.json().catch(() => ({ message: 'Unknown error' }))) as {
+        message?: string;
+      };
+      throw new Error(error.message || `Failed to fix drift: ${response.status}`);
+    }
+
+    const data = (await response.json()) as { result: DriftRemediationResult };
+    return data.result;
+  }
+
+  /**
+   * Check if a task can be rolled back
+   */
+  async canRollback(taskId: string): Promise<boolean> {
+    const response = await fetch(`${this.baseUrl}/api/tasks/${taskId}/rollback/check`, {
+      method: 'GET',
+    });
+
+    if (!response.ok) {
+      return false;
+    }
+
+    const data = (await response.json()) as { canRollback: boolean };
+    return data.canRollback;
+  }
+
+  /**
+   * Rollback a task
+   */
+  async rollback(params: RollbackParams): Promise<RollbackResult> {
+    const response = await fetch(`${this.baseUrl}/api/tasks/${params.taskId}/rollback`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ force: params.force }),
+    });
+
+    if (!response.ok) {
+      const error = (await response.json().catch(() => ({ message: 'Unknown error' }))) as {
+        message?: string;
+      };
+      throw new Error(error.message || `Failed to rollback: ${response.status}`);
+    }
+
+    return response.json() as Promise<RollbackResult>;
+  }
+
+  /**
+   * Resume a task from its last checkpoint
+   */
+  async resumeTask(taskId: string): Promise<ResumeResult> {
+    const response = await fetch(`${this.baseUrl}/api/tasks/${taskId}/resume`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      const error = (await response.json().catch(() => ({ message: 'Unknown error' }))) as {
+        error?: string;
+        message?: string;
+      };
+      return {
+        success: false,
+        error: error.error || error.message || `Failed to resume task: ${response.status}`,
+      };
+    }
+
+    const data = (await response.json()) as { success: boolean; data?: any; error?: string };
+    return {
+      success: data.success,
+      data: data.data,
+      error: data.error,
+    };
+  }
+
+  /**
+   * Get compliance report
+   */
+  async getComplianceReport(params: DriftDetectParams): Promise<any> {
+    const response = await fetch(`${this.baseUrl}/api/drift/compliance`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(params),
+    });
+
+    if (!response.ok) {
+      const error = (await response.json().catch(() => ({ message: 'Unknown error' }))) as {
+        message?: string;
+      };
+      throw new Error(error.message || `Failed to get compliance report: ${response.status}`);
+    }
+
+    return response.json() as Promise<any>;
+  }
+
+  /**
+   * Check if the Core Engine service is available
+   */
+  async isAvailable(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.baseUrl}/health`, {
+        method: 'GET',
+        signal: AbortSignal.timeout(5000),
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Health check (alias for isAvailable)
+   */
+  async healthCheck(): Promise<boolean> {
+    return this.isAvailable();
+  }
+}

package/src/clients/enterprise-client.ts

@@ -0,0 +1,334 @@
+/**
+ * Enterprise API Clients
+ * Clients for auth, team, billing, and audit services
+ */
+
+import { RestClient, ServiceURLs } from '.';
+import { logger } from '../utils';
+import type {
+  DeviceCodeResponse,
+  DevicePollResponse,
+  TokenValidateResponse,
+  Team,
+  TeamMember,
+  CreateTeamRequest,
+  InviteMemberRequest,
+  BillingStatus,
+  SubscribeRequest,
+  Invoice,
+  UsageSummary,
+  AuditLog,
+  AuditLogQuery,
+  CreateAuditLogRequest,
+} from '../types';
+
+// ==================== Auth Client ====================
+
+export class AuthClient {
+  private client: RestClient;
+
+  constructor() {
+    this.client = new RestClient(ServiceURLs.AUTH);
+  }
+
+  async initiateDeviceFlow(): Promise<DeviceCodeResponse> {
+    const response = await this.client.post<DeviceCodeResponse>('/api/auth/device/initiate');
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to initiate device flow');
+    }
+    return response.data;
+  }
+
+  async pollDeviceCode(deviceCode: string): Promise<DevicePollResponse> {
+    const response = await this.client.get<DevicePollResponse>(
+      `/api/auth/device/poll/${deviceCode}`
+    );
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to poll device code');
+    }
+    return response.data;
+  }
+
+  async verifyDeviceCode(userCode: string, userId: string): Promise<boolean> {
+    const response = await this.client.post<{ verified: boolean }>('/api/auth/device/verify', {
+      userCode,
+      userId,
+    });
+    return response.success && response.data?.verified === true;
+  }
+
+  async validateToken(accessToken: string): Promise<TokenValidateResponse> {
+    const response = await this.client.post<TokenValidateResponse>('/api/auth/token/validate', {
+      accessToken,
+    });
+    if (!response.success || !response.data) {
+      return { valid: false };
+    }
+    return response.data;
+  }
+}
+
+// ==================== Team Client ====================
+
+export class TeamClient {
+  private client: RestClient;
+
+  constructor() {
+    this.client = new RestClient(ServiceURLs.TEAM);
+  }
+
+  async createTeam(request: CreateTeamRequest): Promise<Team> {
+    const response = await this.client.post<Team>('/api/team/teams', request);
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to create team');
+    }
+    return response.data;
+  }
+
+  async getTeam(teamId: string): Promise<Team | null> {
+    const response = await this.client.get<Team>(`/api/team/teams/${teamId}`);
+    if (!response.success) {
+      return null;
+    }
+    return response.data || null;
+  }
+
+  async listTeams(userId: string): Promise<Team[]> {
+    const response = await this.client.get<Team[]>(`/api/team/teams?userId=${userId}`);
+    if (!response.success || !response.data) {
+      logger.warn('Failed to list teams; returning empty list', {
+        userId,
+        error: response.error?.message,
+      });
+      return [];
+    }
+    return response.data;
+  }
+
+  async deleteTeam(teamId: string): Promise<void> {
+    const response = await this.client.delete(`/api/team/teams/${teamId}`);
+    if (!response.success) {
+      throw new Error(response.error?.message || 'Failed to delete team');
+    }
+  }
+
+  async inviteMember(teamId: string, request: InviteMemberRequest): Promise<TeamMember> {
+    const response = await this.client.post<TeamMember>(
+      `/api/team/teams/${teamId}/members`,
+      request
+    );
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to invite member');
+    }
+    return response.data;
+  }
+
+  async listMembers(teamId: string): Promise<TeamMember[]> {
+    const response = await this.client.get<TeamMember[]>(`/api/team/teams/${teamId}/members`);
+    if (!response.success || !response.data) {
+      logger.warn('Failed to list team members; returning empty list', {
+        teamId,
+        error: response.error?.message,
+      });
+      return [];
+    }
+    return response.data;
+  }
+
+  async removeMember(teamId: string, userId: string): Promise<void> {
+    const response = await this.client.delete(`/api/team/teams/${teamId}/members/${userId}`);
+    if (!response.success) {
+      throw new Error(response.error?.message || 'Failed to remove member');
+    }
+  }
+
+  async updateMemberRole(teamId: string, userId: string, role: string): Promise<TeamMember> {
+    const response = await this.client.put<TeamMember>(
+      `/api/team/teams/${teamId}/members/${userId}`,
+      { role }
+    );
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to update member role');
+    }
+    return response.data;
+  }
+}
+
+// ==================== Billing Client ====================
+
+export class BillingClient {
+  private client: RestClient;
+
+  constructor() {
+    this.client = new RestClient(ServiceURLs.BILLING);
+  }
+
+  async getStatus(teamId: string): Promise<BillingStatus> {
+    const response = await this.client.get<BillingStatus>(`/api/billing/status?teamId=${teamId}`);
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to get billing status');
+    }
+    return response.data;
+  }
+
+  async subscribe(teamId: string, request: SubscribeRequest): Promise<BillingStatus> {
+    const response = await this.client.post<BillingStatus>('/api/billing/subscribe', {
+      ...request,
+      teamId,
+    });
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to subscribe');
+    }
+    return response.data;
+  }
+
+  async cancel(teamId: string): Promise<BillingStatus> {
+    const response = await this.client.post<BillingStatus>('/api/billing/cancel', { teamId });
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to cancel subscription');
+    }
+    return response.data;
+  }
+
+  async getUsage(
+    teamId: string,
+    period: 'day' | 'week' | 'month' = 'month'
+  ): Promise<UsageSummary> {
+    const response = await this.client.get<UsageSummary>(
+      `/api/billing/usage?teamId=${teamId}&period=${period}`
+    );
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to get usage');
+    }
+    return response.data;
+  }
+
+  async getInvoices(teamId: string, limit: number = 10): Promise<Invoice[]> {
+    const response = await this.client.get<Invoice[]>(
+      `/api/billing/invoices?teamId=${teamId}&limit=${limit}`
+    );
+    if (!response.success || !response.data) {
+      logger.warn('Failed to fetch invoices; returning empty list', {
+        teamId,
+        error: response.error?.message,
+      });
+      return [];
+    }
+    return response.data;
+  }
+
+  async recordUsage(
+    teamId: string,
+    operationType: string,
+    tokensUsed: number,
+    costUsd: number,
+    userId?: string
+  ): Promise<void> {
+    await this.client.post('/api/billing/usage', {
+      teamId,
+      userId,
+      operationType,
+      tokensUsed,
+      costUsd,
+    });
+  }
+}
+
+// ==================== Audit Client ====================
+
+export class AuditClient {
+  private client: RestClient;
+
+  constructor() {
+    this.client = new RestClient(ServiceURLs.AUDIT);
+  }
+
+  async createLog(request: CreateAuditLogRequest): Promise<AuditLog> {
+    const response = await this.client.post<AuditLog>('/api/audit/logs', request);
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message || 'Failed to create audit log');
+    }
+    return response.data;
+  }
+
+  async queryLogs(query: AuditLogQuery = {}): Promise<{
+    logs: AuditLog[];
+    total: number;
+    limit: number;
+    offset: number;
+  }> {
+    const params = new URLSearchParams();
+    if (query.teamId) {
+      params.set('teamId', query.teamId);
+    }
+    if (query.userId) {
+      params.set('userId', query.userId);
+    }
+    if (query.action) {
+      params.set('action', query.action);
+    }
+    if (query.status) {
+      params.set('status', query.status);
+    }
+    if (query.since) {
+      params.set('since', query.since);
+    }
+    if (query.until) {
+      params.set('until', query.until);
+    }
+    if (query.limit) {
+      params.set('limit', query.limit.toString());
+    }
+    if (query.offset) {
+      params.set('offset', query.offset.toString());
+    }
+
+    const response = await this.client.get<{
+      logs: AuditLog[];
+      total: number;
+      limit: number;
+      offset: number;
+    }>(`/api/audit/logs?${params}`);
+
+    if (!response.success || !response.data) {
+      return { logs: [], total: 0, limit: 100, offset: 0 };
+    }
+    return response.data;
+  }
+
+  async exportLogs(format: 'csv' | 'json', query: Partial<AuditLogQuery> = {}): Promise<string> {
+    const params = new URLSearchParams();
+    params.set('format', format);
+    if (query.teamId) {
+      params.set('teamId', query.teamId);
+    }
+    if (query.userId) {
+      params.set('userId', query.userId);
+    }
+    if (query.action) {
+      params.set('action', query.action);
+    }
+    if (query.since) {
+      params.set('since', query.since);
+    }
+    if (query.until) {
+      params.set('until', query.until);
+    }
+
+    const url = `${ServiceURLs.AUDIT}/api/audit/export?${params}`;
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error('Failed to export audit logs');
+    }
+
+    return response.text();
+  }
+}
+
+// ==================== Singleton Instances ====================
+
+export const authClient = new AuthClient();
+export const teamClient = new TeamClient();
+export const billingClient = new BillingClient();
+export const auditClient = new AuditClient();