@simonfestl/husky-cli 1.0.0 → 1.2.0

package/README.md

@@ -174,6 +174,32 @@ husky vm-config update <config-id> --machine-type e2-standard-2
 husky vm-config delete <config-id>
 ```
 
+### Chat / Messaging
+
+```bash
+# Check pending messages
+husky chat pending
+husky chat pending --json
+
+# View inbox (GitHub + Google Chat)
+husky chat inbox
+husky chat inbox --unread
+
+# Reply to any message (auto-detects platform)
+husky chat reply-to <messageId> "Your response"
+
+# Reply in Google Chat thread
+husky chat reply-chat "Message" --thread <threadName>
+
+# Mark message as read
+husky chat mark-read <messageId>
+
+# Watch for messages (inject into tmux)
+husky chat watch-inject --tmux-session supervisor
+```
+
+The `reply-to` command automatically detects whether the message is from GitHub or Google Chat and uses the appropriate API to send the reply.
+
 ### Settings
 
 ```bash
@@ -270,6 +296,17 @@ husky --version
 
 ## Changelog
 
+### v1.1.0 (2026-01-09) - Unified Reply System
+
+**New Features:**
+- `husky chat reply-to` now supports both GitHub and Google Chat
+- Auto-detects platform from message metadata
+- GitHub replies use GitHub App (no PAT required on VM)
+
+**Improvements:**
+- Require 8+ character prefix for messageId matching (prevents misdirected replies)
+- Better error messages for short messageId prefixes
+
 ### v1.0.0 (2026-01-08) - Supervisor Architecture
 
 **BREAKING CHANGES:**

package/dist/commands/chat.js

@@ -1,5 +1,13 @@
 import { Command } from "commander";
 import { getConfig } from "./config.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+// Helper to get the Husky API URL (for Google Chat integration)
+function getHuskyApiUrl() {
+    const config = getConfig();
+    return config.apiUrl || null;
+}
 export const chatCommand = new Command("chat")
     .description("Communicate with the dashboard chat");
 chatCommand
@@ -160,3 +168,502 @@ chatCommand
         process.exit(1);
     }
 });
+chatCommand
+    .command("review <question>")
+    .description("Request human review via Google Chat")
+    .option("--task-id <id>", "Link to a specific task")
+    .option("--context <text>", "Additional context for the reviewer")
+    .option("--priority <level>", "Priority: low, normal, urgent", "normal")
+    .option("--wait", "Wait for human response (polling)")
+    .option("--timeout <seconds>", "Timeout for waiting (default: 300)", "300")
+    .option("--json", "Output as JSON")
+    .action(async (question, options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    const workerId = process.env.HUSKY_WORKER_ID || `agent-${process.pid}`;
+    try {
+        const res = await fetch(`${huskyApiUrl}/api/google-chat/request-review`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                agentId: workerId,
+                taskId: options.taskId,
+                question,
+                context: options.context,
+                priority: options.priority,
+            }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            throw new Error(`API error: ${res.status} - ${error}`);
+        }
+        const data = await res.json();
+        if (!options.wait) {
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else {
+                console.log(`Review requested (ID: ${data.id})`);
+                console.log(`Status: ${data.status}`);
+                console.log(`\nTo check status: husky chat review-status ${data.id}`);
+                console.log(`To wait for response: husky chat review-wait ${data.id}`);
+            }
+            return;
+        }
+        console.log(`Review requested (ID: ${data.id}). Waiting for human response...`);
+        const timeoutMs = parseInt(options.timeout, 10) * 1000;
+        const startTime = Date.now();
+        const pollInterval = 5000;
+        while (Date.now() - startTime < timeoutMs) {
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            const pollRes = await fetch(`${huskyApiUrl}/api/google-chat/review/${data.id}/poll`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            if (!pollRes.ok)
+                continue;
+            const pollData = await pollRes.json();
+            if (pollData.status === "answered" && pollData.response) {
+                if (options.json) {
+                    console.log(JSON.stringify(pollData, null, 2));
+                }
+                else {
+                    console.log(`\nHuman response received from ${pollData.respondedBy || "unknown"}:`);
+                    console.log(`\n${pollData.response}`);
+                }
+                return;
+            }
+            process.stdout.write(".");
+        }
+        console.error("\nTimeout waiting for human response.");
+        process.exit(1);
+    }
+    catch (error) {
+        console.error("Error requesting review:", error);
+        process.exit(1);
+    }
+});
+chatCommand
+    .command("review-status <reviewId>")
+    .description("Check status of a human review request")
+    .option("--json", "Output as JSON")
+    .action(async (reviewId, options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${huskyApiUrl}/api/google-chat/review/${reviewId}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error("Review not found.");
+                process.exit(1);
+            }
+            throw new Error(`API error: ${res.status}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        console.log(`\nReview: ${data.id}`);
+        console.log(`Status: ${data.status}`);
+        console.log(`Question: ${data.question}`);
+        if (data.response) {
+            console.log(`\nResponse from ${data.respondedBy || "unknown"}:`);
+            console.log(data.response);
+        }
+    }
+    catch (error) {
+        console.error("Error checking review status:", error);
+        process.exit(1);
+    }
+});
+// ============================================
+// SUPERVISOR INBOX COMMANDS (Google Chat <-> Supervisor)
+// ============================================
+chatCommand
+    .command("inbox")
+    .description("Get messages from Google Chat (supervisor inbox)")
+    .option("--unread", "Only show unread messages")
+    .option("--limit <n>", "Number of messages", "10")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    try {
+        const params = new URLSearchParams();
+        if (options.unread)
+            params.set("unread", "true");
+        if (options.limit)
+            params.set("limit", options.limit);
+        const res = await fetch(`${huskyApiUrl}/api/google-chat/inbox?${params}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        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(options.unread ? "📭 No unread messages." : "📭 No messages in inbox.");
+            return;
+        }
+        console.log("\n  📬 Supervisor Inbox");
+        console.log("  " + "─".repeat(60));
+        for (const msg of data.messages) {
+            const time = new Date(msg.createdAt).toLocaleString();
+            const readIcon = msg.read ? "✓" : "●";
+            console.log(`  ${readIcon} [${msg.id.slice(0, 8)}] ${msg.senderName} (${time})`);
+            console.log(`    "${msg.text}"`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error fetching inbox:", error);
+        process.exit(1);
+    }
+});
+chatCommand
+    .command("reply-chat <message>")
+    .description("Send a message to Google Chat (supervisor -> human)")
+    .option("--space <name>", "Target space (e.g., spaces/ABC123)")
+    .option("--thread <name>", "Reply in thread (e.g., spaces/ABC123/threads/XYZ)")
+    .action(async (message, options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${huskyApiUrl}/api/google-chat/send`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                text: message,
+                spaceName: options.space,
+                threadName: options.thread,
+            }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            throw new Error(`API error: ${res.status} - ${error}`);
+        }
+        console.log("✅ Message sent to Google Chat.");
+    }
+    catch (error) {
+        console.error("Error sending message:", error);
+        process.exit(1);
+    }
+});
+chatCommand
+    .command("reply-to <messageId> <response>")
+    .description("Reply to a specific inbox message in its thread (supports both GitHub and Google Chat)")
+    .action(async (messageId, response) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    try {
+        // Fetch inbox to find the message
+        const inboxRes = await fetch(`${huskyApiUrl}/api/google-chat/inbox?limit=50`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!inboxRes.ok) {
+            throw new Error(`Failed to fetch inbox: ${inboxRes.status}`);
+        }
+        const data = await inboxRes.json();
+        // Require exact match or at least 8 characters for prefix matching to avoid misdirected replies
+        const msg = data.messages.find(m => m.id === messageId || (messageId.length >= 8 && m.id.startsWith(messageId)));
+        if (!msg) {
+            console.error(`Message ${messageId} not found in inbox.`);
+            if (messageId.length < 8) {
+                console.error("Hint: Provide at least 8 characters of the message ID for prefix matching.");
+            }
+            process.exit(1);
+        }
+        // Check if it's a GitHub message
+        const isGitHub = msg.spaceName?.startsWith("github:");
+        if (isGitHub) {
+            // Use GitHub reply endpoint
+            const sendRes = await fetch(`${huskyApiUrl}/api/github/inbox/${msg.id}/reply`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                },
+                body: JSON.stringify({ text: response }),
+            });
+            if (!sendRes.ok) {
+                const error = await sendRes.text();
+                throw new Error(`API error: ${sendRes.status} - ${error}`);
+            }
+            console.log("✅ Reply posted to GitHub issue.");
+        }
+        else {
+            // Use Google Chat reply
+            const sendRes = await fetch(`${huskyApiUrl}/api/google-chat/send`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                },
+                body: JSON.stringify({
+                    text: response,
+                    spaceName: msg.spaceName,
+                    threadName: msg.threadName,
+                }),
+            });
+            if (!sendRes.ok) {
+                const error = await sendRes.text();
+                throw new Error(`API error: ${sendRes.status} - ${error}`);
+            }
+            // Mark as read
+            await fetch(`${huskyApiUrl}/api/google-chat/inbox/${msg.id}/read`, {
+                method: "POST",
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            console.log("✅ Reply sent to Google Chat and message marked as read.");
+        }
+    }
+    catch (error) {
+        console.error("Error replying:", error);
+        process.exit(1);
+    }
+});
+chatCommand
+    .command("mark-read <messageId>")
+    .description("Mark a message as read")
+    .action(async (messageId) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${huskyApiUrl}/api/google-chat/inbox/${messageId}/read`, {
+            method: "POST",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        console.log("✅ Message marked as read.");
+    }
+    catch (error) {
+        console.error("Error marking message as read:", error);
+        process.exit(1);
+    }
+});
+chatCommand
+    .command("watch")
+    .description("Watch for new messages (blocking, for supervisor agent)")
+    .option("--poll-interval <seconds>", "Poll interval in seconds", "10")
+    .action(async (options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    console.log("👀 Watching for new messages... (Ctrl+C to stop)");
+    const pollInterval = parseInt(options.pollInterval, 10) * 1000;
+    let lastSeenId = "";
+    const poll = async () => {
+        try {
+            const res = await fetch(`${huskyApiUrl}/api/google-chat/inbox?unread=true&limit=5`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            if (!res.ok)
+                return;
+            const data = await res.json();
+            for (const msg of data.messages || []) {
+                if (msg.id !== lastSeenId) {
+                    lastSeenId = msg.id;
+                    const time = new Date(msg.createdAt).toLocaleTimeString();
+                    console.log(`\n📨 [${time}] ${msg.senderName}: ${msg.text}`);
+                }
+            }
+        }
+        catch { }
+    };
+    await poll();
+    setInterval(poll, pollInterval);
+    process.on("SIGINT", () => {
+        console.log("\n👋 Stopped watching.");
+        process.exit(0);
+    });
+    await new Promise(() => { });
+});
+chatCommand
+    .command("watch-inject")
+    .description("Watch for messages and inject them into a tmux session")
+    .option("--poll-interval <seconds>", "Poll interval in seconds", "2")
+    .option("--tmux-session <name>", "Target tmux session name", "supervisor")
+    .option("--tmux-window <name>", "Target tmux window name or index (default: 0)", "0")
+    .option("--hint", "Show reply hint after messages (default: true)", true)
+    .option("--no-hint", "Hide reply hint")
+    .action(async (options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    const tmuxSession = options.tmuxSession;
+    const tmuxWindow = options.tmuxWindow;
+    const tmuxTarget = `${tmuxSession}:${tmuxWindow}`;
+    const pollInterval = parseInt(options.pollInterval, 10) * 1000;
+    const processedIds = new Set();
+    console.log(`📡 Watching for messages (Google Chat & GitHub)...`);
+    console.log(`   Target: ${tmuxTarget}`);
+    console.log(`   Poll interval: ${options.pollInterval}s`);
+    console.log(`   Press Ctrl+C to stop\n`);
+    const injectToTmux = async (text, senderName, spaceName) => {
+        // Detect platform from spaceName
+        const isGitHub = spaceName?.startsWith("github:");
+        const platform = isGitHub ? "GitHub" : "Google Chat";
+        let formattedMessage = `[${platform}] ${senderName}: ${text}`;
+        if (options.hint) {
+            if (isGitHub) {
+                // Extract repo info from spaceName (format: github:owner/repo)
+                const repoInfo = spaceName?.replace("github:", "") || "";
+                formattedMessage += `\n💡 Reply on GitHub: ${repoInfo}`;
+            }
+            else {
+                formattedMessage += `\n💡 Tip: Use \`husky chat reply-chat "your response"\` to reply`;
+            }
+        }
+        const escapedMessage = formattedMessage
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g, '\\"')
+            .replace(/\$/g, "\\$")
+            .replace(/`/g, "\\`")
+            .replace(/'/g, "'\\''");
+        try {
+            await execAsync(`tmux send-keys -t "${tmuxTarget}" "${escapedMessage}" Enter`, { timeout: 5000 });
+            return true;
+        }
+        catch (error) {
+            const err = error;
+            console.error(`   ❌ Failed to inject: ${err.message}`);
+            return false;
+        }
+    };
+    const markAsRead = async (messageId) => {
+        try {
+            await fetch(`${huskyApiUrl}/api/google-chat/inbox/${messageId}/read`, {
+                method: "POST",
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+        }
+        catch { }
+    };
+    const poll = async () => {
+        try {
+            const res = await fetch(`${huskyApiUrl}/api/google-chat/inbox?unread=true&limit=10`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            if (!res.ok)
+                return;
+            const data = await res.json();
+            const messages = (data.messages || []).reverse();
+            for (const msg of messages) {
+                if (processedIds.has(msg.id))
+                    continue;
+                processedIds.add(msg.id);
+                const time = new Date(msg.createdAt).toLocaleTimeString();
+                const platform = msg.spaceName?.startsWith("github:") ? "GitHub" : "Google Chat";
+                console.log(`📨 [${time}] Injecting ${platform} message from ${msg.senderName}`);
+                const success = await injectToTmux(msg.text, msg.senderName, msg.spaceName);
+                if (success) {
+                    await markAsRead(msg.id);
+                    console.log(`   ✓ Injected and marked as read`);
+                }
+            }
+        }
+        catch (error) {
+            const err = error;
+            console.error(`Poll error: ${err.message}`);
+        }
+    };
+    await poll();
+    setInterval(poll, pollInterval);
+    process.on("SIGINT", () => {
+        console.log("\n👋 Stopped watching.");
+        process.exit(0);
+    });
+    await new Promise(() => { });
+});
+// ============================================
+// REVIEW COMMANDS (kept for backwards compatibility)
+// ============================================
+chatCommand
+    .command("review-wait <reviewId>")
+    .description("Wait for a human review response")
+    .option("--timeout <seconds>", "Timeout in seconds (default: 300)", "300")
+    .option("--json", "Output as JSON")
+    .action(async (reviewId, options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    console.log(`Waiting for response to review ${reviewId}...`);
+    const timeoutMs = parseInt(options.timeout, 10) * 1000;
+    const startTime = Date.now();
+    const pollInterval = 5000;
+    try {
+        while (Date.now() - startTime < timeoutMs) {
+            const res = await fetch(`${huskyApiUrl}/api/google-chat/review/${reviewId}/poll`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            if (res.ok) {
+                const data = await res.json();
+                if (data.status === "answered" && data.response) {
+                    if (options.json) {
+                        console.log(JSON.stringify(data, null, 2));
+                    }
+                    else {
+                        console.log(`\nHuman response received from ${data.respondedBy || "unknown"}:`);
+                        console.log(`\n${data.response}`);
+                    }
+                    return;
+                }
+            }
+            process.stdout.write(".");
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+        console.error("\nTimeout waiting for human response.");
+        process.exit(1);
+    }
+    catch (error) {
+        console.error("Error waiting for review:", error);
+        process.exit(1);
+    }
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const initCommand: Command;

package/dist/commands/init.js

@@ -0,0 +1,91 @@
+import { Command } from "commander";
+import { existsSync, writeFileSync } from "fs";
+import { join } from "path";
+import { createRequire } from "module";
+import { generateLLMContext } from "./llm-context.js";
+const require = createRequire(import.meta.url);
+const packageJson = require("../../package.json");
+const HUSKY_MD_FILENAME = "HUSKY.md";
+function generateHuskyMdContent() {
+    const timestamp = new Date().toISOString();
+    const cliRef = generateLLMContext();
+    return `<!-- 
+  Auto-generated by husky init (v${packageJson.version})
+  Generated: ${timestamp}
+  
+  This file instructs AI coding agents to use the Husky CLI.
+  Update with: husky init --force
+-->
+
+${cliRef}
+
+---
+
+## Standard Workflow for AI Agents
+
+### On Session Start
+\`\`\`bash
+husky config test    # Verify API connection
+husky worker whoami  # Confirm worker identity
+\`\`\`
+
+### When Working on a Task
+\`\`\`bash
+# 1. Get task details
+husky task get <id>
+
+# 2. Start the task (creates isolated worktree)
+husky task start <id>
+
+# 3. CD into the worktree directory (MANDATORY)
+cd <worktree-path>  # Path shown in task start output
+
+# 4. Report progress as you work
+husky task message <id> "Analyzing codebase..."
+husky task message <id> "Implementing feature X..."
+
+# 5. When done, create PR and complete
+husky worktree pr <worktree-name> -t "feat: description"
+husky task done <id> --pr <pr-url>
+\`\`\`
+
+**IMPORTANT:** After \`husky task start\`, you MUST \`cd\` into the worktree directory before making any code changes.
+
+### When Handling Customer Support
+\`\`\`bash
+# 1. Get full customer context
+husky biz customers 360 <email>
+
+# 2. Check relevant tickets
+husky biz tickets search "<customer-email>"
+
+# 3. Check order history if needed
+husky biz orders search "<order-id-or-email>"
+
+# 4. Reply with context
+husky biz tickets reply <ticket-id> "Your response..."
+\`\`\`
+`;
+}
+export const initCommand = new Command("init")
+    .description("Initialize Husky in the current directory (creates HUSKY.md)")
+    .option("-f, --force", "Overwrite existing HUSKY.md")
+    .option("-q, --quiet", "Suppress output")
+    .action((options) => {
+    const targetPath = join(process.cwd(), HUSKY_MD_FILENAME);
+    if (existsSync(targetPath) && !options.force) {
+        console.error(`Error: ${HUSKY_MD_FILENAME} already exists.`);
+        console.error("Use --force to overwrite.");
+        process.exit(1);
+    }
+    const content = generateHuskyMdContent();
+    writeFileSync(targetPath, content);
+    if (!options.quiet) {
+        console.log(`✓ Created ${HUSKY_MD_FILENAME}`);
+        console.log("");
+        console.log("  This file instructs AI agents to use the Husky CLI.");
+        console.log("  Commit it to your repository so all agents see it.");
+        console.log("");
+        console.log("  Update with: husky init --force");
+    }
+});

package/dist/commands/preview.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const previewCommand: Command;

package/dist/commands/preview.js

@@ -0,0 +1,161 @@
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+const PREVIEW_DEPLOY_TRIGGER_ID = "80b3ba55-ae74-41cd-b7d0-a477ecc357b1";
+const PREVIEW_CLEANUP_TRIGGER_ID = "965c3e86-677f-4063-b391-43019f621ea2";
+const GCP_PROJECT = "tigerv0";
+async function apiRequest(method, path, body) {
+    const config = getConfig();
+    const url = `${config.apiUrl}${path}`;
+    const response = await fetch(url, {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": config.apiKey || "",
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    return response;
+}
+async function triggerCloudBuild(triggerId, substitutions) {
+    const { execSync } = await import("child_process");
+    const subsArgs = Object.entries(substitutions)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(",");
+    try {
+        const cmd = `gcloud builds triggers run ${triggerId} --project=${GCP_PROJECT} --branch=main --substitutions=${subsArgs} --format="value(metadata.build.id)" 2>&1`;
+        const output = execSync(cmd, { encoding: "utf-8" }).trim();
+        const buildId = output.split("\n").pop() || "";
+        return { success: true, buildId };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: message };
+    }
+}
+export const previewCommand = new Command("preview")
+    .description("Manage PR preview deployments");
+previewCommand
+    .command("list")
+    .description("List active preview deployments")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const response = await apiRequest("GET", "/api/previews");
+        if (!response.ok) {
+            console.error(`Error: ${response.status} ${response.statusText}`);
+            process.exit(1);
+        }
+        const previews = await response.json();
+        if (options.json) {
+            console.log(JSON.stringify(previews, null, 2));
+            return;
+        }
+        if (!previews.length) {
+            console.log("No active previews");
+            return;
+        }
+        console.log("\nActive Previews:\n");
+        for (const p of previews) {
+            console.log(`  PR #${p.prNumber}${p.prTitle ? `: ${p.prTitle}` : ""}`);
+            console.log(`    Status: ${p.status}`);
+            console.log(`    Dashboard: ${p.dashboardUrl}`);
+            console.log(`    Terminal: ${p.terminalUrl}`);
+            console.log(`    Commit: ${p.commitSha.slice(0, 7)}`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Failed to fetch previews:", error);
+        process.exit(1);
+    }
+});
+previewCommand
+    .command("deploy <pr-number>")
+    .description("Deploy a preview for a PR")
+    .option("--branch <branch>", "Branch to deploy (default: from PR)")
+    .action(async (prNumber, options) => {
+    const prNum = parseInt(prNumber, 10);
+    if (isNaN(prNum) || prNum <= 0) {
+        console.error("Error: PR number must be a positive integer");
+        process.exit(1);
+    }
+    console.log(`Triggering preview deployment for PR #${prNum}...`);
+    const result = await triggerCloudBuild(PREVIEW_DEPLOY_TRIGGER_ID, {
+        _PR_NUMBER: String(prNum),
+    });
+    if (result.success) {
+        console.log(`Build started: ${result.buildId}`);
+        console.log(`\nMonitor at: https://console.cloud.google.com/cloud-build/builds/${result.buildId}?project=${GCP_PROJECT}`);
+        console.log("\nPreview URLs will be available once build completes (~5-10 min)");
+    }
+    else {
+        console.error(`Failed to trigger build: ${result.error}`);
+        process.exit(1);
+    }
+});
+previewCommand
+    .command("cleanup [pr-number]")
+    .description("Cleanup preview deployments (specific PR or all merged)")
+    .action(async (prNumber) => {
+    const substitutions = {};
+    if (prNumber) {
+        const prNum = parseInt(prNumber, 10);
+        if (isNaN(prNum) || prNum <= 0) {
+            console.error("Error: PR number must be a positive integer");
+            process.exit(1);
+        }
+        substitutions._PR_NUMBER = String(prNum);
+        console.log(`Cleaning up preview for PR #${prNum}...`);
+    }
+    else {
+        console.log("Cleaning up all merged/closed PR previews...");
+    }
+    const result = await triggerCloudBuild(PREVIEW_CLEANUP_TRIGGER_ID, substitutions);
+    if (result.success) {
+        console.log(`Cleanup started: ${result.buildId}`);
+        console.log(`\nMonitor at: https://console.cloud.google.com/cloud-build/builds/${result.buildId}?project=${GCP_PROJECT}`);
+    }
+    else {
+        console.error(`Failed to trigger cleanup: ${result.error}`);
+        process.exit(1);
+    }
+});
+previewCommand
+    .command("status <pr-number>")
+    .description("Get status of a specific preview")
+    .option("--json", "Output as JSON")
+    .action(async (prNumber, options) => {
+    const prNum = parseInt(prNumber, 10);
+    if (isNaN(prNum) || prNum <= 0) {
+        console.error("Error: PR number must be a positive integer");
+        process.exit(1);
+    }
+    try {
+        const response = await apiRequest("GET", `/api/previews/${prNum}`);
+        if (response.status === 404) {
+            console.log(`No preview found for PR #${prNum}`);
+            process.exit(0);
+        }
+        if (!response.ok) {
+            console.error(`Error: ${response.status} ${response.statusText}`);
+            process.exit(1);
+        }
+        const preview = await response.json();
+        if (options.json) {
+            console.log(JSON.stringify(preview, null, 2));
+            return;
+        }
+        console.log(`\nPreview for PR #${preview.prNumber}`);
+        if (preview.prTitle)
+            console.log(`  Title: ${preview.prTitle}`);
+        console.log(`  Status: ${preview.status}`);
+        console.log(`  Dashboard: ${preview.dashboardUrl}`);
+        console.log(`  Terminal: ${preview.terminalUrl}`);
+        console.log(`  Commit: ${preview.commitSha}`);
+        console.log(`  Created: ${new Date(preview.createdAt).toLocaleString()}`);
+    }
+    catch (error) {
+        console.error("Failed to fetch preview:", error);
+        process.exit(1);
+    }
+});

package/dist/index.js

@@ -24,6 +24,8 @@ import { printLLMContext, llmCommand } from "./commands/llm-context.js";
 import { runInteractiveMode } from "./commands/interactive.js";
 import { serviceAccountCommand } from "./commands/service-account.js";
 import { chatCommand } from "./commands/chat.js";
+import { previewCommand } from "./commands/preview.js";
+import { initCommand } from "./commands/init.js";
 // Read version from package.json
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
@@ -54,7 +56,9 @@ program.addCommand(workerCommand);
 program.addCommand(bizCommand);
 program.addCommand(serviceAccountCommand);
 program.addCommand(chatCommand);
+program.addCommand(previewCommand);
 program.addCommand(llmCommand);
+program.addCommand(initCommand);
 // Handle --llm flag specially
 if (process.argv.includes("--llm")) {
     printLLMContext();

package/package.json

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