@hasna/skills 0.0.2

package/skills/skill-browse/src/client.ts

@@ -0,0 +1,373 @@
+/**
+ * Browser-Use API Client
+ * Wrapper around the Browser-Use Cloud API
+ */
+
+import type {
+  BrowseOptions,
+  BrowseResult,
+  ExtractOptions,
+  ExtractResult,
+  TaskInfo,
+  TaskResult,
+  TaskStep,
+} from './types';
+
+export class BrowserUseClient {
+  private apiKey: string;
+  private baseUrl = 'https://api.browser-use.com/api/v1';
+  private defaultModel: string;
+  private defaultProxy: boolean;
+  private defaultProxyCountry: string;
+
+  constructor(apiKey?: string) {
+    this.apiKey = apiKey || process.env.BROWSER_USE_API_KEY || '';
+    if (!this.apiKey) {
+      throw new Error(
+        'BROWSER_USE_API_KEY environment variable is required. ' +
+          'Get your key from: https://cloud.browser-use.com/billing'
+      );
+    }
+    this.defaultModel = process.env.BROWSER_USE_MODEL || 'gpt-4o';
+    this.defaultProxy = process.env.BROWSER_USE_PROXY === 'true';
+    this.defaultProxyCountry = process.env.BROWSER_USE_PROXY_COUNTRY || 'us';
+  }
+
+  private async request<T>(
+    endpoint: string,
+    method: 'GET' | 'POST' | 'PUT' = 'GET',
+    body?: Record<string, unknown>
+  ): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`;
+    const options: RequestInit = {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+    };
+
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Browser-Use API error (${response.status}): ${errorText}`
+      );
+    }
+
+    return response.json() as T;
+  }
+
+  /**
+   * Run a browser automation task
+   */
+  async runTask(options: BrowseOptions): Promise<TaskResult> {
+    const payload: Record<string, unknown> = {
+      task: options.task,
+      llm_model: options.model || this.defaultModel,
+      use_proxy: options.useProxy ?? this.defaultProxy,
+      proxy_country_code: options.proxyCountry || this.defaultProxyCountry,
+      use_adblock: options.useAdblock ?? false,
+      highlight_elements: options.highlightElements ?? true,
+    };
+
+    // Add secrets/credentials if provided
+    if (options.secrets && Object.keys(options.secrets).length > 0) {
+      payload.secrets = options.secrets;
+    }
+
+    // Add allowed domains if provided
+    if (options.allowedDomains && options.allowedDomains.length > 0) {
+      payload.allowed_domains = options.allowedDomains;
+    }
+
+    const result = await this.request<{
+      id: string;
+      status: string;
+      live_url?: string;
+      output?: string;
+      error?: string;
+    }>('/run-task', 'POST', payload);
+
+    return {
+      taskId: result.id,
+      status: result.status as TaskResult['status'],
+      liveUrl: result.live_url,
+      output: result.output,
+      error: result.error,
+    };
+  }
+
+  /**
+   * Run a task and wait for completion
+   */
+  async browse(options: BrowseOptions): Promise<BrowseResult> {
+    const task = await this.runTask(options);
+    const timeout = options.timeout || 300000; // 5 minutes default
+    const startTime = Date.now();
+    const pollInterval = 2000; // 2 seconds
+
+    console.log(`Task started: ${task.taskId}`);
+    if (task.liveUrl) {
+      console.log(`Live view: ${task.liveUrl}`);
+    }
+
+    // Poll for completion
+    while (Date.now() - startTime < timeout) {
+      const status = await this.getTaskStatus(task.taskId);
+
+      if (status.status === 'finished') {
+        const result = await this.getTask(task.taskId);
+        return {
+          success: true,
+          taskId: task.taskId,
+          output: result.output,
+          liveUrl: task.liveUrl,
+          steps: result.steps,
+        };
+      }
+
+      if (status.status === 'failed' || status.status === 'stopped') {
+        return {
+          success: false,
+          taskId: task.taskId,
+          error: status.error || `Task ${status.status}`,
+          liveUrl: task.liveUrl,
+        };
+      }
+
+      // Wait before next poll
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+
+    return {
+      success: false,
+      taskId: task.taskId,
+      error: 'Task timed out',
+      liveUrl: task.liveUrl,
+    };
+  }
+
+  /**
+   * Extract structured data from a website
+   */
+  async extract(options: ExtractOptions): Promise<ExtractResult> {
+    const payload: Record<string, unknown> = {
+      task: options.task,
+      llm_model: options.model || this.defaultModel,
+      use_proxy: options.useProxy ?? this.defaultProxy,
+      proxy_country_code: options.proxyCountry || this.defaultProxyCountry,
+      use_adblock: options.useAdblock ?? false,
+      highlight_elements: options.highlightElements ?? true,
+    };
+
+    if (options.schema) {
+      payload.structured_output_json = options.schema;
+    }
+
+    // Add secrets/credentials if provided
+    if (options.secrets && Object.keys(options.secrets).length > 0) {
+      payload.secrets = options.secrets;
+    }
+
+    // Add allowed domains if provided
+    if (options.allowedDomains && options.allowedDomains.length > 0) {
+      payload.allowed_domains = options.allowedDomains;
+    }
+
+    const task = await this.request<{
+      id: string;
+      status: string;
+      live_url?: string;
+    }>('/run-task', 'POST', payload);
+
+    const timeout = options.timeout || 300000;
+    const startTime = Date.now();
+    const pollInterval = 2000;
+
+    console.log(`Extraction task started: ${task.id}`);
+    if (task.live_url) {
+      console.log(`Live view: ${task.live_url}`);
+    }
+
+    // Poll for completion
+    while (Date.now() - startTime < timeout) {
+      const result = await this.getTask(task.id);
+
+      if (result.status === 'finished') {
+        let data: unknown = result.output;
+        let savedTo: string | undefined;
+
+        // Try to parse JSON output
+        if (typeof result.output === 'string') {
+          try {
+            data = JSON.parse(result.output);
+          } catch {
+            // Keep as string if not valid JSON
+          }
+        }
+
+        // Save to file if path provided
+        if (options.outputPath && data) {
+          const content =
+            typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+          await Bun.write(options.outputPath, content);
+          savedTo = options.outputPath;
+          console.log(`Data saved to: ${savedTo}`);
+        }
+
+        return {
+          success: true,
+          taskId: task.id,
+          output: result.output,
+          data,
+          savedTo,
+          liveUrl: task.live_url,
+          steps: result.steps,
+        };
+      }
+
+      if (result.status === 'failed' || result.status === 'stopped') {
+        return {
+          success: false,
+          taskId: task.id,
+          error: result.error || `Task ${result.status}`,
+          liveUrl: task.live_url,
+        };
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+
+    return {
+      success: false,
+      taskId: task.id,
+      error: 'Task timed out',
+      liveUrl: task.live_url,
+    };
+  }
+
+  /**
+   * Get task details
+   */
+  async getTask(taskId: string): Promise<TaskResult> {
+    const result = await this.request<{
+      id: string;
+      status: string;
+      output?: string;
+      error?: string;
+      steps?: Array<{
+        id: string;
+        step: number;
+        evaluation_previous_goal?: string;
+        next_goal?: string;
+        url?: string;
+      }>;
+    }>(`/task/${taskId}`);
+
+    // Transform steps to our format
+    const steps = result.steps?.map((s) => ({
+      index: s.step,
+      action: s.next_goal || s.evaluation_previous_goal || `Step ${s.step}`,
+      result: s.evaluation_previous_goal,
+      timestamp: new Date().toISOString(),
+    }));
+
+    return {
+      taskId: result.id,
+      status: result.status as TaskResult['status'],
+      output: result.output,
+      error: result.error,
+      steps,
+    };
+  }
+
+  /**
+   * Get task status
+   */
+  async getTaskStatus(
+    taskId: string
+  ): Promise<{ status: string; error?: string }> {
+    const url = `${this.baseUrl}/task/${taskId}/status`;
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Browser-Use API error (${response.status}): ${errorText}`
+      );
+    }
+
+    const text = await response.text();
+    // Status endpoint returns just the status string, not an object
+    const status = text.replace(/"/g, '');
+    return { status };
+  }
+
+  /**
+   * Pause a running task
+   */
+  async pauseTask(taskId: string): Promise<{ success: boolean }> {
+    return this.request<{ success: boolean }>(`/task/${taskId}/pause`, 'POST');
+  }
+
+  /**
+   * Resume a paused task
+   */
+  async resumeTask(taskId: string): Promise<{ success: boolean }> {
+    return this.request<{ success: boolean }>(`/task/${taskId}/resume`, 'POST');
+  }
+
+  /**
+   * Stop a running task permanently
+   */
+  async stopTask(taskId: string): Promise<{ success: boolean }> {
+    return this.request<{ success: boolean }>(`/task/${taskId}/stop`, 'POST');
+  }
+
+  /**
+   * List all tasks
+   */
+  async listTasks(): Promise<TaskInfo[]> {
+    const result = await this.request<{
+      tasks: Array<{
+        id: string;
+        status: string;
+        task: string;
+        live_url?: string;
+        created_at: string;
+        completed_at?: string;
+      }>;
+    }>('/tasks');
+
+    return (result.tasks || []).map((t) => ({
+      id: t.id,
+      status: t.status as TaskInfo['status'],
+      task: t.task,
+      liveUrl: t.live_url,
+      createdAt: t.created_at,
+      completedAt: t.completed_at,
+    }));
+  }
+
+  /**
+   * Get screenshots from a task
+   */
+  async getTaskScreenshots(taskId: string): Promise<string[]> {
+    const result = await this.request<{ screenshots: string[] }>(
+      `/task/${taskId}/screenshots`
+    );
+    return result.screenshots || [];
+  }
+}

package/skills/skill-browse/src/http-client.ts

@@ -0,0 +1,128 @@
+/**
+ * Skill HTTP Client
+ *
+ * Generic HTTP client for calling the remote skill API server
+ * Usage: import and call executeSkill() from your skill CLI
+ */
+
+const SKILL_API_URL = process.env.SKILL_API_URL || "https://skill.hasnaxyz.com";
+
+export interface SkillRequest {
+  skill: string;
+  command?: string;
+  provider?: string;
+  prompt?: string;
+  text?: string;
+  output?: string;
+  [key: string]: unknown;
+}
+
+export interface SkillResponse {
+  success: boolean;
+  output?: string;
+  error?: string;
+  details?: string;
+}
+
+/**
+ * Execute a skill on the remote server
+ */
+export async function executeSkill(request: SkillRequest): Promise<SkillResponse | Blob> {
+  const { skill, ...params } = request;
+
+  const url = `${SKILL_API_URL}/${skill}/`;
+
+  // Get API key from environment
+  const apiKey = process.env.SKILL_API_KEY;
+  if (!apiKey) {
+    return {
+      success: false,
+      error: "Missing SKILL_API_KEY",
+      details: "Set SKILL_API_KEY environment variable"
+    };
+  }
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": `skill-${skill}-cli/1.0`,
+        "X-API-Key": apiKey
+      },
+      body: JSON.stringify(params)
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      return {
+        success: false,
+        error: error.error || `HTTP ${response.status}`,
+        details: error.details || error.message
+      };
+    }
+
+    // Check if response is a file (binary)
+    const contentType = response.headers.get("Content-Type") || "";
+    if (contentType.includes("image/") ||
+        contentType.includes("audio/") ||
+        contentType.includes("video/") ||
+        contentType.includes("application/")) {
+      return await response.blob();
+    }
+
+    // Otherwise JSON
+    return await response.json();
+
+  } catch (error) {
+    return {
+      success: false,
+      error: "Network error",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Save a blob to a file
+ */
+export async function saveBlob(blob: Blob, outputPath: string): Promise<void> {
+  const buffer = await blob.arrayBuffer();
+  await Bun.write(outputPath, buffer);
+}
+
+/**
+ * Helper to execute a skill and save file if needed
+ */
+export async function executeAndSave(request: SkillRequest): Promise<boolean> {
+  console.log(`🔗 Connecting to ${SKILL_API_URL}...`);
+
+  const result = await executeSkill(request);
+
+  if (result instanceof Blob) {
+    // File response
+    if (!request.output) {
+      console.error("❌ Error: No output path specified");
+      return false;
+    }
+
+    await saveBlob(result, request.output);
+    console.log(`✅ Saved to: ${request.output}`);
+    return true;
+  }
+
+  // JSON response
+  if (!result.success) {
+    console.error(`❌ Error: ${result.error}`);
+    if (result.details) {
+      console.error(`   ${result.details}`);
+    }
+    return false;
+  }
+
+  if (result.output) {
+    console.log(result.output);
+  }
+
+  return true;
+}

package/skills/skill-browse/src/index-http.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env bun
+
+/**
+ * Skill Browse (HTTP Client)
+ * Calls the remote skill API server
+ */
+
+import { executeAndSave, executeSkill } from './http-client';
+import { handleInstallCommand } from './skill-install';
+
+// Skill metadata for install command
+const SKILL_META = {
+  name: 'skill-browse',
+  description: 'Browse skill - calls remote API',
+  version: '1.0.0',
+  commands: `skill-browse <command> [options]`,
+  requiredEnvVars: ['SKILL_API_KEY'],
+};
+
+// Handle install/uninstall commands
+if (await handleInstallCommand(SKILL_META, process.argv.slice(2))) {
+  process.exit(0);
+}
+
+// Parse command line arguments
+function parseArgs(): Record<string, string | boolean> {
+  const args = process.argv.slice(2);
+  const parsed: Record<string, string | boolean> = {};
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const key = args[i].slice(2);
+      const value = args[i + 1];
+      if (value && !value.startsWith('--')) {
+        parsed[key] = value;
+        i++;
+      } else {
+        parsed[key] = true;
+      }
+    } else if (!parsed.command) {
+      parsed.command = args[i];
+    }
+  }
+
+  return parsed;
+}
+
+// Main logic
+async function main() {
+  const args = parseArgs();
+  const command = (args.command as string) || 'help';
+
+  if (command === 'help' || args.help) {
+    console.log(`Skill Browse CLI
+
+USAGE:
+  skill-browse <command> [options]
+
+COMMANDS:
+  Call with any command and it will be forwarded to the remote API server
+
+EXAMPLES:
+  skill-browse generate --provider <provider> [options]`);
+    return;
+  }
+
+  // Extract all parameters
+  const { command: cmd, ...params } = args;
+
+  // Check if output file is expected (for file-generating skills)
+  const fileSkills = ['audio', 'image', 'video', 'emoji'];
+  const isFileSkill = fileSkills.includes('browse');
+
+  if (isFileSkill && params.output) {
+    // Skill that generates files
+    const success = await executeAndSave({
+      skill: 'browse',
+      command: cmd,
+      ...params,
+    });
+    process.exit(success ? 0 : 1);
+  } else {
+    // Skill that returns JSON/text
+    const result = await executeSkill({
+      skill: 'browse',
+      command: cmd,
+      ...params,
+    });
+
+    if (result instanceof Blob) {
+      console.error('❌ Unexpected binary response');
+      process.exit(1);
+    }
+
+    if (result.success && result.output) {
+      console.log(result.output);
+    } else {
+      console.error(`❌ Error: ${result.error}`);
+      if (result.details) {
+        console.error(`   ${result.details}`);
+      }
+      process.exit(1);
+    }
+  }
+}
+
+// Run main
+main().catch((error) => {
+  console.error('❌ Fatal error:', error.message);
+  process.exit(1);
+});