@hasna/connectors 1.2.1 → 1.3.1

package/bin/serve.js

@@ -135,6 +135,22 @@ function migrate(db) {
       created_at TEXT NOT NULL
     )
   `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_usage (
+      id TEXT PRIMARY KEY,
+      connector TEXT NOT NULL,
+      action TEXT NOT NULL,
+      agent_id TEXT,
+      timestamp TEXT NOT NULL
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_usage_connector ON connector_usage(connector, timestamp DESC)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_promotions (
+      connector TEXT UNIQUE NOT NULL,
+      promoted_at TEXT NOT NULL
+    )
+  `);
 }
 var DB_DIR, DB_PATH, _db = null;
 var init_database = __esm(() => {
@@ -483,6 +499,75 @@ var init_scheduler = __esm(() => {
   init_strip();
 });
 
+// src/db/usage.ts
+var exports_usage = {};
+__export(exports_usage, {
+  logUsage: () => logUsage,
+  getUsageStats: () => getUsageStats,
+  getUsageMap: () => getUsageMap,
+  getTopConnectors: () => getTopConnectors,
+  cleanOldUsage: () => cleanOldUsage
+});
+function logUsage(connector, action, agentId, db) {
+  const d = db ?? getDatabase();
+  d.run("INSERT INTO connector_usage (id, connector, action, agent_id, timestamp) VALUES (?, ?, ?, ?, ?)", [shortUuid(), connector, action, agentId ?? null, now()]);
+}
+function getUsageStats(connector, db) {
+  const d = db ?? getDatabase();
+  const total = d.query("SELECT COUNT(*) as c FROM connector_usage WHERE connector = ?").get(connector).c;
+  const d7 = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+  const last7d = d.query("SELECT COUNT(*) as c FROM connector_usage WHERE connector = ? AND timestamp > ?").get(connector, d7).c;
+  const d1 = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+  const last24h = d.query("SELECT COUNT(*) as c FROM connector_usage WHERE connector = ? AND timestamp > ?").get(connector, d1).c;
+  return { connector, total, last7d, last24h };
+}
+function getTopConnectors(limit = 10, days = 7, db) {
+  const d = db ?? getDatabase();
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+  return d.query("SELECT connector, COUNT(*) as count FROM connector_usage WHERE timestamp > ? GROUP BY connector ORDER BY count DESC LIMIT ?").all(since, limit);
+}
+function getUsageMap(days = 7, db) {
+  const top = getTopConnectors(100, days, db);
+  return new Map(top.map((t) => [t.connector, t.count]));
+}
+function cleanOldUsage(days = 30, db) {
+  const d = db ?? getDatabase();
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+  return d.run("DELETE FROM connector_usage WHERE timestamp < ?", [cutoff]).changes;
+}
+var init_usage = __esm(() => {
+  init_database();
+});
+
+// src/db/promotions.ts
+var exports_promotions = {};
+__export(exports_promotions, {
+  promoteConnector: () => promoteConnector,
+  isPromoted: () => isPromoted,
+  getPromotedConnectors: () => getPromotedConnectors,
+  demoteConnector: () => demoteConnector
+});
+function promoteConnector(name, db) {
+  const d = db ?? getDatabase();
+  d.run("INSERT OR REPLACE INTO connector_promotions (connector, promoted_at) VALUES (?, ?)", [name, now()]);
+}
+function demoteConnector(name, db) {
+  const d = db ?? getDatabase();
+  return d.run("DELETE FROM connector_promotions WHERE connector = ?", [name]).changes > 0;
+}
+function getPromotedConnectors(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT connector FROM connector_promotions ORDER BY promoted_at DESC").all().map((r) => r.connector);
+}
+function isPromoted(name, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT 1 FROM connector_promotions WHERE connector = ?").get(name);
+  return !!row;
+}
+var init_promotions = __esm(() => {
+  init_database();
+});
+
 // src/server/serve.ts
 import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6 } from "fs";
 
@@ -6982,6 +7067,16 @@ function loadTokens(name) {
       return null;
     }
   }
+  const profileConfig = loadProfileConfig(name);
+  if (profileConfig.refreshToken || profileConfig.accessToken) {
+    return {
+      accessToken: profileConfig.accessToken,
+      refreshToken: profileConfig.refreshToken,
+      expiresAt: profileConfig.expiresAt,
+      tokenType: profileConfig.tokenType,
+      scope: profileConfig.scope
+    };
+  }
   return null;
 }
 function getAuthStatus(name) {
@@ -7560,6 +7655,30 @@ Dashboard not found at: ${dashboardDir}`);
       if (path === "/api/activity" && method === "GET") {
         return json(activityLog, 200, port);
       }
+      if (path === "/api/hot" && method === "GET") {
+        const { getTopConnectors: getTopConnectors2 } = await Promise.resolve().then(() => (init_usage(), exports_usage));
+        const { getPromotedConnectors: getPromotedConnectors2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+        const limit = parseInt(url2.searchParams.get("limit") || "10", 10);
+        const days = parseInt(url2.searchParams.get("days") || "7", 10);
+        const db = getDatabase2();
+        const top = getTopConnectors2(limit, days, db);
+        const promoted = new Set(getPromotedConnectors2(db));
+        return json(top.map((t) => ({ ...t, promoted: promoted.has(t.connector) })), 200, port);
+      }
+      const promoteMatch = path.match(/^\/api\/connectors\/([^/]+)\/promote$/);
+      if (promoteMatch && method === "POST") {
+        const name = promoteMatch[1];
+        if (!getConnector(name))
+          return json({ error: "Connector not found" }, 404, port);
+        const { promoteConnector: promoteConnector2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+        promoteConnector2(name, getDatabase2());
+        return json({ success: true, connector: name }, 200, port);
+      }
+      if (promoteMatch && method === "DELETE") {
+        const { demoteConnector: demoteConnector2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+        const removed = demoteConnector2(promoteMatch[1], getDatabase2());
+        return json({ success: removed, connector: promoteMatch[1] }, 200, port);
+      }
       if (path === "/api/llm" && method === "GET") {
         const config = getLlmConfig();
         if (!config)

package/connectors/connect-huggingface/src/api/client.ts

@@ -124,6 +124,11 @@ export class HuggingFaceClient {
     return this.request<T>(path, { method: 'DELETE', params });
   }
 
+  /** Get the raw API key (needed by InferenceApi for direct fetch) */
+  getApiKey(): string {
+    return this.apiKey;
+  }
+
   /**
    * Get a preview of the API key (for display/debugging)
    */

package/connectors/connect-huggingface/src/api/datasets.ts

@@ -0,0 +1,73 @@
+import type { HuggingFaceClient } from './client';
+
+export interface DatasetSearchOptions {
+  search?: string;
+  author?: string;
+  filter?: string;
+  sort?: 'likes' | 'downloads' | 'trending' | 'lastModified';
+  direction?: 'asc' | 'desc';
+  limit?: number;
+  full?: boolean;
+}
+
+export interface DatasetInfo {
+  _id: string;
+  id: string;
+  author?: string;
+  sha?: string;
+  lastModified?: string;
+  private?: boolean;
+  gated?: boolean | string;
+  tags?: string[];
+  downloads?: number;
+  likes?: number;
+  description?: string;
+  citation?: string;
+  cardData?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface DatasetSplit {
+  dataset: string;
+  config: string;
+  split: string;
+  num_rows: number;
+  num_bytes: number;
+}
+
+export class DatasetsApi {
+  constructor(private readonly client: HuggingFaceClient) {}
+
+  /** Search/list datasets */
+  async search(options: DatasetSearchOptions = {}): Promise<DatasetInfo[]> {
+    const params: Record<string, string | number | boolean | undefined> = {};
+    if (options.search) params.search = options.search;
+    if (options.author) params.author = options.author;
+    if (options.filter) params.filter = options.filter;
+    if (options.sort) params.sort = options.sort;
+    if (options.direction) params.direction = options.direction === 'desc' ? '-1' : '1';
+    if (options.limit) params.limit = options.limit;
+    if (options.full) params.full = true;
+
+    return this.client.request<DatasetInfo[]>('/datasets', { params });
+  }
+
+  /** Get a single dataset by ID */
+  async get(datasetId: string): Promise<DatasetInfo> {
+    return this.client.request<DatasetInfo>(`/datasets/${datasetId}`);
+  }
+
+  /** Preview first N rows of a dataset split */
+  async preview(datasetId: string, config = 'default', split = 'train', rows = 10): Promise<unknown> {
+    // Uses the datasets-server API
+    const url = `https://datasets-server.huggingface.co/first-rows?dataset=${encodeURIComponent(datasetId)}&config=${config}&split=${split}&rows=${rows}`;
+    const response = await fetch(url, {
+      headers: { Authorization: `Bearer ${this.client.getApiKey()}` },
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Dataset preview failed (${response.status}): ${text}`);
+    }
+    return response.json();
+  }
+}

package/connectors/connect-huggingface/src/api/index.ts

@@ -1,6 +1,9 @@
 import type { HuggingFaceConfig } from '../types';
 import { HuggingFaceClient } from './client';
-import { ExampleApi } from './example';
+import { ModelsApi } from './models';
+import { InferenceApi } from './inference';
+import { DatasetsApi } from './datasets';
+import { SpacesApi } from './spaces';
 
 /**
  * Main HuggingFace API class
@@ -8,42 +11,37 @@ import { ExampleApi } from './example';
 export class HuggingFace {
   private readonly client: HuggingFaceClient;
 
-  // API modules - add more as needed
-  public readonly example: ExampleApi;
+  public readonly models: ModelsApi;
+  public readonly inference: InferenceApi;
+  public readonly datasets: DatasetsApi;
+  public readonly spaces: SpacesApi;
 
   constructor(config: HuggingFaceConfig) {
     this.client = new HuggingFaceClient(config);
-    this.example = new ExampleApi(this.client);
+    this.models = new ModelsApi(this.client);
+    this.inference = new InferenceApi(this.client);
+    this.datasets = new DatasetsApi(this.client);
+    this.spaces = new SpacesApi(this.client);
   }
 
-  /**
-   * Create a client from environment variables
-   * Looks for HUGGINGFACE_API_KEY or HF_TOKEN
-   */
   static fromEnv(): HuggingFace {
     const apiKey = process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN;
     const apiSecret = process.env.HUGGINGFACE_API_SECRET;
-
-    if (!apiKey) {
-      throw new Error('HUGGINGFACE_API_KEY or HF_TOKEN environment variable is required');
-    }
+    if (!apiKey) throw new Error('HUGGINGFACE_API_KEY or HF_TOKEN environment variable is required');
     return new HuggingFace({ apiKey, apiSecret });
   }
 
-  /**
-   * Get a preview of the API key (for debugging)
-   */
   getApiKeyPreview(): string {
     return this.client.getApiKeyPreview();
   }
 
-  /**
-   * Get the underlying client for direct API access
-   */
   getClient(): HuggingFaceClient {
     return this.client;
   }
 }
 
 export { HuggingFaceClient } from './client';
-export { ExampleApi } from './example';
+export { ModelsApi } from './models';
+export { InferenceApi } from './inference';
+export { DatasetsApi } from './datasets';
+export { SpacesApi } from './spaces';

package/connectors/connect-huggingface/src/api/inference.ts

@@ -0,0 +1,100 @@
+import type { HuggingFaceClient } from './client';
+
+const INFERENCE_URL = 'https://api-inference.huggingface.co/models';
+
+export interface TextGenerationOptions {
+  max_new_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  top_k?: number;
+  repetition_penalty?: number;
+  return_full_text?: boolean;
+  stop?: string[];
+}
+
+export interface TextGenerationResult {
+  generated_text: string;
+}
+
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface ChatCompletionResult {
+  choices: Array<{
+    message: { role: string; content: string };
+    finish_reason: string;
+    index: number;
+  }>;
+  model: string;
+  usage?: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
+}
+
+export class InferenceApi {
+  constructor(private readonly client: HuggingFaceClient) {}
+
+  /** Run text generation inference */
+  async textGeneration(
+    model: string,
+    prompt: string,
+    options: TextGenerationOptions = {}
+  ): Promise<TextGenerationResult[]> {
+    const response = await fetch(`${INFERENCE_URL}/${model}`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.client.getApiKey()}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        inputs: prompt,
+        parameters: {
+          max_new_tokens: options.max_new_tokens ?? 256,
+          temperature: options.temperature,
+          top_p: options.top_p,
+          top_k: options.top_k,
+          repetition_penalty: options.repetition_penalty,
+          return_full_text: options.return_full_text ?? false,
+          stop: options.stop,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Inference failed (${response.status}): ${text}`);
+    }
+
+    return response.json();
+  }
+
+  /** Chat completion via HF Inference API (for chat models) */
+  async chat(
+    model: string,
+    messages: ChatMessage[],
+    options: Omit<TextGenerationOptions, 'return_full_text'> = {}
+  ): Promise<ChatCompletionResult> {
+    const response = await fetch(`${INFERENCE_URL}/${model}/v1/chat/completions`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.client.getApiKey()}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model,
+        messages,
+        max_tokens: options.max_new_tokens ?? 256,
+        temperature: options.temperature,
+        top_p: options.top_p,
+        stop: options.stop,
+      }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Chat inference failed (${response.status}): ${text}`);
+    }
+
+    return response.json();
+  }
+}

package/connectors/connect-huggingface/src/api/models.ts

@@ -0,0 +1,66 @@
+import type { HuggingFaceClient } from './client';
+
+export interface ModelSearchOptions {
+  search?: string;
+  author?: string;
+  filter?: string;       // task filter: text-generation, text2text-generation, etc
+  library?: string;      // transformers, gguf, pytorch, etc
+  sort?: 'likes' | 'downloads' | 'trending' | 'lastModified';
+  direction?: 'asc' | 'desc';
+  limit?: number;
+  full?: boolean;        // include all fields
+}
+
+export interface ModelInfo {
+  _id: string;
+  id: string;            // e.g. "meta-llama/Meta-Llama-3-8B"
+  modelId: string;
+  author?: string;
+  sha?: string;
+  lastModified?: string;
+  private?: boolean;
+  disabled?: boolean;
+  gated?: boolean | string;
+  pipeline_tag?: string;
+  tags?: string[];
+  downloads?: number;
+  likes?: number;
+  library_name?: string;
+  [key: string]: unknown;
+}
+
+export interface ModelFile {
+  rfilename: string;
+  size?: number;
+  blobId?: string;
+  lfs?: { size: number; sha256: string; pointerSize: number };
+}
+
+export class ModelsApi {
+  constructor(private readonly client: HuggingFaceClient) {}
+
+  /** Search/list models */
+  async search(options: ModelSearchOptions = {}): Promise<ModelInfo[]> {
+    const params: Record<string, string | number | boolean | undefined> = {};
+    if (options.search) params.search = options.search;
+    if (options.author) params.author = options.author;
+    if (options.filter) params.filter = options.filter;
+    if (options.library) params.library = options.library;
+    if (options.sort) params.sort = options.sort;
+    if (options.direction) params.direction = options.direction === 'desc' ? '-1' : '1';
+    if (options.limit) params.limit = options.limit;
+    if (options.full) params.full = true;
+
+    return this.client.request<ModelInfo[]>('/models', { params });
+  }
+
+  /** Get a single model by ID (e.g. "meta-llama/Meta-Llama-3-8B") */
+  async get(modelId: string): Promise<ModelInfo> {
+    return this.client.request<ModelInfo>(`/models/${modelId}`);
+  }
+
+  /** List files in a model repo */
+  async files(modelId: string): Promise<ModelFile[]> {
+    return this.client.request<ModelFile[]>(`/models/${modelId}/tree/main`);
+  }
+}

package/connectors/connect-huggingface/src/api/spaces.ts

@@ -0,0 +1,42 @@
+import type { HuggingFaceClient } from './client';
+
+export interface SpaceSearchOptions {
+  search?: string;
+  author?: string;
+  sort?: 'likes' | 'trending' | 'lastModified';
+  direction?: 'asc' | 'desc';
+  limit?: number;
+}
+
+export interface SpaceInfo {
+  _id: string;
+  id: string;
+  author?: string;
+  sha?: string;
+  lastModified?: string;
+  private?: boolean;
+  tags?: string[];
+  likes?: number;
+  sdk?: string;
+  runtime?: { stage: string; hardware?: { current?: string } };
+  [key: string]: unknown;
+}
+
+export class SpacesApi {
+  constructor(private readonly client: HuggingFaceClient) {}
+
+  async search(options: SpaceSearchOptions = {}): Promise<SpaceInfo[]> {
+    const params: Record<string, string | number | boolean | undefined> = {};
+    if (options.search) params.search = options.search;
+    if (options.author) params.author = options.author;
+    if (options.sort) params.sort = options.sort;
+    if (options.direction) params.direction = options.direction === 'desc' ? '-1' : '1';
+    if (options.limit) params.limit = options.limit;
+
+    return this.client.request<SpaceInfo[]>('/spaces', { params });
+  }
+
+  async get(spaceId: string): Promise<SpaceInfo> {
+    return this.client.request<SpaceInfo>(`/spaces/${spaceId}`);
+  }
+}