@simonfestl/husky-cli 1.6.5 → 1.7.0

package/README.md

@@ -111,6 +111,34 @@ husky vm update <session-id> --status approved
 husky vm delete <session-id>
 ```
 
+### E2E Testing (E2E Agent)
+
+```bash
+# Run E2E tests for a task
+husky e2e run <task-id>
+husky e2e run <task-id> --secret ADMIN_PASSWORD --retries 2
+husky e2e run <task-id> --env TEST_USER=admin --headed
+
+# E2E Inbox (pending test requests)
+husky e2e inbox                          # List all inbox messages
+husky e2e inbox --status pending         # Filter by status
+husky e2e inbox --task <task-id>         # Filter by task
+
+# Watch for new E2E requests (auto-processing)
+husky e2e watch --interval 30
+husky e2e watch --once                   # Process once and exit
+
+# Browser automation utilities
+husky e2e screenshot <url>               # Take screenshot
+husky e2e screenshot <url> --upload      # Upload to GCS
+husky e2e record <url>                   # Record browser session
+
+# Artifact management
+husky e2e upload <file> --task <id>      # Upload to GCS
+husky e2e list --task <id>               # List artifacts
+husky e2e clean --older-than 7           # Clean old artifacts
+```
+
 ### Business Strategy
 
 ```bash
@@ -296,6 +324,20 @@ husky --version
 
 ## Changelog
 
+### v1.7.0 (2026-01-11) - E2E Agent Production Ready
+
+**New Features:**
+- `husky e2e inbox` - List E2E test requests from API
+- `husky e2e watch` - Watch for and auto-process E2E requests
+- `husky e2e run --secret` - Inject secrets from GCP Secret Manager
+- `husky e2e run --env` - Set environment variables for tests
+- `husky e2e run --retries` - Retry failed tests automatically
+
+**Improvements:**
+- All artifact URLs now use HTTPS
+- Better error handling in E2E commands
+- Updated permissions for e2e_agent role
+
 ### v1.1.0 (2026-01-09) - Unified Reply System
 
 **New Features:**

package/dist/commands/agent.js

@@ -376,6 +376,49 @@ agentCommand
         process.exit(1);
     }
 });
+// husky agent qa-review
+agentCommand
+    .command("qa-review <taskId>")
+    .description("Trigger QA review for a task")
+    .option("--pr <url>", "PR URL to review")
+    .option("--json", "Output as JSON")
+    .action(async (taskId, options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/tasks/${taskId}/assign-reviewer`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                prUrl: options.pr,
+            }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`Error assigning reviewer: ${res.status} - ${error}`);
+            process.exit(1);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+        else {
+            console.log(`\n✓ Task ${taskId} assigned to reviewer`);
+            console.log(`  Inbox ID: ${data.inboxId}`);
+            console.log(`  Message:  ${data.message}`);
+        }
+    }
+    catch (error) {
+        console.error("Error triggering QA review:", error);
+        process.exit(1);
+    }
+});
 // husky agent register
 agentCommand
     .command("register")

package/dist/commands/chat.js

@@ -446,7 +446,22 @@ chatCommand
                 method: "POST",
                 headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
             });
-            console.log("✅ Reply sent to Google Chat and message marked as read.");
+            // Add reaction to original message if messageName is available
+            if (msg.messageName) {
+                try {
+                    await fetch(`${huskyApiUrl}/api/google-chat/messages/${encodeURIComponent(msg.messageName)}/react`, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                        },
+                        body: JSON.stringify({ emoji: "✅" }),
+                    });
+                }
+                catch {
+                    // Reaction is optional - don't fail if it doesn't work
+                }
+            }
         }
     }
     catch (error) {

package/dist/commands/e2e.js

@@ -60,6 +60,21 @@ function uploadToGCS(localPath, gcsPath) {
     console.error("GCS upload failed:", result.stderr);
     return { success: false, url: "" };
 }
+// Helper: Fetch secret from GCP Secret Manager
+async function fetchSecret(secretName) {
+    const result = runCommand("gcloud", [
+        "secrets", "versions", "access", "latest",
+        "--secret", secretName,
+    ]);
+    if (!result.success) {
+        throw new Error(`Failed to fetch secret ${secretName}: ${result.stderr}`);
+    }
+    return result.stdout.trim();
+}
+// Helper: Sleep function
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 // husky e2e run <task-id>
 e2eCommand
     .command("run <taskId>")
@@ -69,16 +84,48 @@ e2eCommand
     .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("--retries <count>", "Number of retries for failed tests", "0")
+    .option("--secret <names...>", "Secrets to fetch from GCP Secret Manager")
+    .option("--env <values...>", "Environment variables (KEY=value)")
     .option("--json", "Output as JSON")
     .action(async (taskId, options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     const config = ensureConfig();
     const timestamp = generateTimestamp();
     const outputDir = options.output || `/tmp/e2e-${taskId}-${timestamp}`;
+    const maxRetries = parseInt(options.retries, 10);
+    // Inject secrets from GCP Secret Manager
+    if (options.secret && options.secret.length > 0) {
+        console.log(`\n  Loading secrets from GCP...`);
+        for (const secretName of options.secret) {
+            try {
+                const value = await fetchSecret(secretName);
+                process.env[secretName] = value;
+                console.log(`  ✓ ${secretName} loaded`);
+            }
+            catch (error) {
+                console.error(`  ✗ Failed to load ${secretName}:`, error.message);
+                process.exit(1);
+            }
+        }
+    }
+    // Inject environment variables
+    if (options.env && options.env.length > 0) {
+        console.log(`\n  Setting environment variables...`);
+        for (const envPair of options.env) {
+            const [key, ...valueParts] = envPair.split("=");
+            const value = valueParts.join("=");
+            process.env[key] = value;
+            console.log(`  ✓ ${key} set`);
+        }
+    }
     console.log(`\n  E2E Tests for Task: ${taskId}\n`);
     console.log(`  Output directory: ${outputDir}`);
     console.log(`  Browser: ${options.browser}`);
     console.log(`  Headless: ${!options.headed}`);
+    if (maxRetries > 0) {
+        console.log(`  Retries: ${maxRetries}`);
+    }
     console.log("");
     // Create output directory
     if (!fs.existsSync(outputDir)) {
@@ -129,9 +176,28 @@ e2eCommand
     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
-    });
+    // Run tests with retry logic
+    let result = { stdout: "", stderr: "", success: false };
+    let attempts = 0;
+    while (attempts <= maxRetries) {
+        attempts++;
+        if (attempts > 1) {
+            console.log(`\n  Retry ${attempts - 1}/${maxRetries}...\n`);
+            await sleep(5000); // Wait 5 seconds before retry
+        }
+        result = runCommand("npx", ["playwright", ...playwrightArgs], {
+            timeout: parseInt(options.timeout, 10) * 2, // Allow 2x timeout for test suite
+        });
+        if (result.success) {
+            break;
+        }
+        // Capture failure screenshot on last attempt
+        if (attempts > maxRetries) {
+            console.log("  Capturing failure screenshot...");
+            const failScreenshot = path.join(outputDir, `failure-${timestamp}.png`);
+            // Note: Playwright already captures screenshots on failure with --screenshot=on
+        }
+    }
     const testResult = {
         taskId,
         taskName,
@@ -183,7 +249,7 @@ e2eCommand
     .option("--video", "Record video of the session")
     .option("--json", "Output as JSON")
     .action(async (url, options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     const timestamp = generateTimestamp();
     const outputFile = options.output || `/tmp/e2e-recording-${timestamp}.ts`;
     const videoDir = `/tmp/e2e-video-${timestamp}`;
@@ -260,7 +326,7 @@ e2eCommand
     .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:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
         process.exit(1);
@@ -312,7 +378,7 @@ e2eCommand
     .option("--upload", "Upload screenshot to GCS")
     .option("--json", "Output as JSON")
     .action(async (url, options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     const timestamp = generateTimestamp();
     const defaultFilename = `screenshot-${timestamp}.png`;
     const outputFile = options.output || `/tmp/${defaultFilename}`;
@@ -415,7 +481,7 @@ e2eCommand
     .option("--limit <n>", "Limit number of results", "20")
     .option("--json", "Output as JSON")
     .action(async (options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     let gcsPath = `gs://${GCS_BUCKET}/e2e/`;
     if (options.task) {
         gcsPath += `${options.task}/`;
@@ -483,7 +549,7 @@ e2eCommand
     .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:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     console.log(`\n  Cleaning E2E Artifacts\n`);
     const tmpDir = "/tmp";
     const e2ePatterns = ["e2e-", "screenshot-", "recording-"];
@@ -526,3 +592,182 @@ e2eCommand
     console.log(`  ${options.dryRun ? "Would clean" : "Cleaned"}: ${cleaned} items (${(totalSize / 1024 / 1024).toFixed(2)} MB)`);
     console.log("");
 });
+// husky e2e inbox - List E2E inbox messages
+e2eCommand
+    .command("inbox")
+    .description("List E2E inbox messages from API")
+    .option("--status <status>", "Filter by status (pending, running, completed, failed)")
+    .option("--task <taskId>", "Filter by task ID")
+    .option("--limit <n>", "Limit number of results", "50")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
+    const config = ensureConfig();
+    const params = new URLSearchParams();
+    if (options.status)
+        params.set("status", options.status);
+    if (options.task)
+        params.set("taskId", options.task);
+    if (options.limit)
+        params.set("limit", options.limit);
+    const url = `${config.apiUrl}/api/e2e/inbox?${params.toString()}`;
+    try {
+        const res = await fetch(url, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            console.error(`Error: ${res.status} ${res.statusText}`);
+            process.exit(1);
+        }
+        const inbox = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(inbox, null, 2));
+            return;
+        }
+        console.log(`\n  E2E Inbox (${inbox.length} items)\n`);
+        if (inbox.length === 0) {
+            console.log("  No E2E inbox messages found.");
+            console.log("");
+            return;
+        }
+        console.log("  " + "-".repeat(80));
+        console.log(`  ${"STATUS".padEnd(12)} ${"TASK ID".padEnd(24)} TITLE`);
+        console.log("  " + "-".repeat(80));
+        for (const item of inbox) {
+            const statusIcons = {
+                pending: "⏳",
+                running: "🔄",
+                completed: "✅",
+                failed: "❌",
+            };
+            const statusIcon = statusIcons[item.status] || "❓";
+            console.log(`  ${statusIcon} ${item.status.padEnd(10)} ${item.taskId.padEnd(24)} ${item.taskTitle?.slice(0, 40) || "N/A"}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error fetching E2E inbox:", error.message);
+        process.exit(1);
+    }
+});
+// husky e2e watch - Watch E2E inbox for new test requests
+e2eCommand
+    .command("watch")
+    .description("Watch E2E inbox for new test requests")
+    .option("--interval <seconds>", "Poll interval in seconds", "30")
+    .option("--once", "Process inbox once and exit")
+    .action(async (options) => {
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
+    const config = ensureConfig();
+    const interval = parseInt(options.interval, 10) * 1000;
+    console.log(`\n  E2E Inbox Watcher\n`);
+    console.log(`  API: ${config.apiUrl}`);
+    console.log(`  Poll interval: ${options.interval}s`);
+    console.log("");
+    const processInbox = async () => {
+        try {
+            // Fetch E2E inbox from API
+            const res = await fetch(`${config.apiUrl}/api/e2e/inbox`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            if (!res.ok) {
+                console.error(`  Error fetching inbox: ${res.status}`);
+                return;
+            }
+            const inbox = await res.json();
+            const pending = inbox.filter((item) => item.status === "pending");
+            if (pending.length === 0) {
+                console.log(`  [${new Date().toISOString()}] No pending E2E requests`);
+                return;
+            }
+            console.log(`  [${new Date().toISOString()}] Found ${pending.length} pending E2E request(s)`);
+            for (const item of pending) {
+                console.log(`\n  Processing: ${item.taskId} - ${item.taskTitle}`);
+                // Update status to running
+                await fetch(`${config.apiUrl}/api/e2e/inbox/${item.id}`, {
+                    method: "PATCH",
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                    },
+                    body: JSON.stringify({ status: "running" }),
+                });
+                // Run E2E tests for this task
+                const timestamp = generateTimestamp();
+                const outputDir = `/tmp/e2e-${item.taskId}-${timestamp}`;
+                console.log(`  Running tests in ${outputDir}...`);
+                const playwrightArgs = [
+                    "test",
+                    "--reporter=list",
+                    `--output=${outputDir}`,
+                    "--timeout=60000",
+                ];
+                const result = runCommand("npx", ["playwright", ...playwrightArgs], {
+                    timeout: 300000, // 5 min
+                });
+                // Upload results
+                const resultsPath = path.join(outputDir, "results.json");
+                const testResult = {
+                    taskId: item.taskId,
+                    success: result.success,
+                    timestamp,
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                };
+                if (!fs.existsSync(outputDir)) {
+                    fs.mkdirSync(outputDir, { recursive: true });
+                }
+                fs.writeFileSync(resultsPath, JSON.stringify(testResult, null, 2));
+                const gcsPath = `e2e/${item.taskId}/${timestamp}/results.json`;
+                const uploadResult = uploadToGCS(resultsPath, gcsPath);
+                // Update inbox status
+                await fetch(`${config.apiUrl}/api/e2e/inbox/${item.id}`, {
+                    method: "PATCH",
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                    },
+                    body: JSON.stringify({
+                        status: result.success ? "completed" : "failed",
+                        completedAt: new Date().toISOString(),
+                        result: {
+                            passed: result.success,
+                            gcsUrl: uploadResult.url,
+                        },
+                    }),
+                });
+                // Update task status via API
+                const taskEndpoint = result.success
+                    ? `${config.apiUrl}/api/tasks/${item.taskId}/e2e/pass`
+                    : `${config.apiUrl}/api/tasks/${item.taskId}/e2e/fail`;
+                await fetch(taskEndpoint, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                    },
+                    body: JSON.stringify({
+                        notes: result.success ? "E2E tests passed" : "E2E tests failed",
+                        testResults: testResult,
+                        screenshots: uploadResult.url ? [uploadResult.url] : [],
+                    }),
+                });
+                console.log(`  ${result.success ? "✓" : "✗"} Task ${item.taskId}: ${result.success ? "PASSED" : "FAILED"}`);
+            }
+        }
+        catch (error) {
+            console.error(`  Error processing inbox:`, error.message);
+        }
+    };
+    // Process once or continuously
+    if (options.once) {
+        await processInbox();
+    }
+    else {
+        console.log("  Watching for E2E requests... (Ctrl+C to stop)\n");
+        while (true) {
+            await processInbox();
+            await sleep(interval);
+        }
+    }
+});

package/dist/commands/task.js

@@ -928,37 +928,60 @@ taskCommand
         process.exit(1);
     }
 });
-// husky task qa-reject [--id <id>] [--notes <text>]
+// husky task qa-reject [--id <id>] [--notes <text>] [--issues <json>]
 taskCommand
     .command("qa-reject")
-    .description("Manually reject QA for a task")
+    .description("Reject QA and request fixes")
     .option("--id <id>", "Task ID (or set HUSKY_TASK_ID)")
     .option("--notes <text>", "Rejection notes")
+    .option("--issues <json>", "Issues as JSON array")
     .action(async (options) => {
     const config = ensureConfig();
     const taskId = getTaskId(options);
+    let issues = [];
+    if (options.issues) {
+        try {
+            issues = JSON.parse(options.issues);
+        }
+        catch {
+            console.error("Error: --issues must be valid JSON");
+            process.exit(1);
+        }
+    }
     try {
-        const res = await fetch(`${config.apiUrl}/api/tasks/${taskId}/qa/approve`, {
+        const res = await fetch(`${config.apiUrl}/api/tasks/${taskId}/qa/reject`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
                 ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
             },
             body: JSON.stringify({
-                approved: false,
                 notes: options.notes,
+                issues,
             }),
         });
         if (!res.ok) {
             throw new Error(`API error: ${res.status}`);
         }
-        console.log(`✗ QA manually rejected for task ${taskId}`);
+        console.log(`✗ QA rejected for task ${taskId}`);
+        console.log(`  Task returned to worker for fixes`);
     }
     catch (error) {
         console.error("Error rejecting QA:", error);
         process.exit(1);
     }
 });
+// husky task qa-request-fix (alias for qa-reject with specific focus)
+taskCommand
+    .command("qa-request-fix")
+    .description("Request fixes from the worker")
+    .option("--id <id>", "Task ID (or set HUSKY_TASK_ID)")
+    .requiredOption("--notes <text>", "Fix instructions")
+    .option("--issues <json>", "Issues as JSON array")
+    .action(async (options) => {
+    // Re-use qa-reject logic
+    await taskCommand.parseAsync(["node", "husky", "task", "qa-reject", "--id", getTaskId(options), "--notes", options.notes, ...(options.issues ? ["--issues", options.issues] : [])], { from: "user" });
+});
 // husky task qa-iteration [--id <id>] --iteration <n> --status <status> [--issues <json>] [--duration <seconds>]
 taskCommand
     .command("qa-iteration")

package/dist/commands/vm.js

@@ -1183,3 +1183,275 @@ function printLog(log) {
     }
     console.log(`${prefix}${timestamp} ${level} ${source} ${log.message}`);
 }
+// ============================================================================
+// Anthropic OAuth Commands (for subscription auth)
+// ============================================================================
+// husky vm auth-status <sessionId>
+vmCommand
+    .command("auth-status <sessionId>")
+    .description("Check Anthropic OAuth status for a VM session")
+    .option("--wait", "Wait for authentication to complete (polling)")
+    .option("--timeout <seconds>", "Timeout for waiting (default: 300)", "300")
+    .option("--json", "Output as JSON")
+    .action(async (sessionId, options) => {
+    const config = ensureConfig();
+    const checkStatus = async () => {
+        const res = await fetch(`${config.apiUrl}/api/vm-sessions/${sessionId}/auth-status`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            throw new Error(`API error: ${res.status} - ${error}`);
+        }
+        return await res.json();
+    };
+    try {
+        let data = await checkStatus();
+        if (options.wait && ["none", "awaiting_url", "awaiting_code"].includes(data.authStatus)) {
+            console.log("Waiting for Anthropic authentication...");
+            const timeoutMs = parseInt(options.timeout, 10) * 1000;
+            const startTime = Date.now();
+            const pollInterval = 3000;
+            while (Date.now() - startTime < timeoutMs) {
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
+                data = await checkStatus();
+                if (!["none", "awaiting_url", "awaiting_code"].includes(data.authStatus)) {
+                    break;
+                }
+                process.stdout.write(".");
+            }
+            console.log("");
+        }
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const statusIcon = {
+            none: "⚪",
+            awaiting_url: "🔗",
+            awaiting_code: "⏳",
+            code_submitted: "📤",
+            authenticated: "✅",
+            failed: "❌",
+        };
+        const icon = statusIcon[data.authStatus] || "❓";
+        console.log(`\n  ${icon} Auth Status: ${data.authStatus.toUpperCase()}`);
+        console.log("  " + "-".repeat(40));
+        console.log(`  VM Status:  ${data.vmStatus}`);
+        if (data.authUrl) {
+            console.log(`  Auth URL:   ${data.authUrl}`);
+        }
+        if (data.authRequestedAt) {
+            console.log(`  Requested:  ${new Date(data.authRequestedAt).toLocaleString()}`);
+        }
+        if (data.authCodeSubmittedAt) {
+            console.log(`  Code sent:  ${new Date(data.authCodeSubmittedAt).toLocaleString()}`);
+        }
+        console.log("");
+        // Exit with error code if not authenticated
+        if (data.authStatus === "failed") {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error("Error checking auth status:", error);
+        process.exit(1);
+    }
+});
+// husky vm submit-auth-code <sessionId> <code>
+vmCommand
+    .command("submit-auth-code <sessionId> <code>")
+    .description("Submit Anthropic auth code to a VM session (fallback if GChat routing fails)")
+    .option("--submitted-by <name>", "Name of person submitting the code")
+    .option("--json", "Output as JSON")
+    .action(async (sessionId, code, options) => {
+    const config = ensureConfig();
+    // Validate code format (same as server-side)
+    const sanitizedCode = code.replace(/[^A-Za-z0-9-_]/g, "");
+    if (sanitizedCode !== code || code.length < 4) {
+        console.error("Error: Invalid auth code format.");
+        console.error("  Code must be at least 4 characters and contain only:");
+        console.error("  - Letters (A-Z, a-z)");
+        console.error("  - Numbers (0-9)");
+        console.error("  - Dashes (-) and underscores (_)");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/vm-sessions/${sessionId}/submit-auth-code`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                code: code,
+                submittedBy: options.submittedBy || "CLI",
+            }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            throw new Error(`API error: ${res.status} - ${error}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        console.log(`\n  ✅ ${data.message}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error submitting auth code:", error);
+        process.exit(1);
+    }
+});
+// husky vm claude-code <sessionId>
+vmCommand
+    .command("claude-code <sessionId>")
+    .description("Connect to Claude Code on a VM via SSH (for debugging/interaction)")
+    .option("--zone <zone>", "GCP zone", "europe-west1-b")
+    .option("--attach", "Attach to existing tmux session instead of new shell")
+    .action(async (sessionId, options) => {
+    const config = ensureConfig();
+    try {
+        // Get session details
+        const res = await fetch(`${config.apiUrl}/api/vm-sessions/${sessionId}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            throw new Error(`API error: ${res.status} - ${error}`);
+        }
+        const session = await res.json();
+        if (session.vmStatus !== "running" && session.vmStatus !== "awaiting_auth") {
+            console.error(`Error: VM is not running (status: ${session.vmStatus})`);
+            process.exit(1);
+        }
+        const zone = options.zone || session.vmZone || "europe-west1-b";
+        const vmName = session.vmName;
+        console.log(`\n  🔗 Connecting to Claude Code on ${vmName}...`);
+        console.log("  " + "-".repeat(40));
+        console.log(`  VM:     ${vmName}`);
+        console.log(`  Zone:   ${zone}`);
+        console.log(`  Status: ${session.vmStatus}`);
+        if (session.authStatus) {
+            console.log(`  Auth:   ${session.authStatus}`);
+        }
+        console.log("");
+        // Build SSH command
+        const sshArgs = [
+            "compute", "ssh", vmName,
+            `--zone=${zone}`,
+        ];
+        if (options.attach) {
+            // Attach to existing tmux session
+            sshArgs.push("--command=tmux attach-session -t main || tmux new-session -s main");
+            console.log("  Attaching to tmux session 'main'...\n");
+        }
+        else {
+            // Just SSH in
+            console.log("  Opening SSH shell...\n");
+            console.log("  Tip: Run 'tmux attach -t main' to see Claude Code output");
+            console.log("");
+        }
+        // Execute SSH
+        const result = spawnSync("gcloud", sshArgs, {
+            stdio: "inherit",
+        });
+        if (result.status !== 0) {
+            console.error("\nSSH connection failed");
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error("Error connecting to VM:", error);
+        process.exit(1);
+    }
+});
+// husky vm send-message <sessionId> <message>
+vmCommand
+    .command("send-message <sessionId> <message>")
+    .description("Send a message directly to a VM agent")
+    .option("--sender <name>", "Sender name", "CLI User")
+    .option("--email <email>", "Sender email")
+    .option("--thread <name>", "Thread name for context")
+    .option("--json", "Output as JSON")
+    .action(async (sessionId, message, options) => {
+    const config = ensureConfig();
+    try {
+        const res = await fetch(`${config.apiUrl}/api/vm-sessions/${sessionId}/send-message`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                content: message,
+                senderName: options.sender,
+                senderEmail: options.email,
+                threadName: options.thread,
+            }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            throw new Error(`API error: ${res.status} - ${error}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        console.log(`✅ ${data.message}`);
+        console.log(`   Message ID: ${data.messageId}`);
+    }
+    catch (error) {
+        console.error("Error sending message:", error);
+        process.exit(1);
+    }
+});
+// husky vm messages <sessionId>
+vmCommand
+    .command("messages <sessionId>")
+    .description("List messages sent to a VM session")
+    .option("--limit <n>", "Number of messages", "20")
+    .option("--status <status>", "Filter by status (pending, delivered, failed)")
+    .option("--json", "Output as JSON")
+    .action(async (sessionId, options) => {
+    const config = ensureConfig();
+    try {
+        const params = new URLSearchParams();
+        if (options.limit)
+            params.set("limit", options.limit);
+        if (options.status)
+            params.set("status", options.status);
+        const res = await fetch(`${config.apiUrl}/api/vm-sessions/${sessionId}/messages?${params}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            throw new Error(`API error: ${res.status} - ${error}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        if (!data.messages || data.messages.length === 0) {
+            console.log("\n  No messages found for this VM session.");
+            return;
+        }
+        console.log("\n  VM Session Messages");
+        console.log("  " + "-".repeat(60));
+        for (const msg of data.messages) {
+            const time = new Date(msg.createdAt).toLocaleTimeString();
+            const statusIcon = msg.status === "delivered" ? "✅" : msg.status === "failed" ? "❌" : "⏳";
+            console.log(`  ${statusIcon} [${time}] ${msg.senderName}`);
+            console.log(`     ${msg.content.substring(0, 60)}${msg.content.length > 60 ? "..." : ""}`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error fetching messages:", error);
+        process.exit(1);
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "1.6.5",
+  "version": "1.7.0",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {