@vizzly-testing/cli 0.19.2 → 0.20.1-beta.0

package/dist/auth/operations.js

@@ -0,0 +1,148 @@
+/**
+ * Auth Operations - Authentication operations with dependency injection
+ *
+ * Each operation takes its dependencies as parameters:
+ * - httpClient: for making HTTP requests
+ * - tokenStore: for reading/writing auth tokens
+ *
+ * This makes them trivially testable without mocking modules.
+ */
+
+import { buildDevicePollPayload, buildLogoutPayload, buildRefreshPayload, buildTokenData, validateTokens } from './core.js';
+
+// ============================================================================
+// Device Flow Operations
+// ============================================================================
+
+/**
+ * Initiate OAuth device flow
+ * @param {Object} httpClient - HTTP client with request method
+ * @returns {Promise<Object>} Device code, user code, verification URL
+ */
+export async function initiateDeviceFlow(httpClient) {
+  return httpClient.request('/api/auth/cli/device/initiate', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  });
+}
+
+/**
+ * Poll for device authorization
+ * @param {Object} httpClient - HTTP client
+ * @param {string} deviceCode - Device code from initiate
+ * @returns {Promise<Object>} Token data or pending status
+ */
+export async function pollDeviceAuthorization(httpClient, deviceCode) {
+  return httpClient.request('/api/auth/cli/device/poll', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(buildDevicePollPayload(deviceCode))
+  });
+}
+
+/**
+ * Complete device flow and save tokens
+ * @param {Object} tokenStore - Token storage with saveTokens method
+ * @param {Object} tokenData - Token response from poll
+ * @returns {Promise<Object>} Token data
+ */
+export async function completeDeviceFlow(tokenStore, tokenData) {
+  await tokenStore.saveTokens(buildTokenData(tokenData));
+  return tokenData;
+}
+
+// ============================================================================
+// Token Operations
+// ============================================================================
+
+/**
+ * Refresh access token using refresh token
+ * @param {Object} httpClient - HTTP client
+ * @param {Object} tokenStore - Token storage
+ * @returns {Promise<Object>} New tokens
+ */
+export async function refresh(httpClient, tokenStore) {
+  let auth = await tokenStore.getTokens();
+  let validation = validateTokens(auth, 'refreshToken');
+  if (!validation.valid) {
+    throw validation.error;
+  }
+  let response = await httpClient.request('/api/auth/cli/refresh', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(buildRefreshPayload(auth.refreshToken))
+  });
+
+  // Preserve existing user data when refreshing
+  await tokenStore.saveTokens(buildTokenData(response, auth.user));
+  return response;
+}
+
+// ============================================================================
+// Logout Operations
+// ============================================================================
+
+/**
+ * Logout and revoke tokens
+ * @param {Object} httpClient - HTTP client
+ * @param {Object} tokenStore - Token storage
+ * @returns {Promise<void>}
+ */
+export async function logout(httpClient, tokenStore) {
+  let auth = await tokenStore.getTokens();
+  if (auth?.refreshToken) {
+    try {
+      await httpClient.request('/api/auth/cli/logout', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(buildLogoutPayload(auth.refreshToken))
+      });
+    } catch (error) {
+      // If server request fails, still clear local tokens
+      console.warn('Warning: Failed to revoke tokens on server:', error.message);
+    }
+  }
+  await tokenStore.clearTokens();
+}
+
+// ============================================================================
+// User Operations
+// ============================================================================
+
+/**
+ * Get current user information
+ * @param {Object} httpClient - HTTP client
+ * @param {Object} tokenStore - Token storage
+ * @returns {Promise<Object>} User and organization data
+ */
+export async function whoami(httpClient, tokenStore) {
+  let auth = await tokenStore.getTokens();
+  let validation = validateTokens(auth, 'accessToken');
+  if (!validation.valid) {
+    throw validation.error;
+  }
+  return httpClient.authenticatedRequest('/api/auth/cli/whoami', auth.accessToken);
+}
+
+/**
+ * Check if user is authenticated
+ * @param {Object} httpClient - HTTP client
+ * @param {Object} tokenStore - Token storage
+ * @returns {Promise<boolean>} True if authenticated
+ */
+export async function isAuthenticated(httpClient, tokenStore) {
+  try {
+    await whoami(httpClient, tokenStore);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/dist/cli.js

@@ -13,8 +13,8 @@ import { tddCommand, validateTddOptions } from './commands/tdd.js';
 import { runDaemonChild, tddStartCommand, tddStatusCommand, tddStopCommand } from './commands/tdd-daemon.js';
 import { uploadCommand, validateUploadOptions } from './commands/upload.js';
 import { validateWhoamiOptions, whoamiCommand } from './commands/whoami.js';
-import { loadPlugins } from './plugin-loader.js';
 import { createPluginServices } from './plugin-api.js';
+import { loadPlugins } from './plugin-loader.js';
 import { createServices } from './services/index.js';
 import { loadConfig } from './utils/config-loader.js';
 import * as output from './utils/output.js';

package/dist/client/index.js

@@ -120,7 +120,6 @@ function createSimpleClient(serverUrl) {
             name,
             image,
             properties: options,
-            threshold: options.threshold || 0,
             fullPage: options.fullPage || false
           }),
           signal: controller.signal

package/dist/commands/doctor.js

@@ -1,6 +1,6 @@
 import { URL } from 'node:url';
+import { createApiClient, getBuilds } from '../api/index.js';
 import { ConfigError } from '../errors/vizzly-error.js';
-import { ApiService } from '../services/api-service.js';
 import { loadConfig } from '../utils/config-loader.js';
 import { getApiToken } from '../utils/environment-config.js';
 import * as output from '../utils/output.js';
@@ -102,13 +102,13 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
       } else {
         output.progress('Checking API connectivity...');
         try {
-          const api = new ApiService({
+          let client = createApiClient({
             baseUrl: config.apiUrl,
             token: config.apiKey,
             command: 'doctor'
           });
           // Minimal, read-only call
-          await api.getBuilds({
+          await getBuilds(client, {
             limit: 1
           });
           diagnostics.connectivity.ok = true;

package/dist/commands/finalize.js

@@ -1,14 +1,27 @@
-import { createServices } from '../services/index.js';
-import { loadConfig } from '../utils/config-loader.js';
-import * as output from '../utils/output.js';
+/**
+ * Finalize command implementation
+ * Uses functional API operations directly
+ */
+
+import { createApiClient as defaultCreateApiClient, finalizeParallelBuild as defaultFinalizeParallelBuild } from '../api/index.js';
+import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
+import * as defaultOutput from '../utils/output.js';
 
 /**
  * Finalize command implementation
  * @param {string} parallelId - Parallel ID to finalize
  * @param {Object} options - Command options
  * @param {Object} globalOptions - Global CLI options
+ * @param {Object} deps - Dependencies for testing
  */
-export async function finalizeCommand(parallelId, options = {}, globalOptions = {}) {
+export async function finalizeCommand(parallelId, options = {}, globalOptions = {}, deps = {}) {
+  let {
+    loadConfig = defaultLoadConfig,
+    createApiClient = defaultCreateApiClient,
+    finalizeParallelBuild = defaultFinalizeParallelBuild,
+    output = defaultOutput,
+    exit = code => process.exit(code)
+  } = deps;
   output.configure({
     json: globalOptions.json,
     verbose: globalOptions.verbose,
@@ -16,16 +29,20 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
   });
   try {
     // Load configuration with CLI overrides
-    const allOptions = {
+    let allOptions = {
       ...globalOptions,
       ...options
     };
-    const config = await loadConfig(globalOptions.config, allOptions);
+    let config = await loadConfig(globalOptions.config, allOptions);
 
     // Validate API token
     if (!config.apiKey) {
       output.error('API token required. Use --token or set VIZZLY_TOKEN environment variable');
-      process.exit(1);
+      exit(1);
+      return {
+        success: false,
+        reason: 'no-api-key'
+      };
     }
     if (globalOptions.verbose) {
       output.info('Configuration loaded');
@@ -35,14 +52,15 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
       });
     }
 
-    // Create services and get API service
+    // Call finalize endpoint via functional API
     output.startSpinner('Finalizing parallel build...');
-    const services = createServices(config, 'finalize');
-    const apiService = services.apiService;
+    let client = createApiClient({
+      baseUrl: config.apiUrl,
+      token: config.apiKey,
+      command: 'finalize'
+    });
+    let result = await finalizeParallelBuild(client, parallelId);
     output.stopSpinner();
-
-    // Call finalize endpoint
-    const result = await apiService.finalizeParallelBuild(parallelId);
     if (globalOptions.json) {
       output.data(result);
     } else {
@@ -50,10 +68,18 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
       output.info(`Status: ${result.build.status}`);
       output.info(`Parallel ID: ${result.build.parallel_id}`);
     }
+    return {
+      success: true,
+      result
+    };
   } catch (error) {
     output.stopSpinner();
     output.error('Failed to finalize parallel build', error);
-    process.exit(1);
+    exit(1);
+    return {
+      success: false,
+      error
+    };
   } finally {
     output.cleanup();
   }
@@ -65,7 +91,7 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
  * @param {Object} options - Command options
  */
 export function validateFinalizeOptions(parallelId, _options) {
-  const errors = [];
+  let errors = [];
   if (!parallelId || parallelId.trim() === '') {
     errors.push('Parallel ID is required');
   }

package/dist/commands/login.js

@@ -3,7 +3,7 @@
  * Authenticates user via OAuth device flow
  */
 
-import { AuthService } from '../services/auth-service.js';
+import { completeDeviceFlow, createAuthClient, createTokenStore, initiateDeviceFlow, pollDeviceAuthorization } from '../auth/index.js';
 import { openBrowser } from '../utils/browser.js';
 import { getApiUrl } from '../utils/environment-config.js';
 import * as output from '../utils/output.js';
@@ -24,14 +24,15 @@ export async function loginCommand(options = {}, globalOptions = {}) {
     output.info('Starting Vizzly authentication...');
     output.blank();
 
-    // Create auth service
-    const authService = new AuthService({
+    // Create auth client and token store
+    let client = createAuthClient({
       baseUrl: options.apiUrl || getApiUrl()
     });
+    let tokenStore = createTokenStore();
 
     // Initiate device flow
     output.startSpinner('Connecting to Vizzly...');
-    const deviceFlow = await authService.initiateDeviceFlow();
+    let deviceFlow = await initiateDeviceFlow(client);
     output.stopSpinner();
 
     // Handle both snake_case and camelCase field names
@@ -83,7 +84,7 @@ export async function loginCommand(options = {}, globalOptions = {}) {
 
     // Check authorization status
     output.startSpinner('Checking authorization status...');
-    const pollResponse = await authService.pollDeviceAuthorization(deviceCode);
+    let pollResponse = await pollDeviceAuthorization(client, deviceCode);
     output.stopSpinner();
     let tokenData = null;
 
@@ -113,7 +114,7 @@ export async function loginCommand(options = {}, globalOptions = {}) {
       user: tokenData.user,
       organizations: tokenData.organizations
     };
-    await authService.completeDeviceFlow(tokens);
+    await completeDeviceFlow(tokenStore, tokens);
 
     // Display success message
     output.success('Successfully authenticated!');

package/dist/commands/logout.js

@@ -3,9 +3,8 @@
  * Clears stored authentication tokens
  */
 
-import { AuthService } from '../services/auth-service.js';
+import { createAuthClient, createTokenStore, getAuthTokens, logout } from '../auth/index.js';
 import { getApiUrl } from '../utils/environment-config.js';
-import { getAuthTokens } from '../utils/global-config.js';
 import * as output from '../utils/output.js';
 
 /**
@@ -30,10 +29,11 @@ export async function logoutCommand(options = {}, globalOptions = {}) {
 
     // Logout
     output.startSpinner('Logging out...');
-    const authService = new AuthService({
+    let client = createAuthClient({
       baseUrl: options.apiUrl || getApiUrl()
     });
-    await authService.logout();
+    let tokenStore = createTokenStore();
+    await logout(client, tokenStore);
     output.stopSpinner();
     output.success('Successfully logged out');
     if (globalOptions.json) {

package/dist/commands/project.js

@@ -5,9 +5,9 @@
 
 import { resolve } from 'node:path';
 import readline from 'node:readline';
-import { AuthService } from '../services/auth-service.js';
+import { createAuthClient, createTokenStore, getAuthTokens, whoami } from '../auth/index.js';
 import { getApiUrl } from '../utils/environment-config.js';
-import { deleteProjectMapping, getAuthTokens, getProjectMapping, getProjectMappings, saveProjectMapping } from '../utils/global-config.js';
+import { deleteProjectMapping, getProjectMapping, getProjectMappings, saveProjectMapping } from '../utils/global-config.js';
 import * as output from '../utils/output.js';
 
 /**
@@ -30,13 +30,14 @@ export async function projectSelectCommand(options = {}, globalOptions = {}) {
       output.info('Run "vizzly login" to authenticate first');
       process.exit(1);
     }
-    const authService = new AuthService({
+    let client = createAuthClient({
       baseUrl: options.apiUrl || getApiUrl()
     });
+    let tokenStore = createTokenStore();
 
     // Get user info to show organizations
     output.startSpinner('Fetching organizations...');
-    const userInfo = await authService.whoami();
+    let userInfo = await whoami(client, tokenStore);
     output.stopSpinner();
     if (!userInfo.organizations || userInfo.organizations.length === 0) {
       output.error('No organizations found');