@simonfestl/husky-cli 1.38.4 → 1.38.6

package/dist/commands/supervisor.js

@@ -250,7 +250,6 @@ supervisorCommand
         }
         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) {

package/dist/index.js

@@ -2,7 +2,7 @@
 import { Command } from "commander";
 import { createRequire } from "module";
 import { taskCommand } from "./commands/task.js";
-import { configCommand } from "./commands/config.js";
+import { configCommand, ensureValidSession, getAuthHeaders, getConfig } from "./commands/config.js";
 import { agentCommand } from "./commands/agent.js";
 import { roadmapCommand } from "./commands/roadmap.js";
 import { changelogCommand } from "./commands/changelog.js";
@@ -33,6 +33,7 @@ import { infraCommand } from "./commands/infra.js";
 import { e2eCommand } from "./commands/e2e.js";
 import { prCommand } from "./commands/pr.js";
 import { youtubeCommand } from "./commands/youtube.js";
+import { researchCommand } from "./commands/research.js";
 import { imageCommand } from "./commands/image.js";
 import { authCommand } from "./commands/auth.js";
 import { businessCommand } from "./commands/business.js";
@@ -45,6 +46,49 @@ import { checkVersion } from "./lib/version-check.js";
 // Read version from package.json
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
+const originalFetch = globalThis.fetch.bind(globalThis);
+function isHuskyApiRequest(requestUrl) {
+    try {
+        const config = getConfig();
+        if (!config.apiUrl)
+            return false;
+        const apiBase = new URL(config.apiUrl);
+        const basePath = apiBase.pathname.replace(/\/$/, "");
+        const apiPrefix = `${basePath}/api/`.replace(/\/{2,}/g, "/");
+        return requestUrl.origin === apiBase.origin && requestUrl.pathname.startsWith(apiPrefix);
+    }
+    catch {
+        return false;
+    }
+}
+function isAuthBypassRequest(request) {
+    if (request.method.toUpperCase() !== "POST")
+        return false;
+    const pathname = new URL(request.url).pathname;
+    return pathname.endsWith("/api/auth/session") || pathname.endsWith("/api/auth/refresh");
+}
+globalThis.fetch = async (input, init) => {
+    const request = new Request(input, init);
+    const requestUrl = new URL(request.url);
+    if (!isHuskyApiRequest(requestUrl) || isAuthBypassRequest(request)) {
+        return originalFetch(request);
+    }
+    const headers = new Headers(request.headers);
+    headers.delete("x-api-key");
+    // Always ensure the stored session is valid (refresh if needed), and
+    // always use the current token for Husky API requests.
+    const ok = await ensureValidSession();
+    if (!ok) {
+        throw new Error("No active session. Run: husky auth login --agent <name>");
+    }
+    const authHeaders = getAuthHeaders();
+    const authToken = authHeaders.Authorization;
+    if (!authToken) {
+        throw new Error("No active session. Run: husky auth login --agent <name>");
+    }
+    headers.set("Authorization", authToken);
+    return originalFetch(new Request(request, { headers }));
+};
 const program = new Command();
 program
     .name("husky")
@@ -82,6 +126,7 @@ program.addCommand(infraCommand);
 program.addCommand(e2eCommand);
 program.addCommand(prCommand);
 program.addCommand(youtubeCommand);
+program.addCommand(researchCommand);
 program.addCommand(imageCommand);
 program.addCommand(authCommand);
 program.addCommand(businessCommand);

package/dist/lib/api-client.d.ts

@@ -2,6 +2,7 @@ export interface ApiRequestOptions {
     method?: string;
     body?: unknown;
     skipAuth?: boolean;
+    signal?: AbortSignal;
 }
 export declare function apiRequest<T>(path: string, options?: ApiRequestOptions): Promise<T>;
 export declare function getApiClient(): {

package/dist/lib/api-client.js

@@ -1,56 +1,10 @@
-import { getConfig, getSessionConfig, setSessionConfig, clearSessionConfig } from "../commands/config.js";
-const REFRESH_THRESHOLD_MS = 5 * 60 * 1000;
-let refreshInProgress = null;
+import { getConfig, getSessionConfig, clearSessionConfig, ensureValidSession } from "../commands/config.js";
 function isSessionExpired(expiresAt) {
     if (!expiresAt)
         return true;
     return new Date(expiresAt).getTime() < Date.now();
 }
-function isSessionExpiringSoon(expiresAt) {
-    if (!expiresAt)
-        return true;
-    return new Date(expiresAt).getTime() - Date.now() < REFRESH_THRESHOLD_MS;
-}
-async function doRefresh(agentName) {
-    const config = getConfig();
-    if (!config.apiUrl || !config.apiKey)
-        return null;
-    try {
-        const url = new URL("/api/auth/session", config.apiUrl);
-        const res = await fetch(url.toString(), {
-            method: "POST",
-            headers: {
-                "x-api-key": config.apiKey,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ agent: agentName }),
-        });
-        if (!res.ok)
-            return null;
-        const session = await res.json();
-        // Extract agent id for storage (API returns object with id, name, emoji)
-        setSessionConfig({
-            token: session.token,
-            expiresAt: session.expiresAt,
-            role: session.role,
-            agent: session.agent.id,
-        });
-        return session;
-    }
-    catch {
-        return null;
-    }
-}
-async function refreshSession(agentName) {
-    if (refreshInProgress) {
-        return refreshInProgress;
-    }
-    refreshInProgress = doRefresh(agentName).finally(() => {
-        refreshInProgress = null;
-    });
-    return refreshInProgress;
-}
-async function doFetch(url, method, authHeader, body) {
+async function doFetch(url, method, authHeader, body, signal) {
     return fetch(url.toString(), {
         method,
         headers: {
@@ -58,61 +12,40 @@ async function doFetch(url, method, authHeader, body) {
             "Content-Type": "application/json",
         },
         body: body ? JSON.stringify(body) : undefined,
+        signal,
     });
 }
-async function getAuthHeader(session, apiKey) {
-    // DEBUG: console.log('DEBUG session:', session?.token ? 'exists' : 'missing', session?.expiresAt);
+function getAuthHeader(session) {
     if (session?.token && session.expiresAt) {
-        // DEBUG: console.log('DEBUG: Checking expiration...');
         if (isSessionExpired(session.expiresAt)) {
-            // DEBUG: console.log('DEBUG: Session expired, refreshing...');
-            if (session.agent) {
-                const newSession = await refreshSession(session.agent);
-                if (newSession) {
-                    // DEBUG: console.log('DEBUG: Refresh successful, using Bearer token');
-                    return { "Authorization": `Bearer ${newSession.token}` };
-                }
-            }
             clearSessionConfig();
-            if (apiKey) {
-                // DEBUG: console.log('DEBUG: Refresh failed, falling back to API key');
-                return { "x-api-key": apiKey };
-            }
-            throw new Error("Session expired and no API key available for refresh");
+            throw new Error("Session expired. Run: husky auth login --agent <name>");
         }
-        if (isSessionExpiringSoon(session.expiresAt) && session.agent) {
-            refreshSession(session.agent).catch(() => { });
-        }
-        // DEBUG: console.log('DEBUG: Using existing Bearer token');
         return { "Authorization": `Bearer ${session.token}` };
     }
-    if (apiKey) {
-        // DEBUG: console.log('DEBUG: No session, using API key');
-        return { "x-api-key": apiKey };
-    }
-    throw new Error("No authentication configured. Run: husky auth login --agent <name> or husky config set api-key <key>");
+    throw new Error("No active session. Run: husky auth login --agent <name>");
 }
 export async function apiRequest(path, options = {}) {
     const config = getConfig();
     if (!config.apiUrl) {
         throw new Error("API URL not configured. Run: husky config set api-url <url>");
     }
+    if (!options.skipAuth) {
+        const ok = await ensureValidSession();
+        if (!ok) {
+            throw new Error("No active session. Run: husky auth login --agent <name>");
+        }
+    }
     const session = getSessionConfig();
     const method = options.method || "GET";
     const url = new URL(path, config.apiUrl);
     const authHeader = options.skipAuth
         ? {}
-        : await getAuthHeader(session, config.apiKey);
-    const res = await doFetch(url, method, authHeader, options.body);
+        : getAuthHeader(session);
+    const res = await doFetch(url, method, authHeader, options.body, options.signal);
     if (!res.ok) {
-        if (res.status === 401 && session?.token && session.agent) {
-            const newSession = await refreshSession(session.agent);
-            if (newSession) {
-                const retryRes = await doFetch(url, method, { "Authorization": `Bearer ${newSession.token}` }, options.body);
-                if (retryRes.ok) {
-                    return retryRes.json();
-                }
-            }
+        if (res.status === 401) {
+            clearSessionConfig();
         }
         const error = await res.json().catch(() => ({ error: res.statusText }));
         throw new Error(error.message || error.error || `HTTP ${res.status}`);

package/dist/lib/biz/api-brain.js

@@ -1,31 +1,18 @@
-import { getConfig } from "../../commands/config.js";
+import { getAuthHeaders, getConfig } from "../../commands/config.js";
 import { canAccessKnowledgeBase as checkKbAccess } from "../permissions-cache.js";
 async function apiRequest(path, options = {}) {
     const config = getConfig();
     if (!config.apiUrl) {
         throw new Error("API not configured. Run: husky config set api-url <url>");
     }
-    // Prefer session token (JWT), fall back to API key for backwards compatibility
+    const authHeaders = getAuthHeaders();
+    if (!authHeaders.Authorization) {
+        throw new Error("Not authenticated. Run: husky auth login --agent <name>");
+    }
     const headers = {
         "Content-Type": "application/json",
+        ...authHeaders,
     };
-    if (config.sessionToken) {
-        // Check if session is expired
-        if (config.sessionExpiresAt) {
-            const expiresAt = new Date(config.sessionExpiresAt);
-            if (expiresAt < new Date()) {
-                throw new Error("Session expired. Run: husky auth login --agent <name>");
-            }
-        }
-        headers["Authorization"] = `Bearer ${config.sessionToken}`;
-    }
-    else if (config.apiKey) {
-        // Legacy fallback - will be rejected by new API but kept for error message
-        headers["x-api-key"] = config.apiKey;
-    }
-    else {
-        throw new Error("Not authenticated. Run: husky auth login --agent <name>");
-    }
     const url = new URL(`/api/brain${path}`, config.apiUrl);
     const res = await fetch(url.toString(), {
         method: options.method || "POST",
@@ -35,10 +22,6 @@ async function apiRequest(path, options = {}) {
     if (!res.ok) {
         const error = await res.json().catch(() => ({ error: res.statusText }));
         if (res.status === 401) {
-            // Check if it's the new API rejecting API key auth
-            if (error.upgrade) {
-                throw new Error("Session required. Run: husky auth login --agent <name>");
-            }
             throw new Error(error.message || "Authentication failed");
         }
         if (res.status === 403) {

package/dist/lib/biz/emove-playwright.js

@@ -173,7 +173,6 @@ export class EmovePlaywrightClient {
         catch (error) {
             // Customer details not available
         }
-        // Extract line items
         const items = [];
         const itemRows = page.locator('table.woocommerce-table--order-details tbody tr.woocommerce-table__line-item');
         const itemCount = await itemRows.count();

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

@@ -18,3 +18,5 @@ export type { Order as ShopifyOrder, Customer as ShopifyCustomer, Product as Sho
 export { SupplierFeedService } from './supplier-feed.js';
 export type { SupplierId, SupplierProduct, SupplierProductSearchResult, SyncStats, } from './supplier-feed.js';
 export * from './supplier-feed-types.js';
+export { RedditClient } from './reddit.js';
+export { YouTubeMonitorClient } from './youtube-monitor.js';

package/dist/lib/biz/index.js

@@ -14,3 +14,5 @@ export { GotessClient } from './gotess.js';
 export { ShopifyClient } from './shopify.js';
 export { SupplierFeedService } from './supplier-feed.js';
 export * from './supplier-feed-types.js';
+export { RedditClient } from './reddit.js';
+export { YouTubeMonitorClient } from './youtube-monitor.js';

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

@@ -0,0 +1,83 @@
+export interface RedditConfig {
+    clientId: string;
+    clientSecret: string;
+    userAgent: string;
+}
+export interface RedditApiPost {
+    id: string;
+    title: string;
+    selftext: string;
+    url: string;
+    author: string;
+    subreddit: string;
+    score: number;
+    upvote_ratio: number;
+    num_comments: number;
+    created_utc: number;
+    permalink: string;
+    is_self: boolean;
+    thumbnail?: string;
+}
+export interface RedditPost {
+    id: string;
+    title: string;
+    selftext: string;
+    url: string;
+    author: string;
+    subreddit: string;
+    score: number;
+    upvoteRatio: number;
+    numComments: number;
+    createdUtc: number;
+    permalink: string;
+    isSelf: boolean;
+    thumbnail?: string;
+}
+export interface RedditTokenResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    scope: string;
+}
+export interface RedditComment {
+    id: string;
+    author: string;
+    body: string;
+    score: number;
+    created_utc: number;
+    replies?: {
+        data: {
+            children: Array<{
+                data: RedditComment;
+            }>;
+        };
+    };
+}
+export declare class RedditClient {
+    private config;
+    private accessToken?;
+    private tokenExpiry?;
+    private baseUrl;
+    private static AUTH_URL;
+    private static TOKEN_REFRESH_BUFFER_MS;
+    constructor(config: RedditConfig);
+    static fromConfig(): RedditClient;
+    private ensureAuthenticated;
+    private makeRequest;
+    getSubredditPosts(subreddit: string, options?: {
+        sort?: 'hot' | 'new' | 'top' | 'rising';
+        time?: 'hour' | 'day' | 'week' | 'month' | 'year' | 'all';
+        limit?: number;
+        after?: string;
+    }): Promise<{
+        posts: RedditPost[];
+        after: string | null;
+    }>;
+    searchSubreddit(subreddit: string, query: string, options?: {
+        sort?: 'relevance' | 'hot' | 'top' | 'new' | 'comments';
+        time?: 'hour' | 'day' | 'week' | 'month' | 'year' | 'all';
+        limit?: number;
+    }): Promise<RedditPost[]>;
+    getPostComments(postId: string, subreddit: string): Promise<RedditComment[]>;
+}
+export declare function isRedditConfigured(): boolean;

package/dist/lib/biz/reddit.js

@@ -0,0 +1,168 @@
+import { getConfig } from "../../commands/config.js";
+function mapRedditPost(raw) {
+    return {
+        id: raw.id,
+        title: raw.title,
+        selftext: raw.selftext,
+        url: raw.url,
+        author: raw.author,
+        subreddit: raw.subreddit,
+        score: raw.score,
+        upvoteRatio: raw.upvote_ratio,
+        numComments: raw.num_comments,
+        createdUtc: raw.created_utc,
+        permalink: raw.permalink,
+        isSelf: raw.is_self,
+        thumbnail: raw.thumbnail,
+    };
+}
+export class RedditClient {
+    config;
+    accessToken;
+    tokenExpiry;
+    baseUrl = 'https://oauth.reddit.com';
+    static AUTH_URL = 'https://www.reddit.com/api/v1/access_token';
+    static TOKEN_REFRESH_BUFFER_MS = 60_000;
+    constructor(config) {
+        this.config = config;
+    }
+    static fromConfig() {
+        const config = getConfig();
+        const env = process.env.HUSKY_ENV || 'PROD';
+        const clientId = process.env[`${env}_REDDIT_CLIENT_ID`] || process.env.REDDIT_CLIENT_ID || config.redditClientId;
+        const clientSecret = process.env[`${env}_REDDIT_CLIENT_SECRET`] || process.env.REDDIT_CLIENT_SECRET || config.redditClientSecret;
+        if (!clientId || !clientSecret) {
+            throw new Error("Reddit credentials not configured. Please set reddit-client-id and reddit-client-secret.");
+        }
+        const clientConfig = {
+            clientId,
+            clientSecret,
+            userAgent: process.env.REDDIT_USER_AGENT || 'HuskyResearchBot/1.0 (by /u/husky-bot)',
+        };
+        return new RedditClient(clientConfig);
+    }
+    async ensureAuthenticated() {
+        if (this.accessToken && this.tokenExpiry && Date.now() < this.tokenExpiry) {
+            return;
+        }
+        const authString = Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString('base64');
+        const timeout = 15000;
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(RedditClient.AUTH_URL, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Basic ${authString}`,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'User-Agent': this.config.userAgent,
+                },
+                body: new URLSearchParams({
+                    grant_type: 'client_credentials',
+                }),
+                signal: controller.signal,
+            });
+            clearTimeout(id);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Reddit auth failed: ${response.status} ${response.statusText} - ${errorText.substring(0, 500)}`);
+            }
+            const data = await response.json();
+            if (!data.access_token) {
+                throw new Error("Reddit auth response missing access_token");
+            }
+            this.accessToken = data.access_token;
+            this.tokenExpiry = Date.now() + (data.expires_in * 1000) - RedditClient.TOKEN_REFRESH_BUFFER_MS;
+        }
+        catch (err) {
+            clearTimeout(id);
+            throw err;
+        }
+    }
+    async makeRequest(endpoint, params, retryCount = 0) {
+        await this.ensureAuthenticated();
+        const url = new URL(`${this.baseUrl}${endpoint}`);
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                url.searchParams.append(key, value);
+            });
+        }
+        const timeout = 15000;
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(url.toString(), {
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`,
+                    'User-Agent': this.config.userAgent,
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(id);
+            if (response.status === 429 && retryCount < 2) {
+                const retryAfter = parseInt(response.headers.get('retry-after') || '5', 10);
+                await new Promise(resolve => setTimeout(resolve, (retryAfter + 1) * 1000));
+                return this.makeRequest(endpoint, params, retryCount + 1);
+            }
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Reddit API error: ${response.status} ${response.statusText} - ${errorText.substring(0, 500)}`);
+            }
+            return response.json();
+        }
+        catch (err) {
+            clearTimeout(id);
+            throw err;
+        }
+    }
+    async getSubredditPosts(subreddit, options = {}) {
+        const { sort = 'hot', time = 'day', limit = 25, after } = options;
+        const params = {
+            limit: Math.min(limit, 100).toString(),
+        };
+        if (time && (sort === 'top' || sort === 'new')) { // Reddit also accepts 't' for some other sorts
+            params.t = time;
+        }
+        if (after) {
+            params.after = after;
+        }
+        const safeSubreddit = encodeURIComponent(subreddit);
+        const data = await this.makeRequest(`/r/${safeSubreddit}/${sort}`, params);
+        return {
+            posts: data.data.children.filter(child => child.kind === 't3').map(child => mapRedditPost(child.data)),
+            after: data.data.after,
+        };
+    }
+    async searchSubreddit(subreddit, query, options = {}) {
+        const { sort = 'relevance', time = 'week', limit = 25 } = options;
+        const params = {
+            q: query,
+            restrict_sr: 'true',
+            sort,
+            t: time,
+            limit: Math.min(limit, 100).toString(),
+        };
+        const safeSubreddit = encodeURIComponent(subreddit);
+        const data = await this.makeRequest(`/r/${safeSubreddit}/search`, params);
+        return data.data.children.filter(child => child.kind === 't3').map(child => mapRedditPost(child.data));
+    }
+    async getPostComments(postId, subreddit) {
+        const safeSubreddit = encodeURIComponent(subreddit);
+        const safePostId = encodeURIComponent(postId);
+        const data = await this.makeRequest(`/r/${safeSubreddit}/comments/${safePostId}`);
+        if (Array.isArray(data) && data.length > 1) {
+            const commentsData = data[1];
+            return commentsData.data.children
+                .filter(child => child.kind === 't1')
+                .map(child => child.data);
+        }
+        return [];
+    }
+}
+export function isRedditConfigured() {
+    const config = getConfig();
+    const env = process.env.HUSKY_ENV || 'PROD';
+    const clientId = process.env[`${env}_REDDIT_CLIENT_ID`] || process.env.REDDIT_CLIENT_ID || config.redditClientId;
+    const clientSecret = process.env[`${env}_REDDIT_CLIENT_SECRET`] || process.env.REDDIT_CLIENT_SECRET || config.redditClientSecret;
+    return !!(clientId && clientSecret);
+}

package/dist/lib/biz/skuterzone-playwright.js

@@ -153,7 +153,6 @@ export class SkuterzonePlaywrightClient {
         catch (error) {
             // Customer details not available
         }
-        // Extract line items
         const items = [];
         const itemRows = page.locator('table.woocommerce-table--order-details tbody tr.woocommerce-table__line-item');
         const itemCount = await itemRows.count();

package/dist/lib/biz/x-client.d.ts

@@ -0,0 +1,27 @@
+export interface XConfig {
+    bearerToken: string;
+}
+export interface XPost {
+    id: string;
+    text: string;
+    authorId: string;
+    username: string;
+    createdAt: string;
+    publicMetrics: {
+        retweetCount: number;
+        replyCount: number;
+        likeCount: number;
+        quoteCount: number;
+    };
+}
+export declare class XClient {
+    private config;
+    private baseUrl;
+    private userIdCache;
+    constructor(config: XConfig);
+    static fromConfig(): XClient | null;
+    private makeRequest;
+    searchRecentTweets(query: string, maxResults?: number): Promise<XPost[]>;
+    getUserTweets(username: string, maxResults?: number): Promise<XPost[]>;
+}
+export declare function isXConfigured(): boolean;