qualty 0.1.7 → 0.1.9

package/bin/qualty.js

@@ -1,14 +1,108 @@
 #!/usr/bin/env node
 
-import { appendFileSync } from "node:fs";
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { spawn } from "node:child_process";
+import { homedir } 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";
 
-/** When unset, CLI uses Qualty development API. Override for production: QUALTY_API_URL=https://qualty-api-production.up.railway.app or local: http://localhost:8000 */
+/** CLI backend URL is fixed by Qualty distribution. */
 const DEFAULT_QUALTY_API_URL = "https://qualty-api-development.up.railway.app";
+const QUALTY_CONFIG_DIR = join(homedir(), ".config", "qualty");
+const QUALTY_CONFIG_PATH = join(QUALTY_CONFIG_DIR, "config.json");
+const QUALTY_SHARED_CREDS_DIR = join(homedir(), ".qualty");
+const QUALTY_SHARED_CREDS_PATH = join(QUALTY_SHARED_CREDS_DIR, "credentials");
+const QUALTY_PROJECT_CONFIG_PATH = join(process.cwd(), ".qualty.json");
 
-function resolveApiUrl(args) {
-  return String(args.api || process.env.QUALTY_API_URL || DEFAULT_QUALTY_API_URL).replace(/\/$/, "");
+function readQualtyConfig() {
+  if (!existsSync(QUALTY_CONFIG_PATH)) return {};
+  try {
+    const raw = readFileSync(QUALTY_CONFIG_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+
+function writeQualtyConfig(config) {
+  mkdirSync(QUALTY_CONFIG_DIR, { recursive: true });
+  writeFileSync(QUALTY_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  try {
+    chmodSync(QUALTY_CONFIG_PATH, 0o600);
+  } catch {
+    // best effort on non-posix systems
+  }
+}
+
+function readSharedCredentials() {
+  if (!existsSync(QUALTY_SHARED_CREDS_PATH)) return {};
+  try {
+    const raw = readFileSync(QUALTY_SHARED_CREDS_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+
+function writeSharedCredentials(token) {
+  mkdirSync(QUALTY_SHARED_CREDS_DIR, { recursive: true });
+  writeFileSync(QUALTY_SHARED_CREDS_PATH, `${JSON.stringify({ api_token: token }, null, 2)}\n`, "utf8");
+  try {
+    chmodSync(QUALTY_SHARED_CREDS_PATH, 0o600);
+  } catch {
+    // best effort on non-posix systems
+  }
+}
+
+function readProjectConfig() {
+  if (!existsSync(QUALTY_PROJECT_CONFIG_PATH)) return {};
+  try {
+    const raw = readFileSync(QUALTY_PROJECT_CONFIG_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+
+function writeProjectConfig(updates) {
+  const current = readProjectConfig();
+  const next = { ...current };
+  for (const [k, v] of Object.entries(updates || {})) {
+    if (v === undefined || v === null || v === "") delete next[k];
+    else next[k] = v;
+  }
+  writeFileSync(QUALTY_PROJECT_CONFIG_PATH, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}
+
+function resolveApiUrl(args, config = {}) {
+  void args;
+  void config;
+  return String(DEFAULT_QUALTY_API_URL).replace(/\/$/, "");
+}
+
+function resolveToken(args, config = {}) {
+  const creds = readSharedCredentials();
+  return args.token || process.env.QUALTY_API_TOKEN || creds.api_token || config.api_token || "";
+}
+
+function resolveOrgId(args, config = {}) {
+  const projectCfg = readProjectConfig();
+  return args.org || process.env.QUALTY_ORG_ID || config.org_id || projectCfg.default_org_id || "";
+}
+
+function maskSecret(secret) {
+  const s = String(secret || "");
+  if (!s) return "(empty)";
+  if (s.length <= 8) return `${"*".repeat(Math.max(0, s.length - 2))}${s.slice(-2)}`;
+  return `${s.slice(0, 4)}...${s.slice(-4)}`;
 }
 
 function parseArgs(argv) {
@@ -38,27 +132,32 @@ function usage() {
   console.log(
     [
       "Usage:",
-      "  qualty connect --project <project-id> [--port 3000] [--api https://your-api] [--token <bearer-token>]",
-      "  qualty run --project <project-id> [--suite-id <suite-id>] [--ids <id1,id2>] [--api https://your-api] [--token <bearer-token>]",
+      "  qualty setup [--token <bearer-token>] [--org <org-id>]",
+      "  qualty connect --project <project-id> [--port 3000] [--token <bearer-token>] [--org <org-id>]",
+      "  qualty run --project <project-id> [--suite-id <suite-id>] [--ids <id1,id2>] [--local] [--token <bearer-token>] [--org <org-id>]",
       "             [--poll-interval 5] [--timeout 30] [--fail-on-failure true] [--no-view-logs]",
+      "             [--local] [--device 1440x900] [--headed] [--local-concurrency 4]",
       "",
       "  After each run, logs include step results, explanation, and final evaluator output (dashboard \"View logs\" data).",
       "  Pass --no-view-logs for a short log only (e.g. very large evaluator text).",
-      "  qualty resolve --project <project-id> [--suite-id <suite-id>] [--ids <id1,id2>] [--json] [--api https://your-api] [--token <bearer-token>]",
+      "  qualty resolve --project <project-id> [--suite-id <suite-id>] [--ids <id1,id2>] [--json] [--token <bearer-token>]",
       "",
       "Env vars:",
-      `  QUALTY_API_URL    Backend API URL (default: ${DEFAULT_QUALTY_API_URL}; set for local/self-hosted)`,
       "  QUALTY_API_TOKEN  Bearer token used for auth",
+      "  QUALTY_ORG_ID     Org context for scoped API requests",
+      "  QUALTY_LOCAL_CONCURRENCY  Local parallel workers for --local runs (default: 4)",
     ].join("\n")
   );
 }
 
-async function apiRequest({ apiUrl, token, path, method = "GET", body }) {
+async function apiRequest({ apiUrl, token, orgId, path, method = "GET", body }) {
+  const normalizedOrgId = String(orgId || "").trim();
   const response = await fetch(`${apiUrl}${path}`, {
     method,
     headers: {
       "Content-Type": "application/json",
       Authorization: `Bearer ${token}`,
+      ...(normalizedOrgId ? { "X-Qualty-Org-Id": normalizedOrgId } : {}),
     },
     body: body ? JSON.stringify(body) : undefined,
   });
@@ -93,10 +192,12 @@ function startCloudflared(token, port) {
 }
 
 async function runConnect(args) {
+  const config = readQualtyConfig();
   const projectId = args.project;
   const port = Number(args.port || 3000);
-  const apiUrl = resolveApiUrl(args);
-  const token = args.token || process.env.QUALTY_API_TOKEN;
+  const apiUrl = resolveApiUrl(args, config);
+  const token = resolveToken(args, config);
+  const orgId = resolveOrgId(args, config);
 
   if (!projectId || !token) {
     usage();
@@ -109,6 +210,7 @@ async function runConnect(args) {
   const connect = await apiRequest({
     apiUrl,
     token,
+    orgId,
     path: "/api/v1/localhost/connect",
     method: "POST",
     body: { project_id: projectId, port },
@@ -129,6 +231,7 @@ async function runConnect(args) {
       await apiRequest({
         apiUrl,
         token,
+        orgId,
         path: "/api/v1/localhost/heartbeat",
         method: "POST",
         body: { project_id: projectId },
@@ -145,6 +248,7 @@ async function runConnect(args) {
       await apiRequest({
         apiUrl,
         token,
+        orgId,
         path: "/api/v1/localhost/disconnect",
         method: "POST",
         body: { project_id: projectId },
@@ -164,6 +268,163 @@ async function runConnect(args) {
   process.on("SIGTERM", shutdown);
 }
 
+async function runSetup(args) {
+  const existing = readQualtyConfig();
+  const sharedCreds = readSharedCredentials();
+  const projectCfg = readProjectConfig();
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const hasStdin = process.stdin.isTTY;
+  const ask = async (prompt, fallback = "") => {
+    if (!hasStdin) return fallback;
+    const answer = await rl.question(prompt);
+    const v = String(answer || "").trim();
+    return v || fallback;
+  };
+  const askYesNo = async (prompt, defaultValue = false) => {
+    if (!hasStdin) return defaultValue;
+    const answer = String(await rl.question(prompt)).trim();
+    if (!answer) return defaultValue;
+    const raw = answer.toLowerCase();
+    if (["y", "yes"].includes(raw)) return true;
+    if (["n", "no"].includes(raw)) return false;
+    return defaultValue;
+  };
+  const askChoice = async (prompt, min, max, defaultValue) => {
+    if (!hasStdin) return defaultValue;
+    while (true) {
+      const answer = String(await rl.question(prompt)).trim();
+      if (!answer) return defaultValue;
+      const n = Number(answer);
+      if (Number.isInteger(n) && n >= min && n <= max) return n;
+      // eslint-disable-next-line no-console
+      console.log(`[qualty] Please enter a number from ${min} to ${max}.`);
+    }
+  };
+
+  try {
+    const currentOrgId = String(args.org || existing.org_id || projectCfg.default_org_id || "");
+    const currentToken = String(args.token || process.env.QUALTY_API_TOKEN || sharedCreds.api_token || existing.api_token || "");
+
+    let token = "";
+    if (args.token) {
+      token = String(args.token).trim();
+    } else if (currentToken) {
+      const updateToken = await askYesNo(`API token already set (${maskSecret(currentToken)}). Update it? [y/N]: `, false);
+      if (updateToken) {
+        token = String(await ask("New Qualty API token [required]: ", "")).trim();
+      } else {
+        token = currentToken;
+      }
+    } else {
+      token = String(await ask("Qualty API token [required]: ", "")).trim();
+    }
+
+    if (!token) {
+      throw new Error("API token is required. Re-run setup and provide QUALTY_API_TOKEN.");
+    }
+
+    let organizations = [];
+    let currentOrgName = "";
+    try {
+      const orgResp = await apiRequest({
+        apiUrl: resolveApiUrl({}, {}),
+        token,
+        orgId: "",
+        path: "/api/v1/orgs",
+      });
+      organizations = Array.isArray(orgResp?.organizations) ? orgResp.organizations : [];
+      const byId = new Map(
+        organizations
+          .filter((o) => o && typeof o === "object")
+          .map((o) => [String(o.id || ""), String(o.name || "").trim()])
+      );
+      currentOrgName = byId.get(currentOrgId) || "";
+    } catch {
+      organizations = [];
+    }
+
+    let orgId = "";
+    let orgName = "";
+    if (args.org) {
+      orgId = String(args.org).trim();
+      orgName = currentOrgName || "selected organization";
+    } else if (organizations.length > 0) {
+      const orgRows = organizations
+        .map((o) => ({
+          id: String(o?.id || ""),
+          name: String(o?.name || "").trim() || "Unnamed org",
+        }))
+        .filter((o) => o.id);
+      const currentIndex = orgRows.findIndex((o) => o.id === currentOrgId);
+      if (currentIndex >= 0) {
+        const updateOrg = await askYesNo(
+          `Organization already set (${orgRows[currentIndex].name}). Update it? [y/N]: `,
+          false
+        );
+        if (!updateOrg) {
+          orgId = orgRows[currentIndex].id;
+          orgName = orgRows[currentIndex].name;
+        }
+      }
+      if (!orgId) {
+        // eslint-disable-next-line no-console
+        console.log("[qualty] Choose organization:");
+        for (let i = 0; i < orgRows.length; i += 1) {
+          // eslint-disable-next-line no-console
+          console.log(`  ${i + 1}) ${orgRows[i].name}`);
+        }
+        const defaultChoice = currentIndex >= 0 ? currentIndex + 1 : 1;
+        const picked = await askChoice(
+          `Select org [1-${orgRows.length}] (default ${defaultChoice}): `,
+          1,
+          orgRows.length,
+          defaultChoice
+        );
+        orgId = orgRows[picked - 1].id;
+        orgName = orgRows[picked - 1].name;
+      }
+    } else if (currentOrgId) {
+      const updateOrg = await askYesNo("Organization already set. Update it? [y/N]: ", false);
+      if (!updateOrg) {
+        orgId = currentOrgId;
+        orgName = "saved organization";
+      } else {
+        orgId = String(await ask("New Qualty Org ID [required]: ", "")).trim();
+      }
+    } else {
+      orgId = String(await ask("Qualty Org ID [required]: ", "")).trim();
+    }
+
+    if (!orgId) {
+      throw new Error("Org ID is required. Re-run setup and provide QUALTY_ORG_ID.");
+    }
+
+    const next = {
+      org_id: orgId,
+    };
+    // Keep token in the same place MCP uses.
+    writeSharedCredentials(token);
+    writeQualtyConfig(next);
+    // Keep org in MCP-compatible per-project config too.
+    writeProjectConfig({ default_org_id: orgId });
+    // eslint-disable-next-line no-console
+    console.log(`[qualty] Saved config to ${QUALTY_CONFIG_PATH}`);
+    // eslint-disable-next-line no-console
+    console.log(`[qualty] Saved shared token to ${QUALTY_SHARED_CREDS_PATH} (used by MCP)`);
+    // eslint-disable-next-line no-console
+    console.log(`[qualty] Saved project org to ${QUALTY_PROJECT_CONFIG_PATH} (MCP-compatible)`);
+    // eslint-disable-next-line no-console
+    console.log(`[qualty] Org: ${orgName || "configured"}`);
+    // eslint-disable-next-line no-console
+    console.log(`[qualty] Token: ${maskSecret(token)}`);
+  } finally {
+    rl.close();
+  }
+}
+
 function parseBoolean(value, defaultValue) {
   if (value === undefined) return defaultValue;
   if (typeof value === "boolean") return value;
@@ -173,6 +434,17 @@ function parseBoolean(value, defaultValue) {
   throw new Error(`Invalid boolean value: ${value}`);
 }
 
+function resolveLocalConcurrency(args) {
+  const raw = args["local-concurrency"] ?? process.env.QUALTY_LOCAL_CONCURRENCY ?? 4;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(
+      `Invalid local concurrency: ${raw}. Use --local-concurrency <integer>=1 or QUALTY_LOCAL_CONCURRENCY>=1`
+    );
+  }
+  return n;
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -498,8 +770,10 @@ function printQualtyViewLogsReport(executionId, status) {
 }
 
 async function runCi(args) {
-  const apiUrl = resolveApiUrl(args);
-  const token = args.token || process.env.QUALTY_API_TOKEN;
+  const config = readQualtyConfig();
+  const apiUrl = resolveApiUrl(args, config);
+  const token = resolveToken(args, config);
+  const orgId = resolveOrgId(args, config);
   const projectId = args.project;
   const suiteId = args["suite-id"];
   const explicitIds = String(args.ids || "")
@@ -524,7 +798,7 @@ async function runCi(args) {
     throw new Error("Invalid --timeout. Must be > 0.");
   }
 
-  const savedJobs = await resolveSavedJobs({ apiUrl, token, projectId, suiteId, explicitIds });
+  const savedJobs = await resolveSavedJobs({ apiUrl, token, orgId, projectId, suiteId, explicitIds });
   if (!Array.isArray(savedJobs) || savedJobs.length === 0) {
     throw new Error(
       "No saved tests matched your selector. The test ID may be invalid, deleted, or outside your token authorization scope."
@@ -546,6 +820,7 @@ async function runCi(args) {
   const startResp = await apiRequest({
     apiUrl,
     token,
+    orgId,
     path: "/api/v1/ci/run",
     method: "POST",
     body: startPayload,
@@ -568,6 +843,7 @@ async function runCi(args) {
     const batch = await apiRequest({
       apiUrl,
       token,
+      orgId,
       path: "/api/v1/status/batch",
       method: "POST",
       body: { job_ids: executionJobIds },
@@ -633,7 +909,7 @@ async function runCi(args) {
   }
 }
 
-async function resolveSavedJobs({ apiUrl, token, projectId, suiteId, explicitIds }) {
+async function resolveSavedJobs({ apiUrl, token, orgId, projectId, suiteId, explicitIds }) {
   const query = new URLSearchParams();
   if (projectId) query.set("project_id", String(projectId));
   if (suiteId) query.set("suite_id", String(suiteId));
@@ -641,13 +917,16 @@ async function resolveSavedJobs({ apiUrl, token, projectId, suiteId, explicitIds
   return apiRequest({
     apiUrl,
     token,
+    orgId,
     path: `/api/v1/saved-jobs?${query.toString()}`,
   });
 }
 
 async function runResolve(args) {
-  const apiUrl = resolveApiUrl(args);
-  const token = args.token || process.env.QUALTY_API_TOKEN;
+  const config = readQualtyConfig();
+  const apiUrl = resolveApiUrl(args, config);
+  const token = resolveToken(args, config);
+  const orgId = resolveOrgId(args, config);
   const projectId = args.project;
   const suiteId = args["suite-id"];
   const explicitIds = String(args.ids || "")
@@ -663,7 +942,7 @@ async function runResolve(args) {
     throw new Error("Provide --project, --suite-id, or --ids to select tests.");
   }
 
-  const savedJobs = await resolveSavedJobs({ apiUrl, token, projectId, suiteId, explicitIds });
+  const savedJobs = await resolveSavedJobs({ apiUrl, token, orgId, projectId, suiteId, explicitIds });
   if (!Array.isArray(savedJobs) || savedJobs.length === 0) {
     throw new Error(
       "No saved tests matched your selector. The test ID may be invalid, deleted, or outside your token authorization scope."
@@ -687,6 +966,127 @@ async function runResolve(args) {
   }
 }
 
+async function maybePromptSuiteIdForLocalRun({ args, apiUrl, token, orgId }) {
+  const existingSuiteId = String(args["suite-id"] || "").trim();
+  const explicitIds = String(args.ids || "")
+    .split(",")
+    .map((id) => id.trim())
+    .filter(Boolean);
+  if (existingSuiteId || explicitIds.length > 0) {
+    return existingSuiteId || "";
+  }
+
+  const projectId = String(args.project || "").trim();
+  if (!projectId) {
+    return "";
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return "";
+  }
+
+  const suites = await apiRequest({
+    apiUrl,
+    token,
+    orgId,
+    path: `/api/v1/test-suites?project_id=${encodeURIComponent(projectId)}`,
+  });
+  const rows = (Array.isArray(suites) ? suites : [])
+    .map((s) => ({
+      id: String(s?.id || "").trim(),
+      name: String(s?.name || "").trim() || "Unnamed suite",
+      jobCount: Number(Array.isArray(s?.job_ids) ? s.job_ids.length : 0),
+      sequenceCount: Number(Array.isArray(s?.sequence_ids) ? s.sequence_ids.length : 0),
+    }))
+    .filter((s) => s.id);
+
+  if (rows.length === 0) {
+    throw new Error(
+      "No test suites found for this project. Create a suite first in dashboard, or pass --ids explicitly."
+    );
+  }
+
+  // eslint-disable-next-line no-console
+  console.log("[qualty] No --suite-id or --ids provided. Choose a suite:");
+  for (let i = 0; i < rows.length; i += 1) {
+    const s = rows[i];
+    const details = `${s.jobCount} test(s)${
+      s.sequenceCount > 0 ? `, ${s.sequenceCount} sequence(s)` : ""
+    }`;
+    // eslint-disable-next-line no-console
+    console.log(`  ${i + 1}) ${s.name} (${details})`);
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    while (true) {
+      const raw = String(
+        await rl.question(`Select suite [1-${rows.length}] (default 1): `)
+      ).trim();
+      const picked = raw ? Number(raw) : 1;
+      if (Number.isInteger(picked) && picked >= 1 && picked <= rows.length) {
+        const suite = rows[picked - 1];
+        // eslint-disable-next-line no-console
+        console.log(`[qualty] Selected suite: ${suite.name}`);
+        return suite.id;
+      }
+      // eslint-disable-next-line no-console
+      console.log(`[qualty] Please enter a number from 1 to ${rows.length}.`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function maybePromptProjectIdForLocalRun({ args, apiUrl, token, orgId }) {
+  const existingProjectId = String(args.project || "").trim();
+  if (existingProjectId) return existingProjectId;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return existingProjectId;
+
+  const projectsPayload = await apiRequest({
+    apiUrl,
+    token,
+    orgId,
+    path: "/api/v1/projects",
+  });
+  const rows = (Array.isArray(projectsPayload) ? projectsPayload : [])
+    .map((p) => ({
+      id: String(p?.id || "").trim(),
+      name: String(p?.name || "").trim() || "Unnamed project",
+    }))
+    .filter((p) => p.id);
+
+  if (rows.length === 0) {
+    throw new Error("No projects found for this account/org. Create a project first.");
+  }
+
+  // eslint-disable-next-line no-console
+  console.log("[qualty] No --project provided. Choose a project:");
+  for (let i = 0; i < rows.length; i += 1) {
+    // eslint-disable-next-line no-console
+    console.log(`  ${i + 1}) ${rows[i].name}`);
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    while (true) {
+      const raw = String(
+        await rl.question(`Select project [1-${rows.length}] (default 1): `)
+      ).trim();
+      const picked = raw ? Number(raw) : 1;
+      if (Number.isInteger(picked) && picked >= 1 && picked <= rows.length) {
+        const project = rows[picked - 1];
+        // eslint-disable-next-line no-console
+        console.log(`[qualty] Selected project: ${project.name}`);
+        return project.id;
+      }
+      // eslint-disable-next-line no-console
+      console.log(`[qualty] Please enter a number from 1 to ${rows.length}.`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
 async function main() {
   const args = parseArgs(process.argv);
   const command = args._[0];
@@ -698,7 +1098,49 @@ async function main() {
     await runConnect(args);
     return;
   }
+  if (command === "setup") {
+    await runSetup(args);
+    return;
+  }
   if (command === "run") {
+    const config = readQualtyConfig();
+    if (parseBoolean(args.local, false)) {
+      const apiUrl = resolveApiUrl(args, config);
+      const token = resolveToken(args, config);
+      const orgId = resolveOrgId(args, config);
+      const projectId =
+        (await maybePromptProjectIdForLocalRun({
+          args,
+          apiUrl,
+          token,
+          orgId,
+        })) || args.project;
+      const suiteId =
+        (await maybePromptSuiteIdForLocalRun({
+          args: { ...args, project: projectId },
+          apiUrl,
+          token,
+          orgId,
+        })) || args["suite-id"];
+      await runLocalCi({
+        apiUrl,
+        token,
+        orgId,
+        projectId,
+        suiteId,
+        explicitIds: String(args.ids || "")
+          .split(",")
+          .map((id) => id.trim())
+          .filter(Boolean),
+        resolveSavedJobs,
+        apiRequest,
+        failOnFailure: parseBoolean(args["fail-on-failure"], true),
+        device: args.device || "1440x900",
+        headless: !parseBoolean(args.headed, false),
+        localConcurrency: resolveLocalConcurrency(args),
+      });
+      return;
+    }
     await runCi(args);
     return;
   }
@@ -706,7 +1148,7 @@ async function main() {
     await runResolve(args);
     return;
   }
-  if (command !== "connect" && command !== "run" && command !== "resolve") {
+  if (command !== "setup" && command !== "connect" && command !== "run" && command !== "resolve") {
     throw new Error(`Unknown command: ${command}`);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualty",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Qualty CLI for localhost and CI test runs",
   "bin": {
     "qualty": "bin/qualty.js"
@@ -9,5 +9,9 @@
   "license": "UNLICENSED",
   "files": [
     "bin"
-  ]
+  ],
+  "dependencies": {
+    "playwright": "1.60.0",
+    "rrweb": "^2.0.0-alpha.4"
+  }
 }