@simonfestl/husky-cli 1.6.3 → 1.6.5

package/dist/commands/biz/qdrant.js

@@ -5,6 +5,7 @@
  */
 import { Command } from "commander";
 import { QdrantClient } from "../../lib/biz/index.js";
+import { requireRole } from "../../lib/permissions.js";
 export const qdrantCommand = new Command("qdrant")
     .description("Vector database operations (Qdrant)");
 // husky biz qdrant collections
@@ -167,4 +168,32 @@ qdrantCommand
         process.exit(1);
     }
 });
+// husky biz qdrant delete-collection <name> (ADMIN ONLY)
+qdrantCommand
+    .command("delete-collection <name>")
+    .description("Delete an entire collection (ADMIN ONLY)")
+    .option("-f, --force", "Skip confirmation")
+    .action(async (name, options) => {
+    try {
+        // Require admin role
+        requireRole("admin");
+        const client = QdrantClient.fromConfig();
+        // Get collection info first
+        const info = await client.getCollection(name);
+        if (!options.force) {
+            console.log(`\n  ⚠️  DANGER: About to DELETE collection "${name}"`);
+            console.log(`     Points: ${info.pointsCount}`);
+            console.log(`     Vectors: ${info.vectorsCount}`);
+            console.log(`\n     This action is IRREVERSIBLE!`);
+            console.log(`     Use --force to confirm deletion\n`);
+            process.exit(0);
+        }
+        await client.deleteCollection(name);
+        console.log(`✓ Deleted collection "${name}"`);
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
 export default qdrantCommand;

package/dist/commands/completion.js

@@ -135,7 +135,7 @@ ${subcommandCases}
       return 0
       ;;
     --agent)
-      COMPREPLY=( $(compgen -W "claude-code gemini-cli custom" -- \${cur}) )
+      COMPREPLY=( $(compgen -W "claude-code gemini-cli opencode custom" -- \${cur}) )
       return 0
       ;;
     --type)
@@ -268,7 +268,7 @@ complete -c husky -l project -d "Project ID" -r
 complete -c husky -l status -d "Filter by status" -r -a "backlog in_progress review done pending running completed failed"
 complete -c husky -l priority -d "Priority level" -r -a "low medium high urgent must should could wont"
 complete -c husky -l assignee -d "Assignee type" -r -a "human llm unassigned"
-complete -c husky -l agent -d "Agent type" -r -a "claude-code gemini-cli custom"
+complete -c husky -l agent -d "Agent type" -r -a "claude-code gemini-cli opencode custom"
 complete -c husky -l type -d "Type filter" -r -a "global project architecture patterns decisions learnings"
 complete -c husky -l value-stream -d "Value stream" -r -a "order_to_delivery procure_to_pay returns_management product_lifecycle customer_service marketing_sales finance_accounting hr_operations it_operations general"
 complete -c husky -l action -d "Action type" -r -a "manual semi_automated fully_automated"

package/dist/commands/e2e.d.ts

@@ -0,0 +1,11 @@
+/**
+ * E2E Testing commands for E2E Agent
+ *
+ * Commands for browser automation and E2E testing:
+ * - husky e2e run <task-id> - Run E2E tests for a task
+ * - husky e2e record <url> - Record a browser session with Playwright
+ * - husky e2e upload <file> - Upload recording to GCS bucket husky-files-tigerv0
+ * - husky e2e screenshot <url> - Take a screenshot of a URL
+ */
+import { Command } from "commander";
+export declare const e2eCommand: Command;

package/dist/commands/e2e.js

@@ -0,0 +1,528 @@
+/**
+ * E2E Testing commands for E2E Agent
+ *
+ * Commands for browser automation and E2E testing:
+ * - husky e2e run <task-id> - Run E2E tests for a task
+ * - husky e2e record <url> - Record a browser session with Playwright
+ * - husky e2e upload <file> - Upload recording to GCS bucket husky-files-tigerv0
+ * - husky e2e screenshot <url> - Take a screenshot of a URL
+ */
+import { Command } from "commander";
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { requireAnyPermission } from "../lib/permissions.js";
+import { getConfig } from "./config.js";
+export const e2eCommand = new Command("e2e")
+    .description("E2E testing and browser automation (E2E Agent)");
+// GCS bucket for E2E artifacts
+const GCS_BUCKET = "husky-files-tigerv0";
+// Helper: Ensure API is configured
+function ensureConfig() {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    return config;
+}
+// Helper: Run a command and return result
+function runCommand(cmd, args, options) {
+    const result = spawnSync(cmd, args, {
+        encoding: "utf-8",
+        maxBuffer: 50 * 1024 * 1024,
+        timeout: options?.timeout || 300000, // 5 min default
+        cwd: options?.cwd,
+    });
+    return {
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
+        success: result.status === 0,
+    };
+}
+// Helper: Generate timestamp for filenames
+function generateTimestamp() {
+    const now = new Date();
+    return now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
+}
+// Helper: Upload file to GCS
+function uploadToGCS(localPath, gcsPath) {
+    const fullGcsPath = `gs://${GCS_BUCKET}/${gcsPath}`;
+    const result = runCommand("gcloud", [
+        "storage", "cp", localPath, fullGcsPath,
+    ]);
+    if (result.success) {
+        return {
+            success: true,
+            url: `https://storage.googleapis.com/${GCS_BUCKET}/${gcsPath}`,
+        };
+    }
+    console.error("GCS upload failed:", result.stderr);
+    return { success: false, url: "" };
+}
+// husky e2e run <task-id>
+e2eCommand
+    .command("run <taskId>")
+    .description("Run E2E tests for a task")
+    .option("--headless", "Run in headless mode (default: true)", true)
+    .option("--headed", "Run in headed mode with visible browser")
+    .option("--browser <browser>", "Browser to use (chromium, firefox, webkit)", "chromium")
+    .option("--timeout <ms>", "Test timeout in milliseconds", "60000")
+    .option("--output <dir>", "Output directory for results")
+    .option("--json", "Output as JSON")
+    .action(async (taskId, options) => {
+    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    const config = ensureConfig();
+    const timestamp = generateTimestamp();
+    const outputDir = options.output || `/tmp/e2e-${taskId}-${timestamp}`;
+    console.log(`\n  E2E Tests for Task: ${taskId}\n`);
+    console.log(`  Output directory: ${outputDir}`);
+    console.log(`  Browser: ${options.browser}`);
+    console.log(`  Headless: ${!options.headed}`);
+    console.log("");
+    // Create output directory
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    // Fetch task details from API
+    let taskUrl;
+    let taskName;
+    try {
+        const res = await fetch(`${config.apiUrl}/api/tasks/${taskId}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (res.ok) {
+            const task = await res.json();
+            taskName = task.title || task.name;
+            // Check if task has a preview URL or target URL
+            taskUrl = task.previewUrl || task.targetUrl || task.metadata?.url;
+            console.log(`  Task: ${taskName}`);
+            if (taskUrl) {
+                console.log(`  URL: ${taskUrl}`);
+            }
+        }
+    }
+    catch {
+        console.warn("  Warning: Could not fetch task details");
+    }
+    // Look for test files in current directory or task worktree
+    const testPatterns = [
+        "e2e/**/*.spec.ts",
+        "e2e/**/*.test.ts",
+        "tests/e2e/**/*.spec.ts",
+        "tests/e2e/**/*.test.ts",
+        "*.e2e.ts",
+    ];
+    console.log("\n  Running Playwright tests...\n");
+    const playwrightArgs = [
+        "test",
+        "--reporter=list",
+        `--output=${outputDir}`,
+        `--timeout=${options.timeout}`,
+    ];
+    if (!options.headed) {
+        playwrightArgs.push("--headed=false");
+    }
+    else {
+        playwrightArgs.push("--headed");
+    }
+    if (options.browser) {
+        playwrightArgs.push(`--project=${options.browser}`);
+    }
+    const result = runCommand("npx", ["playwright", ...playwrightArgs], {
+        timeout: parseInt(options.timeout, 10) * 2, // Allow 2x timeout for test suite
+    });
+    const testResult = {
+        taskId,
+        taskName,
+        taskUrl,
+        success: result.success,
+        timestamp,
+        outputDir,
+        browser: options.browser,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+    // Save results to file
+    const resultsPath = path.join(outputDir, "results.json");
+    fs.writeFileSync(resultsPath, JSON.stringify(testResult, null, 2));
+    // Upload results to GCS
+    const gcsPath = `e2e/${taskId}/${timestamp}/results.json`;
+    const uploadResult = uploadToGCS(resultsPath, gcsPath);
+    if (options.json) {
+        console.log(JSON.stringify({
+            ...testResult,
+            gcsUrl: uploadResult.url,
+        }, null, 2));
+    }
+    else {
+        console.log(result.stdout);
+        if (result.stderr) {
+            console.error(result.stderr);
+        }
+        console.log("\n  " + "═".repeat(50));
+        console.log(`  Result: ${result.success ? "PASSED" : "FAILED"}`);
+        console.log(`  Output: ${outputDir}`);
+        if (uploadResult.success) {
+            console.log(`  GCS: ${uploadResult.url}`);
+        }
+        console.log("");
+    }
+    if (!result.success) {
+        process.exit(1);
+    }
+});
+// husky e2e record <url>
+e2eCommand
+    .command("record <url>")
+    .description("Record a browser session with Playwright codegen")
+    .option("-o, --output <file>", "Output file for recorded script")
+    .option("--browser <browser>", "Browser to use (chromium, firefox, webkit)", "chromium")
+    .option("--device <device>", "Emulate device (e.g., 'iPhone 13', 'Pixel 5')")
+    .option("--viewport <size>", "Viewport size (e.g., '1280x720')")
+    .option("--video", "Record video of the session")
+    .option("--json", "Output as JSON")
+    .action(async (url, options) => {
+    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    const timestamp = generateTimestamp();
+    const outputFile = options.output || `/tmp/e2e-recording-${timestamp}.ts`;
+    const videoDir = `/tmp/e2e-video-${timestamp}`;
+    console.log(`\n  Recording Browser Session\n`);
+    console.log(`  URL: ${url}`);
+    console.log(`  Browser: ${options.browser}`);
+    console.log(`  Output: ${outputFile}`);
+    if (options.device) {
+        console.log(`  Device: ${options.device}`);
+    }
+    if (options.viewport) {
+        console.log(`  Viewport: ${options.viewport}`);
+    }
+    console.log("");
+    const codegenArgs = [
+        "playwright", "codegen",
+        url,
+        `-o`, outputFile,
+        `-b`, options.browser,
+    ];
+    if (options.device) {
+        codegenArgs.push("--device", options.device);
+    }
+    if (options.viewport) {
+        const [width, height] = options.viewport.split("x").map(Number);
+        codegenArgs.push("--viewport-size", `${width},${height}`);
+    }
+    if (options.video) {
+        if (!fs.existsSync(videoDir)) {
+            fs.mkdirSync(videoDir, { recursive: true });
+        }
+        codegenArgs.push("--save-storage", path.join(videoDir, "storage.json"));
+    }
+    console.log("  Starting Playwright Codegen...");
+    console.log("  Interact with the browser, then close it to save the recording.\n");
+    // Run codegen interactively
+    const codegen = spawnSync("npx", codegenArgs, {
+        stdio: "inherit",
+        encoding: "utf-8",
+    });
+    if (codegen.status === 0 && fs.existsSync(outputFile)) {
+        console.log(`\n  Recording saved to: ${outputFile}`);
+        // Upload to GCS
+        const gcsPath = `e2e/recordings/${timestamp}/${path.basename(outputFile)}`;
+        const uploadResult = uploadToGCS(outputFile, gcsPath);
+        if (options.json) {
+            console.log(JSON.stringify({
+                success: true,
+                url,
+                outputFile,
+                gcsUrl: uploadResult.url,
+                timestamp,
+            }, null, 2));
+        }
+        else {
+            if (uploadResult.success) {
+                console.log(`  Uploaded to: ${uploadResult.url}`);
+            }
+            console.log("\n  To run this recording:");
+            console.log(`    npx playwright test ${outputFile}`);
+            console.log("");
+        }
+    }
+    else {
+        console.error("\n  Recording failed or was cancelled.");
+        process.exit(1);
+    }
+});
+// husky e2e upload <file>
+e2eCommand
+    .command("upload <file>")
+    .description("Upload a file to the E2E GCS bucket")
+    .option("--task <taskId>", "Associate with a task ID")
+    .option("--type <type>", "File type (screenshot, video, recording, report)", "file")
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    if (!fs.existsSync(file)) {
+        console.error(`Error: File not found: ${file}`);
+        process.exit(1);
+    }
+    const timestamp = generateTimestamp();
+    const filename = path.basename(file);
+    const taskPrefix = options.task ? `${options.task}/` : "";
+    const gcsPath = `e2e/${taskPrefix}${options.type}s/${timestamp}-${filename}`;
+    console.log(`\n  Uploading to GCS\n`);
+    console.log(`  File: ${file}`);
+    console.log(`  Type: ${options.type}`);
+    if (options.task) {
+        console.log(`  Task: ${options.task}`);
+    }
+    console.log("");
+    const uploadResult = uploadToGCS(file, gcsPath);
+    if (options.json) {
+        console.log(JSON.stringify({
+            success: uploadResult.success,
+            file,
+            gcsPath,
+            url: uploadResult.url,
+            timestamp,
+        }, null, 2));
+    }
+    else {
+        if (uploadResult.success) {
+            console.log(`  Uploaded successfully!`);
+            console.log(`  URL: ${uploadResult.url}`);
+        }
+        else {
+            console.error(`  Upload failed.`);
+            process.exit(1);
+        }
+    }
+    console.log("");
+});
+// husky e2e screenshot <url>
+e2eCommand
+    .command("screenshot <url>")
+    .description("Take a screenshot of a URL")
+    .option("-o, --output <file>", "Output file path")
+    .option("--full-page", "Capture full page (not just viewport)")
+    .option("--viewport <size>", "Viewport size (e.g., '1920x1080')", "1920x1080")
+    .option("--device <device>", "Emulate device (e.g., 'iPhone 13', 'Pixel 5')")
+    .option("--wait <ms>", "Wait time before screenshot in ms", "2000")
+    .option("--selector <selector>", "Wait for selector before screenshot")
+    .option("--task <taskId>", "Associate with a task ID")
+    .option("--upload", "Upload screenshot to GCS")
+    .option("--json", "Output as JSON")
+    .action(async (url, options) => {
+    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    const timestamp = generateTimestamp();
+    const defaultFilename = `screenshot-${timestamp}.png`;
+    const outputFile = options.output || `/tmp/${defaultFilename}`;
+    console.log(`\n  Taking Screenshot\n`);
+    console.log(`  URL: ${url}`);
+    console.log(`  Viewport: ${options.viewport}`);
+    console.log(`  Full page: ${options.fullPage || false}`);
+    if (options.device) {
+        console.log(`  Device: ${options.device}`);
+    }
+    console.log(`  Output: ${outputFile}`);
+    console.log("");
+    // Build Playwright script
+    const [width, height] = options.viewport.split("x").map(Number);
+    const deviceConfig = options.device ? `devices[${JSON.stringify(options.device)}]` : "null";
+    // Use JSON.stringify to safely encode user-provided values and prevent injection
+    const safeUrl = JSON.stringify(url);
+    const safeOutputFile = JSON.stringify(outputFile);
+    const safeSelector = options.selector ? JSON.stringify(options.selector) : null;
+    const script = `
+const { chromium, devices } = require('playwright');
+
+(async () => {
+  const browser = await chromium.launch({ headless: true });
+  const deviceConfig = ${deviceConfig};
+  const contextOptions = deviceConfig ? { ...deviceConfig } : {
+    viewport: { width: ${width}, height: ${height} }
+  };
+  const context = await browser.newContext(contextOptions);
+  const page = await context.newPage();
+
+  await page.goto(${safeUrl}, { waitUntil: 'networkidle' });
+
+  ${safeSelector ? `await page.waitForSelector(${safeSelector});` : ""}
+  await page.waitForTimeout(${options.wait});
+
+  await page.screenshot({
+    path: ${safeOutputFile},
+    fullPage: ${options.fullPage || false}
+  });
+
+  await browser.close();
+  console.log('Screenshot saved to: ' + ${safeOutputFile});
+})();
+`;
+    // Write and execute script
+    const scriptPath = `/tmp/screenshot-script-${timestamp}.js`;
+    fs.writeFileSync(scriptPath, script);
+    console.log("  Capturing screenshot...\n");
+    const result = runCommand("node", [scriptPath], { timeout: 60000 });
+    // Clean up script
+    try {
+        fs.unlinkSync(scriptPath);
+    }
+    catch {
+        // Ignore cleanup errors - temp script file may already be deleted
+    }
+    if (!result.success || !fs.existsSync(outputFile)) {
+        console.error("  Screenshot failed:");
+        console.error(result.stderr || result.stdout);
+        process.exit(1);
+    }
+    const fileStats = fs.statSync(outputFile);
+    let gcsUrl = "";
+    // Upload if requested
+    if (options.upload) {
+        const taskPrefix = options.task ? `${options.task}/` : "";
+        const gcsPath = `e2e/${taskPrefix}screenshots/${defaultFilename}`;
+        const uploadResult = uploadToGCS(outputFile, gcsPath);
+        gcsUrl = uploadResult.url;
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            success: true,
+            url,
+            outputFile,
+            fileSize: fileStats.size,
+            viewport: options.viewport,
+            fullPage: options.fullPage || false,
+            gcsUrl: gcsUrl || undefined,
+            timestamp,
+        }, null, 2));
+    }
+    else {
+        console.log(`  Screenshot captured successfully!`);
+        console.log(`  File: ${outputFile}`);
+        console.log(`  Size: ${(fileStats.size / 1024).toFixed(1)} KB`);
+        if (gcsUrl) {
+            console.log(`  GCS: ${gcsUrl}`);
+        }
+        console.log("");
+    }
+});
+// husky e2e list
+e2eCommand
+    .command("list")
+    .description("List E2E artifacts in GCS bucket")
+    .option("--task <taskId>", "Filter by task ID")
+    .option("--type <type>", "Filter by type (screenshots, videos, recordings, reports)")
+    .option("--limit <n>", "Limit number of results", "20")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    let gcsPath = `gs://${GCS_BUCKET}/e2e/`;
+    if (options.task) {
+        gcsPath += `${options.task}/`;
+    }
+    if (options.type) {
+        gcsPath += `${options.type}/`;
+    }
+    console.log(`\n  E2E Artifacts\n`);
+    console.log(`  Bucket: ${GCS_BUCKET}`);
+    if (options.task) {
+        console.log(`  Task: ${options.task}`);
+    }
+    if (options.type) {
+        console.log(`  Type: ${options.type}`);
+    }
+    console.log("");
+    const result = runCommand("gcloud", [
+        "storage", "ls", "-l", gcsPath,
+    ]);
+    if (!result.success) {
+        if (result.stderr.includes("CommandException") || result.stderr.includes("not found")) {
+            console.log("  No artifacts found.");
+        }
+        else {
+            console.error("Error listing artifacts:", result.stderr);
+        }
+        return;
+    }
+    const lines = result.stdout.trim().split("\n").filter(Boolean);
+    const artifacts = lines
+        .slice(0, parseInt(options.limit, 10))
+        .map((line) => {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 3) {
+            return {
+                size: parts[0],
+                date: parts[1],
+                path: parts[2],
+            };
+        }
+        return null;
+    })
+        .filter(Boolean);
+    if (options.json) {
+        console.log(JSON.stringify({ artifacts }, null, 2));
+    }
+    else {
+        console.log("  " + "-".repeat(70));
+        console.log(`  ${"SIZE".padEnd(12)} ${"DATE".padEnd(20)} PATH`);
+        console.log("  " + "-".repeat(70));
+        for (const artifact of artifacts) {
+            if (artifact) {
+                const displayPath = artifact.path.replace(`gs://${GCS_BUCKET}/`, "");
+                console.log(`  ${artifact.size.padEnd(12)} ${artifact.date.padEnd(20)} ${displayPath}`);
+            }
+        }
+        console.log("");
+    }
+});
+// husky e2e clean
+e2eCommand
+    .command("clean")
+    .description("Clean up local E2E artifacts")
+    .option("--all", "Remove all E2E artifacts from /tmp")
+    .option("--older-than <days>", "Remove artifacts older than N days", "7")
+    .option("--dry-run", "Show what would be deleted without deleting")
+    .action(async (options) => {
+    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    console.log(`\n  Cleaning E2E Artifacts\n`);
+    const tmpDir = "/tmp";
+    const e2ePatterns = ["e2e-", "screenshot-", "recording-"];
+    const maxAge = parseInt(options.olderThan, 10) * 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    let cleaned = 0;
+    let totalSize = 0;
+    try {
+        const files = fs.readdirSync(tmpDir);
+        for (const file of files) {
+            const isE2E = e2ePatterns.some((p) => file.startsWith(p));
+            if (!isE2E)
+                continue;
+            const filePath = path.join(tmpDir, file);
+            const stats = fs.statSync(filePath);
+            const age = now - stats.mtime.getTime();
+            if (options.all || age > maxAge) {
+                if (options.dryRun) {
+                    console.log(`  Would delete: ${file} (${(stats.size / 1024).toFixed(1)} KB)`);
+                }
+                else {
+                    if (stats.isDirectory()) {
+                        fs.rmSync(filePath, { recursive: true });
+                    }
+                    else {
+                        fs.unlinkSync(filePath);
+                    }
+                    console.log(`  Deleted: ${file}`);
+                }
+                cleaned++;
+                totalSize += stats.size;
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error cleaning artifacts:", error);
+        process.exit(1);
+    }
+    console.log("");
+    console.log(`  ${options.dryRun ? "Would clean" : "Cleaned"}: ${cleaned} items (${(totalSize / 1024 / 1024).toFixed(2)} MB)`);
+    console.log("");
+});

package/dist/commands/infra.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Infrastructure commands for DevOps agent
+ *
+ * Commands for monitoring and managing GCP infrastructure:
+ * - husky infra status - Show all services status
+ * - husky infra vms - List VMs with status
+ * - husky infra logs <service> - View recent logs
+ * - husky infra scale <pool> --count <n> - Scale VM pool
+ */
+import { Command } from "commander";
+export declare const infraCommand: Command;