qualty 0.1.0

package/bin/qualty.js

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import process from "node:process";
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 2; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token.startsWith("--")) {
+      const [k, v] = token.split("=");
+      const key = k.slice(2);
+      if (v !== undefined) {
+        args[key] = v;
+      } else if (argv[i + 1] && !argv[i + 1].startsWith("--")) {
+        args[key] = argv[i + 1];
+        i += 1;
+      } else {
+        args[key] = true;
+      }
+    } else {
+      args._.push(token);
+    }
+  }
+  return args;
+}
+
+function usage() {
+  // eslint-disable-next-line no-console
+  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>]",
+      "             [--poll-interval 5] [--timeout 30] [--fail-on-failure true]",
+      "  qualty resolve --project <project-id> [--suite-id <suite-id>] [--ids <id1,id2>] [--json] [--api https://your-api] [--token <bearer-token>]",
+      "",
+      "Env vars:",
+      "  QUALTY_API_URL    Backend API URL (default: http://localhost:8000)",
+      "  QUALTY_API_TOKEN  Bearer token used for auth",
+    ].join("\n")
+  );
+}
+
+async function apiRequest({ apiUrl, token, path, method = "GET", body }) {
+  const response = await fetch(`${apiUrl}${path}`, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const detail = data.detail || data.error || `HTTP ${response.status}`;
+    throw new Error(detail);
+  }
+  return data;
+}
+
+function startCloudflared(token, port) {
+  const baseArgs = [
+    "tunnel",
+    "--no-autoupdate",
+    "--protocol",
+    "http2",
+    "--url",
+    `http://localhost:${port}`,
+    "run",
+    "--token",
+    token,
+  ];
+  const cmd = spawn("cloudflared", baseArgs, { stdio: "inherit" });
+  cmd.on("error", () => {
+    // Fallback for machines without global cloudflared.
+    spawn("npx", ["cloudflared", ...baseArgs], { stdio: "inherit" });
+  });
+  return cmd;
+}
+
+async function runConnect(args) {
+  const projectId = args.project;
+  const port = Number(args.port || 3000);
+  const apiUrl = (args.api || process.env.QUALTY_API_URL || "http://localhost:8000").replace(/\/$/, "");
+  const token = args.token || process.env.QUALTY_API_TOKEN;
+
+  if (!projectId || !token) {
+    usage();
+    process.exit(1);
+  }
+  if (!Number.isFinite(port) || port < 1 || port > 65535) {
+    throw new Error("Invalid --port. Must be between 1 and 65535.");
+  }
+
+  const connect = await apiRequest({
+    apiUrl,
+    token,
+    path: "/api/v1/localhost/connect",
+    method: "POST",
+    body: { project_id: projectId, port },
+  });
+
+  const hostUrl = connect.localhost?.url;
+  // eslint-disable-next-line no-console
+  console.log(`Connected ✅ ${hostUrl} -> http://localhost:${port}`);
+
+  const cloudflaredToken = connect.tunnel?.token;
+  if (!cloudflaredToken) {
+    throw new Error("Backend did not return a cloudflared token.");
+  }
+  const cloudflared = startCloudflared(cloudflaredToken, port);
+
+  const hb = setInterval(async () => {
+    try {
+      await apiRequest({
+        apiUrl,
+        token,
+        path: "/api/v1/localhost/heartbeat",
+        method: "POST",
+        body: { project_id: projectId },
+      });
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error(`[heartbeat] ${(err && err.message) || err}`);
+    }
+  }, 15000);
+
+  const shutdown = async () => {
+    clearInterval(hb);
+    try {
+      await apiRequest({
+        apiUrl,
+        token,
+        path: "/api/v1/localhost/disconnect",
+        method: "POST",
+        body: { project_id: projectId },
+      });
+    } catch {
+      // best effort
+    }
+    try {
+      cloudflared.kill("SIGTERM");
+    } catch {
+      // ignore
+    }
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+function parseBoolean(value, defaultValue) {
+  if (value === undefined) return defaultValue;
+  if (typeof value === "boolean") return value;
+  const raw = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "y", "on"].includes(raw)) return true;
+  if (["0", "false", "no", "n", "off"].includes(raw)) return false;
+  throw new Error(`Invalid boolean value: ${value}`);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function runCi(args) {
+  const apiUrl = (args.api || process.env.QUALTY_API_URL || "http://localhost:8000").replace(/\/$/, "");
+  const token = args.token || process.env.QUALTY_API_TOKEN;
+  const projectId = args.project;
+  const suiteId = args["suite-id"];
+  const explicitIds = String(args.ids || "")
+    .split(",")
+    .map((id) => id.trim())
+    .filter(Boolean);
+  const pollIntervalSec = Number(args["poll-interval"] || 5);
+  const timeoutMin = Number(args.timeout || 30);
+  const failOnFailure = parseBoolean(args["fail-on-failure"], true);
+
+  if (!token) {
+    throw new Error("Missing auth token. Pass --token or set QUALTY_API_TOKEN.");
+  }
+  if (!projectId && !suiteId && explicitIds.length === 0) {
+    throw new Error("Provide --project, --suite-id, or --ids to select tests.");
+  }
+  if (!Number.isFinite(pollIntervalSec) || pollIntervalSec <= 0) {
+    throw new Error("Invalid --poll-interval. Must be > 0.");
+  }
+  if (!Number.isFinite(timeoutMin) || timeoutMin <= 0) {
+    throw new Error("Invalid --timeout. Must be > 0.");
+  }
+
+  const savedJobs = await resolveSavedJobs({ apiUrl, token, 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."
+    );
+  }
+  // eslint-disable-next-line no-console
+  console.log(`[qualty] Selected ${savedJobs.length} saved test(s).`);
+  for (const job of savedJobs) {
+    // eslint-disable-next-line no-console
+    console.log(`  - ${job.id} :: ${job.name}`);
+  }
+
+  const startPayload = {
+    project_id: projectId ? String(projectId) : undefined,
+    suite_id: suiteId ? String(suiteId) : undefined,
+    job_ids: explicitIds.length > 0 ? explicitIds : savedJobs.map((job) => job.id),
+  };
+
+  const startResp = await apiRequest({
+    apiUrl,
+    token,
+    path: "/api/v1/ci/run",
+    method: "POST",
+    body: startPayload,
+  });
+
+  const runs = Array.isArray(startResp.runs) ? startResp.runs : [];
+  const started = runs.filter((run) => run.execution_job_id);
+  if (started.length === 0) {
+    throw new Error("Failed to start any runs.");
+  }
+  // eslint-disable-next-line no-console
+  console.log(`[qualty] Started ${started.length}/${runs.length} run(s).`);
+
+  const executionJobIds = started.map((run) => run.execution_job_id);
+  const deadlineMs = Date.now() + timeoutMin * 60 * 1000;
+  const terminalStatuses = new Set(["completed", "failed", "cancelled"]);
+  const finalStatuses = {};
+
+  while (Date.now() < deadlineMs) {
+    const batch = await apiRequest({
+      apiUrl,
+      token,
+      path: "/api/v1/status/batch",
+      method: "POST",
+      body: { job_ids: executionJobIds },
+    });
+    const statuses = batch.statuses || {};
+    let doneCount = 0;
+    for (const executionId of executionJobIds) {
+      const status = statuses[executionId];
+      if (!status) continue;
+      finalStatuses[executionId] = status;
+      if (terminalStatuses.has(status.status)) {
+        doneCount += 1;
+      }
+    }
+
+    // eslint-disable-next-line no-console
+    console.log(`[qualty] Progress: ${doneCount}/${executionJobIds.length} finished`);
+    if (doneCount === executionJobIds.length) {
+      break;
+    }
+    await sleep(pollIntervalSec * 1000);
+  }
+
+  const unresolved = executionJobIds.filter((id) => !terminalStatuses.has(finalStatuses[id]?.status));
+  if (unresolved.length > 0) {
+    throw new Error(`Timeout after ${timeoutMin} minute(s). Unfinished runs: ${unresolved.join(", ")}`);
+  }
+
+  let passed = 0;
+  let failed = 0;
+  for (const executionId of executionJobIds) {
+    const status = finalStatuses[executionId];
+    const isPass = status.status === "completed" && Number(status.failed_tests || 0) === 0;
+    if (isPass) passed += 1;
+    else failed += 1;
+    // eslint-disable-next-line no-console
+    console.log(
+      `[qualty] ${executionId} => status=${status.status}, failed_tests=${status.failed_tests ?? "n/a"}`
+    );
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(`[qualty] Summary: ${passed} passed, ${failed} failed.`);
+  if (failOnFailure && failed > 0) {
+    process.exit(1);
+  }
+}
+
+async function resolveSavedJobs({ apiUrl, token, projectId, suiteId, explicitIds }) {
+  const query = new URLSearchParams();
+  if (projectId) query.set("project_id", String(projectId));
+  if (suiteId) query.set("suite_id", String(suiteId));
+  if (explicitIds.length > 0) query.set("ids", explicitIds.join(","));
+  return apiRequest({
+    apiUrl,
+    token,
+    path: `/api/v1/saved-jobs?${query.toString()}`,
+  });
+}
+
+async function runResolve(args) {
+  const apiUrl = (args.api || process.env.QUALTY_API_URL || "http://localhost:8000").replace(/\/$/, "");
+  const token = args.token || process.env.QUALTY_API_TOKEN;
+  const projectId = args.project;
+  const suiteId = args["suite-id"];
+  const explicitIds = String(args.ids || "")
+    .split(",")
+    .map((id) => id.trim())
+    .filter(Boolean);
+  const asJson = parseBoolean(args.json, false);
+
+  if (!token) {
+    throw new Error("Missing auth token. Pass --token or set QUALTY_API_TOKEN.");
+  }
+  if (!projectId && !suiteId && explicitIds.length === 0) {
+    throw new Error("Provide --project, --suite-id, or --ids to select tests.");
+  }
+
+  const savedJobs = await resolveSavedJobs({ apiUrl, token, 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."
+    );
+  }
+
+  const tests = savedJobs.map((job) => ({
+    id: job.id,
+    name: String(job.name || job.id),
+  }));
+  if (asJson) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify(tests));
+    return;
+  }
+  // eslint-disable-next-line no-console
+  console.log(`[qualty] Resolved ${tests.length} saved test(s).`);
+  for (const test of tests) {
+    // eslint-disable-next-line no-console
+    console.log(`  - ${test.id} :: ${test.name}`);
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  const command = args._[0];
+  if (!command || command === "help" || command === "--help") {
+    usage();
+    process.exit(0);
+  }
+  if (command === "connect") {
+    await runConnect(args);
+    return;
+  }
+  if (command === "run") {
+    await runCi(args);
+    return;
+  }
+  if (command === "resolve") {
+    await runResolve(args);
+    return;
+  }
+  if (command !== "connect" && command !== "run" && command !== "resolve") {
+    throw new Error(`Unknown command: ${command}`);
+  }
+}
+
+main().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error(`[qualty] ${err.message || err}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "qualty",
+  "version": "0.1.0",
+  "description": "Qualty CLI for localhost and CI test runs",
+  "bin": {
+    "qualty": "bin/qualty.js"
+  },
+  "type": "module",
+  "license": "UNLICENSED",
+  "files": [
+    "bin"
+  ]
+}