qualty 0.1.18 → 0.1.20

package/bin/local-runner.js

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync, mkdtempSync, existsSync } from "node:fs";
+import { mkdirSync, writeFileSync, mkdtempSync, existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { createInterface } from "node:readline/promises";
@@ -78,6 +78,161 @@ function localAuthStatePath({ orgId, projectId, profile }) {
   return join(homedir(), ".qualty", "local-contexts", orgSeg, projectSeg, `${profileSeg}.json`);
 }
 
+export function summarizeStorageStateFile(statePath) {
+  const path = String(statePath || "").trim();
+  if (!path || !existsSync(path)) {
+    return { exists: false, path };
+  }
+  const stat = statSync(path);
+  let parsed = null;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    return {
+      exists: true,
+      path,
+      bytes: stat.size,
+      parseError: String(err?.message || err),
+    };
+  }
+  const cookies = Array.isArray(parsed.cookies) ? parsed.cookies : [];
+  const origins = Array.isArray(parsed.origins) ? parsed.origins : [];
+  return {
+    exists: true,
+    path,
+    bytes: stat.size,
+    cookieCount: cookies.length,
+    cookieDomains: [...new Set(cookies.map((c) => c.domain || c.url || "?"))],
+    storageOrigins: origins.map((entry) => ({
+      origin: entry.origin || "?",
+      localStorageKeys: Array.isArray(entry.localStorage)
+        ? entry.localStorage.map((item) => String(item?.name || "").trim()).filter(Boolean)
+        : [],
+    })),
+  };
+}
+
+function hostFromUrl(rawUrl) {
+  try {
+    return new URL(String(rawUrl || "").trim()).host;
+  } catch {
+    return "";
+  }
+}
+
+export function logAuthStateDiagnostics(prefix, summary, details = {}) {
+  const tag = prefix || "[qualty][auth]";
+  const {
+    profile = "",
+    source = "",
+    claimProfileName = "",
+    claimLocalProfileName = "",
+    testUrl = "",
+    noAuthState = false,
+  } = details;
+
+  if (noAuthState) {
+    // eslint-disable-next-line no-console
+    console.log(`${tag} skipped (--no-auth-state)`);
+    return;
+  }
+
+  if (source) {
+    // eslint-disable-next-line no-console
+    console.log(`${tag} resolution: ${source}`);
+  }
+  if (profile) {
+    // eslint-disable-next-line no-console
+    console.log(`${tag} profile: "${profile}"`);
+  }
+  if (claimProfileName) {
+    // eslint-disable-next-line no-console
+    console.log(`${tag} dashboard saved login: "${claimProfileName}"`);
+  }
+  if (claimLocalProfileName && claimLocalProfileName !== profile) {
+    // eslint-disable-next-line no-console
+    console.log(`${tag} dashboard local_profile_name: "${claimLocalProfileName}"`);
+  }
+
+  if (!summary?.path) {
+    // eslint-disable-next-line no-console
+    console.log(`${tag} no auth state path resolved`);
+    return;
+  }
+
+  if (!summary.exists) {
+    // eslint-disable-next-line no-console
+    console.log(`${tag} auth state file missing: ${summary.path}`);
+    return;
+  }
+
+  if (summary.parseError) {
+    // eslint-disable-next-line no-console
+    console.log(
+      `${tag} auth state file is not valid JSON (${summary.bytes} bytes): ${summary.parseError}`
+    );
+    return;
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(`${tag} auth state file found (${summary.bytes} bytes): ${summary.path}`);
+  // eslint-disable-next-line no-console
+  console.log(
+    `${tag} contents: ${summary.cookieCount} cookie(s)` +
+      (summary.cookieDomains.length ? ` [${summary.cookieDomains.join(", ")}]` : "")
+  );
+  for (const originEntry of summary.storageOrigins || []) {
+    const keys = originEntry.localStorageKeys.length
+      ? originEntry.localStorageKeys.join(", ")
+      : "none";
+    // eslint-disable-next-line no-console
+    console.log(`${tag} origin ${originEntry.origin}: localStorage keys [${keys}]`);
+  }
+
+  if (testUrl) {
+    const testHost = hostFromUrl(testUrl);
+    const storageHosts = new Set(
+      (summary.storageOrigins || [])
+        .map((entry) => hostFromUrl(entry.origin))
+        .filter(Boolean)
+    );
+    for (const cookieDomain of summary.cookieDomains || []) {
+      if (cookieDomain && cookieDomain !== "?") storageHosts.add(String(cookieDomain).replace(/^\./, ""));
+    }
+    // eslint-disable-next-line no-console
+    console.log(`${tag} test URL: ${testUrl}`);
+    if (testHost && storageHosts.size > 0 && !storageHosts.has(testHost)) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `${tag} warning: test host "${testHost}" does not match saved auth origins/cookies (${[...storageHosts].join(", ")}). localStorage will not apply until origins match.`
+      );
+    }
+  }
+
+  const emptyStorage =
+    summary.cookieCount === 0 &&
+    (summary.storageOrigins || []).every((entry) => entry.localStorageKeys.length === 0);
+  if (emptyStorage) {
+    // eslint-disable-next-line no-console
+    console.warn(`${tag} warning: auth state file appears empty (no cookies or localStorage)`);
+  }
+}
+
+export async function logAuthStateAfterInjection(tag, context, { testUrl = "" } = {}) {
+  try {
+    const cookies = await context.cookies();
+    // eslint-disable-next-line no-console
+    console.log(`${tag} injected into browser context: ${cookies.length} cookie(s) loaded`);
+    if (testUrl) {
+      // eslint-disable-next-line no-console
+      console.log(`${tag} localStorage applies after navigation to a matching origin (${testUrl})`);
+    }
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.warn(`${tag} could not verify injected auth state: ${err?.message || err}`);
+  }
+}
+
 const localBindingSetupPromises = new Map();
 
 async function promptYesNo(question, defaultYes = true) {
@@ -1131,6 +1286,37 @@ export async function runLocalExecution({
         ? resolvedStoragePath
         : null;
 
+  let authSource = "none";
+  if (!noAuthState && finalStoragePath) {
+    if (setupFromClaim?.path && finalStoragePath === setupFromClaim.path) {
+      authSource = "interactive setup during run";
+    } else if (storageStatePath && finalStoragePath === storageStatePath) {
+      authSource = "--auth-profile flag";
+    } else if (resolvedStoragePath && finalStoragePath === resolvedStoragePath) {
+      authSource = claimProfile ? "dashboard saved login profile" : "resolved profile path";
+    } else {
+      authSource = "resolved profile path";
+    }
+  }
+
+  logAuthStateDiagnostics("[qualty][auth]", summarizeStorageStateFile(finalStoragePath), {
+    profile: effectiveProfile || "",
+    source: authSource,
+    claimProfileName: String(claimSavedLogin?.name || "").trim(),
+    claimLocalProfileName: claimProfile,
+    testUrl: url,
+    noAuthState: Boolean(noAuthState),
+  });
+
+  if (!noAuthState && effectiveProfile && !finalStoragePath) {
+    const candidates = [storageStatePath, resolvedStoragePath].filter(Boolean);
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[qualty][auth] profile "${effectiveProfile}" was requested but no auth state file exists` +
+        (candidates.length ? ` (checked: ${candidates.join(", ")})` : "")
+    );
+  }
+
   const browserServer = await chromium.launchServer({
     headless: headless !== false,
     host: "127.0.0.1",
@@ -1142,10 +1328,14 @@ export async function runLocalExecution({
   };
   if (finalStoragePath) {
     contextOptions.storageState = finalStoragePath;
-    const logProfile = effectiveProfile || "default";
-    console.log(`[qualty][auth] using saved context "${logProfile}": ${finalStoragePath}`);
   }
   const context = await browser.newContext(contextOptions);
+  if (finalStoragePath) {
+    await logAuthStateAfterInjection("[qualty][auth]", context, { testUrl: url });
+  } else if (!noAuthState && (effectiveProfile || claimSavedLogin?.name)) {
+    // eslint-disable-next-line no-console
+    console.log("[qualty][auth] running without saved login state injection");
+  }
   const page = await context.newPage();
   const networkCollector = attachNetworkCollector(page);
   const attachmentSpecs = Array.isArray(claim.file_attachments) ? claim.file_attachments : [];

package/bin/qualty.js

@@ -15,7 +15,7 @@ import { homedir, hostname } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import process from "node:process";
-import { rewriteUrlForLocalRun, runLocalCi } from "./local-runner.js";
+import { rewriteUrlForLocalRun, runLocalCi, summarizeStorageStateFile, logAuthStateDiagnostics } from "./local-runner.js";
 
 /** CLI backend URL is fixed by Qualty distribution. */
 const DEFAULT_QUALTY_API_URL = "https://qualty-api-production.up.railway.app";
@@ -1630,7 +1630,12 @@ function resolveLocalAuthStateForRun({ args, orgId, projectId }) {
   const profile = requestedProfile;
   if (!profile) return null;
   const path = localAuthStatePath({ orgId, projectId, profile });
-  if (!existsSync(path)) return null;
+  const summary = summarizeStorageStateFile(path);
+  logAuthStateDiagnostics("[qualty][auth]", summary, {
+    profile,
+    source: "pre-run --auth-profile check",
+  });
+  if (!summary.exists) return null;
   return { profile, path };
 }
 
@@ -1949,10 +1954,6 @@ async function main() {
         ...(authChoice.noAuthState ? { "no-auth-state": true } : {}),
       };
       const localAuth = resolveLocalAuthStateForRun({ args: localAuthArgs, orgId, projectId });
-      if (localAuth?.path) {
-        // eslint-disable-next-line no-console
-        console.log(`[qualty][auth] Reusing profile "${localAuth.profile}"`);
-      }
       const localRunArgs = {
         apiUrl,
         token,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualty",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Qualty CLI for localhost and CI test runs",
   "bin": {
     "qualty": "bin/qualty.js"