@vizzly-testing/cli 0.39.0 → 0.39.2

package/dist/{auth/client.js → domains/auth/auth-client.js}

@@ -1,12 +1,13 @@
+import { getPackageVersion } from '../../shared/package-info.js';
+import { parseAuthError, parseAuthenticatedError } from './auth-errors.js';
+import { buildAuthUserAgent, buildRequestHeaders } from './auth-headers.js';
+
 /**
  * Auth Client - HTTP client factory for authentication
  *
  * Creates a thin HTTP wrapper that can be injected into operations.
  */
 
-import { getPackageVersion } from '../utils/package-info.js';
-import { buildAuthUserAgent, buildRequestHeaders, parseAuthError, parseAuthenticatedError } from './core.js';
-
 /**
  * Parse response body based on content type
  * @param {Response} response - Fetch response

package/dist/domains/auth/auth-errors.js

@@ -0,0 +1,50 @@
+import { AuthError, VizzlyError } from '../../shared/vizzly-error.js';
+
+/**
+ * Parse error from API response
+ * @param {number} status - HTTP status code
+ * @param {Object|string} body - Response body (parsed JSON or text)
+ * @param {string} endpoint - API endpoint for context
+ * @returns {Error} Appropriate error type
+ */
+export function parseAuthError(status, body, _endpoint) {
+  let errorText = '';
+  if (typeof body === 'object' && body !== null) {
+    errorText = body.error || body.message || '';
+  } else if (typeof body === 'string') {
+    errorText = body;
+  }
+  let retryAfter = Number(body?.retryAfter);
+  let context = {
+    status,
+    serverCode: body?.code,
+    retryAfter: retryAfter > 0 ? retryAfter : undefined
+  };
+  if (status === 401) {
+    return new AuthError(errorText || 'Invalid credentials. Please check your email/username and password.', context);
+  }
+  if (status === 429) {
+    return new VizzlyError('Too many login attempts. Please try again later.', 'RATE_LIMIT_ERROR', context);
+  }
+  return new VizzlyError(`Authentication request failed: ${status}${errorText ? ` - ${errorText}` : ''}`, 'AUTH_REQUEST_ERROR', context);
+}
+
+/**
+ * Parse error for authenticated requests (different error messages)
+ * @param {number} status - HTTP status code
+ * @param {Object|string} body - Response body
+ * @param {string} endpoint - API endpoint
+ * @returns {Error} Appropriate error type
+ */
+export function parseAuthenticatedError(status, body, endpoint) {
+  let errorText = '';
+  if (typeof body === 'object' && body !== null) {
+    errorText = body.error || body.message || '';
+  } else if (typeof body === 'string') {
+    errorText = body;
+  }
+  if (status === 401) {
+    return new AuthError('Authentication token is invalid or expired. Please run "vizzly login" again.');
+  }
+  return new VizzlyError(`API request failed: ${status}${errorText ? ` - ${errorText}` : ''} (${endpoint})`, 'API_REQUEST_ERROR');
+}

package/dist/domains/auth/auth-headers.js

@@ -0,0 +1,41 @@
+/**
+ * Build Authorization header from access token
+ * @param {string|null} accessToken - Access token
+ * @returns {Object} Headers object with Authorization if token exists
+ */
+export function buildAuthHeader(accessToken) {
+  if (!accessToken) return {};
+  return {
+    Authorization: `Bearer ${accessToken}`
+  };
+}
+
+/**
+ * Build User-Agent header for auth requests
+ * @param {string} version - CLI version
+ * @returns {string} User-Agent string
+ */
+export function buildAuthUserAgent(version) {
+  return `vizzly-cli/${version} (auth)`;
+}
+
+/**
+ * Build complete headers for a request
+ * @param {Object} options - Header options
+ * @returns {Object} Complete headers object
+ */
+export function buildRequestHeaders({
+  userAgent,
+  accessToken,
+  contentType,
+  extra = {}
+}) {
+  return {
+    'User-Agent': userAgent,
+    ...(accessToken ? buildAuthHeader(accessToken) : {}),
+    ...(contentType ? {
+      'Content-Type': contentType
+    } : {}),
+    ...extra
+  };
+}

package/dist/domains/auth/auth.normalizers.js

@@ -0,0 +1,50 @@
+/**
+ * Build token data for storage from API response
+ * @param {Object} response - API response with tokens
+ * @param {Object|null} existingUser - Existing user data to preserve
+ * @returns {Object} Token data for storage
+ */
+export function buildTokenData(response, existingUser = null) {
+  return {
+    accessToken: response.accessToken,
+    refreshToken: response.refreshToken,
+    expiresAt: response.expiresAt,
+    user: response.user || existingUser
+  };
+}
+export function normalizeDeviceFlowResponse(deviceFlow) {
+  let verificationUri = deviceFlow.verification_uri || deviceFlow.verificationUri;
+  let userCode = deviceFlow.user_code || deviceFlow.userCode;
+  let deviceCode = deviceFlow.device_code || deviceFlow.deviceCode;
+  if (!verificationUri || !userCode || !deviceCode) {
+    throw new Error('Invalid device flow response from server');
+  }
+  return {
+    verificationUri,
+    userCode,
+    deviceCode,
+    urlWithCode: deviceFlow.verification_uri_complete || deviceFlow.verificationUriComplete || `${verificationUri}?code=${encodeURIComponent(userCode)}`
+  };
+}
+export function buildTokens(tokenData, now = Date.now()) {
+  let tokensData = tokenData.tokens || tokenData;
+  let tokenExpiresIn = tokensData.expiresIn || tokensData.expires_in;
+  let tokenExpiresAt = tokenExpiresIn ? new Date(now + tokenExpiresIn * 1000).toISOString() : tokenData.expires_at || tokenData.expiresAt;
+  return {
+    accessToken: tokensData.accessToken || tokensData.access_token,
+    refreshToken: tokensData.refreshToken || tokensData.refresh_token,
+    expiresAt: tokenExpiresAt,
+    user: tokenData.user,
+    organizations: tokenData.organizations
+  };
+}
+
+/** Map protocol codes without depending on the server's human-readable text. */
+export function deviceAuthorizationStatus(error) {
+  return {
+    AUTHORIZATION_PENDING: 'pending',
+    ACCESS_DENIED: 'denied',
+    EXPIRED_TOKEN: 'expired',
+    INVALID_DEVICE_CODE: 'invalid'
+  }[error.context?.serverCode];
+}

package/dist/{server/routers/auth.js → domains/auth/auth.routes.js}

@@ -1,13 +1,13 @@
+import { parseJsonBody } from '../../adapters/http/middleware/json-parser.js';
+import { sendError, sendJson, sendServiceUnavailable, sendSuccess } from '../../adapters/http/middleware/response.js';
+import * as output from '../../shared/output.js';
+import { buildTokens, normalizeDeviceFlowResponse } from './auth.normalizers.js';
+
 /**
  * Auth Router
  * Handles authentication endpoints (device flow login, logout, status)
  */
 
-import { buildTokens, normalizeDeviceFlowResponse } from '../../auth/core.js';
-import * as output from '../../utils/output.js';
-import { parseJsonBody } from '../middleware/json-parser.js';
-import { sendError, sendJson, sendServiceUnavailable, sendSuccess } from '../middleware/response.js';
-
 /**
  * Create auth router
  * @param {Object} context - Router context
@@ -27,10 +27,10 @@ export function createAuthRouter({
     // Get auth status and user info
     if (req.method === 'GET' && pathname === '/api/auth/status') {
       try {
-        const isAuthenticated = await authService.isAuthenticated();
+        let isAuthenticated = await authService.isAuthenticated();
         let user = null;
         if (isAuthenticated) {
-          const whoami = await authService.whoami();
+          let whoami = await authService.whoami();
           user = whoami.user;
         }
         sendSuccess(res, {
@@ -72,8 +72,8 @@ export function createAuthRouter({
     // Poll device authorization status
     if (req.method === 'POST' && pathname === '/api/auth/poll') {
       try {
-        const body = await parseJsonBody(req);
-        const {
+        let body = await parseJsonBody(req);
+        let {
           deviceCode
         } = body;
         if (!deviceCode) {

package/dist/domains/auth/auth.rules.js

@@ -0,0 +1,19 @@
+export function resolveAuthorizedTokenData(pollResponse) {
+  let accessToken = pollResponse.tokens?.accessToken || pollResponse.tokens?.access_token;
+  if (accessToken) {
+    return pollResponse;
+  }
+  if (pollResponse.status === 'pending') {
+    throw new Error('Authorization not complete yet. Please complete the authorization in your browser and try running "vizzly login" again.');
+  }
+  if (pollResponse.status === 'expired') {
+    throw new Error('Device code expired. Please try logging in again.');
+  }
+  if (pollResponse.status === 'invalid') {
+    throw new Error('Device code is invalid or expired. Please try logging in again.');
+  }
+  if (pollResponse.status === 'denied') {
+    throw new Error('Authorization denied. Please try logging in again.');
+  }
+  throw new Error('Unexpected response from authorization server. Please try logging in again.');
+}

package/dist/domains/auth/auth.serializers.js

@@ -0,0 +1,32 @@
+/**
+ * Build device poll request payload
+ * @param {string} deviceCode - Device code from initiate
+ * @returns {Object} Request payload
+ */
+export function buildDevicePollPayload(deviceCode) {
+  return {
+    device_code: deviceCode
+  };
+}
+
+/**
+ * Build refresh token request payload
+ * @param {string} refreshToken - Refresh token
+ * @returns {Object} Request payload
+ */
+export function buildRefreshPayload(refreshToken) {
+  return {
+    refreshToken
+  };
+}
+
+/**
+ * Build logout request payload
+ * @param {string} refreshToken - Refresh token to revoke
+ * @returns {Object} Request payload
+ */
+export function buildLogoutPayload(refreshToken) {
+  return {
+    refreshToken
+  };
+}

package/dist/{auth/operations.js → domains/auth/auth.service.js}

@@ -1,3 +1,11 @@
+import * as output from '../../shared/output.js';
+import { getApiUrl } from '../config/environment.js';
+import { buildTokenData, deviceAuthorizationStatus } from './auth.normalizers.js';
+import { buildDevicePollPayload, buildLogoutPayload, buildRefreshPayload } from './auth.serializers.js';
+import { validateTokens } from './auth.validations.js';
+import { createAuthClient } from './auth-client.js';
+import { createTokenStore } from './token-store.js';
+
 /**
  * Auth Operations - Authentication operations with dependency injection
  *
@@ -8,12 +16,114 @@
  * This makes them trivially testable without mocking modules.
  */
 
-import * as output from '../utils/output.js';
-import { buildDevicePollPayload, buildLogoutPayload, buildRefreshPayload, buildTokenData, deviceAuthorizationStatus, validateTokens } from './core.js';
+/**
+ * Auth Service
+ * Wraps auth operations for use by the HTTP server
+ *
+ * Provides the interface expected by src/domains/auth/auth.routes.js:
+ * - isAuthenticated() - Returns boolean, false if no tokens or API call fails
+ * - whoami() - Throws if not authenticated or tokens invalid
+ * - initiateDeviceFlow() - Throws on API error
+ * - pollDeviceAuthorization(deviceCode) - Returns pending status or tokens, throws on error
+ * - completeDeviceFlow(tokens) - Saves tokens to global config
+ * - logout() - Clears local tokens, may warn if server revocation fails
+ * - authenticatedRequest(endpoint, options) - Throws 'Not authenticated' if no tokens
+ *
+ * Error handling:
+ * - isAuthenticated() never throws, returns false on any error
+ * - whoami() throws if tokens are missing/invalid (caller should check isAuthenticated first)
+ * - authenticatedRequest() throws 'Not authenticated' if no access token
+ * - Device flow methods throw on API errors (network, server errors)
+ */
 
-// ============================================================================
-// Device Flow Operations
-// ============================================================================
+/**
+ * Create an auth service instance
+ * @param {Object} [options]
+ * @param {string} [options.apiUrl] - API base URL (defaults to VIZZLY_API_URL or https://app.vizzly.dev)
+ * @param {Object} [options.httpClient] - Injectable HTTP client (for testing)
+ * @param {Object} [options.tokenStore] - Injectable token store (for testing)
+ * @returns {Object} Auth service
+ */
+export function createAuthService(options = {}) {
+  let apiUrl = options.apiUrl || getApiUrl();
+
+  // Create HTTP client for API requests (uses auth client for proper auth handling)
+  // Allow injection for testing
+  let httpClient = options.httpClient || createAuthClient({
+    baseUrl: apiUrl
+  });
+
+  // Create token store adapter for global config
+  // Allow injection for testing
+  let tokenStore = options.tokenStore || createTokenStore();
+  return {
+    /**
+     * Check if user is authenticated
+     * @returns {Promise<boolean>}
+     */
+    async isAuthenticated() {
+      return isAuthenticated(httpClient, tokenStore);
+    },
+    /**
+     * Get current user information
+     * @returns {Promise<Object>} User and organization data
+     */
+    async whoami() {
+      return whoami(httpClient, tokenStore);
+    },
+    /**
+     * Initiate OAuth device flow
+     * @returns {Promise<Object>} Device code info
+     */
+    async initiateDeviceFlow() {
+      return initiateDeviceFlow(httpClient);
+    },
+    /**
+     * Poll for device authorization
+     * @param {string} deviceCode
+     * @returns {Promise<Object>} Token data or pending status
+     */
+    async pollDeviceAuthorization(deviceCode) {
+      return pollDeviceAuthorization(httpClient, deviceCode);
+    },
+    /**
+     * Complete device flow and save tokens
+     * @param {Object} tokens - Token data
+     * @returns {Promise<Object>}
+     */
+    async completeDeviceFlow(tokens) {
+      return completeDeviceFlow(tokenStore, tokens);
+    },
+    /**
+     * Logout and revoke tokens
+     * @returns {Promise<void>}
+     */
+    async logout() {
+      return logout(httpClient, tokenStore);
+    },
+    /**
+     * Refresh access token
+     * @returns {Promise<Object>} New tokens
+     */
+    async refresh() {
+      return refresh(httpClient, tokenStore);
+    },
+    /**
+     * Make an authenticated request to the API
+     * Used by cloud-proxy router for proxying requests
+     * @param {string} endpoint - API endpoint
+     * @param {Object} options - Fetch options
+     * @returns {Promise<Object>} Response data
+     */
+    async authenticatedRequest(endpoint, options = {}) {
+      let auth = await tokenStore.getTokens();
+      if (!auth?.accessToken) {
+        throw new Error('Not authenticated');
+      }
+      return httpClient.authenticatedRequest(endpoint, auth.accessToken, options);
+    }
+  };
+}
 
 /**
  * Initiate OAuth device flow
@@ -65,10 +175,6 @@ export async function completeDeviceFlow(tokenStore, tokenData) {
   return tokenData;
 }
 
-// ============================================================================
-// Token Operations
-// ============================================================================
-
 /**
  * Refresh access token using refresh token
  * @param {Object} httpClient - HTTP client
@@ -94,10 +200,6 @@ export async function refresh(httpClient, tokenStore) {
   return response;
 }
 
-// ============================================================================
-// Logout Operations
-// ============================================================================
-
 /**
  * Logout and revoke tokens
  * @param {Object} httpClient - HTTP client
@@ -123,10 +225,6 @@ export async function logout(httpClient, tokenStore) {
   await tokenStore.clearTokens();
 }
 
-// ============================================================================
-// User Operations
-// ============================================================================
-
 /**
  * Get current user information
  * @param {Object} httpClient - HTTP client

package/dist/domains/auth/auth.validations.js

@@ -0,0 +1,21 @@
+import { AuthError } from '../../shared/vizzly-error.js';
+
+/**
+ * Validate that tokens exist and have required fields
+ * @param {Object|null} auth - Auth tokens object
+ * @param {string} requiredField - Field that must exist ('accessToken' or 'refreshToken')
+ * @returns {{ valid: boolean, error: Error|null }}
+ */
+export function validateTokens(auth, requiredField = 'accessToken') {
+  if (!auth?.[requiredField]) {
+    let message = requiredField === 'refreshToken' ? 'No refresh token found. Please run "vizzly login" first.' : 'No authentication token found. Please run "vizzly login" first.';
+    return {
+      valid: false,
+      error: new AuthError(message)
+    };
+  }
+  return {
+    valid: true,
+    error: null
+  };
+}

package/dist/{api/client.js → domains/auth/cloud-client.js}

@@ -5,10 +5,10 @@
  * The client handles authentication, token refresh, and error handling.
  */
 
-import { AuthError, VizzlyError } from '../errors/vizzly-error.js';
-import { getAuthTokens, saveAuthTokens } from '../utils/global-config.js';
-import { getPackageVersion } from '../utils/package-info.js';
-import { buildApiUrl, buildRequestHeaders, buildUserAgent, extractErrorBody, isAuthError, parseApiError, shouldRetryWithRefresh } from './core.js';
+import { buildApiUrl, buildRequestHeaders, buildUserAgent, extractErrorBody, isAuthError, parseApiError } from '../../shared/cloud-protocol.js';
+import { getPackageVersion } from '../../shared/package-info.js';
+import { AuthError, VizzlyError } from '../../shared/vizzly-error.js';
+import { getAuthTokens, saveAuthTokens } from './token-store.js';
 
 /**
  * Default API URL
@@ -85,8 +85,9 @@ export function createApiClient(options = {}) {
       let errorBody = await extractErrorBody(response);
 
       // Handle 401 with token refresh
-      if (retryAuthentication && shouldRetryWithRefresh(response.status, isRetry, !isProjectToken(token) && (await hasRefreshToken()))) {
-        let refreshed = await attemptTokenRefresh();
+      if (retryAuthentication && response.status === 401 && !isRetry && !isProjectToken(token)) {
+        let auth = await getAuthTokens();
+        let refreshed = auth?.accessToken === token && auth.refreshToken ? await attemptTokenRefresh(auth) : null;
         if (refreshed) {
           token = refreshed;
           return request(endpoint, fetchOptions, true);
@@ -95,7 +96,9 @@ export function createApiClient(options = {}) {
 
       // Auth error
       if (isAuthError(response.status)) {
-        throw new AuthError('Invalid or expired API token. Run "vizzly project link <org>/<project>" or set VIZZLY_TOKEN.');
+        throw new AuthError('Invalid or expired API token. Run "vizzly project link <org>/<project>" or set VIZZLY_TOKEN.', {
+          status: response.status
+        });
       }
 
       // Other errors
@@ -114,21 +117,11 @@ export function createApiClient(options = {}) {
     return response.json();
   }
 
-  /**
-   * Check if refresh token is available
-   */
-  async function hasRefreshToken() {
-    let auth = await getAuthTokens();
-    return !!auth?.refreshToken;
-  }
-
   /**
    * Attempt to refresh the access token
    * @returns {Promise<string|null>} New token or null if refresh failed
    */
-  async function attemptTokenRefresh() {
-    let auth = await getAuthTokens();
-    if (!auth?.refreshToken) return null;
+  async function attemptTokenRefresh(auth) {
     try {
       let refreshUrl = buildApiUrl(baseUrl, '/api/auth/cli/refresh');
       let response = await fetch(refreshUrl, {

package/dist/{commands/login.js → domains/auth/login.commands.js}

@@ -1,16 +1,19 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { openBrowser } from '../../shared/browser.js';
+import * as output from '../../shared/output.js';
+import { getApiUrl } from '../config/environment.js';
+import { buildTokens, normalizeDeviceFlowResponse } from './auth.normalizers.js';
+import { resolveAuthorizedTokenData } from './auth.rules.js';
+import { completeDeviceFlow, initiateDeviceFlow, pollDeviceAuthorization } from './auth.service.js';
+import { createAuthClient } from './auth-client.js';
+import { waitForLoginPoll } from './login-wait.js';
+import { createTokenStore } from './token-store.js';
+
 /**
  * Login command implementation
  * Authenticates user via OAuth device flow
  */
 
-import { setTimeout as delay } from 'node:timers/promises';
-import { buildTokens, normalizeDeviceFlowResponse, resolveAuthorizedTokenData } from '../auth/core.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 { waitForLoginPoll } from '../utils/login-poll-wait.js';
-import * as output from '../utils/output.js';
-
 /**
  * Login command implementation using OAuth device flow
  * @param {Object} options - Command options

package/dist/{commands/logout.js → domains/auth/logout.commands.js}

@@ -1,12 +1,14 @@
+import * as defaultOutput from '../../shared/output.js';
+import { getApiUrl as defaultGetApiUrl } from '../config/environment.js';
+import { logout as defaultLogout } from './auth.service.js';
+import { createAuthClient as defaultCreateAuthClient } from './auth-client.js';
+import { createTokenStore as defaultCreateTokenStore, getAuthTokens as defaultGetAuthTokens } from './token-store.js';
+
 /**
  * Logout command implementation
  * Clears stored authentication tokens
  */
 
-import { createAuthClient as defaultCreateAuthClient, createTokenStore as defaultCreateTokenStore, getAuthTokens as defaultGetAuthTokens, logout as defaultLogout } from '../auth/index.js';
-import { getApiUrl as defaultGetApiUrl } from '../utils/environment-config.js';
-import * as defaultOutput from '../utils/output.js';
-
 /**
  * Logout command implementation
  * @param {Object} options - Command options

package/dist/domains/auth/token-store.js

@@ -0,0 +1,81 @@
+import { loadGlobalConfig, saveGlobalConfig } from '../../shared/global-config.js';
+
+/**
+ * Get authentication tokens from global config
+ * @returns {Promise<Object|null>} Token object with accessToken, refreshToken, expiresAt, user, or null if not found
+ */
+export async function getAuthTokens() {
+  let config = await loadGlobalConfig();
+  if (!config.auth?.accessToken) {
+    return null;
+  }
+  return config.auth;
+}
+
+/**
+ * Save authentication tokens to global config
+ * @param {Object} auth - Auth object with accessToken, refreshToken, expiresAt, user
+ * @returns {Promise<void>}
+ */
+export async function saveAuthTokens(auth) {
+  let config = await loadGlobalConfig();
+  config.auth = {
+    accessToken: auth.accessToken,
+    refreshToken: auth.refreshToken,
+    expiresAt: auth.expiresAt,
+    user: auth.user
+  };
+  await saveGlobalConfig(config);
+}
+
+/**
+ * Clear authentication tokens from global config
+ * @returns {Promise<void>}
+ */
+export async function clearAuthTokens() {
+  let config = await loadGlobalConfig();
+  delete config.auth;
+  await saveGlobalConfig(config);
+}
+function hasValidAccessToken(auth, now = Date.now()) {
+  if (!auth?.accessToken) {
+    return false;
+  }
+  if (!auth.expiresAt) {
+    return true;
+  }
+  let expiresAt = new Date(auth.expiresAt).getTime();
+  // Treat tokens expiring within five minutes as unavailable.
+  let bufferMs = 5 * 60 * 1000;
+  return now < expiresAt - bufferMs;
+}
+
+/**
+ * Check if authentication tokens exist and are not expired
+ * @returns {Promise<boolean>} True if valid tokens exist
+ */
+export async function hasValidTokens() {
+  let auth = await getAuthTokens();
+  return hasValidAccessToken(auth);
+}
+
+/**
+ * Get the access token from global config if valid and not expired
+ * @returns {Promise<string|null>} Access token or null
+ */
+export async function getAccessToken() {
+  let auth = await getAuthTokens();
+  return hasValidAccessToken(auth) ? auth.accessToken : null;
+}
+
+/**
+ * Create a token store adapter from global-config functions
+ * Used by auth operations that need tokenStore parameter
+ */
+export function createTokenStore() {
+  return {
+    getTokens: getAuthTokens,
+    saveTokens: saveAuthTokens,
+    clearTokens: clearAuthTokens
+  };
+}

package/dist/{commands/whoami.js → domains/auth/whoami.commands.js}

@@ -1,11 +1,14 @@
+import * as defaultOutput from '../../shared/output.js';
+import { getApiUrl as defaultGetApiUrl } from '../config/environment.js';
+import { whoami as defaultWhoami } from './auth.service.js';
+import { createAuthClient as defaultCreateAuthClient } from './auth-client.js';
+import { createTokenStore as defaultCreateTokenStore, getAuthTokens as defaultGetAuthTokens } from './token-store.js';
+
 /**
  * Whoami command implementation
  * Shows current user and authentication status
  */
 
-import { createAuthClient as defaultCreateAuthClient, createTokenStore as defaultCreateTokenStore, getAuthTokens as defaultGetAuthTokens, whoami as defaultWhoami } from '../auth/index.js';
-import { getApiUrl as defaultGetApiUrl } from '../utils/environment-config.js';
-import * as defaultOutput from '../utils/output.js';
 export function getTokenExpiryStatus(expiresAt, now = new Date()) {
   let expiresDate = new Date(expiresAt);
   let msUntilExpiry = expiresDate.getTime() - now.getTime();