@simonfestl/husky-cli 1.33.0 → 1.34.0

package/dist/commands/biz/tickets.d.ts

@@ -1,7 +1,13 @@
 /**
  * Husky Biz Tickets Command
  *
- * Manages support tickets via Zendesk API
+ * Manages support tickets via Zendesk API.
+ * Supports API proxy (server-side credentials) with fallback to direct API.
+ *
+ * Proxy Support:
+ * - list, get, create, reply, search commands try proxy first
+ * - Other commands use direct API (local credentials required)
+ * - Use --no-proxy flag to skip proxy
  */
 import { Command } from "commander";
 export declare const ticketsCommand: Command;

package/dist/commands/biz/tickets.js

@@ -1,14 +1,34 @@
 /**
  * Husky Biz Tickets Command
  *
- * Manages support tickets via Zendesk API
+ * Manages support tickets via Zendesk API.
+ * Supports API proxy (server-side credentials) with fallback to direct API.
+ *
+ * Proxy Support:
+ * - list, get, create, reply, search commands try proxy first
+ * - Other commands use direct API (local credentials required)
+ * - Use --no-proxy flag to skip proxy
  */
 import { Command } from "commander";
-import { ZendeskClient } from "../../lib/biz/index.js";
+import { ZendeskClient, tryZendeskProxy } from "../../lib/biz/index.js";
 import { AgentBrain } from "../../lib/biz/agent-brain.js";
 import * as fs from "fs";
 import * as path from "path";
 import { errorWithAutoHint } from "../../lib/error-hints.js";
+// Helper to get client - tries proxy first for supported operations
+async function getClient(options = {}) {
+    if (!options.noProxy) {
+        const proxy = await tryZendeskProxy();
+        if (proxy) {
+            return proxy;
+        }
+    }
+    return ZendeskClient.fromConfig();
+}
+// Type guard to check if client is proxy client
+function isProxyClient(client) {
+    return 'isAvailable' in client;
+}
 export const ticketsCommand = new Command("tickets")
     .description("Manage support tickets (Zendesk)");
 // husky biz tickets list
@@ -18,9 +38,10 @@ ticketsCommand
     .option("-s, --status <status>", "Filter by status (new, open, pending, solved, closed)")
     .option("-l, --limit <num>", "Number of tickets", "25")
     .option("--json", "Output as JSON")
+    .option("--no-proxy", "Skip API proxy, use direct API")
     .action(async (options) => {
     try {
-        const client = ZendeskClient.fromConfig();
+        const client = await getClient(options);
         const tickets = await client.listTickets({
             per_page: parseInt(options.limit, 10),
             status: options.status,
@@ -29,7 +50,8 @@ ticketsCommand
             console.log(JSON.stringify(tickets, null, 2));
             return;
         }
-        console.log(`\n  🎫 Tickets (${tickets.length})\n`);
+        const proxyLabel = isProxyClient(client) ? " (via proxy)" : "";
+        console.log(`\n  🎫 Tickets (${tickets.length})${proxyLabel}\n`);
         if (tickets.length === 0) {
             console.log("  No tickets found.");
             return;
@@ -51,14 +73,24 @@ ticketsCommand
     .command("get <id>")
     .description("Get ticket with conversation history")
     .option("--json", "Output as JSON")
+    .option("--no-proxy", "Skip API proxy, use direct API")
     .action(async (id, options) => {
     try {
-        const client = ZendeskClient.fromConfig();
+        const client = await getClient(options);
         const ticketId = parseInt(id, 10);
-        const [ticket, comments] = await Promise.all([
-            client.getTicket(ticketId),
-            client.getTicketComments(ticketId),
-        ]);
+        let ticket;
+        let comments;
+        if (isProxyClient(client)) {
+            const result = await client.getTicket(ticketId);
+            ticket = result.ticket;
+            comments = result.comments;
+        }
+        else {
+            [ticket, comments] = await Promise.all([
+                client.getTicket(ticketId),
+                client.getTicketComments(ticketId),
+            ]);
+        }
         if (options.json) {
             console.log(JSON.stringify({ ticket, comments }, null, 2));
             return;
@@ -95,11 +127,18 @@ ticketsCommand
     .command("reply <id>")
     .description("Reply to a ticket (public)")
     .requiredOption("-m, --message <text>", "Reply message")
+    .option("--no-proxy", "Skip API proxy, use direct API")
     .action(async (id, options) => {
     try {
-        const client = ZendeskClient.fromConfig();
-        const ticket = await client.addComment(parseInt(id, 10), options.message, true);
-        console.log(`✓ Public reply added to ticket #${ticket.id}`);
+        const client = await getClient(options);
+        const ticketId = parseInt(id, 10);
+        if (isProxyClient(client)) {
+            await client.replyToTicket(ticketId, options.message, true);
+        }
+        else {
+            await client.addComment(ticketId, options.message, true);
+        }
+        console.log(`✓ Public reply added to ticket #${id}`);
     }
     catch (error) {
         console.error("Error:", error.message);
@@ -296,9 +335,10 @@ ticketsCommand
     .option("-e, --email <email>", "Requester email")
     .option("-p, --priority <priority>", "Priority (low, normal, high, urgent)")
     .option("--json", "Output as JSON")
+    .option("--no-proxy", "Skip API proxy, use direct API")
     .action(async (options) => {
     try {
-        const client = ZendeskClient.fromConfig();
+        const client = await getClient(options);
         const ticketData = {
             subject: options.subject,
             comment: { body: options.message },
@@ -309,7 +349,13 @@ ticketsCommand
         if (options.priority) {
             ticketData.priority = options.priority;
         }
-        const ticket = await client.createTicket(ticketData);
+        let ticket;
+        if (isProxyClient(client)) {
+            ticket = await client.createTicket(ticketData);
+        }
+        else {
+            ticket = await client.createTicket(ticketData);
+        }
         if (options.json) {
             console.log(JSON.stringify(ticket, null, 2));
             return;
@@ -328,9 +374,10 @@ ticketsCommand
     .command("search <query>")
     .description("Search tickets (Zendesk search syntax)")
     .option("--json", "Output as JSON")
+    .option("--no-proxy", "Skip API proxy, use direct API")
     .action(async (query, options) => {
     try {
-        const client = ZendeskClient.fromConfig();
+        const client = await getClient(options);
         const tickets = await client.searchTickets(query);
         if (options.json) {
             console.log(JSON.stringify(tickets, null, 2));

package/dist/commands/supervisor.d.ts

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

package/dist/commands/supervisor.js

@@ -0,0 +1,528 @@
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+import { spawn, execSync } from "child_process";
+import { promisify } from "util";
+import { exec } from "child_process";
+const execAsync = promisify(exec);
+export const supervisorCommand = new Command("supervisor")
+    .description("Manage Husky Supervisor Agent");
+// supervisor start
+supervisorCommand
+    .command("start")
+    .description("Start the supervisor agent")
+    .option("--session <name>", "Tmux session name", "supervisor")
+    .option("--id <id>", "Agent ID", "supervisor")
+    .option("--name <name>", "Agent display name", "Husky Supervisor")
+    .option("--vm <name>", "VM name (auto-detected if not provided)")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    console.log("🐕 Starting Husky Supervisor Agent...");
+    // Set environment variables
+    const env = {
+        ...process.env,
+        HUSKY_API_URL: config.apiUrl,
+        HUSKY_API_KEY: config.apiKey,
+        HUSKY_AGENT_ID: options.id,
+        HUSKY_SUPERVISOR_SESSION: options.session,
+    };
+    // Get the supervisor script path
+    const scriptPath = new URL("../scripts/supervisor-start.sh", import.meta.url).pathname;
+    try {
+        // Run the supervisor script
+        const child = spawn(scriptPath, [], {
+            env,
+            stdio: "inherit",
+        });
+        child.on("close", (code) => {
+            if (code !== 0) {
+                console.error(`Supervisor script exited with code ${code}`);
+                process.exit(code);
+            }
+        });
+    }
+    catch (error) {
+        console.error("Error starting supervisor:", error);
+        process.exit(1);
+    }
+});
+// supervisor status
+supervisorCommand
+    .command("status")
+    .description("Check supervisor status")
+    .option("--session <name>", "Tmux session name", "supervisor")
+    .action(async (options) => {
+    try {
+        const { stdout } = await execAsync(`tmux has-session -t "${options.session}"`);
+        console.log("✅ Supervisor is running");
+        console.log(`Session: ${options.session}`);
+        // List windows
+        const { stdout: windows } = await execAsync(`tmux list-windows -t "${options.session}"`);
+        console.log("\nActive windows:");
+        console.log(windows);
+    }
+    catch (error) {
+        console.log("❌ Supervisor is not running");
+        process.exit(1);
+    }
+});
+// supervisor stop
+supervisorCommand
+    .command("stop")
+    .description("Stop the supervisor agent")
+    .option("--session <name>", "Tmux session name", "supervisor")
+    .action(async (options) => {
+    try {
+        await execAsync(`tmux kill-session -t "${options.session}"`);
+        console.log("✅ Supervisor stopped successfully");
+    }
+    catch (error) {
+        console.log("❌ Supervisor is not running or failed to stop");
+        process.exit(1);
+    }
+});
+// supervisor restart
+supervisorCommand
+    .command("restart")
+    .description("Restart the supervisor agent")
+    .option("--session <name>", "Tmux session name", "supervisor")
+    .action(async (options) => {
+    try {
+        console.log("🔄 Restarting supervisor...");
+        await execAsync(`tmux kill-session -t "${options.session}"`);
+        console.log("✅ Old supervisor stopped");
+        // Start new supervisor
+        const scriptPath = new URL("../scripts/supervisor-start.sh", import.meta.url).pathname;
+        const config = getConfig();
+        const child = spawn(scriptPath, [], {
+            env: {
+                ...process.env,
+                HUSKY_API_URL: config.apiUrl,
+                HUSKY_API_KEY: config.apiKey,
+            },
+            stdio: "inherit",
+        });
+        child.on("close", (code) => {
+            if (code !== 0) {
+                console.error(`Supervisor restart failed with code ${code}`);
+                process.exit(code);
+            }
+        });
+    }
+    catch (error) {
+        console.error("Error restarting supervisor:", error);
+        process.exit(1);
+    }
+});
+// supervisor attach
+supervisorCommand
+    .command("attach")
+    .description("Attach to the supervisor tmux session")
+    .option("--session <name>", "Tmux session name", "supervisor")
+    .option("--window <name>", "Window name or number (default: supervisor)", "supervisor")
+    .action(async (options) => {
+    try {
+        const { stdout } = await execAsync(`tmux has-session -t "${options.session}"`);
+        // Attach to specific window
+        spawn("tmux", ["attach", "-t", `${options.session}:${options.window}`], {
+            stdio: "inherit",
+        });
+    }
+    catch (error) {
+        console.error("❌ Supervisor is not running");
+        console.log("Start it with: husky supervisor start");
+        process.exit(1);
+    }
+});
+// supervisor logs
+supervisorCommand
+    .command("logs")
+    .description("Show logs from supervisor windows")
+    .option("--session <name>", "Tmux session name", "supervisor")
+    .option("--window <name>", "Window name (supervisor, messages, tasks, vms, heartbeat)")
+    .option("--lines <n>", "Number of lines to show", "50")
+    .action(async (options) => {
+    try {
+        await execAsync(`tmux has-session -t "${options.session}"`);
+        const window = options.window || "supervisor";
+        const lines = options.lines;
+        console.log(`📋 Showing last ${lines} lines from '${window}' window:\n`);
+        // Capture output from tmux pane
+        const { stdout } = await execAsync(`tmux capture-pane -t "${options.session}:${window}" -p | tail -n ${lines}`);
+        console.log(stdout);
+    }
+    catch (error) {
+        console.error("❌ Failed to get logs");
+        if (error instanceof Error && error.message.includes("session")) {
+            console.error("Supervisor is not running");
+        }
+        process.exit(1);
+    }
+});
+// supervisor message
+supervisorCommand
+    .command("message")
+    .description("Send a message to the supervisor interface")
+    .argument("<message>", "Message to send")
+    .option("--session <name>", "Tmux session name", "supervisor")
+    .action(async (message, options) => {
+    try {
+        await execAsync(`tmux has-session -t "${options.session}"`);
+        // Send message to supervisor window
+        const escapedMessage = message
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g, '\\"')
+            .replace(/\$/g, "\\$");
+        await execAsync(`tmux send-keys -t "${options.session}:supervisor" "${escapedMessage}" Enter`);
+        console.log("✅ Message sent to supervisor");
+    }
+    catch (error) {
+        console.error("❌ Failed to send message");
+        if (error instanceof Error && error.message.includes("session")) {
+            console.error("Supervisor is not running");
+        }
+        process.exit(1);
+    }
+});
+// supervisor execute
+supervisorCommand
+    .command("execute")
+    .description("Execute a command in the supervisor interface")
+    .argument("<command>", "Command to execute")
+    .option("--session <name>", "Tmux session name", "supervisor")
+    .option("--window <name>", "Window to execute in", "supervisor")
+    .action(async (command, options) => {
+    try {
+        await execAsync(`tmux has-session -t "${options.session}"`);
+        // Send command to specified window
+        const escapedCommand = command
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g, '\\"')
+            .replace(/\$/g, "\\$");
+        await execAsync(`tmux send-keys -t "${options.session}:${options.window}" "${escapedCommand}" Enter`);
+        console.log(`✅ Command sent to ${options.window} window`);
+    }
+    catch (error) {
+        console.error("❌ Failed to execute command");
+        if (error instanceof Error && error.message.includes("session")) {
+            console.error("Supervisor is not running");
+        }
+        process.exit(1);
+    }
+});
+// supervisor workflow
+supervisorCommand
+    .command("workflow")
+    .description("Show supervisor workflow status and next actions")
+    .option("--json", "Output as JSON")
+    .action(async (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 {
+        // Get task backlog
+        const tasksRes = await fetch(`${config.apiUrl}/api/tasks?status=backlog&assignee=llm&limit=10`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        // Get VM status
+        const vmCommand = "gcloud compute instances list --filter='name~husky-' --format='json(name,status,zone,machineType)'";
+        const { stdout: vmOutput } = await execAsync(vmCommand);
+        const vms = JSON.parse(vmOutput || "[]");
+        // Get registered agents
+        const agentsRes = await fetch(`${config.apiUrl}/api/agents`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        const tasks = tasksRes.ok ? await tasksRes.json() : { tasks: [] };
+        const agents = agentsRes.ok ? await agentsRes.json() : { agents: [] };
+        if (options.json) {
+            console.log(JSON.stringify({
+                tasks: tasks.tasks || [],
+                vms,
+                agents: agents.agents || [],
+                timestamp: new Date().toISOString(),
+            }, null, 2));
+            return;
+        }
+        console.log("\n🐕 Husky Supervisor Workflow Status");
+        console.log("=".repeat(50));
+        // Task status
+        console.log("\n📋 Task Backlog:");
+        const backlogTasks = tasks.tasks || [];
+        if (backlogTasks.length === 0) {
+            console.log("  No tasks in backlog");
+        }
+        else {
+            backlogTasks.forEach((task, i) => {
+                console.log(`  ${i + 1}. ${task.title} (${task.id})`);
+                console.log(`     Priority: ${task.priority} | Assignee: ${task.assignee}`);
+            });
+        }
+        // VM status
+        console.log("\n🖥️  VM Fleet Status:");
+        const runningWorkers = vms.filter((vm) => vm.name.includes("worker") && vm.status === "RUNNING");
+        const suspendedWorkers = vms.filter((vm) => vm.name.includes("worker") && vm.status === "SUSPENDED");
+        const terminatedWorkers = vms.filter((vm) => vm.name.includes("worker") && vm.status === "TERMINATED");
+        console.log(`  Running workers: ${runningWorkers.length}`);
+        console.log(`  Suspended workers: ${suspendedWorkers.length}`);
+        console.log(`  Terminated workers: ${terminatedWorkers.length}`);
+        if (vms.find((vm) => vm.name.includes("supervisor"))) {
+            const supervisorVm = vms.find((vm) => vm.name.includes("supervisor"));
+            console.log(`  Supervisor VM: ${supervisorVm.status}`);
+        }
+        // Agent status
+        console.log("\n🤖 Registered Agents:");
+        const agentList = agents.agents || [];
+        const onlineAgents = agentList.filter((agent) => agent.status === "online");
+        const busyAgents = agentList.filter((agent) => agent.status === "busy");
+        const offlineAgents = agentList.filter((agent) => agent.status === "offline");
+        console.log(`  Online: ${onlineAgents.length}, Busy: ${busyAgents.length}, Offline: ${offlineAgents.length}`);
+        // Next actions
+        console.log("\n🎯 Suggested Actions:");
+        if (backlogTasks.length > 0 && runningWorkers.length === 0) {
+            console.log("  • Start worker VM(s) to handle task backlog");
+        }
+        if (terminatedWorkers.length > 0 && backlogTasks.length > 0) {
+            console.log("  • Resume terminated worker VMs");
+        }
+        if (backlogTasks.length > 0) {
+            console.log("  • Assign tasks to available workers");
+        }
+        if (offlineAgents.length > 0) {
+            console.log("  • Check on offline agents");
+        }
+        if (backlogTasks.length === 0 && runningWorkers.length > 0) {
+            console.log("  • Suspend idle worker VMs to save costs");
+        }
+        console.log("\nQuick commands:");
+        console.log("  husky supervisor start    - Start supervisor");
+        console.log("  husky supervisor attach   - Attach to supervisor");
+        console.log("  husk supervisor status   - Check status");
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error getting workflow status:", error);
+        process.exit(1);
+    }
+});
+// supervisor cycle
+supervisorCommand
+    .command("cycle")
+    .description("Run the main supervisor loop (for automation)")
+    .option("--interval <seconds>", "Loop interval in seconds", "300") // 5 minutes default
+    .option("--once", "Run once and exit")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    const interval = parseInt(options.interval) * 1000;
+    console.log(`🐕 Starting supervisor cycle${options.once ? ' (once)' : ` (every ${options.interval}s)`}...`);
+    const runCycle = async () => {
+        try {
+            console.log(`\n[${new Date().toLocaleTimeString()}] Running supervisor cycle...`);
+            // Step 1: Check for new tasks
+            const tasksRes = await fetch(`${config.apiUrl}/api/tasks?status=backlog&assignee=llm&limit=5`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            if (tasksRes.ok) {
+                const tasksData = await tasksRes.json();
+                const tasks = tasksData.tasks || [];
+                if (tasks.length > 0) {
+                    console.log(`  Found ${tasks.length} tasks in backlog`);
+                    // Step 2: Check available worker VMs
+                    const { stdout: vmOutput } = await execAsync("gcloud compute instances list --filter='name~husky-worker' --format='json(name,status,zone)'");
+                    const vms = JSON.parse(vmOutput || "[]");
+                    const runningWorkers = vms.filter((vm) => vm.name.includes("worker") && vm.status === "RUNNING");
+                    if (runningWorkers.length === 0) {
+                        console.log("  No worker VMs running, starting one...");
+                        // This would need to be implemented based on your GCP setup
+                        console.log("  TODO: Implement VM startup logic");
+                    }
+                    // Step 3: Assign tasks to workers
+                    tasks.forEach((task) => {
+                        console.log(`  Task ${task.id}: ${task.title}`);
+                    });
+                }
+                else {
+                    console.log("  No tasks in backlog");
+                }
+            }
+            console.log(`[${new Date().toLocaleTimeString()}] Cycle completed`);
+        }
+        catch (error) {
+            console.error(`[${new Date().toLocaleTimeString()}] Cycle error:`, error);
+        }
+    };
+    if (options.once) {
+        await runCycle();
+    }
+    else {
+        await runCycle();
+        setInterval(runCycle, interval);
+        console.log(`\nSupervisor cycle running. Press Ctrl+C to stop.`);
+        // Keep process alive
+        process.on("SIGINT", () => {
+            console.log("\n👋 Stopping supervisor cycle...");
+            process.exit(0);
+        });
+        await new Promise(() => { });
+    }
+});
+function checkGitHubPR(branch) {
+    try {
+        const result = execSync(`gh pr view "${branch}" --json url,mergedAt,state -q '{"url":.url,"mergedAt":.mergedAt,"state":.state}'`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        const data = JSON.parse(result.trim());
+        return {
+            exists: true,
+            merged: data.mergedAt !== null && data.mergedAt !== "",
+            url: data.url,
+            state: data.state,
+        };
+    }
+    catch {
+        return { exists: false, merged: false };
+    }
+}
+supervisorCommand
+    .command("auto-track")
+    .description("Automatic task status tracking based on GitHub PR state")
+    .option("--interval <minutes>", "Check interval in minutes", "5")
+    .option("--dry-run", "Show what would be updated without making changes")
+    .option("--once", "Run once and exit")
+    .option("--stale-hours <hours>", "Hours before task is considered stale", "24")
+    .option("--alert", "Send alerts for stale tasks to Google Chat")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    const intervalMs = parseInt(options.interval) * 60 * 1000;
+    const staleMs = parseInt(options.staleHours) * 60 * 60 * 1000;
+    const headers = {};
+    if (config.apiKey)
+        headers["x-api-key"] = config.apiKey;
+    console.log(`🔄 Starting auto-tracking loop (interval: ${options.interval}m, stale: ${options.staleHours}h)`);
+    if (options.dryRun)
+        console.log("   DRY RUN MODE - no changes will be made\n");
+    async function checkAndUpdate() {
+        const timestamp = new Date().toLocaleTimeString();
+        console.log(`\n[${timestamp}] Checking task statuses...`);
+        try {
+            const res = await fetch(`${config.apiUrl}/api/tasks?status=in_progress,review&limit=50`, { headers });
+            if (!res.ok) {
+                console.error(`  ❌ Failed to fetch tasks: ${res.status}`);
+                return;
+            }
+            const data = await res.json();
+            const tasks = data.tasks || [];
+            if (tasks.length === 0) {
+                console.log("  No in_progress or review tasks found");
+                return;
+            }
+            console.log(`  Found ${tasks.length} active tasks`);
+            const staleTasks = [];
+            const now = Date.now();
+            for (const task of tasks) {
+                const taskAge = now - new Date(task.updatedAt).getTime();
+                const isStale = taskAge > staleMs;
+                if (isStale) {
+                    staleTasks.push(task);
+                }
+                if (!task.worktreeBranch) {
+                    console.log(`  📌 ${task.id}: No branch linked (${task.status})${isStale ? " ⚠️ STALE" : ""}`);
+                    continue;
+                }
+                const prStatus = checkGitHubPR(task.worktreeBranch);
+                if (prStatus.merged && task.status !== "done") {
+                    console.log(`  ✅ ${task.id}: PR merged → marking done`);
+                    if (!options.dryRun) {
+                        const updateRes = await fetch(`${config.apiUrl}/api/tasks/${task.id}`, {
+                            method: "PATCH",
+                            headers: { ...headers, "Content-Type": "application/json" },
+                            body: JSON.stringify({
+                                status: "done",
+                                statusMessage: "PR merged - auto-tracked by supervisor",
+                            }),
+                        });
+                        if (!updateRes.ok) {
+                            console.error(`     ❌ Failed to update task: ${updateRes.status}`);
+                        }
+                    }
+                }
+                else if (prStatus.exists && task.status === "in_progress") {
+                    console.log(`  📝 ${task.id}: PR exists (${prStatus.state}) → marking review`);
+                    if (!options.dryRun) {
+                        const updateRes = await fetch(`${config.apiUrl}/api/tasks/${task.id}`, {
+                            method: "PATCH",
+                            headers: { ...headers, "Content-Type": "application/json" },
+                            body: JSON.stringify({
+                                status: "review",
+                                prUrl: prStatus.url,
+                                statusMessage: "PR opened - auto-tracked by supervisor",
+                            }),
+                        });
+                        if (!updateRes.ok) {
+                            console.error(`     ❌ Failed to update task: ${updateRes.status}`);
+                        }
+                    }
+                }
+                else if (!prStatus.exists && task.status === "in_progress") {
+                    console.log(`  🔨 ${task.id}: In progress, no PR yet${isStale ? " ⚠️ STALE" : ""}`);
+                }
+                else {
+                    console.log(`  ℹ️  ${task.id}: ${task.status} (PR: ${prStatus.exists ? prStatus.state : "none"})${isStale ? " ⚠️ STALE" : ""}`);
+                }
+            }
+            if (staleTasks.length > 0) {
+                console.log(`\n  ⚠️  Found ${staleTasks.length} stale tasks (>${options.staleHours}h inactive):`);
+                staleTasks.forEach((t) => {
+                    const hours = Math.round((now - new Date(t.updatedAt).getTime()) / (1000 * 60 * 60));
+                    console.log(`     - ${t.title} (${t.id}) - ${hours}h inactive`);
+                });
+                if (options.alert && !options.dryRun) {
+                    const alertMessage = `⚠️ **Stale Task Alert**\n\n${staleTasks.length} tasks inactive for >${options.staleHours}h:\n\n${staleTasks.map((t) => `- ${t.title} (${t.id})`).join("\n")}\n\nPlease review and update status.`;
+                    try {
+                        const chatRes = await fetch(`${config.apiUrl}/api/google-chat/send`, {
+                            method: "POST",
+                            headers: { ...headers, "Content-Type": "application/json" },
+                            body: JSON.stringify({
+                                text: alertMessage,
+                                spaceName: process.env.GOOGLE_CHAT_DM_SPACE,
+                            }),
+                        });
+                        if (chatRes.ok) {
+                            console.log("  📣 Stale task alert sent to Google Chat");
+                        }
+                    }
+                    catch (error) {
+                        console.error("  ❌ Failed to send alert:", error);
+                    }
+                }
+            }
+            console.log(`[${new Date().toLocaleTimeString()}] Check completed`);
+        }
+        catch (error) {
+            console.error(`[${timestamp}] Error:`, error);
+        }
+    }
+    if (options.once) {
+        await checkAndUpdate();
+    }
+    else {
+        await checkAndUpdate();
+        setInterval(checkAndUpdate, intervalMs);
+        console.log(`\nAuto-tracking running. Press Ctrl+C to stop.`);
+        process.on("SIGINT", () => {
+            console.log("\n👋 Stopping auto-tracking...");
+            process.exit(0);
+        });
+        await new Promise(() => { });
+    }
+});

package/dist/commands/task.js

@@ -154,7 +154,8 @@ taskCommand
         // Note: We don't pass projectId to API to avoid Firestore index requirement
         // Instead, we filter client-side which is fine for reasonable task counts
         const api = getApiClient();
-        let tasks = await api.get(url.pathname + url.search);
+        const response = await api.get(url.pathname + url.search);
+        let tasks = response.tasks;
         // Client-side filtering by projectId (avoids Firestore composite index)
         if (filterProjectId) {
             tasks = tasks.filter(t => t.projectId === filterProjectId);

package/dist/commands/youtube.js

@@ -2,24 +2,47 @@ import { Command } from "commander";
 import { GoogleGenerativeAI } from "@google/generative-ai";
 import { getConfig } from "./config.js";
 import { z } from "zod";
+import { apiRequest } from "../lib/api-client.js";
 // Input validation schemas
 const YouTubeUrlSchema = z.string().min(1, "YouTube URL cannot be empty");
 const YouTubeOptionsSchema = z.object({
     json: z.boolean().optional(),
-    prompt: z.string().max(10000, "Custom prompt too long (max 10000 characters)").optional()
+    prompt: z.string().max(10000, "Custom prompt too long (max 10000 characters)").optional(),
+    language: z.enum(["en", "de"]).optional(),
+    useProxy: z.boolean().optional(),
 });
 export const youtubeCommand = new Command("youtube")
     .description("YouTube video summarization using Gemini AI")
     .argument("<url>", "YouTube video URL")
     .option("--json", "Output as JSON")
     .option("--prompt <prompt>", "Custom summarization prompt")
+    .option("--language <lang>", "Summary language (en, de)", "de")
+    .option("--no-proxy", "Skip API proxy, use direct Gemini API")
     .action(async (url, options) => {
     try {
         // Validate URL
         const validatedUrl = YouTubeUrlSchema.parse(url);
         // Validate options
         const validatedOptions = YouTubeOptionsSchema.parse(options);
-        await summarizeVideo(validatedUrl, validatedOptions);
+        // Try proxy first (if not disabled)
+        if (validatedOptions.useProxy !== false) {
+            try {
+                await summarizeViaProxy(validatedUrl, validatedOptions);
+                return;
+            }
+            catch (error) {
+                const err = error;
+                // Only fall back on auth/access errors, not on video errors
+                if (!err.message.includes("403") && !err.message.includes("401") && !err.message.includes("Forbidden")) {
+                    throw error;
+                }
+                if (!validatedOptions.json) {
+                    console.log("⚠️  Proxy unavailable, falling back to direct API...\n");
+                }
+            }
+        }
+        // Fall back to direct API
+        await summarizeVideoDirect(validatedUrl, validatedOptions);
     }
     catch (error) {
         if (error instanceof z.ZodError) {
@@ -58,13 +81,50 @@ function extractVideoId(url) {
     throw new Error(`Invalid YouTube URL: ${url}`);
 }
 /**
- * Summarize YouTube video using Gemini (directly with URL)
+ * Summarize via API proxy (uses server-side credentials)
  */
-async function summarizeVideo(url, options) {
+async function summarizeViaProxy(url, options) {
     const videoId = extractVideoId(url);
     const fullUrl = `https://www.youtube.com/watch?v=${videoId}`;
-    console.log(`📹 Video: ${videoId}`);
-    console.log(`🔗 URL: ${fullUrl}\n`);
+    if (!options.json) {
+        console.log(`📹 Video: ${videoId}`);
+        console.log(`🔗 URL: ${fullUrl}`);
+        console.log(`🌐 Using API proxy...\n`);
+    }
+    const result = await apiRequest("/api/proxy/youtube/summarize", {
+        method: "POST",
+        body: {
+            url: fullUrl,
+            prompt: options.prompt,
+            language: options.language || "de",
+        },
+    });
+    if (options.json) {
+        console.log(JSON.stringify({
+            videoId: result.videoId,
+            url: result.url,
+            summary: result.summary,
+            language: result.language,
+        }, null, 2));
+    }
+    else {
+        console.log('📝 Zusammenfassung:');
+        console.log('='.repeat(70));
+        console.log(result.summary);
+        console.log('='.repeat(70));
+        console.log(`\n✓ URL: ${result.url}`);
+    }
+}
+/**
+ * Summarize YouTube video using direct Gemini API (fallback)
+ */
+async function summarizeVideoDirect(url, options) {
+    const videoId = extractVideoId(url);
+    const fullUrl = `https://www.youtube.com/watch?v=${videoId}`;
+    if (!options.json) {
+        console.log(`📹 Video: ${videoId}`);
+        console.log(`🔗 URL: ${fullUrl}\n`);
+    }
     // Get Gemini API key
     // Priority: Standard Gemini API (has 3.0) > Vertex AI (has 2.5 Pro) > Config
     const config = getConfig();
@@ -92,12 +152,29 @@ async function summarizeVideo(url, options) {
     // Use Gemini 3.0 for standard API, 2.5 Pro for Vertex AI
     const modelName = isVertex ? "gemini-2.5-pro" : "gemini-3.0-flash";
     const modelLabel = isVertex ? "Gemini 2.5 Pro (Vertex AI)" : "Gemini 3.0 Flash";
-    console.log(`🤖 Analyzing with ${modelLabel}...\n`);
+    if (!options.json) {
+        console.log(`🤖 Analyzing with ${modelLabel}...\n`);
+    }
     // Initialize Gemini
     const genAI = new GoogleGenerativeAI(geminiApiKey);
     const model = genAI.getGenerativeModel({ model: modelName });
     // Custom prompt or default
-    const prompt = options.prompt || `
+    const prompt = options.prompt || (options.language === "en" ? `
+Create a structured summary of this YouTube video.
+
+Format:
+## Main Topics
+[3-5 key points]
+
+## Key Insights
+[Most important learnings]
+
+## Summary
+[1-2 paragraph overview]
+
+## Keywords
+[Relevant keywords, comma-separated]
+  `.trim() : `
 Erstelle eine strukturierte Zusammenfassung dieses YouTube Videos.
 
 Format:
@@ -112,7 +189,7 @@ Format:
 
 ## Keywords
 [Relevante Keywords kommagetrennt]
-  `.trim();
+  `.trim());
     // Gemini can directly analyze YouTube URLs
     let summary;
     try {

package/dist/index.js

@@ -38,6 +38,8 @@ import { authCommand } from "./commands/auth.js";
 import { businessCommand } from "./commands/business.js";
 import { planCommand } from "./commands/plan.js";
 import { diagramsCommand } from "./commands/diagrams.js";
+import { supervisorCommand } from "./commands/supervisor.js";
+import { checkVersion } from "./lib/version-check.js";
 // Read version from package.json
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
@@ -83,16 +85,23 @@ program.addCommand(authCommand);
 program.addCommand(businessCommand);
 program.addCommand(planCommand);
 program.addCommand(diagramsCommand);
+program.addCommand(supervisorCommand);
 // Handle --llm flag specially
 if (process.argv.includes("--llm")) {
     printLLMContext();
     process.exit(0);
 }
-// Check if no command was provided - run interactive mode
-if (process.argv.length <= 2) {
-    runInteractiveMode();
-}
-else {
-    program.parse();
+const skipVersionCheck = ["--version", "-V", "--help", "-h", "completion"].some((flag) => process.argv.includes(flag));
+async function main() {
+    if (!skipVersionCheck) {
+        await checkVersion({ silent: process.env.HUSKY_SKIP_VERSION_CHECK === "1" });
+    }
+    if (process.argv.length <= 2) {
+        runInteractiveMode();
+    }
+    else {
+        program.parse();
+    }
 }
+main();
 // trigger CI

package/dist/lib/biz/index.d.ts

@@ -3,6 +3,7 @@
  */
 export { BillbeeClient } from './billbee.js';
 export { ZendeskClient } from './zendesk.js';
+export { ZendeskProxyClient, getZendeskProxyClient, tryZendeskProxy } from './zendesk-proxy.js';
 export { SeaTableClient } from './seatable.js';
 export { QdrantClient } from './qdrant.js';
 export { EmbeddingService, EMBEDDING_MODELS } from './embeddings.js';

package/dist/lib/biz/index.js

@@ -3,6 +3,7 @@
  */
 export { BillbeeClient } from './billbee.js';
 export { ZendeskClient } from './zendesk.js';
+export { ZendeskProxyClient, getZendeskProxyClient, tryZendeskProxy } from './zendesk-proxy.js';
 export { SeaTableClient } from './seatable.js';
 export { QdrantClient } from './qdrant.js';
 export { EmbeddingService, EMBEDDING_MODELS } from './embeddings.js';

package/dist/lib/biz/zendesk-proxy.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Zendesk Proxy Client
+ *
+ * Wraps API proxy calls for Zendesk operations.
+ * This client uses server-side credentials via the Husky API proxy.
+ */
+import type { ZendeskTicket, ZendeskUser, TicketComment, ZendeskMacro } from './zendesk-types.js';
+export declare class ZendeskProxyClient {
+    private available;
+    /**
+     * Check if proxy is available (has permission)
+     */
+    isAvailable(): Promise<boolean>;
+    listTickets(params?: {
+        status?: string;
+        per_page?: number;
+        page?: number;
+    }): Promise<ZendeskTicket[]>;
+    getTicket(ticketId: number): Promise<{
+        ticket: ZendeskTicket;
+        comments: TicketComment[];
+    }>;
+    createTicket(data: {
+        subject: string;
+        comment: {
+            body: string;
+        };
+        requester?: {
+            email: string;
+        };
+        priority?: string;
+        tags?: string[];
+    }): Promise<ZendeskTicket>;
+    updateTicket(ticketId: number, data: {
+        status?: string;
+        priority?: string;
+        assignee_id?: number;
+        tags?: string[];
+        custom_fields?: Array<{
+            id: number;
+            value: unknown;
+        }>;
+    }): Promise<ZendeskTicket>;
+    replyToTicket(ticketId: number, body: string, isPublic?: boolean): Promise<ZendeskTicket>;
+    searchTickets(query: string): Promise<ZendeskTicket[]>;
+    listUsers(): Promise<ZendeskUser[]>;
+    listMacros(): Promise<ZendeskMacro[]>;
+}
+export declare function getZendeskProxyClient(): ZendeskProxyClient;
+/**
+ * Try to use proxy, return null if unavailable.
+ * Useful for checking if proxy should be used.
+ */
+export declare function tryZendeskProxy(): Promise<ZendeskProxyClient | null>;
+export default ZendeskProxyClient;

package/dist/lib/biz/zendesk-proxy.js

@@ -0,0 +1,113 @@
+/**
+ * Zendesk Proxy Client
+ *
+ * Wraps API proxy calls for Zendesk operations.
+ * This client uses server-side credentials via the Husky API proxy.
+ */
+import { apiRequest } from '../api-client.js';
+export class ZendeskProxyClient {
+    available = null;
+    /**
+     * Check if proxy is available (has permission)
+     */
+    async isAvailable() {
+        if (this.available !== null) {
+            return this.available;
+        }
+        try {
+            await apiRequest('/api/proxy/zendesk/users', {
+                method: 'GET',
+            });
+            this.available = true;
+            return true;
+        }
+        catch (error) {
+            const err = error;
+            if (err.message.includes('403') || err.message.includes('401') || err.message.includes('Forbidden')) {
+                this.available = false;
+                return false;
+            }
+            // Network error - treat as unavailable
+            this.available = false;
+            return false;
+        }
+    }
+    // =========================================================================
+    // TICKETS
+    // =========================================================================
+    async listTickets(params) {
+        const query = new URLSearchParams();
+        if (params?.status)
+            query.set('status', params.status);
+        if (params?.per_page)
+            query.set('per_page', String(params.per_page));
+        if (params?.page)
+            query.set('page', String(params.page));
+        const queryString = query.toString();
+        const endpoint = `/api/proxy/zendesk/tickets${queryString ? `?${queryString}` : ''}`;
+        const response = await apiRequest(endpoint);
+        return response.tickets;
+    }
+    async getTicket(ticketId) {
+        const response = await apiRequest(`/api/proxy/zendesk/tickets/${ticketId}`);
+        return response;
+    }
+    async createTicket(data) {
+        const response = await apiRequest('/api/proxy/zendesk/tickets', {
+            method: 'POST',
+            body: data,
+        });
+        return response.ticket;
+    }
+    async updateTicket(ticketId, data) {
+        const response = await apiRequest(`/api/proxy/zendesk/tickets/${ticketId}`, {
+            method: 'PATCH',
+            body: data,
+        });
+        return response.ticket;
+    }
+    async replyToTicket(ticketId, body, isPublic = true) {
+        const response = await apiRequest(`/api/proxy/zendesk/tickets/${ticketId}/reply`, {
+            method: 'POST',
+            body: { body, public: isPublic },
+        });
+        return response.ticket;
+    }
+    async searchTickets(query) {
+        const params = new URLSearchParams({ query });
+        const response = await apiRequest(`/api/proxy/zendesk/search?${params}`);
+        return response.tickets;
+    }
+    // =========================================================================
+    // USERS
+    // =========================================================================
+    async listUsers() {
+        const response = await apiRequest('/api/proxy/zendesk/users');
+        return response.users;
+    }
+    // =========================================================================
+    // MACROS
+    // =========================================================================
+    async listMacros() {
+        const response = await apiRequest('/api/proxy/zendesk/macros');
+        return response.macros;
+    }
+}
+// Singleton instance
+let proxyClient = null;
+export function getZendeskProxyClient() {
+    if (!proxyClient) {
+        proxyClient = new ZendeskProxyClient();
+    }
+    return proxyClient;
+}
+/**
+ * Try to use proxy, return null if unavailable.
+ * Useful for checking if proxy should be used.
+ */
+export async function tryZendeskProxy() {
+    const client = getZendeskProxyClient();
+    const available = await client.isAvailable();
+    return available ? client : null;
+}
+export default ZendeskProxyClient;

package/dist/lib/version-check.d.ts

@@ -0,0 +1,4 @@
+export declare function checkVersion(options?: {
+    silent?: boolean;
+}): Promise<void>;
+export declare function getCurrentVersion(): string;

package/dist/lib/version-check.js

@@ -0,0 +1,112 @@
+import { createRequire } from "module";
+import { getConfig } from "../commands/config.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const require = createRequire(import.meta.url);
+const packageJson = require("../../package.json");
+const CACHE_FILE = path.join(os.homedir(), ".husky", "version-cache.json");
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+function readCache() {
+    try {
+        if (!fs.existsSync(CACHE_FILE))
+            return null;
+        const data = JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+        const checkedAt = new Date(data.checkedAt).getTime();
+        if (Date.now() - checkedAt > CACHE_TTL_MS)
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(cache) {
+    try {
+        const dir = path.dirname(CACHE_FILE);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+    }
+    catch {
+        // Ignore cache write errors
+    }
+}
+async function fetchLatestVersion() {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch("https://registry.npmjs.org/@simonfestl/husky-cli/latest", { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data.version || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchMinApiVersion() {
+    try {
+        const config = getConfig();
+        if (!config.apiUrl)
+            return null;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch(`${config.apiUrl}/api/health`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        const minVersion = res.headers.get("X-Min-CLI-Version");
+        return minVersion || null;
+    }
+    catch {
+        return null;
+    }
+}
+function compareVersions(a, b) {
+    const partsA = a.split(".").map(Number);
+    const partsB = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+        const numA = partsA[i] || 0;
+        const numB = partsB[i] || 0;
+        if (numA < numB)
+            return -1;
+        if (numA > numB)
+            return 1;
+    }
+    return 0;
+}
+export async function checkVersion(options = {}) {
+    const currentVersion = packageJson.version;
+    let cache = readCache();
+    if (!cache) {
+        const [latestVersion, minApiVersion] = await Promise.all([
+            fetchLatestVersion(),
+            fetchMinApiVersion(),
+        ]);
+        if (latestVersion) {
+            cache = {
+                latestVersion,
+                checkedAt: new Date().toISOString(),
+                minApiVersion: minApiVersion || undefined,
+            };
+            writeCache(cache);
+        }
+    }
+    if (!cache)
+        return;
+    if (cache.minApiVersion && compareVersions(currentVersion, cache.minApiVersion) < 0) {
+        console.error(`\n⛔ CLI version ${currentVersion} is below minimum required (${cache.minApiVersion})`);
+        console.error(`   Run: sudo npm install -g @simonfestl/husky-cli@latest\n`);
+        process.exit(1);
+    }
+    if (!options.silent && compareVersions(currentVersion, cache.latestVersion) < 0) {
+        console.warn(`\n⚠️  CLI outdated: ${currentVersion} → ${cache.latestVersion}`);
+        console.warn(`   Run: sudo npm install -g @simonfestl/husky-cli@latest\n`);
+    }
+}
+export function getCurrentVersion() {
+    return packageJson.version;
+}

package/package.json

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