qualty 0.1.14 → 0.1.16

package/bin/local-runner.js

@@ -9,6 +9,36 @@ function safePathSegment(value, fallback) {
   return normalized || fallback;
 }
 
+/**
+ * Rewrite a dashboard/production test URL to localhost for local CLI runs.
+ * Keeps pathname, search, and hash; swaps origin to http://localhost:<port>.
+ */
+export function rewriteUrlForLocalRun(rawUrl, port) {
+  const portNum = Number(port);
+  if (!Number.isFinite(portNum) || portNum < 1 || portNum > 65535) {
+    return String(rawUrl || "").trim();
+  }
+  const trimmed = String(rawUrl || "").trim();
+  if (!trimmed) return trimmed;
+
+  let parsed;
+  try {
+    const withProtocol = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+    parsed = new URL(withProtocol);
+  } catch {
+    return trimmed;
+  }
+
+  const suffix = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  return `http://localhost:${portNum}${suffix}`;
+}
+
+function resolveLocalPort(rawPort, fallback = 3000) {
+  const portNum = Number(rawPort);
+  if (Number.isFinite(portNum) && portNum >= 1 && portNum <= 65535) return portNum;
+  return fallback;
+}
+
 function localAuthStatePath({ orgId, projectId, profile }) {
   const orgSeg = safePathSegment(orgId || "default-org", "default-org");
   const projectSeg = safePathSegment(projectId || "default-project", "default-project");
@@ -177,6 +207,7 @@ async function preflightMissingLocalBindings({
   savedJobs,
   explicitAuthProfile,
   noAuthState,
+  localPort = 3000,
 }) {
   if (noAuthState) return;
   if (explicitAuthProfile) return;
@@ -195,14 +226,16 @@ async function preflightMissingLocalBindings({
     const entry = missingByProfile.get(profileName) || {
       localProfileName: profileName,
       projectId: String(job?.project_id || projectId || "").trim(),
-      startUrl: String(job?.url || "").trim(),
+      startUrl: rewriteUrlForLocalRun(String(job?.url || "").trim(), localPort),
       tests: [],
     };
     entry.tests.push({
       id: String(job?.id || "").trim(),
       name: String(job?.name || job?.id || "Unnamed test").trim(),
     });
-    if (!entry.startUrl) entry.startUrl = String(job?.url || "").trim();
+    if (!entry.startUrl) {
+      entry.startUrl = rewriteUrlForLocalRun(String(job?.url || "").trim(), localPort);
+    }
     missingByProfile.set(profileName, entry);
   }
   if (missingByProfile.size === 0) return;
@@ -1016,7 +1049,14 @@ export async function runLocalExecution({
     body: { device },
   });
 
-  const url = claim.url;
+  const originalUrl = String(claim.url || "").trim();
+  const localPort = resolveLocalPort(claim.local_port);
+  const url = rewriteUrlForLocalRun(originalUrl, localPort);
+  if (url !== originalUrl) {
+    // eslint-disable-next-line no-console
+    console.log(`[qualty] Local URL rewrite: ${originalUrl} -> ${url}`);
+  }
+  claim.url = url;
   const viewport = claim.viewport || { width: 1440, height: 900 };
   const steps = Array.isArray(claim.steps) ? claim.steps : [];
   const totalSteps = claim.total_steps || steps.length;
@@ -1279,6 +1319,21 @@ export async function runLocalExecution({
   return { success: runSuccess, stepsJson, error: runError };
 }
 
+async function fetchProjectLocalPort({ apiRequest, apiUrl, token, orgId, projectId }) {
+  if (!projectId) return 3000;
+  try {
+    const project = await apiRequest({
+      apiUrl,
+      token,
+      orgId,
+      path: `/api/v1/projects/${encodeURIComponent(String(projectId))}`,
+    });
+    return resolveLocalPort(project?.localhost?.port);
+  } catch {
+    return 3000;
+  }
+}
+
 export async function runLocalCi({
   apiUrl,
   token,
@@ -1301,6 +1356,8 @@ export async function runLocalCi({
     throw new Error("No saved tests matched your selector.");
   }
 
+  const localPort = await fetchProjectLocalPort({ apiRequest, apiUrl, token, orgId, projectId });
+
   const startResp = await apiRequest({
     apiUrl,
     token,
@@ -1328,6 +1385,7 @@ export async function runLocalCi({
     savedJobs,
     explicitAuthProfile: String(authProfile || "").trim(),
     noAuthState: Boolean(noAuthState),
+    localPort,
   });
 
   const concurrency = Math.max(1, Number(localConcurrency) || 4);
@@ -1411,5 +1469,8 @@ export async function runLocalCi({
 
   // eslint-disable-next-line no-console
   console.log(`[qualty] Local summary: ${passed} passed, ${failed} failed.`);
-  if (failOnFailure && failed > 0) process.exit(1);
+  if (failOnFailure && failed > 0) {
+    throw new Error(`${failed} local run(s) failed`);
+  }
+  return { passed, failed, total: started.length };
 }

package/bin/qualty.js

@@ -6,10 +6,11 @@ import { homedir, hostname } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import process from "node:process";
-import { runLocalCi } from "./local-runner.js";
+import { rewriteUrlForLocalRun, runLocalCi } from "./local-runner.js";
 
 /** CLI backend URL is fixed by Qualty distribution. */
-const DEFAULT_QUALTY_API_URL = "https://qualty-api-development.up.railway.app";
+const DEFAULT_QUALTY_API_URL = "https://qualty-api-production.up.railway.app";
+
 
 const QUALTY_CONFIG_DIR = join(homedir(), ".config", "qualty");
 const QUALTY_CONFIG_PATH = join(QUALTY_CONFIG_DIR, "config.json");
@@ -979,6 +980,200 @@ async function resolveSavedJobs({ apiUrl, token, orgId, projectId, suiteId, expl
   });
 }
 
+async function resolveLocalSuitePlan({ apiUrl, token, orgId, suiteId }) {
+  const suite = await apiRequest({
+    apiUrl,
+    token,
+    orgId,
+    path: `/api/v1/test-suites/${encodeURIComponent(String(suiteId))}`,
+  });
+  const suiteJobIds = Array.isArray(suite?.job_ids)
+    ? suite.job_ids.map((id) => String(id || "").trim()).filter(Boolean)
+    : [];
+  const sequenceRefs = Array.isArray(suite?.sequences) ? suite.sequences : [];
+  const sequenceIds = sequenceRefs
+    .map((s) => String(s?.id || "").trim())
+    .filter(Boolean);
+  if (sequenceIds.length === 0) {
+    return { suiteName: String(suite?.name || "").trim() || "Suite", standaloneJobIds: suiteJobIds, sequences: [] };
+  }
+
+  const sequencePayloads = await Promise.all(
+    sequenceIds.map((sequenceId) =>
+      apiRequest({
+        apiUrl,
+        token,
+        orgId,
+        path: `/api/v1/test-sequences/${encodeURIComponent(sequenceId)}`,
+      }).catch(() => null)
+    )
+  );
+
+  const sequencePlans = [];
+  const sequenceJobIds = new Set();
+  for (const payload of sequencePayloads) {
+    if (!payload || !Array.isArray(payload.items)) continue;
+    const grouped = new Map();
+    for (const item of payload.items) {
+      const stage = Number(item?.stage);
+      const position = Number(item?.position);
+      const jobId = String(item?.job_id || "").trim();
+      if (!Number.isFinite(stage) || !jobId) continue;
+      if (!grouped.has(stage)) grouped.set(stage, []);
+      grouped.get(stage).push({
+        stage,
+        position: Number.isFinite(position) ? position : 9999,
+        jobId,
+        jobName: String(item?.job_name || jobId).trim(),
+      });
+      sequenceJobIds.add(jobId);
+    }
+    const stages = Array.from(grouped.entries())
+      .sort((a, b) => a[0] - b[0])
+      .map(([stage, entries]) => {
+        const sorted = entries.sort((a, b) => a.position - b.position);
+        const seen = new Set();
+        const jobs = [];
+        for (const row of sorted) {
+          if (seen.has(row.jobId)) continue;
+          seen.add(row.jobId);
+          jobs.push({ id: row.jobId, name: row.jobName });
+        }
+        return { stage, jobs };
+      })
+      .filter((s) => s.jobs.length > 0);
+
+    if (stages.length > 0) {
+      sequencePlans.push({
+        id: String(payload.id || "").trim(),
+        name: String(payload.name || "Sequence").trim(),
+        stopOnFailure: Boolean(payload.stop_on_failure),
+        stages,
+      });
+    }
+  }
+
+  const standaloneJobIds = suiteJobIds.filter((jobId) => !sequenceJobIds.has(jobId));
+  return {
+    suiteName: String(suite?.name || "").trim() || "Suite",
+    standaloneJobIds,
+    sequences: sequencePlans,
+  };
+}
+
+async function runLocalSuiteWithSequences({
+  apiUrl,
+  token,
+  orgId,
+  projectId,
+  suiteId,
+  resolveSavedJobs,
+  apiRequest,
+  failOnFailure,
+  device,
+  headless,
+  localConcurrency,
+  authProfile,
+  noAuthState,
+  storageStatePath,
+}) {
+  const plan = await resolveLocalSuitePlan({ apiUrl, token, orgId, suiteId });
+  if (!plan.sequences.length) {
+    return runLocalCi({
+      apiUrl,
+      token,
+      orgId,
+      projectId,
+      suiteId,
+      explicitIds: [],
+      resolveSavedJobs,
+      apiRequest,
+      failOnFailure,
+      device,
+      headless,
+      localConcurrency,
+      authProfile,
+      noAuthState,
+      storageStatePath,
+    });
+  }
+
+  let passed = 0;
+  let failed = 0;
+  let total = 0;
+  // eslint-disable-next-line no-console
+  console.log(`[qualty] Running suite "${plan.suiteName}" with ${plan.sequences.length} sequence(s) locally.`);
+
+  if (plan.standaloneJobIds.length > 0) {
+    // eslint-disable-next-line no-console
+    console.log(`[qualty] Running ${plan.standaloneJobIds.length} standalone test(s) in suite first.`);
+    const result = await runLocalCi({
+      apiUrl,
+      token,
+      orgId,
+      projectId,
+      suiteId: "",
+      explicitIds: plan.standaloneJobIds,
+      resolveSavedJobs,
+      apiRequest,
+      failOnFailure: false,
+      device,
+      headless,
+      localConcurrency,
+      authProfile,
+      noAuthState,
+      storageStatePath,
+    });
+    passed += result.passed;
+    failed += result.failed;
+    total += result.total;
+  }
+
+  for (const sequence of plan.sequences) {
+    // eslint-disable-next-line no-console
+    console.log(`[qualty] Sequence: ${sequence.name}`);
+    for (const stage of sequence.stages) {
+      const stageJobIds = stage.jobs.map((j) => j.id);
+      // eslint-disable-next-line no-console
+      console.log(
+        `[qualty]   Stage ${stage.stage}: ${stage.jobs.map((j) => j.name).join(", ")}`
+      );
+      const result = await runLocalCi({
+        apiUrl,
+        token,
+        orgId,
+        projectId,
+        suiteId: "",
+        explicitIds: stageJobIds,
+        resolveSavedJobs,
+        apiRequest,
+        failOnFailure: false,
+        device,
+        headless,
+        localConcurrency,
+        authProfile,
+        noAuthState,
+        storageStatePath,
+      });
+      passed += result.passed;
+      failed += result.failed;
+      total += result.total;
+      if (sequence.stopOnFailure && result.failed > 0) {
+        // eslint-disable-next-line no-console
+        console.log(`[qualty]   Stage failed; stopping remaining stages for sequence "${sequence.name}".`);
+        break;
+      }
+    }
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(`[qualty] Local suite summary: ${passed} passed, ${failed} failed.`);
+  if (failOnFailure && failed > 0) {
+    throw new Error(`${failed} local run(s) failed`);
+  }
+  return { passed, failed, total };
+}
+
 async function runResolve(args) {
   const config = readQualtyConfig();
   const apiUrl = resolveApiUrl(args, config);
@@ -1232,6 +1427,7 @@ async function runAuthSetup(args) {
       id: String(p?.id || "").trim(),
       name: String(p?.name || "").trim() || "Unnamed project",
       url: String(p?.url || "").trim(),
+      localPort: Number(p?.localhost?.port) || 3000,
     }))
     .filter((p) => p.id);
   if (projects.length === 0) {
@@ -1343,7 +1539,15 @@ async function runAuthSetup(args) {
     }
     const context = await browser.newContext();
     const page = await context.newPage();
-    const startUrl = project.url || "about:blank";
+    const rawStartUrl = project.url || "about:blank";
+    const startUrl =
+      rawStartUrl === "about:blank"
+        ? rawStartUrl
+        : rewriteUrlForLocalRun(rawStartUrl, project.localPort);
+    if (startUrl !== rawStartUrl) {
+      // eslint-disable-next-line no-console
+      console.log(`[qualty][auth] Local URL rewrite: ${rawStartUrl} -> ${startUrl}`);
+    }
     await page.goto(startUrl, { waitUntil: "domcontentloaded", timeout: 60000 }).catch(() => {});
     // eslint-disable-next-line no-console
     console.log(`[qualty][auth] Browser opened for project "${project.name}".`);
@@ -1428,6 +1632,10 @@ async function main() {
           token,
           orgId,
         })) || args["suite-id"];
+      const explicitIds = String(args.ids || "")
+        .split(",")
+        .map((id) => id.trim())
+        .filter(Boolean);
       const shouldPromptAuthProfile = parseBoolean(args["prompt-auth-profile"], false);
       const authChoice = shouldPromptAuthProfile
         ? await maybePromptAuthProfileForLocalRun({
@@ -1449,16 +1657,13 @@ async function main() {
         // eslint-disable-next-line no-console
         console.log(`[qualty][auth] Reusing profile "${localAuth.profile}"`);
       }
-      await runLocalCi({
+      const localRunArgs = {
         apiUrl,
         token,
         orgId,
         projectId,
         suiteId,
-        explicitIds: String(args.ids || "")
-          .split(",")
-          .map((id) => id.trim())
-          .filter(Boolean),
+        explicitIds,
         resolveSavedJobs,
         apiRequest,
         failOnFailure: parseBoolean(args["fail-on-failure"], true),
@@ -1468,7 +1673,12 @@ async function main() {
         authProfile: localAuth?.profile || authChoice.authProfile || "",
         noAuthState: Boolean(authChoice.noAuthState || parseBoolean(args["no-auth-state"], false)),
         storageStatePath: localAuth?.path,
-      });
+      };
+      if (suiteId && explicitIds.length === 0) {
+        await runLocalSuiteWithSequences(localRunArgs);
+      } else {
+        await runLocalCi(localRunArgs);
+      }
       return;
     }
     await runCi(args);

package/package.json

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