@simonfestl/husky-cli 1.32.0 → 1.33.1

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/project.js

@@ -261,6 +261,154 @@ projectCommand
         process.exit(1);
     }
 });
+projectCommand
+    .command("list-configs")
+    .description("List all project configurations")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = ensureConfig();
+    try {
+        const res = await fetch(`${config.apiUrl}/api/project-configs`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const configs = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(configs, null, 2));
+        }
+        else {
+            printProjectConfigs(configs);
+        }
+    }
+    catch (error) {
+        console.error("Error fetching project configs:", error);
+        process.exit(1);
+    }
+});
+projectCommand
+    .command("show-config <repo>")
+    .description("Show configuration for a repository (owner/repo)")
+    .option("--json", "Output as JSON")
+    .action(async (repo, options) => {
+    const config = ensureConfig();
+    try {
+        const url = new URL("/api/project-configs", config.apiUrl);
+        url.searchParams.set("repo", repo);
+        const res = await fetch(url.toString(), {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: No configuration found for repository ${repo}`);
+            }
+            else {
+                console.error(`Error: API returned ${res.status}`);
+            }
+            process.exit(1);
+        }
+        const projectConfig = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(projectConfig, null, 2));
+        }
+        else {
+            printProjectConfigDetail(projectConfig);
+        }
+    }
+    catch (error) {
+        console.error("Error fetching project config:", error);
+        process.exit(1);
+    }
+});
+projectCommand
+    .command("enable-pr-agent <repo>")
+    .description("Enable PR Agent for a repository (owner/repo)")
+    .option("--json", "Output as JSON")
+    .action(async (repo, options) => {
+    const config = ensureConfig();
+    try {
+        const res = await fetch(`${config.apiUrl}/api/project-configs`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                repo,
+                prAgentEnabled: true,
+            }),
+        });
+        if (!res.ok) {
+            const errorData = await res.json().catch(() => ({}));
+            throw new Error(errorData.error || `API error: ${res.status}`);
+        }
+        const projectConfig = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(projectConfig, null, 2));
+        }
+        else {
+            console.log(`✓ PR Agent enabled for ${repo}`);
+            console.log(`  Repository: ${projectConfig.repo}`);
+            console.log(`  PR Agent: ${projectConfig.prAgentEnabled ? "Enabled" : "Disabled"}`);
+        }
+    }
+    catch (error) {
+        console.error("Error enabling PR Agent:", error);
+        process.exit(1);
+    }
+});
+projectCommand
+    .command("disable-pr-agent <repo>")
+    .description("Disable PR Agent for a repository (owner/repo)")
+    .option("--json", "Output as JSON")
+    .action(async (repo, options) => {
+    const config = ensureConfig();
+    try {
+        const url = new URL("/api/project-configs", config.apiUrl);
+        url.searchParams.set("repo", repo);
+        const getRes = await fetch(url.toString(), {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!getRes.ok) {
+            if (getRes.status === 404) {
+                console.error(`Error: No configuration found for repository ${repo}`);
+            }
+            else {
+                console.error(`Error: API returned ${getRes.status}`);
+            }
+            process.exit(1);
+        }
+        const projectConfig = await getRes.json();
+        const updateRes = await fetch(`${config.apiUrl}/api/project-configs/${projectConfig.id}`, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                prAgentEnabled: false,
+            }),
+        });
+        if (!updateRes.ok) {
+            const errorData = await updateRes.json().catch(() => ({}));
+            throw new Error(errorData.error || `API error: ${updateRes.status}`);
+        }
+        const updatedConfig = await updateRes.json();
+        if (options.json) {
+            console.log(JSON.stringify(updatedConfig, null, 2));
+        }
+        else {
+            console.log(`✓ PR Agent disabled for ${repo}`);
+            console.log(`  Repository: ${updatedConfig.repo}`);
+            console.log(`  PR Agent: ${updatedConfig.prAgentEnabled ? "Enabled" : "Disabled"}`);
+        }
+    }
+    catch (error) {
+        console.error("Error disabling PR Agent:", error);
+        process.exit(1);
+    }
+});
 // ============================================
 // KNOWLEDGE MANAGEMENT COMMANDS
 // ============================================
@@ -459,7 +607,6 @@ function printKnowledgeList(projectId, knowledge) {
         const truncatedTitle = entry.title.length > 33 ? entry.title.substring(0, 30) + "..." : entry.title;
         console.log(`  ${entry.id.padEnd(24)} [${categoryConfig.icon}] ${categoryConfig.label.padEnd(10)} ${truncatedTitle}`);
     }
-    // Summary by category
     const byCategory = {};
     for (const entry of knowledge) {
         byCategory[entry.category] = (byCategory[entry.category] || 0) + 1;
@@ -471,3 +618,32 @@ function printKnowledgeList(projectId, knowledge) {
         .join(", ");
     console.log(`  By Category: ${categoryStr}\n`);
 }
+function printProjectConfigs(configs) {
+    if (configs.length === 0) {
+        console.log("\n  No project configurations found.");
+        console.log("  Enable PR Agent with: husky project enable-pr-agent <owner/repo>\n");
+        return;
+    }
+    console.log("\n  PROJECT CONFIGURATIONS");
+    console.log("  " + "-".repeat(80));
+    console.log(`  ${"REPOSITORY".padEnd(40)} ${"PR AGENT".padEnd(15)} ${"UPDATED".padEnd(20)}`);
+    console.log("  " + "-".repeat(80));
+    for (const config of configs) {
+        const status = config.prAgentEnabled ? "✓ Enabled" : "✗ Disabled";
+        const updated = new Date(config.updatedAt).toLocaleDateString();
+        const truncatedRepo = config.repo.length > 38 ? config.repo.substring(0, 35) + "..." : config.repo;
+        console.log(`  ${truncatedRepo.padEnd(40)} ${status.padEnd(15)} ${updated}`);
+    }
+    console.log("  " + "-".repeat(80));
+    console.log(`  Total: ${configs.length} configuration(s)\n`);
+}
+function printProjectConfigDetail(config) {
+    console.log(`\n  Project Configuration: ${config.repo}`);
+    console.log("  " + "=".repeat(60));
+    console.log(`  ID:          ${config.id}`);
+    console.log(`  Repository:  ${config.repo}`);
+    console.log(`  PR Agent:    ${config.prAgentEnabled ? "✓ Enabled" : "✗ Disabled"}`);
+    console.log(`  Created:     ${new Date(config.createdAt).toLocaleString()}`);
+    console.log(`  Updated:     ${new Date(config.updatedAt).toLocaleString()}`);
+    console.log("");
+}

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,7 @@ 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 { checkVersion } from "./lib/version-check.js";
 // Read version from package.json
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
@@ -88,11 +89,17 @@ 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.32.0",
+  "version": "1.33.1",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {