@simonfestl/husky-cli 1.38.4 → 1.38.6

package/dist/lib/biz/x-client.js

@@ -0,0 +1,123 @@
+import { getConfig } from "../../commands/config.js";
+export class XClient {
+    config;
+    baseUrl = 'https://api.twitter.com/2';
+    userIdCache = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    static fromConfig() {
+        const config = getConfig();
+        const env = process.env.HUSKY_ENV || 'PROD';
+        const bearerToken = process.env[`${env}_X_BEARER_TOKEN`] || process.env.X_BEARER_TOKEN || config.xBearerToken;
+        if (!bearerToken) {
+            return null;
+        }
+        return new XClient({ bearerToken });
+    }
+    async makeRequest(endpoint, params, retryCount = 0) {
+        const url = new URL(`${this.baseUrl}${endpoint}`);
+        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.config.bearerToken}`,
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(id);
+            if (response.status === 429 && retryCount < 2) {
+                const resetTime = parseInt(response.headers.get('x-rate-limit-reset') || '0', 10);
+                const waitTime = resetTime ? Math.max(0, (resetTime * 1000) - Date.now() + 1000) : 5000;
+                // Cap wait time to 30s for CLI
+                if (waitTime < 30000) {
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                    return this.makeRequest(endpoint, params, retryCount + 1);
+                }
+            }
+            if (!response.ok) {
+                const error = await response.text();
+                // Redact token if it somehow ended up in the error text
+                const redactedError = error.replace(this.config.bearerToken, '[REDACTED]');
+                throw new Error(`X API error: ${response.status} ${response.statusText} - ${redactedError}`);
+            }
+            return response.json();
+        }
+        catch (err) {
+            clearTimeout(id);
+            throw err;
+        }
+    }
+    async searchRecentTweets(query, maxResults = 10) {
+        const clampedResults = Math.max(10, Math.min(maxResults, 100));
+        const data = await this.makeRequest('/tweets/search/recent', {
+            query,
+            max_results: clampedResults.toString(),
+            'tweet.fields': 'created_at,public_metrics,author_id',
+            expansions: 'author_id',
+            'user.fields': 'username',
+        });
+        if (!data.data)
+            return [];
+        const users = new Map(data.includes?.users?.map(u => [u.id, u.username]) || []);
+        return data.data.map(tweet => ({
+            id: tweet.id,
+            text: tweet.text,
+            authorId: tweet.author_id,
+            username: users.get(tweet.author_id) || 'unknown',
+            createdAt: tweet.created_at,
+            publicMetrics: {
+                retweetCount: tweet.public_metrics?.retweet_count ?? 0,
+                replyCount: tweet.public_metrics?.reply_count ?? 0,
+                likeCount: tweet.public_metrics?.like_count ?? 0,
+                quoteCount: tweet.public_metrics?.quote_count ?? 0,
+            },
+        }));
+    }
+    async getUserTweets(username, maxResults = 10) {
+        const clampedResults = Math.max(5, Math.min(maxResults, 100));
+        const cleanUsername = encodeURIComponent(username.replace('@', ''));
+        // 1. Resolve username to ID (with cache)
+        let userId = this.userIdCache.get(cleanUsername);
+        if (!userId) {
+            const userData = await this.makeRequest(`/users/by/username/${cleanUsername}`, {});
+            if (!userData.data)
+                return [];
+            userId = userData.data.id;
+            this.userIdCache.set(cleanUsername, userId);
+        }
+        // 2. Get tweets
+        const data = await this.makeRequest(`/users/${encodeURIComponent(userId)}/tweets`, {
+            max_results: clampedResults.toString(),
+            'tweet.fields': 'created_at,public_metrics,author_id',
+            expansions: 'author_id',
+            'user.fields': 'username',
+        });
+        if (!data.data)
+            return [];
+        return data.data.map(tweet => ({
+            id: tweet.id,
+            text: tweet.text,
+            authorId: tweet.author_id,
+            username: username,
+            createdAt: tweet.created_at,
+            publicMetrics: {
+                retweetCount: tweet.public_metrics?.retweet_count ?? 0,
+                replyCount: tweet.public_metrics?.reply_count ?? 0,
+                likeCount: tweet.public_metrics?.like_count ?? 0,
+                quoteCount: tweet.public_metrics?.quote_count ?? 0,
+            },
+        }));
+    }
+}
+export function isXConfigured() {
+    const config = getConfig();
+    const env = process.env.HUSKY_ENV || 'PROD';
+    const bearerToken = process.env[`${env}_X_BEARER_TOKEN`] || process.env.X_BEARER_TOKEN || config.xBearerToken;
+    return !!bearerToken;
+}

package/dist/lib/biz/youtube-monitor.d.ts

@@ -0,0 +1,72 @@
+export interface YouTubeConfig {
+    apiKey: string;
+}
+export interface YouTubeVideo {
+    id: string;
+    title: string;
+    description: string;
+    channelId: string;
+    channelTitle: string;
+    publishedAt: string;
+    thumbnails: {
+        default?: {
+            url: string;
+            width: number;
+            height: number;
+        };
+        medium?: {
+            url: string;
+            width: number;
+            height: number;
+        };
+        high?: {
+            url: string;
+            width: number;
+            height: number;
+        };
+    };
+    duration?: string;
+    viewCount?: string;
+    likeCount?: string;
+    commentCount?: string;
+}
+export interface YouTubeChannel {
+    id: string;
+    title: string;
+    description: string;
+    customUrl?: string;
+    publishedAt: string;
+    thumbnails: {
+        default?: {
+            url: string;
+        };
+        medium?: {
+            url: string;
+        };
+        high?: {
+            url: string;
+        };
+    };
+    subscriberCount?: string;
+    videoCount?: string;
+}
+export declare class YouTubeMonitorClient {
+    private config;
+    private baseUrl;
+    constructor(config: YouTubeConfig);
+    static fromConfig(): YouTubeMonitorClient;
+    private makeRequest;
+    getChannelById(channelId: string): Promise<YouTubeChannel | null>;
+    getChannelByHandle(handle: string): Promise<YouTubeChannel | null>;
+    getLatestVideos(channelId: string, options?: {
+        maxResults?: number;
+        publishedAfter?: Date;
+    }): Promise<YouTubeVideo[]>;
+    getVideoTranscript(videoId: string): Promise<string | null>;
+    searchVideos(query: string, options?: {
+        maxResults?: number;
+        publishedAfter?: Date;
+        channelId?: string;
+    }): Promise<YouTubeVideo[]>;
+}
+export declare function isYouTubeConfigured(): boolean;

package/dist/lib/biz/youtube-monitor.js

@@ -0,0 +1,180 @@
+import { getConfig } from "../../commands/config.js";
+function mapChannelItem(item) {
+    return {
+        id: item.id,
+        title: item.snippet.title,
+        description: item.snippet.description,
+        customUrl: item.snippet.customUrl,
+        publishedAt: item.snippet.publishedAt,
+        thumbnails: item.snippet.thumbnails,
+        subscriberCount: item.statistics?.subscriberCount,
+        videoCount: item.statistics?.videoCount,
+    };
+}
+export class YouTubeMonitorClient {
+    config;
+    baseUrl = 'https://www.googleapis.com/youtube/v3';
+    constructor(config) {
+        this.config = config;
+    }
+    static fromConfig() {
+        const config = getConfig();
+        const env = process.env.HUSKY_ENV || 'PROD';
+        const apiKey = process.env[`${env}_YOUTUBE_API_KEY`] || process.env.YOUTUBE_API_KEY || config.youtubeApiKey;
+        if (!apiKey) {
+            throw new Error("YouTube API Key not configured. Please set youtube-api-key.");
+        }
+        const clientConfig = {
+            apiKey,
+        };
+        return new YouTubeMonitorClient(clientConfig);
+    }
+    async makeRequest(endpoint, params, retryCount = 0) {
+        const url = new URL(`${this.baseUrl}${endpoint}`);
+        url.searchParams.append('key', this.config.apiKey);
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null)
+                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(), {
+                signal: controller.signal,
+            });
+            clearTimeout(id);
+            if (response.status === 429 && retryCount < 2) {
+                await new Promise(resolve => setTimeout(resolve, 5000 * (retryCount + 1)));
+                return this.makeRequest(endpoint, params, retryCount + 1);
+            }
+            if (!response.ok) {
+                const error = await response.text();
+                // Redact API key from error message
+                const redactedError = error.replace(this.config.apiKey, '[REDACTED]');
+                throw new Error(`YouTube API error: ${response.status} ${response.statusText} - ${redactedError}`);
+            }
+            return response.json();
+        }
+        catch (err) {
+            clearTimeout(id);
+            throw err;
+        }
+    }
+    async getChannelById(channelId) {
+        const data = await this.makeRequest('/channels', {
+            part: 'snippet,statistics',
+            id: channelId,
+        });
+        if (!data.items || data.items.length === 0) {
+            return null;
+        }
+        return mapChannelItem(data.items[0]);
+    }
+    async getChannelByHandle(handle) {
+        const cleanHandle = handle.startsWith('@') ? handle : `@${handle}`;
+        const data = await this.makeRequest('/channels', {
+            part: 'snippet,statistics',
+            forHandle: cleanHandle,
+        });
+        if (!data.items || data.items.length === 0) {
+            return null;
+        }
+        return mapChannelItem(data.items[0]);
+    }
+    async getLatestVideos(channelId, options = {}) {
+        const { maxResults = 10, publishedAfter } = options;
+        const clampedResults = Math.min(maxResults, 50);
+        const params = {
+            part: 'snippet',
+            channelId,
+            type: 'video',
+            order: 'date',
+            maxResults: clampedResults.toString(),
+        };
+        if (publishedAfter) {
+            params.publishedAfter = publishedAfter.toISOString();
+        }
+        const data = await this.makeRequest('/search', params);
+        if (!data.items || data.items.length === 0) {
+            return [];
+        }
+        const videoIds = data.items.map(item => item.id.videoId).filter(Boolean);
+        if (videoIds.length === 0) {
+            return [];
+        }
+        // Get video details for duration, view count, etc. (Max 50 IDs per call)
+        const detailsData = await this.makeRequest('/videos', {
+            part: 'contentDetails,statistics',
+            id: videoIds.slice(0, 50).join(','),
+        });
+        const detailsMap = new Map(detailsData.items?.map(item => [item.id, item]) || []);
+        return data.items
+            .filter(item => item.id.videoId)
+            .map(item => {
+            const videoId = item.id.videoId;
+            const details = detailsMap.get(videoId);
+            return {
+                id: videoId,
+                title: item.snippet.title,
+                description: item.snippet.description,
+                channelId: item.snippet.channelId,
+                channelTitle: item.snippet.channelTitle,
+                publishedAt: item.snippet.publishedAt,
+                thumbnails: item.snippet.thumbnails,
+                duration: details?.contentDetails?.duration,
+                viewCount: details?.statistics?.viewCount,
+                likeCount: details?.statistics?.likeCount,
+                commentCount: details?.statistics?.commentCount,
+            };
+        });
+    }
+    async getVideoTranscript(videoId) {
+        try {
+            const { YoutubeTranscript } = await import('youtube-transcript');
+            const transcript = await YoutubeTranscript.fetchTranscript(videoId);
+            return transcript.map(entry => entry.text).join(' ');
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async searchVideos(query, options = {}) {
+        const { maxResults = 10, publishedAfter, channelId } = options;
+        const clampedResults = Math.min(maxResults, 50);
+        const params = {
+            part: 'snippet',
+            q: query,
+            type: 'video',
+            order: 'date',
+            maxResults: clampedResults.toString(),
+        };
+        if (publishedAfter) {
+            params.publishedAfter = publishedAfter.toISOString();
+        }
+        if (channelId) {
+            params.channelId = channelId;
+        }
+        const data = await this.makeRequest('/search', params);
+        if (!data.items) {
+            return [];
+        }
+        return data.items
+            .filter(item => item.id.videoId)
+            .map(item => ({
+            id: item.id.videoId,
+            title: item.snippet.title,
+            description: item.snippet.description,
+            channelId: item.snippet.channelId,
+            channelTitle: item.snippet.channelTitle,
+            publishedAt: item.snippet.publishedAt,
+            thumbnails: item.snippet.thumbnails,
+        }));
+    }
+}
+export function isYouTubeConfigured() {
+    const config = getConfig();
+    const env = process.env.HUSKY_ENV || 'PROD';
+    const apiKey = process.env[`${env}_YOUTUBE_API_KEY`] || process.env.YOUTUBE_API_KEY || config.youtubeApiKey;
+    return !!apiKey;
+}

package/dist/lib/permissions-cache.js

@@ -1,26 +1,21 @@
-import { getConfig, isSessionActive } from "../commands/config.js";
+import { getConfig, getAuthHeaders } from "../commands/config.js";
 const CACHE_TTL_MS = 5 * 60 * 1000;
 let cache = null;
 let fetchPromise = null;
 async function fetchPermissions() {
     const config = getConfig();
-    if (!config.apiUrl || !config.apiKey) {
+    if (!config.apiUrl) {
         throw new Error("API not configured");
     }
-    // If there's an active session, use the session's role
-    // This ensures permissions match the logged-in agent, not the API key
-    const roleToFetch = isSessionActive() && config.sessionRole
-        ? config.sessionRole
-        : undefined;
-    // Build URL - if we have a session role, request permissions for that specific role
-    const url = new URL("/api/auth/whoami", config.apiUrl);
-    if (roleToFetch) {
-        url.searchParams.set("role", roleToFetch);
+    const authHeaders = getAuthHeaders();
+    if (!authHeaders.Authorization) {
+        throw new Error("No active session. Run: husky auth login --agent <name>");
     }
+    const url = new URL("/api/auth/whoami", config.apiUrl);
     const res = await fetch(url.toString(), {
         method: "GET",
         headers: {
-            "x-api-key": config.apiKey,
+            ...authHeaders,
             "Content-Type": "application/json",
         },
     });
@@ -29,12 +24,8 @@ async function fetchPermissions() {
         throw new Error(error.message || error.error || `HTTP ${res.status}`);
     }
     const data = await res.json();
-    // If we have a session role, override the returned role with the session role
-    // and fetch permissions for that role
-    const effectiveRole = roleToFetch || data.role;
-    const effectivePermissions = roleToFetch
-        ? await fetchPermissionsForRole(config.apiUrl, config.apiKey, roleToFetch)
-        : data.permissions;
+    const effectiveRole = data.role || config.sessionRole || "unknown";
+    const effectivePermissions = data.permissions || [];
     const kbPermissions = effectivePermissions
         .filter((p) => p.startsWith("kb:"))
         .map((p) => p.replace("kb:", ""));
@@ -45,23 +36,6 @@ async function fetchPermissions() {
         fetchedAt: Date.now(),
     };
 }
-async function fetchPermissionsForRole(apiUrl, apiKey, role) {
-    // Use the /permissions/:role endpoint to get permissions for a specific role
-    const url = new URL(`/api/auth/permissions/${encodeURIComponent(role)}`, apiUrl);
-    const res = await fetch(url.toString(), {
-        method: "GET",
-        headers: {
-            "x-api-key": apiKey,
-            "Content-Type": "application/json",
-        },
-    });
-    if (!res.ok) {
-        // Fall back to empty permissions if fetch fails
-        return [];
-    }
-    const data = await res.json();
-    return data.permissions || [];
-}
 export async function getPermissions() {
     const now = Date.now();
     if (cache && now - cache.fetchedAt < CACHE_TTL_MS) {

package/package.json

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