@vizzly-testing/cli 0.38.0 → 0.39.0

package/dist/commands/login.js

@@ -3,110 +3,13 @@
  * 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';
-function createLoginDeps(deps = {}) {
-  return {
-    completeDeviceFlow: deps.completeDeviceFlow || completeDeviceFlow,
-    createAuthClient: deps.createAuthClient || createAuthClient,
-    createTokenStore: deps.createTokenStore || createTokenStore,
-    getApiUrl: deps.getApiUrl || getApiUrl,
-    initiateDeviceFlow: deps.initiateDeviceFlow || initiateDeviceFlow,
-    now: deps.now || (() => Date.now()),
-    openBrowser: deps.openBrowser || openBrowser,
-    output: deps.output || output,
-    pollDeviceAuthorization: deps.pollDeviceAuthorization || pollDeviceAuthorization,
-    waitForEnter: deps.waitForEnter || waitForEnter,
-    exit: deps.exit || (code => process.exit(code))
-  };
-}
-function configureOutput(output, globalOptions) {
-  output.configure({
-    json: globalOptions.json,
-    verbose: globalOptions.verbose,
-    color: !globalOptions.noColor
-  });
-}
-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: `${verificationUri}?code=${encodeURIComponent(userCode)}`
-  };
-}
-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 === 'denied') {
-    throw new Error('Authorization denied. Please try logging in again.');
-  }
-  throw new Error('Unexpected response from authorization server. Please try logging in again.');
-}
-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
-  };
-}
-export function getTokenExpiryHint(expiresAt, now = Date.now()) {
-  if (!expiresAt) {
-    return null;
-  }
-  let expiry = new Date(expiresAt);
-  let msUntilExpiry = expiry.getTime() - now;
-  let daysUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60 * 24));
-  let hoursUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60));
-  let minutesUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60));
-  if (daysUntilExpiry > 0) {
-    return `Token expires in ${daysUntilExpiry} day${daysUntilExpiry !== 1 ? 's' : ''}`;
-  }
-  if (hoursUntilExpiry > 0) {
-    return `Token expires in ${hoursUntilExpiry} hour${hoursUntilExpiry !== 1 ? 's' : ''}`;
-  }
-  if (minutesUntilExpiry > 0) {
-    return `Token expires in ${minutesUntilExpiry} minute${minutesUntilExpiry !== 1 ? 's' : ''}`;
-  }
-  return null;
-}
-export async function waitForEnter(stdin = process.stdin) {
-  await new Promise(resolve => {
-    let canSetRawMode = typeof stdin.setRawMode === 'function';
-    if (canSetRawMode) {
-      stdin.setRawMode(true);
-    }
-    stdin.resume();
-    stdin.once('data', () => {
-      if (canSetRawMode) {
-        stdin.setRawMode(false);
-      }
-      stdin.pause();
-      resolve();
-    });
-  });
-}
 
 /**
  * Login command implementation using OAuth device flow
@@ -115,19 +18,14 @@ export async function waitForEnter(stdin = process.stdin) {
  */
 export async function loginCommand(options = {}, globalOptions = {}, deps = {}) {
   let {
-    completeDeviceFlow,
-    createAuthClient,
-    createTokenStore,
-    getApiUrl,
-    initiateDeviceFlow,
-    now,
-    openBrowser,
-    output,
-    pollDeviceAuthorization,
-    waitForEnter,
-    exit
-  } = createLoginDeps(deps);
-  configureOutput(output, globalOptions);
+    now = Date.now,
+    delay: sleep = delay
+  } = deps;
+  output.configure({
+    json: globalOptions.json,
+    verbose: globalOptions.verbose,
+    color: !globalOptions.noColor
+  });
   let colors = output.getColors();
   try {
     output.header('login');
@@ -142,6 +40,12 @@ export async function loginCommand(options = {}, globalOptions = {}, deps = {})
     output.startSpinner('Connecting to Vizzly...');
     let deviceFlow = await initiateDeviceFlow(client);
     output.stopSpinner();
+    let expiresIn = Number(deviceFlow.expires_in ?? deviceFlow.expiresIn);
+    let lifetime = Number.isFinite(expiresIn) && expiresIn > 0 ? Math.min(expiresIn, 120) : 120;
+    let deadline = now() + lifetime * 1000;
+    let timeoutMessage = expiresIn > 0 && expiresIn <= 120 ? 'Device code expired. Please try logging in again.' : 'Login timed out after 2 minutes. Please try logging in again.';
+    let interval = Number(deviceFlow.interval);
+    let pollDelay = Number.isFinite(interval) && interval > 0 ? interval * 1000 : 5000;
 
     // Handle both snake_case and camelCase field names
     let {
@@ -166,14 +70,57 @@ export async function loginCommand(options = {}, globalOptions = {}, deps = {})
       output.hint('Please open the URL manually');
     }
     output.blank();
-    output.hint('After authorizing, press Enter to continue...');
-
-    // Wait for user to press Enter
-    await waitForEnter();
-
-    // Check authorization status
-    output.startSpinner('Checking authorization...');
-    let pollResponse = await pollDeviceAuthorization(client, deviceCode);
+    output.hint('Waiting for authorization in your browser (up to 2 minutes)...');
+    let interactive = process.stdin.isTTY && !globalOptions.json;
+    let backoff = false;
+    let lastCheckAt = 0;
+    let pollResponse;
+    while (true) {
+      let remaining = deadline - now();
+      if (remaining <= 0) {
+        throw new Error(timeoutMessage);
+      }
+      await waitForLoginPoll({
+        milliseconds: Math.min(pollDelay, remaining),
+        manualAllowed: !backoff,
+        earliestCheckAt: lastCheckAt + 1000,
+        stdin: interactive ? process.stdin : {
+          isTTY: false
+        },
+        now,
+        sleep,
+        onTick: (milliseconds, canCheck) => {
+          let seconds = Math.ceil(milliseconds / 1000);
+          let message = backoff ? `Rate limited. Next check in ${seconds}s` : `Next check in ${seconds}s`;
+          if (canCheck) message += ' — press Enter to check now';
+          if (interactive) output.updateSpinner(message);else output.hint(message);
+        }
+      });
+      remaining = deadline - now();
+      if (remaining <= 0) {
+        throw new Error(timeoutMessage);
+      }
+      lastCheckAt = now();
+      output.updateSpinner('Checking authorization...');
+      try {
+        pollResponse = await pollDeviceAuthorization(client, deviceCode, {
+          signal: AbortSignal.timeout(Math.ceil(Math.min(remaining, 30000)))
+        });
+      } catch (error) {
+        if (now() >= deadline) {
+          throw new Error(timeoutMessage);
+        }
+        if (error.code !== 'RATE_LIMIT_ERROR') throw error;
+        backoff = true;
+        let retryAfter = Number(error.context?.retryAfter);
+        if (Number.isFinite(retryAfter) && retryAfter > 0) {
+          pollDelay = Math.max(pollDelay, retryAfter * 1000);
+        }
+        continue;
+      }
+      backoff = false;
+      if (pollResponse.status !== 'pending') break;
+    }
     output.stopSpinner();
     let tokenData = resolveAuthorizedTokenData(pollResponse);
 
@@ -201,17 +148,8 @@ export async function loginCommand(options = {}, globalOptions = {}, deps = {})
       let orgItems = tokens.organizations.map(org => `${org.name}${org.slug ? ` (@${org.slug})` : ''}`);
       output.list(orgItems);
     }
-
-    // Show token expiry info
-    if (tokens.expiresAt) {
-      output.blank();
-      let expiryHint = getTokenExpiryHint(tokens.expiresAt, now());
-      if (expiryHint) {
-        output.hint(expiryHint);
-      }
-    }
     output.blank();
-    output.hint('Run "vizzly project link <org>/<project>" to enable cloud uploads');
+    output.hint('You can now browse cloud builds and download baselines');
     output.cleanup();
   } catch (error) {
     output.stopSpinner();
@@ -222,18 +160,14 @@ export async function loginCommand(options = {}, globalOptions = {}, deps = {})
       output.blank();
       output.hint('Please try logging in again');
       output.hint("If you don't have an account, sign up at https://vizzly.dev");
-      output.cleanup();
-      exit(1);
     } else if (error.code === 'RATE_LIMIT_ERROR') {
       output.error('Too many login attempts', error);
       output.blank();
       output.hint('Please wait a few minutes before trying again');
-      output.cleanup();
-      exit(1);
     } else {
       output.error('Login failed', error);
-      output.cleanup();
-      exit(1);
     }
+    output.cleanup();
+    process.exit(1);
   }
 }

package/dist/commands/project.js

@@ -1,9 +1,11 @@
 import { createApiClient as defaultCreateApiClient } from '../api/client.js';
 import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
 import { getApiUrl as defaultGetApiUrl } from '../utils/environment-config.js';
+import { preflightChanges } from '../utils/file-changes.js';
 import { getAccessToken as defaultGetAccessToken } from '../utils/global-config.js';
 import * as defaultOutput from '../utils/output.js';
-import { saveProjectLink as defaultSaveProjectLink } from '../utils/project-link-store.js';
+import { planProjectBinding as defaultPlanProjectBinding, writeProjectBinding as defaultWriteProjectBinding } from '../utils/project-binding.js';
+import { getProjectLink as defaultGetProjectLink, saveProjectLink as defaultSaveProjectLink } from '../utils/project-link-store.js';
 export function parseProjectSelector(selector, options = {}) {
   let organizationSlug = options.org || null;
   let projectSlug = options.project || null;
@@ -42,7 +44,10 @@ export async function projectLinkCommand(selector, options = {}, globalOptions =
     getApiUrl = defaultGetApiUrl,
     loadConfig = defaultLoadConfig,
     output = defaultOutput,
+    getProjectLink = defaultGetProjectLink,
+    planProjectBinding = defaultPlanProjectBinding,
     saveProjectLink = defaultSaveProjectLink,
+    writeProjectBinding = defaultWriteProjectBinding,
     exit = code => process.exit(code)
   } = deps;
   output.configure({
@@ -55,66 +60,145 @@ export async function projectLinkCommand(selector, options = {}, globalOptions =
     projectSlug
   } = parseProjectSelector(selector, options);
   try {
-    let config = await loadConfig(globalOptions.config, globalOptions);
-    let userToken = config.userToken || globalOptions.token || (await getAccessToken());
-    if (!userToken) {
+    let config;
+    let configError;
+    try {
+      config = await loadConfig(globalOptions.config, globalOptions);
+    } catch (error) {
+      configError = error;
+    }
+    let apiUrl = config?.apiUrl || getApiUrl();
+    let project = {
+      organizationSlug,
+      projectSlug
+    };
+    let binding = await planProjectBinding({
+      configPath: globalOptions.config || config?._configPath,
+      project,
+      apiUrl,
+      currentProject: config?.project,
+      currentApiUrl: config?._configApiUrl
+    });
+    if (binding.status === 'manual') {
+      let result = {
+        linked: false,
+        organizationSlug,
+        projectSlug,
+        binding: {
+          status: 'manual',
+          configPath: binding.configPath,
+          instructions: binding.instructions
+        }
+      };
+      if (globalOptions.json) output.data(result);else {
+        output.error('Project configuration needs an explicit edit');
+        output.hint(binding.instructions);
+      }
+      output.cleanup();
+      exit(2);
+      return result;
+    }
+    if (configError) throw configError;
+    if (binding.after !== null) {
+      await preflightChanges([{
+        path: binding.configPath,
+        before: binding.before,
+        after: binding.after
+      }]);
+    }
+    let linkedProject = !options.name && !options.expiresAt ? await getProjectLink({
+      apiUrl,
+      ...project
+    }) : null;
+    let reused = Boolean(linkedProject);
+    let userToken = linkedProject ? null : config.userToken || globalOptions.token || (await getAccessToken());
+    if (!linkedProject && !userToken) {
       output.error('Login required before linking a project');
       output.hint('Run "vizzly login" first, then try project link again');
       output.cleanup();
       exit(1);
-      return;
+      return {
+        linked: false,
+        reason: 'auth_required'
+      };
     }
-    output.startSpinner(`Linking ${organizationSlug}/${projectSlug}...`);
-    let apiUrl = config.apiUrl || getApiUrl();
-    let client = createApiClient({
-      baseUrl: apiUrl,
-      token: userToken,
-      command: 'project-link'
-    });
-    let response = await client.request(`/api/cli/${projectSlug}/link-token`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Organization': organizationSlug
-      },
-      body: JSON.stringify({
-        name: options.name,
-        expiresAt: options.expiresAt
-      })
-    });
-    let linkedProject = await saveProjectLink({
-      apiUrl,
-      organizationSlug: response.organization?.slug || organizationSlug,
-      organizationName: response.organization?.name,
-      projectSlug: response.project?.slug || projectSlug,
-      projectName: response.project?.name,
-      token: response.token.token,
-      tokenId: response.token.id,
-      tokenPrefix: response.token.token_prefix,
-      expiresAt: response.token.expires_at,
-      createdAt: response.token.created_at
-    });
+    if (!linkedProject) {
+      output.startSpinner(`Linking ${organizationSlug}/${projectSlug}...`);
+      let client = createApiClient({
+        baseUrl: apiUrl,
+        token: userToken,
+        command: 'project-link'
+      });
+      let response = await client.request(`/api/cli/${projectSlug}/link-token`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Organization': organizationSlug
+        },
+        body: JSON.stringify({
+          name: options.name,
+          expiresAt: options.expiresAt
+        })
+      });
+      linkedProject = await saveProjectLink({
+        apiUrl,
+        organizationSlug: response.organization?.slug || organizationSlug,
+        organizationName: response.organization?.name,
+        projectSlug: response.project?.slug || projectSlug,
+        projectName: response.project?.name,
+        token: response.token.token,
+        tokenId: response.token.id,
+        tokenPrefix: response.token.token_prefix,
+        expiresAt: response.token.expires_at,
+        createdAt: response.token.created_at
+      });
+    }
+    if (linkedProject.organizationSlug !== organizationSlug || linkedProject.projectSlug !== projectSlug) {
+      binding = await planProjectBinding({
+        configPath: binding.configPath,
+        project: {
+          organizationSlug: linkedProject.organizationSlug,
+          projectSlug: linkedProject.projectSlug
+        },
+        apiUrl,
+        currentProject: config?.project,
+        currentApiUrl: config?._configApiUrl
+      });
+      if (binding.status === 'manual') throw new Error(binding.instructions);
+    }
+    await writeProjectBinding(binding);
     output.stopSpinner();
+    let result = {
+      linked: true,
+      organizationSlug: linkedProject.organizationSlug,
+      projectSlug: linkedProject.projectSlug,
+      tokenPrefix: linkedProject.tokenPrefix,
+      storage: linkedProject.storage,
+      reused,
+      binding: {
+        status: 'bound',
+        configPath: binding.configPath
+      }
+    };
     if (globalOptions.json) {
-      output.data({
-        linked: true,
-        organizationSlug: linkedProject.organizationSlug,
-        projectSlug: linkedProject.projectSlug,
-        tokenPrefix: linkedProject.tokenPrefix,
-        storage: linkedProject.storage
-      });
+      output.data(result);
       output.cleanup();
-      return;
+      return result;
     }
     output.complete(`Linked ${linkedProject.organizationSlug}/${linkedProject.projectSlug}`);
-    output.hint(`Active project: ${linkedProject.organizationSlug}/${linkedProject.projectSlug}`);
+    output.hint(`Repository project: ${linkedProject.organizationSlug}/${linkedProject.projectSlug}`);
     output.hint(`Cloud uploads and project-scoped context will use ${linkedProject.tokenPrefix}...`);
     output.hint(`Credential storage: ${linkedProject.storage}`);
     output.cleanup();
+    return result;
   } catch (error) {
     output.stopSpinner();
     output.error('Failed to link project', error);
     output.cleanup();
     exit(1);
+    return {
+      linked: false,
+      reason: 'link_failed'
+    };
   }
 }

package/dist/commands/run.js

@@ -274,8 +274,8 @@ export async function runCommand(testCommand, options = {}, globalOptions = {},
       commitAuthorName: commitAuthor.name,
       commitAuthorEmail: commitAuthor.email,
       environment: config.build.environment,
-      threshold: config.comparison.threshold,
-      minClusterSize: config.comparison.minClusterSize,
+      threshold: config._comparisonOverrides?.threshold,
+      minClusterSize: config._comparisonOverrides?.minClusterSize,
       eager: config.eager || false,
       allowNoToken: config.allowNoToken || false,
       wait: config.wait || options.wait || false,