@qabyai/qli 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { chromium } from "playwright";
+import { chmodSync, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from "fs";
+import { spawn } from "child_process";
+import { pipeline } from "stream/promises";
+import { basename, dirname, extname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import https from "https";
+import chalk from "chalk";
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+import superjson from "superjson";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+//#region src/utils/ngrok-binary.ts
+const NGROK_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "bin");
+const NGROK_BINARY = join(NGROK_DIR, process.platform === "win32" ? "ngrok.exe" : "ngrok");
+function getPlatformInfo() {
+	const platform = process.platform;
+	const arch = process.arch;
+	if (platform === "darwin") if (arch === "arm64") return {
+		downloadUrl: "https://bin.ngrok.com/c/bNyj1mQVY4c/ngrok-v3-stable-darwin-arm64.zip",
+		isArchive: true,
+		archiveType: "zip"
+	};
+	else return {
+		downloadUrl: "https://bin.ngrok.com/c/bNyj1mQVY4c/ngrok-v3-stable-darwin-amd64.zip",
+		isArchive: true,
+		archiveType: "zip"
+	};
+	else if (platform === "linux") return {
+		downloadUrl: "https://bin.ngrok.com/c/bNyj1mQVY4c/ngrok-v3-stable-linux-amd64.tgz",
+		isArchive: true,
+		archiveType: "tgz"
+	};
+	else if (platform === "win32") return {
+		downloadUrl: "https://bin.ngrok.com/c/bNyj1mQVY4c/ngrok-v3-stable-windows-amd64.zip",
+		isArchive: true,
+		archiveType: "zip"
+	};
+	else throw new Error(`Unsupported platform: ${platform}`);
+}
+async function downloadFile(url, filePath) {
+	return new Promise((resolve$1, reject) => {
+		https.get(url, (response) => {
+			if (response.statusCode !== 200) {
+				reject(/* @__PURE__ */ new Error(`Failed to download: ${response.statusCode}`));
+				return;
+			}
+			pipeline(response, createWriteStream(filePath)).then(() => resolve$1()).catch(reject);
+		}).on("error", reject);
+	});
+}
+async function extractArchive(archivePath, extractDir, type) {
+	return new Promise((resolve$1, reject) => {
+		let command$2;
+		let args;
+		if (type === "zip") {
+			command$2 = "unzip";
+			args = [
+				"-o",
+				archivePath,
+				"-d",
+				extractDir
+			];
+		} else {
+			command$2 = "tar";
+			args = [
+				"-xzf",
+				archivePath,
+				"-C",
+				extractDir
+			];
+		}
+		const process$1 = spawn(command$2, args);
+		process$1.on("close", (code) => {
+			if (code === 0) resolve$1();
+			else reject(/* @__PURE__ */ new Error(`Extraction failed with code ${code}`));
+		});
+		process$1.on("error", reject);
+	});
+}
+async function ensureNgrokBinary() {
+	if (existsSync(NGROK_BINARY)) return NGROK_BINARY;
+	if (!existsSync(NGROK_DIR)) mkdirSync(NGROK_DIR, { recursive: true });
+	const platformInfo = getPlatformInfo();
+	const tempArchivePath = join(NGROK_DIR, `ngrok.${platformInfo.archiveType}`);
+	try {
+		console.log("📦 Downloading ngrok binary...");
+		await downloadFile(platformInfo.downloadUrl, tempArchivePath);
+		console.log("📂 Extracting ngrok binary...");
+		await extractArchive(tempArchivePath, NGROK_DIR, platformInfo.archiveType);
+		if (existsSync(NGROK_BINARY)) {
+			chmodSync(NGROK_BINARY, 493);
+			rmSync(tempArchivePath);
+			return NGROK_BINARY;
+		} else throw new Error(`Binary not found after extraction. Expected: ${NGROK_BINARY}`);
+	} catch (error) {
+		if (existsSync(tempArchivePath)) rmSync(tempArchivePath);
+		throw error;
+	}
+}
+async function startNgrokTunnel(port, authtoken) {
+	return new Promise((resolve$1, reject) => {
+		const initTunnel = async () => {
+			try {
+				const ngrokProcess = spawn(await ensureNgrokBinary(), [
+					"http",
+					port.toString(),
+					"--authtoken",
+					authtoken,
+					"--log=stdout",
+					"--log-format=json"
+				], { stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				] });
+				let output = "";
+				let errorOutput = "";
+				let tunnelUrl = "";
+				let resolved = false;
+				ngrokProcess.stdout?.on("data", (data) => {
+					const chunk = data.toString();
+					output += chunk;
+					const urlMatch = chunk.match(/"url":"(https:\/\/[^"]+)"/);
+					if (urlMatch && !tunnelUrl && !resolved) {
+						tunnelUrl = urlMatch[1];
+						resolved = true;
+						resolve$1({
+							url: tunnelUrl,
+							process: ngrokProcess
+						});
+					}
+				});
+				ngrokProcess.stderr?.on("data", (data) => {
+					const chunk = data.toString();
+					errorOutput += chunk;
+					if (chunk.includes("ERRO") || chunk.includes("failed to")) {
+						if (!resolved) {
+							resolved = true;
+							reject(/* @__PURE__ */ new Error(`Ngrok error: ${chunk}`));
+						}
+					}
+				});
+				ngrokProcess.on("error", (error) => {
+					if (!resolved) {
+						resolved = true;
+						reject(/* @__PURE__ */ new Error(`Failed to start ngrok: ${error.message}`));
+					}
+				});
+				ngrokProcess.on("exit", (code) => {
+					if (code !== 0 && !resolved) {
+						resolved = true;
+						reject(/* @__PURE__ */ new Error(`Ngrok exited with code ${code}`));
+					}
+				});
+				setTimeout(() => {
+					if (!resolved) {
+						ngrokProcess.kill();
+						resolved = true;
+						reject(/* @__PURE__ */ new Error("Timeout waiting for ngrok tunnel URL"));
+					}
+				}, 2e4);
+			} catch (error) {
+				reject(error);
+			}
+		};
+		initTunnel();
+	});
+}
+
+//#endregion
+//#region src/commands/browser.ts
+var browser_exports = /* @__PURE__ */ __export({
+	builder: () => builder$1,
+	command: () => command$1,
+	desc: () => desc$1,
+	handler: () => handler$1
+});
+const command$1 = "browser";
+const desc$1 = "Start Playwright browser server with ngrok tunnel";
+const builder$1 = (yargs$1) => yargs$1.option("port", {
+	type: "number",
+	default: 9222,
+	describe: "Port to run the browser server on"
+}).option("headless", {
+	type: "boolean",
+	default: false,
+	describe: "Run browser in headless mode"
+});
+const handler$1 = async (argv) => {
+	const { port = 9222, headless = false } = argv;
+	try {
+		console.log(chalk.gray("[debug] Starting Playwright browser server..."));
+		const browserServer = await chromium.launchServer({
+			headless,
+			port,
+			args: [
+				"--no-sandbox",
+				"--disable-setuid-sandbox",
+				"--disable-web-security",
+				"--disable-features=VizDisplayCompositor"
+			]
+		});
+		const wsEndpoint = browserServer.wsEndpoint();
+		console.log(chalk.gray("[debug] Browser server started successfully!"));
+		console.log(chalk.gray(`[debug] WebSocket endpoint: ${wsEndpoint}`));
+		const sessionId = wsEndpoint.split("/").pop() || "";
+		let tunnelUrl;
+		let ngrokProcess;
+		try {
+			console.log(chalk.gray("[debug] Creating secure tunnel..."));
+			const result = await startNgrokTunnel(port, "38bZ22nMOQFcUhqpTi3SFIphrjX_68vsN6T945JmNVaNGYjHs");
+			tunnelUrl = result.url;
+			ngrokProcess = result.process;
+			console.log(chalk.gray("[debug] Tunnel established!"));
+			const completeWsUrl = `${tunnelUrl.replace("https://", "wss://")}/${sessionId}`;
+			console.log(chalk.green.bold(`\n${completeWsUrl}\n`));
+			console.log(chalk.cyan("💡 Copy the URL above and paste it in your browser"));
+		} catch (error) {
+			console.error(chalk.red("[debug] Failed to create tunnel:"));
+			console.error(chalk.red(`[debug]    ${error.message || error}`));
+			console.log(chalk.gray("[debug]    → Browser server will continue running locally only"));
+			console.log(chalk.gray("[debug]    → Check your internet connection or try again later"));
+			console.log(chalk.green.bold(`\nws://localhost:${port}/${sessionId}\n`));
+			console.log(chalk.cyan("💡 Copy the URL above and paste it in your browser (local only)"));
+		}
+		console.log(chalk.dim("\nPress Ctrl+C to stop"));
+		const shutdown = async () => {
+			console.log(chalk.gray("\n[debug] Shutting down..."));
+			if (ngrokProcess) try {
+				ngrokProcess.kill("SIGTERM");
+				console.log(chalk.gray("[debug]    ✅ Tunnel closed"));
+			} catch (error) {
+				console.log(chalk.gray(`[debug]    ⚠️  Error closing tunnel: ${error instanceof Error ? error.message : "Unknown error"}`));
+			}
+			try {
+				await browserServer.close();
+				console.log(chalk.gray("[debug]    ✅ Browser server closed"));
+			} catch (error) {
+				console.log(chalk.gray(`[debug]    ❌ Error closing browser server: ${error instanceof Error ? error.message : "Unknown error"}`));
+			}
+			console.log(chalk.gray("\nGoodbye! 👋"));
+			process.exit(0);
+		};
+		process.on("SIGINT", shutdown);
+		process.on("SIGTERM", shutdown);
+	} catch (error) {
+		console.error(chalk.red("❌ Failed to start browser server:"), error);
+		process.exit(1);
+	}
+};
+
+//#endregion
+//#region src/api/client.ts
+function createClient(apiKey, apiUrl) {
+	return createTRPCClient({ links: [httpBatchLink({
+		url: `${apiUrl}/trpc`,
+		headers() {
+			return { "x-api-key": apiKey };
+		},
+		transformer: superjson
+	})] });
+}
+
+//#endregion
+//#region src/commands/context.ts
+var context_exports = /* @__PURE__ */ __export({
+	builder: () => builder,
+	command: () => command,
+	desc: () => desc,
+	handler: () => handler
+});
+const command = "context";
+const desc = "Scan and upload codebase to generate context documents";
+const builder = (yargs$1) => yargs$1.option("api-key", {
+	type: "string",
+	describe: "API key for authentication (or set QABYAI_API_KEY env var)"
+}).option("dir", {
+	type: "string",
+	describe: "Directory to scan (defaults to current directory)"
+});
+const INCLUDE_DIR_PATTERNS = [
+	"src/",
+	"app/",
+	"pages/",
+	"lib/",
+	"routes/",
+	"components/",
+	"models/",
+	"api/"
+];
+const INCLUDE_FILE_EXACT = [
+	"package.json",
+	"tsconfig.json",
+	"README.md",
+	".env.example"
+];
+const INCLUDE_FILE_SUFFIXES = [
+	".config.ts",
+	".config.js",
+	".config.mjs"
+];
+const EXCLUDE_DIRS = new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".next",
+	".git",
+	"__snapshots__",
+	".turbo",
+	".cache",
+	"coverage"
+]);
+const EXCLUDE_EXTENSIONS = new Set([
+	".lock",
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".ico",
+	".svg",
+	".woff",
+	".woff2",
+	".ttf",
+	".eot",
+	".mp4",
+	".mp3",
+	".webm",
+	".webp",
+	".avif",
+	".snap",
+	".map"
+]);
+const EXCLUDE_FILES = new Set([
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"yarn.lock"
+]);
+const MAX_FILE_SIZE = 50 * 1024;
+const MAX_TOTAL_SIZE = 5 * 1024 * 1024;
+function shouldIncludeFile(relativePath, fileSize) {
+	const name = basename(relativePath);
+	const ext = extname(relativePath).toLowerCase();
+	if (EXCLUDE_FILES.has(name)) return false;
+	if (EXCLUDE_EXTENSIONS.has(ext)) return false;
+	for (const dir of EXCLUDE_DIRS) if (relativePath.includes(dir + "/")) return false;
+	if (fileSize > MAX_FILE_SIZE) return false;
+	for (const dir of INCLUDE_DIR_PATTERNS) if (relativePath.startsWith(dir) || relativePath.includes(`/${dir}`)) return true;
+	if (INCLUDE_FILE_EXACT.includes(name)) return true;
+	for (const suffix of INCLUDE_FILE_SUFFIXES) if (name.endsWith(suffix)) return true;
+	return false;
+}
+function scanDirectory(rootDir) {
+	const files = [];
+	let totalSize = 0;
+	function walk(dir, relativeBase) {
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) if (entry.isDirectory()) {
+			if (EXCLUDE_DIRS.has(entry.name)) continue;
+			walk(join(dir, entry.name), relativeBase ? `${relativeBase}/${entry.name}` : entry.name);
+		} else if (entry.isFile()) {
+			const fullPath = join(dir, entry.name);
+			const relativePath = relativeBase ? `${relativeBase}/${entry.name}` : entry.name;
+			let stat;
+			try {
+				stat = statSync(fullPath);
+			} catch {
+				continue;
+			}
+			if (totalSize + stat.size > MAX_TOTAL_SIZE) continue;
+			if (shouldIncludeFile(relativePath, stat.size)) try {
+				const content = readFileSync(fullPath, "utf-8");
+				files.push({
+					path: relativePath,
+					content
+				});
+				totalSize += stat.size;
+			} catch {}
+		}
+	}
+	walk(rootDir, "");
+	return files;
+}
+function sleep(ms) {
+	return new Promise((resolve$1) => setTimeout(resolve$1, ms));
+}
+const handler = async (argv) => {
+	const apiKey = argv["api-key"] || process.env.QABYAI_API_KEY;
+	if (!apiKey) {
+		console.error(chalk.red("API key required. Use --api-key flag or set QABYAI_API_KEY env var."));
+		console.error(chalk.gray("Get your API key at https://qaby.ai/settings/api-keys"));
+		process.exit(1);
+	}
+	const dir = resolve(argv.dir || process.cwd());
+	const apiUrl = process.env.QABYAI_API_URL || "https://qaby.ai";
+	const dirName = basename(dir);
+	const client = createClient(apiKey, apiUrl);
+	console.log(chalk.gray(`Scanning ${dir}...\n`));
+	const files = scanDirectory(dir);
+	if (files.length === 0) {
+		console.error(chalk.red("No matching files found. Make sure you are in a project directory."));
+		process.exit(1);
+	}
+	let jobId;
+	try {
+		jobId = (await client.context.cliScan.mutate({
+			dirName,
+			files
+		})).jobId;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "Unknown error";
+		console.error(chalk.red(`Failed: ${message}`));
+		process.exit(1);
+	}
+	console.log(chalk.white.bold("Generating knowledge base...\n"));
+	const spinnerFrames = [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	];
+	let frame = 0;
+	let lastStatus = "";
+	while (true) {
+		await sleep(3e3);
+		try {
+			const status = await client.context.cliScanStatus.query({ jobId });
+			if (status.status !== lastStatus) {
+				if (lastStatus) process.stdout.write("\r\x1B[K");
+				if (status.status === "pending") console.log(chalk.gray(`  Queued for processing`));
+				else if (status.status === "running") console.log(chalk.gray(`  Analyzing codebase and generating docs`));
+				lastStatus = status.status;
+			}
+			if (status.status === "completed") {
+				process.stdout.write("\r\x1B[K");
+				const docCount = status.generatedDocuments ?? 0;
+				console.log(chalk.green(`  Created ${docCount} document${docCount !== 1 ? "s" : ""}`));
+				console.log(chalk.green("\nDone!"));
+				console.log(chalk.cyan("View documents at: https://qaby.ai/context/documents"));
+				break;
+			}
+			if (status.status === "failed") {
+				process.stdout.write("\r\x1B[K");
+				console.error(chalk.red("\nKnowledge generation failed."));
+				if (status.error) console.error(chalk.red(status.error));
+				process.exit(1);
+			}
+			process.stdout.write(`\r  ${chalk.blue(spinnerFrames[frame++ % spinnerFrames.length])} ${chalk.gray("Processing...")}`);
+		} catch {
+			process.stdout.write(`\r  ${chalk.blue(spinnerFrames[frame++ % spinnerFrames.length])} ${chalk.gray("Processing...")}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/index.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
+async function main() {
+	console.log(chalk.blue.bold(`🤖 QAbyAI CLI v${packageJson.version}\n`));
+	yargs(hideBin(process.argv)).scriptName("qli").usage("$0 <command> [options]").command(browser_exports).command(context_exports).demandCommand(1, "You need to specify a command").strict().help().alias("help", "h").version(packageJson.version).alias("version", "v").completion().parse();
+}
+main().catch((error) => {
+	console.error(chalk.red("❌ Fatal error:"), error);
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@qabyai/qli",
+  "version": "1.0.0",
+  "description": "QAbyAI CLI tool for browser automation",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "bin": {
+    "qli": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "dependencies": {
+    "@trpc/client": "^11.6.0",
+    "chalk": "^5.3.0",
+    "playwright": "^1.58.0",
+    "superjson": "^2.2.6",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@miloas/tsdown": "^0.13.0",
+    "@types/node": "^20.11.20",
+    "@types/yargs": "^17.0.32",
+    "typescript": "^5.9.3",
+    "backend": "1.0.0"
+  },
+  "scripts": {
+    "check": "tsgo --noEmit",
+    "build": "tsdown",
+    "serve:build": "tsdown",
+    "serve:watch": "tsdown --watch",
+    "dev": "node dist/index.js",
+    "cli": "node dist/index.js"
+  }
+}