qualty 0.1.8 → 0.1.10

package/bin/local-runner.js

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync, mkdtempSync } from "node:fs";
+import { mkdirSync, writeFileSync, mkdtempSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -754,6 +754,7 @@ export async function runLocalExecution({
   executionId,
   device,
   headless,
+  storageStatePath,
 }) {
   const { chromium } = await import("playwright");
 
@@ -777,9 +778,14 @@ export async function runLocalExecution({
   });
   const cdpEndpoint = browserServer.wsEndpoint();
   const browser = await chromium.connect(cdpEndpoint);
-  const context = await browser.newContext({
+  const contextOptions = {
     viewport: { width: viewport.width || 1440, height: viewport.height || 900 },
-  });
+  };
+  if (storageStatePath && existsSync(storageStatePath)) {
+    contextOptions.storageState = storageStatePath;
+    console.log(`[qualty][auth] using saved context: ${storageStatePath}`);
+  }
+  const context = await browser.newContext(contextOptions);
   const page = await context.newPage();
   const networkCollector = attachNetworkCollector(page);
   const labelToPath = await downloadProjectAttachments({
@@ -985,6 +991,7 @@ export async function runLocalCi({
   device,
   headless,
   localConcurrency = 4,
+  storageStatePath,
 }) {
   const savedJobs = await resolveSavedJobs({ apiUrl, token, orgId, projectId, suiteId, explicitIds });
   if (!Array.isArray(savedJobs) || savedJobs.length === 0) {
@@ -1040,6 +1047,7 @@ export async function runLocalCi({
           executionId: id,
           device,
           headless,
+          storageStatePath,
         });
         if (result.success) {
           passed += 1;

package/bin/qualty.js

@@ -1,15 +1,108 @@
 #!/usr/bin/env node
 
-import { appendFileSync } from "node:fs";
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, 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) {
@@ -39,17 +132,18 @@ function usage() {
   console.log(
     [
       "Usage:",
-      "  qualty connect --project <project-id> [--port 3000] [--api https://your-api] [--token <bearer-token>] [--org <org-id>]",
-      "  qualty run --project <project-id> [--suite-id <suite-id>] [--ids <id1,id2>] [--local] [--api https://your-api] [--token <bearer-token>] [--org <org-id>]",
+      "  qualty setup [--token <bearer-token>] [--org <org-id>]",
+      "  qualty auth setup [--project <project-id>] [--profile <profile-name>] [--headed]",
+      "  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]",
+      "             [--local] [--device 1440x900] [--headed] [--local-concurrency 4] [--auth-profile <profile>] [--no-auth-state]",
       "",
       "  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)",
@@ -99,11 +193,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 orgId = args.org || process.env.QUALTY_ORG_ID;
+  const apiUrl = resolveApiUrl(args, config);
+  const token = resolveToken(args, config);
+  const orgId = resolveOrgId(args, config);
 
   if (!projectId || !token) {
     usage();
@@ -174,6 +269,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;
@@ -194,6 +446,38 @@ function resolveLocalConcurrency(args) {
   return n;
 }
 
+function safePathSegment(value, fallback = "default") {
+  const out = String(value || "")
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  return out || fallback;
+}
+
+function localAuthStatePath({ orgId, projectId, profile }) {
+  const orgSeg = safePathSegment(orgId || "default-org", "default-org");
+  const projectSeg = safePathSegment(projectId || "default-project", "default-project");
+  const profileSeg = safePathSegment(profile || "default", "default");
+  return join(QUALTY_SHARED_CREDS_DIR, "local-contexts", orgSeg, projectSeg, `${profileSeg}.json`);
+}
+
+function listLocalAuthProfiles({ orgId, projectId }) {
+  const orgSeg = safePathSegment(orgId || "default-org", "default-org");
+  const projectSeg = safePathSegment(projectId || "default-project", "default-project");
+  const dir = join(QUALTY_SHARED_CREDS_DIR, "local-contexts", orgSeg, projectSeg);
+  if (!existsSync(dir)) return [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isFile() && e.name.endsWith(".json"))
+      .map((e) => e.name.replace(/\.json$/i, ""))
+      .filter(Boolean)
+      .sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -519,9 +803,10 @@ function printQualtyViewLogsReport(executionId, status) {
 }
 
 async function runCi(args) {
-  const apiUrl = resolveApiUrl(args);
-  const token = args.token || process.env.QUALTY_API_TOKEN;
-  const orgId = args.org || process.env.QUALTY_ORG_ID;
+  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 || "")
@@ -671,9 +956,10 @@ async function resolveSavedJobs({ apiUrl, token, orgId, projectId, suiteId, expl
 }
 
 async function runResolve(args) {
-  const apiUrl = resolveApiUrl(args);
-  const token = args.token || process.env.QUALTY_API_TOKEN;
-  const orgId = args.org || process.env.QUALTY_ORG_ID;
+  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 || "")
@@ -713,6 +999,312 @@ 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();
+  }
+}
+
+function resolveLocalAuthStateForRun({ args, orgId, projectId }) {
+  if (parseBoolean(args["no-auth-state"], false)) return null;
+  const projectCfg = readProjectConfig();
+  const requestedProfile = String(args["auth-profile"] || "").trim();
+  const savedProjectId = String(projectCfg.local_auth_project_id || "").trim();
+  const savedProfile = String(projectCfg.local_auth_profile || "").trim();
+  const profile =
+    requestedProfile ||
+    (savedProjectId && String(projectId || "").trim() === savedProjectId ? savedProfile : "");
+  if (!profile) return null;
+  const path = localAuthStatePath({ orgId, projectId, profile });
+  if (!existsSync(path)) return null;
+  return { profile, path };
+}
+
+async function maybePromptAuthProfileForLocalRun({ args, orgId, projectId }) {
+  const requestedProfile = String(args["auth-profile"] || "").trim();
+  if (requestedProfile) return { authProfile: requestedProfile, noAuthState: false };
+  if (parseBoolean(args["no-auth-state"], false)) return { authProfile: "", noAuthState: true };
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return { authProfile: "", noAuthState: false };
+  if (!projectId) return { authProfile: "", noAuthState: false };
+
+  const profiles = listLocalAuthProfiles({ orgId, projectId });
+  if (profiles.length === 0) return { authProfile: "", noAuthState: false };
+
+  const projectCfg = readProjectConfig();
+  const defaultProfile = String(projectCfg.local_auth_profile || "").trim();
+  const defaultIndex = profiles.findIndex((p) => p === defaultProfile);
+
+  // eslint-disable-next-line no-console
+  console.log("[qualty][auth] Choose saved login state:");
+  // eslint-disable-next-line no-console
+  console.log("  0) Run without saved login state");
+  for (let i = 0; i < profiles.length; i += 1) {
+    const isDefault = defaultIndex === i ? " (default)" : "";
+    // eslint-disable-next-line no-console
+    console.log(`  ${i + 1}) ${profiles[i]}${isDefault}`);
+  }
+
+  const defaultChoice = defaultIndex >= 0 ? defaultIndex + 1 : 0;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    while (true) {
+      const raw = String(
+        await rl.question(`Select login state [0-${profiles.length}] (default ${defaultChoice}): `)
+      ).trim();
+      const picked = raw ? Number(raw) : defaultChoice;
+      if (!Number.isInteger(picked) || picked < 0 || picked > profiles.length) {
+        // eslint-disable-next-line no-console
+        console.log(`[qualty] Please enter a number from 0 to ${profiles.length}.`);
+        continue;
+      }
+      if (picked === 0) {
+        // eslint-disable-next-line no-console
+        console.log("[qualty][auth] Running without saved login state.");
+        return { authProfile: "", noAuthState: true };
+      }
+      const profile = profiles[picked - 1];
+      // eslint-disable-next-line no-console
+      console.log(`[qualty][auth] Selected profile "${profile}"`);
+      return { authProfile: profile, noAuthState: false };
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function runAuthSetup(args) {
+  const config = readQualtyConfig();
+  const apiUrl = resolveApiUrl(args, config);
+  const token = resolveToken(args, config);
+  const orgId = resolveOrgId(args, config);
+  if (!token) {
+    throw new Error("Missing auth token. Run `qualty setup` first.");
+  }
+  if (!orgId) {
+    throw new Error("Missing org. Run `qualty setup` first.");
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Interactive auth setup requires a TTY terminal.");
+  }
+
+  const projectsPayload = await apiRequest({
+    apiUrl,
+    token,
+    orgId,
+    path: "/api/v1/projects",
+  });
+  const projects = (Array.isArray(projectsPayload) ? projectsPayload : [])
+    .map((p) => ({
+      id: String(p?.id || "").trim(),
+      name: String(p?.name || "").trim() || "Unnamed project",
+      url: String(p?.url || "").trim(),
+    }))
+    .filter((p) => p.id);
+  if (projects.length === 0) {
+    throw new Error("No projects found. Create a project first.");
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  let project = null;
+  try {
+    const requestedProjectId = String(args.project || "").trim();
+    if (requestedProjectId) {
+      project = projects.find((p) => p.id === requestedProjectId) || null;
+      if (!project) {
+        throw new Error(`Project ${requestedProjectId} not found.`);
+      }
+    } else {
+      // eslint-disable-next-line no-console
+      console.log("[qualty] Choose project for saved local auth:");
+      for (let i = 0; i < projects.length; i += 1) {
+        // eslint-disable-next-line no-console
+        console.log(`  ${i + 1}) ${projects[i].name}`);
+      }
+      while (!project) {
+        const raw = String(await rl.question(`Select project [1-${projects.length}] (default 1): `)).trim();
+        const picked = raw ? Number(raw) : 1;
+        if (Number.isInteger(picked) && picked >= 1 && picked <= projects.length) {
+          project = projects[picked - 1];
+        } else {
+          // eslint-disable-next-line no-console
+          console.log(`[qualty] Please enter a number from 1 to ${projects.length}.`);
+        }
+      }
+    }
+
+    let profile = String(args.profile || "").trim();
+    if (!profile) {
+      const current = String(readProjectConfig().local_auth_profile || "default").trim() || "default";
+      profile = String(await rl.question(`Profile name [${current}]: `)).trim() || current;
+    }
+    const statePath = localAuthStatePath({
+      orgId,
+      projectId: project.id,
+      profile,
+    });
+    mkdirSync(join(statePath, ".."), { recursive: true });
+
+    const { chromium } = await import("playwright");
+    const headed = parseBoolean(args.headed, true);
+    let browser = null;
+    try {
+      browser = await chromium.launch({
+        headless: !headed,
+        channel: "chrome",
+        args: ["--disable-blink-features=AutomationControlled"],
+      });
+      // eslint-disable-next-line no-console
+      console.log("[qualty][auth] Using local Chrome channel for login setup.");
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.log(`[qualty][auth] Chrome channel unavailable, falling back to Playwright Chromium (${err?.message || err}).`);
+      browser = await chromium.launch({
+        headless: !headed,
+        args: ["--disable-blink-features=AutomationControlled"],
+      });
+    }
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    const startUrl = project.url || "about:blank";
+    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}".`);
+    // eslint-disable-next-line no-console
+    console.log("[qualty][auth] Complete login in the browser, then press Enter here to save context.");
+    await rl.question("Press Enter to save local auth context...");
+    await context.storageState({ path: statePath });
+    await context.close();
+    await browser.close();
+
+    writeProjectConfig({
+      local_auth_project_id: project.id,
+      local_auth_profile: profile,
+      default_org_id: orgId,
+    });
+    // eslint-disable-next-line no-console
+    console.log(`[qualty][auth] Saved local context profile "${profile}" for project "${project.name}".`);
+    // eslint-disable-next-line no-console
+    console.log(`[qualty][auth] Path: ${statePath}`);
+  } finally {
+    rl.close();
+  }
+}
+
 async function main() {
   const args = parseArgs(process.argv);
   const command = args._[0];
@@ -724,14 +1316,59 @@ async function main() {
     await runConnect(args);
     return;
   }
+  if (command === "setup") {
+    await runSetup(args);
+    return;
+  }
+  if (command === "auth") {
+    const sub = args._[1];
+    if (sub === "setup") {
+      await runAuthSetup(args);
+      return;
+    }
+    throw new Error("Unknown auth subcommand. Use: qualty auth setup");
+  }
   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"];
+      const authChoice = await maybePromptAuthProfileForLocalRun({
+        args,
+        orgId,
+        projectId,
+      });
+      const localAuthArgs = {
+        ...args,
+        ...(authChoice.authProfile ? { "auth-profile": authChoice.authProfile } : {}),
+        ...(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}"`);
+      }
       await runLocalCi({
-        apiUrl: resolveApiUrl(args),
-        token: args.token || process.env.QUALTY_API_TOKEN,
-        orgId: args.org || process.env.QUALTY_ORG_ID,
-        projectId: args.project,
-        suiteId: args["suite-id"],
+        apiUrl,
+        token,
+        orgId,
+        projectId,
+        suiteId,
         explicitIds: String(args.ids || "")
           .split(",")
           .map((id) => id.trim())
@@ -742,6 +1379,7 @@ async function main() {
         device: args.device || "1440x900",
         headless: !parseBoolean(args.headed, false),
         localConcurrency: resolveLocalConcurrency(args),
+        storageStatePath: localAuth?.path,
       });
       return;
     }
@@ -752,7 +1390,13 @@ async function main() {
     await runResolve(args);
     return;
   }
-  if (command !== "connect" && command !== "run" && command !== "resolve") {
+  if (
+    command !== "setup" &&
+    command !== "auth" &&
+    command !== "connect" &&
+    command !== "run" &&
+    command !== "resolve"
+  ) {
     throw new Error(`Unknown command: ${command}`);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualty",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Qualty CLI for localhost and CI test runs",
   "bin": {
     "qualty": "bin/qualty.js"
@@ -11,6 +11,7 @@
     "bin"
   ],
   "dependencies": {
-    "playwright": "1.60.0"
+    "playwright": "1.60.0",
+    "rrweb": "^2.0.0-alpha.4"
   }
 }