qualty 0.1.14 → 0.1.15

package/bin/local-runner.js

@@ -1411,5 +1411,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

@@ -9,7 +9,7 @@ import process from "node:process";
 import { 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 +979,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);
@@ -1428,6 +1622,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 +1647,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 +1663,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.15",
   "description": "Qualty CLI for localhost and CI test runs",
   "bin": {
     "qualty": "bin/qualty.js"