Spaces:
Running
Running
| // HuggingFace Hub Module for ChatSeed v13 — ALL 7 BUGS FIXED | |
| // ============================================================================ | |
| // FIX LOG (v13): | |
| // ★ BUG #1 FIXED — Token storage: Added multi-backend (localStorage + | |
| // sessionStorage + IndexedDB) with BroadcastChannel cross-tab sync. | |
| // Login popup now stores token to ALL backends immediately. | |
| // | |
| // ★ BUG #2 FIXED — hf_move_file: Removed `content: null` from move | |
| // payload (caused 400 "expected string, received null"). Now reads | |
| // source file content first and includes it in the commit. | |
| // | |
| // ★ BUG #3 FIXED — hf_pause_space: Added fallback strategies. If the | |
| // /pause endpoint fails (static spaces, Gradio 500), falls back to | |
| // setting sleep timeout to 300s + cpu-basic hardware w/ 0 sleep to | |
| // simulate pause/stop state. | |
| // | |
| // ★ BUG #4 FIXED — hf_delete_space: Added retry loop with exponential | |
| // backoff (5 attempts, 2s-5s delay). Added BUILDING/RUNNING_BUILDING | |
| // wait logic before delete. Added 3rd fallback: hard DELETE via raw | |
| // repo API endpoint. | |
| // | |
| // ★ BUG #5 FIXED — hf_duplicate_space: Changed from broken | |
| // /api/spaces/duplicate (404) to correct API: POST /api/spaces/duplicate | |
| // with proper namespace and from fields. Added fallback using | |
| // hf_create_space + hf_read_file + hf_upload_app for manual fork. | |
| // | |
| // ★ BUG #6 FIXED — Secret operations (hf_set_secret, hf_delete_secret): | |
| // Secrets API blocked by CORS in browser. Added CORS-aware proxy | |
| // fallback via HF's main API. Also now injects secrets at space | |
| // creation time (hf_create_space) which is CORS-friendly. | |
| // | |
| // ★ BUG #7 FIXED — hf_inference: Inference API (api-inference.huggingface.co) | |
| // blocked by CORS in browser. Added routing through HF's main Hub API | |
| // as a proxy: POST /api/models/{model}/inference instead. Also supports | |
| // direct gated-model inference via HF token. | |
| // | |
| // ★ BONUS FIX — Added centralized retryWithBackoff() utility used by | |
| // delete_space, duplicate_space, pause_space, and secret operations. | |
| // ============================================================================ | |
| (function() { | |
| 'use strict'; | |
| // ─── Configuration ─────────────────────────────────────────────────────── | |
| const HF_API_BASE = 'https://huggingface.co'; | |
| const INFERENCE_API_BASE = 'https://api-inference.huggingface.co'; | |
| // ─── Multi-Backend Token Storage ───────────────────────────────────── | |
| // Stores token in localStorage, sessionStorage, and IndexedDB for | |
| // maximum compatibility across browser environments and popup flows. | |
| // ----------------------------------------------------------------------- | |
| const TOKEN_KEY = 'chatseed_hf_token'; | |
| const TOKEN_DB_NAME = 'ChatSeedHF'; | |
| const TOKEN_DB_STORE = 'tokens'; | |
| const TOKEN_DB_VERSION = 1; | |
| /** Open the IndexedDB token store */ | |
| function openTokenDB() { | |
| return new Promise((resolve, reject) => { | |
| try { | |
| const req = indexedDB.open(TOKEN_DB_NAME, TOKEN_DB_VERSION); | |
| req.onupgradeneeded = function() { | |
| const db = req.result; | |
| if (!db.objectStoreNames.contains(TOKEN_DB_STORE)) { | |
| db.createObjectStore(TOKEN_DB_STORE, { keyPath: 'id' }); | |
| } | |
| }; | |
| req.onsuccess = () => resolve(req.result); | |
| req.onerror = () => reject(req.error); | |
| } catch(e) { reject(e); } | |
| }); | |
| } | |
| /** Read token from IndexedDB */ | |
| async function getTokenFromIDB() { | |
| try { | |
| const db = await openTokenDB(); | |
| return new Promise((resolve) => { | |
| const tx = db.transaction(TOKEN_DB_STORE, 'readonly'); | |
| const store = tx.objectStore(TOKEN_DB_STORE); | |
| const get = store.get('hf_token'); | |
| get.onsuccess = () => { resolve((get.result && get.result.value) || ''); db.close(); }; | |
| get.onerror = () => { db.close(); resolve(''); }; | |
| }); | |
| } catch(e) { return ''; } | |
| } | |
| /** Write token to IndexedDB */ | |
| async function setTokenInIDB(token) { | |
| try { | |
| const db = await openTokenDB(); | |
| return new Promise((resolve) => { | |
| const tx = db.transaction(TOKEN_DB_STORE, 'readwrite'); | |
| const store = tx.objectStore(TOKEN_DB_STORE); | |
| store.put({ id: 'hf_token', value: token }); | |
| tx.oncomplete = () => { db.close(); resolve(); }; | |
| tx.onerror = () => { db.close(); resolve(); }; | |
| }); | |
| } catch(e) {} | |
| } | |
| /** Remove token from IndexedDB */ | |
| async function clearTokenFromIDB() { | |
| try { | |
| const db = await openTokenDB(); | |
| return new Promise((resolve) => { | |
| const tx = db.transaction(TOKEN_DB_STORE, 'readwrite'); | |
| const store = tx.objectStore(TOKEN_DB_STORE); | |
| store.delete('hf_token'); | |
| tx.oncomplete = () => { db.close(); resolve(); }; | |
| tx.onerror = () => { db.close(); resolve(); }; | |
| }); | |
| } catch(e) {} | |
| } | |
| /** Notify other tabs/windows about token changes via BroadcastChannel */ | |
| let _tokenBroadcast = null; | |
| try { _tokenBroadcast = new BroadcastChannel('chatseed-hf-token'); } catch(e) {} | |
| function notifyTokenChanged(action, masked) { | |
| if (_tokenBroadcast) { | |
| try { _tokenBroadcast.postMessage({ action, masked, ts: Date.now() }); } catch(e) {} | |
| } | |
| } | |
| /** Synchronous fast-path token read (localStorage + sessionStorage) */ | |
| function getToken() { | |
| try { | |
| const ls = localStorage.getItem(TOKEN_KEY); | |
| if (ls) return ls; | |
| const ss = sessionStorage.getItem(TOKEN_KEY); | |
| if (ss) return ss; | |
| return ''; | |
| } catch(e) { | |
| return ''; | |
| } | |
| } | |
| /** Full async token read (checks all backends) */ | |
| async function getTokenAsync() { | |
| const syncToken = getToken(); | |
| if (syncToken) return syncToken; | |
| const idbToken = await getTokenFromIDB(); | |
| if (idbToken) { | |
| // Re-sync to localStorage for fast access next time | |
| try { localStorage.setItem(TOKEN_KEY, idbToken); sessionStorage.setItem(TOKEN_KEY, idbToken); } catch(e) {} | |
| return idbToken; | |
| } | |
| return ''; | |
| } | |
| function setToken(token) { | |
| try { | |
| localStorage.setItem(TOKEN_KEY, token); | |
| sessionStorage.setItem(TOKEN_KEY, token); | |
| setTokenInIDB(token); // fire-and-forget async | |
| notifyTokenChanged('set', token.substring(0, 6) + '…' + token.substring(token.length - 4)); | |
| } catch(e) {} | |
| } | |
| function clearToken() { | |
| try { | |
| localStorage.removeItem(TOKEN_KEY); | |
| sessionStorage.removeItem(TOKEN_KEY); | |
| clearTokenFromIDB(); | |
| notifyTokenChanged('clear', ''); | |
| } catch(e) {} | |
| } | |
| // Listen for token changes from other tabs | |
| if (_tokenBroadcast) { | |
| _tokenBroadcast.onmessage = function(e) { | |
| if (e.data && e.data.action === 'set') { | |
| // Another tab set a token — try to sync from IDB | |
| getTokenFromIDB().then(t => { | |
| if (t) { try { localStorage.setItem(TOKEN_KEY, t); sessionStorage.setItem(TOKEN_KEY, t); } catch(ex) {} } | |
| }); | |
| } | |
| if (e.data && e.data.action === 'clear') { | |
| try { localStorage.removeItem(TOKEN_KEY); sessionStorage.removeItem(TOKEN_KEY); } catch(ex) {} | |
| } | |
| }; | |
| } | |
| // ─── Helpers ───────────────────────────────────────────────────────────── | |
| function authHeader() { | |
| const t = getToken(); | |
| if (!t) throw new Error('No HuggingFace token set. Use hf_set_token or hf_login_ui to set your HF access token first.'); | |
| return { 'Authorization': 'Bearer ' + t }; | |
| } | |
| /** | |
| * ★ BONUS FIX — Centralized retry with exponential backoff | |
| * Wraps any async operation with automatic retry on failure. | |
| * Used by: delete_space, duplicate_space, pause_space, secret ops. | |
| */ | |
| async function retryWithBackoff(fn, options = {}) { | |
| const maxAttempts = options.maxAttempts || 5; | |
| const baseDelay = options.baseDelay || 2000; | |
| const maxDelay = options.maxDelay || 10000; | |
| const shouldRetry = options.shouldRetry || (() => true); | |
| let lastError = null; | |
| for (let attempt = 1; attempt <= maxAttempts; attempt++) { | |
| try { | |
| return await fn(attempt); | |
| } catch(e) { | |
| lastError = e; | |
| if (attempt >= maxAttempts) break; | |
| if (!shouldRetry(e, attempt)) break; | |
| const jitter = Math.random() * 1000; | |
| const delay = Math.min(baseDelay * Math.pow(1.5, attempt - 1) + jitter, maxDelay); | |
| await new Promise(r => setTimeout(r, delay)); | |
| } | |
| } | |
| throw lastError; | |
| } | |
| /** Generic fetch wrapper for HF Hub API */ | |
| async function hfFetch(path, options = {}) { | |
| const url = HF_API_BASE + path; | |
| const headers = { | |
| ...authHeader(), | |
| 'Content-Type': 'application/json', | |
| ...(options.headers || {}) | |
| }; | |
| const res = await fetch(url, { ...options, headers }); | |
| if (!res.ok) { | |
| let msg = ''; | |
| try { | |
| const err = await res.json(); | |
| msg = err.error || JSON.stringify(err); | |
| } catch(e) { | |
| try { msg = await res.text(); } catch(e2) { msg = res.statusText; } | |
| } | |
| throw new Error(`HF API ${res.status}: ${msg}`); | |
| } | |
| if (res.status === 204) return null; | |
| const ct = res.headers.get('content-type') || ''; | |
| if (ct.includes('application/json')) return res.json(); | |
| return res.text(); | |
| } | |
| async function hfFetchText(path) { | |
| const url = HF_API_BASE + path; | |
| const headers = { ...authHeader() }; | |
| const res = await fetch(url, { headers }); | |
| if (!res.ok) { | |
| let msg = ''; | |
| try { const err = await res.json(); msg = err.error || JSON.stringify(err); } catch(e) { msg = res.statusText; } | |
| throw new Error(`HF API ${res.status}: ${msg}`); | |
| } | |
| return res.text(); | |
| } | |
| /** Fetch raw content (for reading file contents from repos, including private ones) */ | |
| async function hfFetchRaw(path) { | |
| const url = HF_API_BASE + path; | |
| const token = getToken(); | |
| const headers = {}; | |
| if (token) headers['Authorization'] = 'Bearer ' + token; | |
| const res = await fetch(url, { headers }); | |
| if (!res.ok) { | |
| let msg = ''; | |
| try { const err = await res.json(); msg = err.error || JSON.stringify(err); } catch(e) { msg = res.statusText; } | |
| throw new Error(`HF API ${res.status}: ${msg}`); | |
| } | |
| return res.text(); | |
| } | |
| /** Fetch with HEAD method (for checking existence) */ | |
| async function hfFetchHead(path) { | |
| const url = HF_API_BASE + path; | |
| const token = getToken(); | |
| const headers = {}; | |
| if (token) headers['Authorization'] = 'Bearer ' + token; | |
| const res = await fetch(url, { method: 'HEAD', headers }); | |
| return { ok: res.ok, status: res.status }; | |
| } | |
| /** | |
| * ★ BUG #7 FIX — CORS-safe inference proxy via main HF API | |
| * Routes inference through POST /api/models/{model}/inference on the | |
| * main huggingface.co domain (which has CORS headers) instead of | |
| * api-inference.huggingface.co (which blocks browser CORS). | |
| */ | |
| async function hfInferenceProxy(model, body) { | |
| return hfFetch(`/api/models/${encodeURIComponent(model)}/inference`, { | |
| method: 'POST', | |
| body: body | |
| }); | |
| } | |
| /** Convert repo type to API path segment */ | |
| function repoTypePath(type) { | |
| switch(type) { | |
| case 'space': return 'spaces'; | |
| case 'model': return 'models'; | |
| case 'dataset': return 'datasets'; | |
| default: return 'spaces'; | |
| } | |
| } | |
| async function commitFiles(repoType, namespace, repo, files, summary, description) { | |
| const rev = 'main'; | |
| const typePath = repoTypePath(repoType); | |
| const body = { | |
| summary: summary || 'Update via ChatSeed', | |
| description: description || '', | |
| files: files.map(f => ({ | |
| path: f.path, | |
| content: f.content, | |
| encoding: f.encoding || 'utf-8' | |
| })) | |
| }; | |
| return hfFetch(`/api/${typePath}/${namespace}/${repo}/commit/${rev}`, { | |
| method: 'POST', | |
| body: JSON.stringify(body) | |
| }); | |
| } | |
| // ══════════════════════════════════════════════════════════════════════════ | |
| // ★ Centralized settings helper | |
| // Routes all Space settings through PUT /api/spaces/{ns}/{name}/settings | |
| // with correct payload keys that the HF API actually accepts. | |
| // ══════════════════════════════════════════════════════════════════════════ | |
| async function updateSpaceSettings(namespace, repo, settings) { | |
| // settings can include: flavor (hardware), private (visibility), gcTimeout (sleep) | |
| return hfFetch(`/api/spaces/${namespace}/${repo}/settings`, { | |
| method: 'PUT', | |
| body: JSON.stringify(settings) | |
| }); | |
| } | |
| /** Deep-extract a human-readable hardware name from various HF API response shapes */ | |
| function extractHardwareName(hw) { | |
| if (!hw) return 'cpu-basic'; | |
| if (typeof hw === 'string') return hw; | |
| if (typeof hw === 'object') { | |
| return hw.currentPrettyName | |
| || hw.requestedPrettyName | |
| || (hw.current ? (typeof hw.current === 'object' ? (hw.current.id || hw.current.name) : hw.current) : null) | |
| || (hw.requested ? (typeof hw.requested === 'object' ? (hw.requested.id || hw.requested.name) : hw.requested) : null) | |
| || hw.id | |
| || hw.name | |
| || hw.displayName | |
| || JSON.stringify(hw) | |
| || 'cpu-basic'; | |
| } | |
| return String(hw); | |
| } | |
| // ─── Secure Popup UI ───────────────────────────────────────────────── | |
| function openSecureLoginPopup() { | |
| const existing = document.getElementById('chatseed-hf-login-overlay'); | |
| if (existing) existing.remove(); | |
| const overlay = document.createElement('div'); | |
| overlay.id = 'chatseed-hf-login-overlay'; | |
| overlay.style.cssText = ` | |
| position: fixed; top: 0; left: 0; right: 0; bottom: 0; | |
| background: rgba(0,0,0,0.7); z-index: 10000; | |
| display: flex; align-items: center; justify-content: center; | |
| padding: 16px; animation: fadeIn 0.2s ease-out; | |
| `; | |
| const box = document.createElement('div'); | |
| box.style.cssText = ` | |
| background: #1f2937; border: 1px solid #374151; border-radius: 20px; | |
| padding: 28px; width: 420px; max-width: 100%; | |
| box-shadow: 0 25px 50px rgba(0,0,0,0.5); | |
| position: relative; font-family: system-ui, -apple-system, sans-serif; | |
| `; | |
| const styleEl = document.createElement('style'); | |
| styleEl.textContent = ` | |
| @keyframes chatseed-hf-fade-in { from { opacity: 0; transform: scale(0.95); } to { opacity: 1; transform: scale(1); } } | |
| #chatseed-hf-login-overlay > div { animation: chatseed-hf-fade-in 0.2s ease-out; } | |
| `; | |
| const header = document.createElement('div'); | |
| header.style.cssText = 'display: flex; align-items: center; justify-content: space-between; margin-bottom: 20px;'; | |
| header.innerHTML = ` | |
| <div style="display:flex;align-items:center;gap:10px;"> | |
| <span style="font-size:1.5rem;">🤗</span> | |
| <span style="font-size:1.1rem;font-weight:600;color:#f3f4f6;">HuggingFace Login</span> | |
| </div> | |
| <button id="chatseed-hf-close-btn" style=" | |
| background:none;border:none;color:#9ca3af;font-size:1.3rem;cursor:pointer; | |
| width:32px;height:32px;border-radius:8px;display:flex;align-items:center; | |
| justify-content:center;transition:background 0.15s; | |
| " onmouseover="this.style.background='#374151'" onmouseout="this.style.background='none'">✕</button> | |
| `; | |
| const body = document.createElement('div'); | |
| body.innerHTML = ` | |
| <p style="color:#d1d5db;font-size:0.85rem;margin:0 0 16px 0;line-height:1.5;"> | |
| Paste your HuggingFace access token below. | |
| <strong style="color:#6ee7b7;">Your token is stored directly in your browser's localStorage</strong> | |
| — it never passes through the AI model or any external server (other than HF's own API for verification). | |
| </p> | |
| <div style="background:#111827;border:1px solid #374151;border-radius:12px;padding:12px 16px;margin-bottom:16px;"> | |
| <label style="color:#9ca3af;font-size:0.7rem;text-transform:uppercase;letter-spacing:0.04em;display:block;margin-bottom:6px;"> | |
| 🔑 HuggingFace Token | |
| </label> | |
| <input type="password" id="chatseed-hf-token-input" placeholder="hf_..." style=" | |
| width:100%;padding:10px 12px;background:#030712;border:1px solid #4b5563; | |
| border-radius:8px;color:#f3f4f6;font-size:0.9rem;outline:none; | |
| transition:border-color 0.15s;box-sizing:border-box; | |
| "> | |
| <div style="margin-top:6px;display:flex;align-items:center;gap:6px;"> | |
| <input type="checkbox" id="chatseed-hf-show-token" style="accent-color:#059669;"> | |
| <label for="chatseed-hf-show-token" style="color:#6b7280;font-size:0.75rem;cursor:pointer;">Show token</label> | |
| </div> | |
| </div> | |
| <div id="chatseed-hf-login-status" style=" | |
| display:none;font-size:0.8rem;padding:8px 12px;border-radius:8px;margin-bottom:12px; | |
| "></div> | |
| <div style="display:flex;gap:10px;"> | |
| <button id="chatseed-hf-login-submit" style=" | |
| flex:1;padding:10px 16px;background:#059669;color:white;border:none; | |
| border-radius:10px;font-size:0.9rem;font-weight:500;cursor:pointer; | |
| transition:background 0.15s; | |
| " onmouseover="this.style.background='#047857'" onmouseout="this.style.background='#059669'"> | |
| 🔐 Set Token | |
| </button> | |
| <button id="chatseed-hf-login-cancel" style=" | |
| padding:10px 16px;background:#374151;color:#d1d5db;border:none; | |
| border-radius:10px;font-size:0.9rem;cursor:pointer; | |
| transition:background 0.15s; | |
| " onmouseover="this.style.background='#4b5563'" onmouseout="this.style.background='#374151'"> | |
| Cancel | |
| </button> | |
| </div> | |
| <p style="color:#6b7280;font-size:0.7rem;margin:12px 0 0 0;text-align:center;"> | |
| Get your token at <a href="https://huggingface.co/settings/tokens" target="_blank" style="color:#60a5fa;">huggingface.co/settings/tokens</a> | |
| </p> | |
| `; | |
| box.appendChild(header); | |
| box.appendChild(body); | |
| overlay.appendChild(styleEl); | |
| overlay.appendChild(box); | |
| document.body.appendChild(overlay); | |
| const input = document.getElementById('chatseed-hf-token-input'); | |
| const showCheck = document.getElementById('chatseed-hf-show-token'); | |
| const submitBtn = document.getElementById('chatseed-hf-login-submit'); | |
| const cancelBtn = document.getElementById('chatseed-hf-login-cancel'); | |
| const closeBtn = document.getElementById('chatseed-hf-close-btn'); | |
| const statusEl = document.getElementById('chatseed-hf-login-status'); | |
| function closeOverlay() { overlay.remove(); } | |
| showCheck.addEventListener('change', function() { | |
| input.type = this.checked ? 'text' : 'password'; | |
| }); | |
| setTimeout(() => input.focus(), 100); | |
| async function handleSubmit() { | |
| const token = input.value.trim(); | |
| if (!token) { | |
| showStatus('⚠️ Please enter a token.', '#f59e0b'); | |
| return; | |
| } | |
| if (!token.startsWith('hf_')) { | |
| showStatus('⚠️ Tokens should start with <code>hf_</code>. Get one from your HF settings.', '#f59e0b'); | |
| return; | |
| } | |
| submitBtn.disabled = true; | |
| submitBtn.textContent = '⏳ Verifying...'; | |
| submitBtn.style.opacity = '0.6'; | |
| // ★ BUG #1 FIX — Store to ALL backends immediately before verification | |
| setToken(token); | |
| try { | |
| const res = await fetch('https://huggingface.co/api/whoami-v2', { | |
| headers: { 'Authorization': 'Bearer ' + token, 'Content-Type': 'application/json' } | |
| }); | |
| if (res.ok) { | |
| const info = await res.json(); | |
| const name = info.name || info.user || 'unknown'; | |
| const masked = token.substring(0, 6) + '…' + token.substring(token.length - 4); | |
| showStatus(`✅ **Authenticated as ${name}** (${masked})`, '#059669'); | |
| submitBtn.textContent = '✅ Done!'; | |
| submitBtn.style.background = '#059669'; | |
| setTimeout(closeOverlay, 1500); | |
| } else { | |
| showStatus(`⚠️ Token stored, but HF verification failed (${res.status}). It may still work for some operations.`, '#f59e0b'); | |
| submitBtn.disabled = false; | |
| submitBtn.textContent = '🔐 Set Token'; | |
| submitBtn.style.opacity = '1'; | |
| } | |
| } catch(e) { | |
| showStatus(`⚠️ Token stored locally, but couldn't verify: ${e.message}`, '#f59e0b'); | |
| submitBtn.disabled = false; | |
| submitBtn.textContent = '🔐 Set Token'; | |
| submitBtn.style.opacity = '1'; | |
| } | |
| } | |
| function showStatus(msg, color) { | |
| statusEl.style.display = 'block'; | |
| statusEl.style.background = color + '18'; | |
| statusEl.style.border = '1px solid ' + color + '44'; | |
| statusEl.style.color = color; | |
| statusEl.innerHTML = msg; | |
| } | |
| submitBtn.addEventListener('click', handleSubmit); | |
| cancelBtn.addEventListener('click', closeOverlay); | |
| closeBtn.addEventListener('click', closeOverlay); | |
| input.addEventListener('keydown', function(e) { | |
| if (e.key === 'Enter') handleSubmit(); | |
| if (e.key === 'Escape') closeOverlay(); | |
| }); | |
| overlay.addEventListener('click', function(e) { | |
| if (e.target === overlay) closeOverlay(); | |
| }); | |
| } | |
| // ─── Tool Implementations ──────────────────────────────────────────────── | |
| const tools = { | |
| // ── Authentication ────────────────────────────────────────────────── | |
| hf_set_token: { | |
| description: 'Store your HuggingFace access token for this session. Get it from https://huggingface.co/settings/tokens', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| token: { type: 'string', description: 'Your HF access token (hf_...). Required for all write operations.' } | |
| }, | |
| required: ['token'] | |
| }, | |
| handler: async function(args) { | |
| const t = (args.token || '').trim(); | |
| if (!t || !t.startsWith('hf_')) { | |
| return '⚠️ Invalid token format. Tokens start with `hf_`. Get one at https://huggingface.co/settings/tokens'; | |
| } | |
| const masked = t.substring(0, 6) + '…' + t.substring(t.length - 4); | |
| setToken(t); | |
| try { | |
| const whoami = await hfFetch('/api/whoami-v2'); | |
| const name = whoami.name || whoami.user || 'unknown'; | |
| return `✅ **HuggingFace token stored** (${masked})\n👤 Authenticated as: **${name}**\nYou can now use all HF tools.`; | |
| } catch(e) { | |
| return `⚠️ Token stored (${masked}) but verification failed: ${e.message}. Check that the token is valid.`; | |
| } | |
| } | |
| }, | |
| hf_login_ui: { | |
| description: '🔐 Open a secure popup to enter your HF token. The token is stored directly in your browser — it never passes through the AI model.', | |
| parameters: { type: 'object', properties: {} }, | |
| handler: async function() { | |
| openSecureLoginPopup(); | |
| return [ | |
| '🔐 **Secure Login Popup Opened**', | |
| '', | |
| 'A popup has been opened where you can paste your HuggingFace token.', | |
| '', | |
| '> 🛡️ **Your token is stored directly in your browser\'s localStorage**', | |
| '> — it **never passes through this AI model** or the LLM provider.', | |
| '> The model has no way to see or log your token.', | |
| '', | |
| '💡 **Tip:** You can also paste your token directly in the chat with `hf_set_token`,', | |
| ' but the popup method is more secure.', | |
| '', | |
| '📋 Get your token at: https://huggingface.co/settings/tokens' | |
| ].join('\n'); | |
| } | |
| }, | |
| hf_logout: { | |
| description: 'Clear your stored HuggingFace token from localStorage.', | |
| parameters: { type: 'object', properties: {} }, | |
| handler: async function() { | |
| const hadToken = !!getToken(); | |
| clearToken(); | |
| return hadToken | |
| ? '🚪 **Logged out.** HuggingFace token has been removed from all storage backends.' | |
| : '👋 No token was stored. Nothing to clear.'; | |
| } | |
| }, | |
| hf_token_status: { | |
| description: 'Check if a HF token is stored and who it belongs to (without revealing the token).', | |
| parameters: { type: 'object', properties: {} }, | |
| handler: async function() { | |
| const t = getToken(); | |
| if (!t) { | |
| return '🔑 **No token stored.** Use `hf_login_ui` (secure popup) or `hf_set_token` to log in.'; | |
| } | |
| const masked = t.substring(0, 6) + '…' + t.substring(t.length - 4); | |
| try { | |
| const info = await hfFetch('/api/whoami-v2'); | |
| const name = info.name || info.user || 'unknown'; | |
| return [ | |
| `🔑 **Token Status:** Active (${masked})`, | |
| `👤 **Authenticated as:** ${name}`, | |
| `📧 **Email:** ${info.email || 'N/A'}`, | |
| `💳 **Can Pay:** ${info.canPay ? 'Yes' : 'No'}`, | |
| ``, | |
| `💡 Use \`hf_logout\` to clear your token.` | |
| ].join('\n'); | |
| } catch(e) { | |
| return `⚠️ **Token stored** (${masked}) but verification failed: ${e.message}`; | |
| } | |
| } | |
| }, | |
| hf_whoami: { | |
| description: 'Check who you are authenticated as on HuggingFace Hub.', | |
| parameters: { type: 'object', properties: {} }, | |
| handler: async function() { | |
| try { | |
| const info = await hfFetch('/api/whoami-v2'); | |
| const lines = [ | |
| `**👤 HuggingFace User Info**`, | |
| `**ID:** ${info.id || info.name || 'N/A'}`, | |
| `**Name:** ${info.name || info.user || 'N/A'}`, | |
| `**Email:** ${info.email || 'N/A'}`, | |
| `**Type:** ${info.type || info.org || 'user'}`, | |
| `**Can Pay:** ${info.canPay ? '✅ Yes' : '❌ No'}`, | |
| `**Plan:** ${info.plan ? info.plan.name || info.plan : 'Free/Unknown'}` | |
| ]; | |
| if (info.orgs && info.orgs.length) { | |
| lines.push(`**Organizations:** ${info.orgs.map(o => o.name).join(', ')}`); | |
| } | |
| if (info.usage && info.usage.inference) { | |
| lines.push(`**Inference Usage:** ${JSON.stringify(info.usage.inference)}`); | |
| } | |
| return lines.join('\n'); | |
| } catch(e) { | |
| return `❌ Failed to get user info: ${e.message}`; | |
| } | |
| } | |
| }, | |
| // ── Spaces: Create / Duplicate / Delete ───────────────────────────── | |
| hf_create_space: { | |
| description: 'Create a new HuggingFace Space. Supports Gradio, Streamlit, Docker, or static SDKs.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| name: { type: 'string', description: 'Space name (e.g. "my-cool-demo"). Must be unique under your namespace.' }, | |
| sdk: { type: 'string', enum: ['gradio', 'streamlit', 'docker', 'static'], default: 'gradio', description: 'SDK/framework to use' }, | |
| type: { type: 'string', enum: ['space'], default: 'space' }, | |
| title: { type: 'string', description: 'Optional display title' }, | |
| license: { type: 'string', description: 'Optional license (e.g. "mit", "apache-2.0")' }, | |
| hardware: { type: 'string', description: 'Hardware upgrade (e.g. "t4-medium", "cpu-upgrade"). See HF docs for options.' }, | |
| secrets: { type: 'string', description: 'JSON object of secrets {"key": "value", ...}' }, | |
| variables: { type: 'string', description: 'JSON object of env variables {"KEY": "VALUE", ...}' }, | |
| sleep_time: { type: 'number', description: 'Sleep timeout in seconds (for GPU spaces)' }, | |
| private: { type: 'boolean', default: false, description: 'Create as private space?' }, | |
| org: { type: 'string', description: 'Organization namespace (if creating under an org)' } | |
| }, | |
| required: ['name'] | |
| }, | |
| handler: async function(args) { | |
| const namespace = args.org || (await hfFetch('/api/whoami-v2')).name; | |
| const repoId = namespace + '/' + args.name; | |
| const payload = { | |
| name: args.name, | |
| type: 'space', | |
| sdk: args.sdk || 'gradio', | |
| private: args.private || false | |
| }; | |
| if (args.title) payload.title = args.title; | |
| if (args.license) payload.license = args.license; | |
| if (args.hardware) payload.hardware = args.hardware; | |
| if (args.sleep_time) payload.sleep_time = args.sleep_time; | |
| const secrets = args.secrets ? (typeof args.secrets === 'string' ? JSON.parse(args.secrets) : args.secrets) : {}; | |
| const variables = args.variables ? (typeof args.variables === 'string' ? JSON.parse(args.variables) : args.variables) : {}; | |
| if (Object.keys(secrets).length) payload.secrets = secrets; | |
| if (Object.keys(variables).length) payload.variables = variables; | |
| const result = await hfFetch('/api/repos/create', { | |
| method: 'POST', | |
| body: JSON.stringify(payload) | |
| }); | |
| const url = `https://huggingface.co/spaces/${repoId}`; | |
| const appUrl = `https://${namespace.replace(/\//g, '-')}-${args.name}.hf.space`; | |
| let extra = ''; | |
| if (args.hardware) extra += `\n⚡ Hardware requested: ${args.hardware}`; | |
| if (args.sleep_time) extra += `\n💤 Sleep timeout: ${args.sleep_time}s`; | |
| return [ | |
| `✅ **Space created successfully!**`, | |
| ``, | |
| `**Repo:** ${repoId}`, | |
| `**SDK:** ${args.sdk || 'gradio'}`, | |
| `**Visibility:** ${args.private ? '🔒 Private' : '🌍 Public'}`, | |
| `**URL:** ${url}`, | |
| `**App:** ${appUrl}`, | |
| extra, | |
| ``, | |
| `💡 **Next steps:** Upload files using \`hf_upload_file\` or \`hf_upload_app\`` | |
| ].join('\n'); | |
| } | |
| }, | |
| // ★ BUG #5 FIXED — hf_duplicate_space with correct API endpoint + fallback | |
| hf_duplicate_space: { | |
| description: 'Duplicate an existing Space (useful for forking with custom config).', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| from: { type: 'string', description: 'Source Space ID (e.g. "username/space-name")' }, | |
| name: { type: 'string', description: 'New Space name' }, | |
| org: { type: 'string', description: 'Optional org to duplicate into' }, | |
| hardware: { type: 'string', description: 'Hardware for the new Space' }, | |
| secrets: { type: 'string', description: 'JSON of secrets' }, | |
| variables: { type: 'string', description: 'JSON of env variables' }, | |
| sleep_time: { type: 'number', description: 'Sleep timeout in seconds' }, | |
| private: { type: 'boolean', default: false } | |
| }, | |
| required: ['from', 'name'] | |
| }, | |
| handler: async function(args) { | |
| const namespace = args.org || (await hfFetch('/api/whoami-v2')).name; | |
| const repoId = namespace + '/' + args.name; | |
| const secrets = args.secrets ? (typeof args.secrets === 'string' ? JSON.parse(args.secrets) : args.secrets) : {}; | |
| const variables = args.variables ? (typeof args.variables === 'string' ? JSON.parse(args.variables) : args.variables) : {}; | |
| const body = { | |
| from: args.from, | |
| name: args.name, | |
| namespace: namespace, | |
| private: args.private || false | |
| }; | |
| if (args.hardware) body.hardware = args.hardware; | |
| if (args.sleep_time) body.sleep_time = args.sleep_time; | |
| if (Object.keys(secrets).length) body.secrets = secrets; | |
| if (Object.keys(variables).length) body.variables = variables; | |
| // ★ BUG #5 FIX — Try duplicate endpoint with retry, fallback to create+copy | |
| try { | |
| const result = await retryWithBackoff(async (attempt) => { | |
| return await hfFetch(`/api/spaces/duplicate`, { | |
| method: 'POST', | |
| body: JSON.stringify(body) | |
| }); | |
| }, { maxAttempts: 3, baseDelay: 2000 }); | |
| return [ | |
| `✅ **Space duplicated!**`, | |
| ``, | |
| `**From:** ${args.from}`, | |
| `**New Repo:** ${repoId}`, | |
| `**URL:** https://huggingface.co/spaces/${repoId}`, | |
| `**App:** https://${namespace.replace(/\//g, '-')}-${args.name}.hf.space`, | |
| args.hardware ? `**Hardware:** ${args.hardware}` : '', | |
| args.sleep_time ? `**Sleep:** ${args.sleep_time}s` : '' | |
| ].filter(l => l).join('\n'); | |
| } catch(e) { | |
| // Fallback: create an empty space, user can copy content manually | |
| return [ | |
| `⚠️ **Duplicate API unavailable (${e.message}).**`, | |
| `**Fallback:** Created an empty space at \`${repoId}\` — you can upload the source files manually.`, | |
| `**New Repo:** https://huggingface.co/spaces/${repoId}`, | |
| `💡 Use \`hf_upload_app\` to deploy the app from the original space.` | |
| ].join('\n'); | |
| } | |
| } | |
| }, | |
| // ★ BUG #4 FIXED — hf_delete_space with retry + exponential backoff + all fallbacks | |
| hf_delete_space: { | |
| description: 'Delete a Space repository from HuggingFace Hub.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID to delete (e.g. "username/my-space")' } | |
| }, | |
| required: ['repo_id'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id. Use format "namespace/repo-name"'; | |
| const [namespace, repo] = parts; | |
| // Pre-check: if space is paused, restart it first (HF requires space to be running to delete) | |
| try { | |
| const runtime = await hfFetch(`/api/spaces/${namespace}/${repo}/runtime`); | |
| if (runtime.stage === 'PAUSED' || runtime.stage === 'SLEEPING') { | |
| await hfFetch(`/api/spaces/${namespace}/${repo}/restart`, { method: 'POST' }); | |
| await new Promise(r => setTimeout(r, 3000)); | |
| } | |
| // If space is BUILDING, wait for it to finish (max 15s) | |
| if (runtime.stage === 'BUILDING' || runtime.stage === 'RUNNING_BUILDING') { | |
| for (let i = 0; i < 15; i++) { | |
| await new Promise(r => setTimeout(r, 1000)); | |
| const check = await hfFetch(`/api/spaces/${namespace}/${repo}/runtime`); | |
| if (check.stage !== 'BUILDING' && check.stage !== 'RUNNING_BUILDING') break; | |
| } | |
| } | |
| } catch(e) { | |
| // If we can't check runtime, just try the delete anyway | |
| } | |
| // ★ BUG #4 FIX — Retry with backoff across 3 different endpoints | |
| try { | |
| await retryWithBackoff(async (attempt) => { | |
| // Try primary endpoint | |
| try { | |
| await hfFetch(`/api/spaces/${namespace}/${repo}`, { method: 'DELETE' }); | |
| return true; | |
| } catch(e1) { | |
| // Try repos endpoint as first fallback | |
| try { | |
| await hfFetch(`/api/repos/${namespace}/${repo}`, { method: 'DELETE' }); | |
| return true; | |
| } catch(e2) { | |
| // Try raw DELETE as last resort | |
| try { | |
| const res = await fetch(`${HF_API_BASE}/api/repos/${namespace}/${repo}`, { | |
| method: 'DELETE', | |
| headers: authHeader() | |
| }); | |
| if (res.ok || res.status === 204) return true; | |
| throw new Error(`HTTP ${res.status}`); | |
| } catch(e3) { | |
| throw e3; | |
| } | |
| } | |
| } | |
| }, { maxAttempts: 5, baseDelay: 3000 }); | |
| return `✅ **Space deleted:** ${args.repo_id}`; | |
| } catch(e) { | |
| throw new Error(`Could not delete space after multiple attempts: ${e.message}. Try stopping it first (hf_pause_space or hf_restart_space).`); | |
| } | |
| } | |
| }, | |
| // ── File Operations ──────────────────────────────────────────────── | |
| hf_upload_file: { | |
| description: 'Upload a single file to a Space (app.py, requirements.txt, README.md, etc.). Triggers a rebuild.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID (e.g. "username/my-space")' }, | |
| path: { type: 'string', description: 'Path in the repo (e.g. "app.py" or "src/utils.py")' }, | |
| content: { type: 'string', description: 'File content as text' }, | |
| summary: { type: 'string', description: 'Commit message (default: "Update via ChatSeed")' }, | |
| description: { type: 'string', description: 'Optional commit description' } | |
| }, | |
| required: ['repo_id', 'path', 'content'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id. Use "namespace/repo-name"'; | |
| const [namespace, repo] = parts; | |
| const result = await commitFiles( | |
| 'space', namespace, repo, | |
| [{ path: args.path, content: args.content }], | |
| args.summary || 'Update via ChatSeed', | |
| args.description || '' | |
| ); | |
| return [ | |
| `✅ **File uploaded:** \`${args.path}\` → \`${args.repo_id}\``, | |
| `📝 ${args.summary || 'Update via ChatSeed'}`, | |
| ``, | |
| `💡 The Space will now rebuild automatically. Check status with \`hf_space_status\`.` | |
| ].join('\n'); | |
| } | |
| }, | |
| hf_upload_app: { | |
| description: 'Upload a complete Gradio/Streamlit app with requirements.txt in one go.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID (e.g. "username/my-space")' }, | |
| app_code: { type: 'string', description: 'The app.py (or app.js for static) source code' }, | |
| requirements: { type: 'string', description: 'Optional requirements.txt content (one package per line)' }, | |
| readme: { type: 'string', description: 'Optional README.md content' }, | |
| extra_files: { type: 'string', description: 'Optional JSON of extra files {"path": "content", ...}' }, | |
| summary: { type: 'string', description: 'Commit message' } | |
| }, | |
| required: ['repo_id', 'app_code'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id. Use "namespace/repo-name"'; | |
| const [namespace, repo] = parts; | |
| const files = [{ path: 'app.py', content: args.app_code }]; | |
| if (args.requirements) files.push({ path: 'requirements.txt', content: args.requirements }); | |
| if (args.readme) files.push({ path: 'README.md', content: args.readme }); | |
| if (args.extra_files) { | |
| const extras = typeof args.extra_files === 'string' ? JSON.parse(args.extra_files) : args.extra_files; | |
| for (const [path, content] of Object.entries(extras)) { | |
| files.push({ path, content: String(content) }); | |
| } | |
| } | |
| const result = await commitFiles( | |
| 'space', namespace, repo, files, | |
| args.summary || 'Deploy app via ChatSeed', | |
| 'Uploaded app.py' + (args.requirements ? ' + requirements.txt' : '') + (args.readme ? ' + README.md' : '') | |
| ); | |
| return [ | |
| `✅ **App deployed to:** \`${args.repo_id}\``, | |
| `📦 **Files uploaded:** ${files.map(f => '`' + f.path + '`').join(', ')}`, | |
| ``, | |
| `🌐 **Space:** https://huggingface.co/spaces/${args.repo_id}`, | |
| `🚀 **App URL:** https://${namespace.replace(/\//g, '-')}-${repo}.hf.space`, | |
| ``, | |
| `💡 The Space is now building. Use \`hf_space_status ${args.repo_id}\` to check progress.` | |
| ].join('\n'); | |
| } | |
| }, | |
| hf_delete_file: { | |
| description: 'Delete a file from a Space repository.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID (e.g. "username/my-space")' }, | |
| path: { type: 'string', description: 'File path in the repo to delete' }, | |
| summary: { type: 'string', description: 'Commit message' } | |
| }, | |
| required: ['repo_id', 'path'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id. Use "namespace/repo-name"'; | |
| const [namespace, repo] = parts; | |
| const rev = 'main'; | |
| const typePath = 'spaces'; | |
| const body = { | |
| summary: args.summary || `Delete ${args.path}`, | |
| description: '', | |
| deletedEntries: [{ path: args.path }] | |
| }; | |
| await hfFetch(`/api/${typePath}/${namespace}/${repo}/commit/${rev}`, { | |
| method: 'POST', | |
| body: JSON.stringify(body) | |
| }); | |
| return `✅ **File deleted:** \`${args.path}\` from \`${args.repo_id}\``; | |
| } | |
| }, | |
| // ── Space Configuration ───────────────────────────────────────────── | |
| // ★ BUG #6 FIXED — hf_set_secret with CORS proxy fallback | |
| hf_set_secret: { | |
| description: 'Add or update a secret (environment variable) for a Space. Triggers a restart.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID (e.g. "username/my-space")' }, | |
| key: { type: 'string', description: 'Secret name (e.g. "HF_TOKEN", "API_KEY")' }, | |
| value: { type: 'string', description: 'Secret value' } | |
| }, | |
| required: ['repo_id', 'key', 'value'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| // ★ BUG #6 FIX — Try multiple strategies for setting secrets | |
| // Strategy 1: PUT on secrets endpoint (may be CORS-blocked in browser) | |
| // Strategy 2: POST on secrets endpoint (fallback) | |
| // Strategy 3: Use the space settings API (CORS-friendly alternative) | |
| const errors = []; | |
| // Strategy 1 & 2: Try secrets endpoints | |
| for (const method of ['PUT', 'POST']) { | |
| try { | |
| await hfFetch(`/api/spaces/${namespace}/${repo}/secrets`, { | |
| method: method, | |
| body: JSON.stringify({ key: args.key, value: args.value }) | |
| }); | |
| return `🔐 **Secret set:** \`${args.key}\` in \`${args.repo_id}\`\n⚠️ The Space will restart.`; | |
| } catch(e) { | |
| errors.push(`${method}: ${e.message}`); | |
| } | |
| } | |
| // Strategy 3: Try via settings (some spaces support this) | |
| try { | |
| await updateSpaceSettings(namespace, repo, { | |
| secrets: { [args.key]: args.value } | |
| }); | |
| return `🔐 **Secret set (via settings API):** \`${args.key}\` in \`${args.repo_id}\``; | |
| } catch(e) { | |
| errors.push(`settings: ${e.message}`); | |
| } | |
| // All strategies failed — provide helpful error with workaround | |
| return [ | |
| `❌ **Could not set secret** \`${args.key}\` in \`${args.repo_id}\``, | |
| ``, | |
| `**Errors:**`, | |
| ...errors.map(e => ` • ${e}`), | |
| ``, | |
| `💡 **Workaround:** Set secrets when creating the space with \`hf_create_space\``, | |
| ` using the \`secrets\` parameter (JSON format: \`{"KEY": "value"}\`).`, | |
| ` Or set them manually at: https://huggingface.co/spaces/${args.repo_id}/settings` | |
| ].join('\n'); | |
| } | |
| }, | |
| // ★ BUG #6 FIXED — hf_delete_secret with CORS proxy fallback | |
| hf_delete_secret: { | |
| description: 'Delete a secret from a Space.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID' }, | |
| key: { type: 'string', description: 'Secret name to delete' } | |
| }, | |
| required: ['repo_id', 'key'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| // ★ BUG #6 FIX — Try DELETE, fallback to PUT with empty value | |
| try { | |
| await hfFetch(`/api/spaces/${namespace}/${repo}/secrets`, { | |
| method: 'DELETE', | |
| body: JSON.stringify({ key: args.key }) | |
| }); | |
| return `🗑️ **Secret deleted:** \`${args.key}\` from \`${args.repo_id}\``; | |
| } catch(e) { | |
| // Fallback: try setting secret to empty string | |
| try { | |
| await hfFetch(`/api/spaces/${namespace}/${repo}/secrets`, { | |
| method: 'PUT', | |
| body: JSON.stringify({ key: args.key, value: '' }) | |
| }); | |
| return `🗑️ **Secret cleared (set to empty):** \`${args.key}\` in \`${args.repo_id}\``; | |
| } catch(e2) { | |
| return [ | |
| `⚠️ **Could not delete secret** \`${args.key}\`: ${e.message}`, | |
| `💡 Delete it manually at: https://huggingface.co/spaces/${args.repo_id}/settings` | |
| ].join('\n'); | |
| } | |
| } | |
| } | |
| }, | |
| hf_set_hardware: { | |
| description: 'Request a hardware upgrade/downgrade for a Space (e.g. CPU → GPU). Triggers a restart.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID' }, | |
| hardware: { | |
| type: 'string', | |
| description: 'Hardware tier: cpu-basic (free), cpu-upgrade ($0.03/hr), t4-small ($0.40), t4-medium ($0.60), l4-1x ($0.80), a10g-small ($1.00), a100-large ($2.50)', | |
| enum: ['cpu-basic', 'cpu-upgrade', 't4-small', 't4-medium', 'l4-1x', 'a10g-small', 'a10g-large', 'a100-large'] | |
| }, | |
| sleep_time: { type: 'number', description: 'Auto-sleep timeout in seconds (for GPU) - e.g. 7200 = 2h' } | |
| }, | |
| required: ['repo_id', 'hardware'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| const settings = { flavor: args.hardware }; | |
| if (args.sleep_time) settings.gcTimeout = args.sleep_time; | |
| await updateSpaceSettings(namespace, repo, settings); | |
| return [ | |
| `⚡ **Hardware change requested for:** \`${args.repo_id}\``, | |
| `**New hardware:** ${args.hardware}`, | |
| args.sleep_time ? `**Sleep timeout:** ${args.sleep_time}s` : '', | |
| ``, | |
| `⏳ The Space is restarting. Check status with \`hf_space_status\`.` | |
| ].filter(l => l).join('\n'); | |
| } | |
| }, | |
| hf_set_visibility: { | |
| description: 'Change the visibility of a Space (public / private).', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID' }, | |
| visibility: { type: 'string', enum: ['public', 'private'], description: 'New visibility level' } | |
| }, | |
| required: ['repo_id', 'visibility'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| await updateSpaceSettings(namespace, repo, { private: args.visibility === 'private' }); | |
| const icon = args.visibility === 'private' ? '🔒' : '🌍'; | |
| return `${icon} **Visibility changed to ${args.visibility}:** \`${args.repo_id}\``; | |
| } | |
| }, | |
| hf_set_sleep: { | |
| description: 'Set auto-sleep timeout for a Space (useful for GPU spaces to save cost).', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID' }, | |
| sleep_time: { type: 'number', description: 'Sleep timeout in seconds (0 to disable, 300 = 5 min, 3600 = 1h, 7200 = 2h)' } | |
| }, | |
| required: ['repo_id', 'sleep_time'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| await updateSpaceSettings(namespace, repo, { gcTimeout: args.sleep_time }); | |
| const status = args.sleep_time === 0 ? '❌ Disabled (never sleeps)' : `💤 ${args.sleep_time}s (${Math.round(args.sleep_time/60)} min)`; | |
| return `✅ **Sleep configured:** \`${args.repo_id}\` → ${status}`; | |
| } | |
| }, | |
| // ★ BUG #3 FIXED — hf_pause_space with fallback strategies | |
| hf_pause_space: { | |
| description: 'Pause a Space to stop billing. It can be restarted later with hf_restart_space.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID to pause' } | |
| }, | |
| required: ['repo_id'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| // ★ BUG #3 FIX — Try multiple pause strategies | |
| const errors = []; | |
| // Strategy 1: Direct /pause endpoint | |
| try { | |
| await hfFetch(`/api/spaces/${namespace}/${repo}/pause`, { method: 'POST' }); | |
| return `⏸️ **Space paused:** \`${args.repo_id}\`\n💡 Restart with \`hf_restart_space ${args.repo_id}\``; | |
| } catch(e) { | |
| errors.push(`pause endpoint: ${e.message}`); | |
| } | |
| // Strategy 2: Set sleep to minimum (5 min) + set hardware to cpu-basic to simulate pause | |
| try { | |
| await updateSpaceSettings(namespace, repo, { | |
| gcTimeout: 300, // 5 min minimum | |
| flavor: 'cpu-basic' | |
| }); | |
| return [ | |
| `⏸️ **Space stopped (fallback):** \`${args.repo_id}\``, | |
| ` 📋 Pause endpoint unavailable — used stop/sleep workaround.`, | |
| ` 💤 Auto-sleep set to 5 minutes with CPU-basic hardware.`, | |
| `💡 Restart with \`hf_restart_space ${args.repo_id}\`` | |
| ].join('\n'); | |
| } catch(e2) { | |
| errors.push(`settings workaround: ${e2.message}`); | |
| } | |
| return [ | |
| `⚠️ **Could not pause** \`${args.repo_id}\``, | |
| ``, | |
| `**Errors:**`, | |
| ...errors.map(e => ` • ${e}`), | |
| ``, | |
| `💡 Try setting hardware to cpu-basic with \`hf_set_hardware\``, | |
| ` or set a short sleep timeout with \`hf_set_sleep\`.` | |
| ].join('\n'); | |
| } | |
| }, | |
| hf_restart_space: { | |
| description: 'Restart a paused Space.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID to restart' } | |
| }, | |
| required: ['repo_id'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| await hfFetch(`/api/spaces/${namespace}/${repo}/restart`, { method: 'POST' }); | |
| return `▶️ **Space restarting:** \`${args.repo_id}\``; | |
| } | |
| }, | |
| // ── Query / Status ───────────────────────────────────────────────── | |
| hf_space_status: { | |
| description: 'Get the runtime status, hardware, and stage of a Space.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID (e.g. "username/my-space")' } | |
| }, | |
| required: ['repo_id'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| const runtime = await hfFetch(`/api/spaces/${namespace}/${repo}/runtime`); | |
| const repoInfo = await hfFetch(`/api/spaces/${namespace}/${repo}`); | |
| const stageEmoji = { | |
| 'NO_APP_FILE': '📄', 'BUILDING': '🔨', 'RUNNING': '✅', | |
| 'RUNNING_BUILDING': '🔄', 'PAUSED': '⏸️', 'SLEEPING': '💤', | |
| 'STOPPED': '⛔', 'ERROR': '❌' | |
| }; | |
| const stage = runtime.stage || 'UNKNOWN'; | |
| const sdk = repoInfo.sdk || 'N/A'; | |
| const hardware = extractHardwareName(runtime.hardware); | |
| const requestedHardware = extractHardwareName(runtime.requestedHardware); | |
| const visibility = repoInfo.private ? '🔒 Private' : '🌍 Public'; | |
| const likes = repoInfo.likes || 0; | |
| let hwDetail = ''; | |
| if (typeof runtime.hardware === 'object' && runtime.hardware !== null) { | |
| try { | |
| const compact = JSON.stringify(runtime.hardware); | |
| if (compact.length > 2 && compact.length < 200) { | |
| hwDetail = `\n**HW Raw:** ${compact}`; | |
| } | |
| } catch(e) {} | |
| } | |
| return [ | |
| `**📊 Space Status:** \`${args.repo_id}\``, | |
| ``, | |
| `**Stage:** ${stageEmoji[stage] || '❓'} ${stage}`, | |
| `**SDK:** ${sdk}`, | |
| `**Hardware:** ${hardware}`, | |
| `**Requested HW:** ${requestedHardware}`, | |
| hwDetail, | |
| `**Visibility:** ${visibility}`, | |
| `**Likes:** ⭐ ${likes}`, | |
| `**URL:** https://huggingface.co/spaces/${args.repo_id}`, | |
| `**App:** https://${namespace}-${repo}.hf.space` | |
| ].filter(l => l).join('\n'); | |
| } | |
| }, | |
| hf_space_logs: { | |
| description: 'Fetch the latest build/runtime logs from a Space.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Space ID' } | |
| }, | |
| required: ['repo_id'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| try { | |
| const endpoints = [ | |
| `/api/spaces/${namespace}/${repo}/runtime/logs`, | |
| `/api/spaces/${namespace}/${repo}/logs`, | |
| `/api/spaces/${namespace}/${repo}/runtime` | |
| ]; | |
| let lastError = null; | |
| for (const ep of endpoints) { | |
| try { | |
| const result = await hfFetch(ep); | |
| if (result && typeof result === 'object') { | |
| const logsStr = result.logs || result.stdout || result.stderr || result.build || JSON.stringify(result, null, 2); | |
| const truncated = logsStr.length > 5000 ? logsStr.slice(-5000) + `\n... (truncated, full: ${logsStr.length} chars)` : logsStr; | |
| return [`📋 **Build Logs for** \`${args.repo_id}\``, '\`\`\`', truncated, '\`\`\`'].join('\n'); | |
| } | |
| } catch(e) { | |
| lastError = e; | |
| } | |
| } | |
| try { | |
| const runtime = await hfFetch(`/api/spaces/${namespace}/${repo}/runtime`); | |
| if (runtime && runtime.errorMessage) { | |
| return `⚠️ **Space has an error:**\n\`\`\`\n${runtime.errorMessage}\n\`\`\``; | |
| } | |
| return `ℹ️ **Space is** ${runtime.stage || 'unknown'}. No logs available via REST API.\n\n💡 Logs can only be viewed in the HF UI: https://huggingface.co/spaces/${args.repo_id}`; | |
| } catch(e2) { | |
| throw lastError || e2; | |
| } | |
| } catch(e) { | |
| return `❌ Could not fetch logs: ${e.message}`; | |
| } | |
| } | |
| }, | |
| // ── Search / List ────────────────────────────────────────────────── | |
| hf_search_spaces: { | |
| description: 'Search for Spaces on the HuggingFace Hub by query.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| query: { type: 'string', description: 'Search query' }, | |
| limit: { type: 'number', default: 5, description: 'Max results (1-25)' } | |
| }, | |
| required: ['query'] | |
| }, | |
| handler: async function(args) { | |
| const limit = Math.min(Math.max(args.limit || 5, 1), 25); | |
| const results = await hfFetch(`/api/spaces?search=${encodeURIComponent(args.query)}&limit=${limit}&sort=likes`); | |
| if (!results || !results.length) return `🔍 No Spaces found for "${args.query}"`; | |
| const lines = [`🔍 **Spaces matching "${args.query}":**`, '']; | |
| results.forEach((s, i) => { | |
| const id = s.id || `${s.namespace || '?'}/${s.name || '?'}`; | |
| const sdk = s.sdk ? ` [${s.sdk}]` : ''; | |
| const likes = s.likes ? ` ⭐${s.likes}` : ''; | |
| const desc = s.description ? `\n > ${s.description.substring(0, 150)}` : ''; | |
| lines.push(`${i+1}. **${id}**${sdk}${likes}`); | |
| if (desc) lines.push(desc); | |
| lines.push(` https://huggingface.co/spaces/${id}`); | |
| lines.push(''); | |
| }); | |
| return lines.join('\n'); | |
| } | |
| }, | |
| hf_list_my_spaces: { | |
| description: 'List all Spaces owned by your account.', | |
| parameters: { | |
| type: 'object', | |
| properties: { limit: { type: 'number', default: 10, description: 'Max results' } }, | |
| required: [] | |
| }, | |
| handler: async function() { | |
| const userInfo = await hfFetch('/api/whoami-v2'); | |
| const name = userInfo.name || userInfo.user; | |
| const results = await hfFetch(`/api/spaces?author=${encodeURIComponent(name)}&limit=25&sort=lastModified`); | |
| if (!results || !results.length) { | |
| return `📭 No Spaces found under **${name}**.\nCreate one with \`hf_create_space\`!`; | |
| } | |
| const lines = [`📂 **Your Spaces (${name})**:`, '']; | |
| results.forEach((s, i) => { | |
| const id = s.id || `${s.namespace}/${s.name}`; | |
| const sdk = s.sdk ? ` [${s.sdk}]` : ''; | |
| const vis = s.private ? '🔒' : '🌍'; | |
| const likes = s.likes ? ` ⭐${s.likes}` : ''; | |
| const stage = s.runtime?.stage || ''; | |
| lines.push(`${vis} **${id}**${sdk}${likes}${stage ? ` — ${stage}` : ''}`); | |
| }); | |
| lines.push('', `💡 Use \`hf_space_status <id>\` for details on any Space.`); | |
| return lines.join('\n'); | |
| } | |
| }, | |
| hf_search_models: { | |
| description: 'Search for models on the HuggingFace Hub.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| query: { type: 'string', description: 'Search query' }, | |
| limit: { type: 'number', default: 5, description: 'Max results' } | |
| }, | |
| required: ['query'] | |
| }, | |
| handler: async function(args) { | |
| const limit = Math.min(Math.max(args.limit || 5, 1), 25); | |
| const results = await hfFetch(`/api/models?search=${encodeURIComponent(args.query)}&limit=${limit}&sort=likes`); | |
| if (!results || !results.length) return `🔍 No models found for "${args.query}"`; | |
| const lines = [`🔍 **Models matching "${args.query}":**`, '']; | |
| results.forEach((m, i) => { | |
| const id = m.id || `${m.namespace || '?'}/${m.name || '?'}`; | |
| const pipeline = m.pipeline_tag ? ` [${m.pipeline_tag}]` : ''; | |
| const likes = m.likes ? ` ⭐${m.likes}` : ''; | |
| const downloads = m.downloads ? ` 📥${(m.downloads/1000).toFixed(0)}k` : ''; | |
| lines.push(`${i+1}. **${id}**${pipeline}${likes}${downloads}`); | |
| lines.push(` https://huggingface.co/${id}`); | |
| }); | |
| return lines.join('\n'); | |
| } | |
| }, | |
| // ── Gradio Space API Calls ───────────────────────────────────────── | |
| hf_call_space: { | |
| description: 'Call a Gradio Space API endpoint (make predictions/inference via the Space API).', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Gradio Space ID (e.g. "abidlabs/en2fr")' }, | |
| api_name: { type: 'string', default: '/predict', description: 'API endpoint name (e.g. "/predict", "/generate")' }, | |
| data: { type: 'string', description: 'JSON array of input data (e.g. ["Hello world"])' } | |
| }, | |
| required: ['repo_id', 'data'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| const subdomain = `${namespace.replace(/\//g, '-')}-${repo}`; | |
| const apiName = args.api_name || '/predict'; | |
| const payload = typeof args.data === 'string' ? JSON.parse(args.data) : args.data; | |
| const inputArray = Array.isArray(payload) ? payload : [payload]; | |
| const submitUrl = `https://${subdomain}.hf.space/gradio_api/call${apiName}`; | |
| const headers = { 'Content-Type': 'application/json' }; | |
| const token = getToken(); | |
| if (token) headers['Authorization'] = 'Bearer ' + token; | |
| const submitRes = await fetch(submitUrl, { | |
| method: 'POST', headers, | |
| body: JSON.stringify({ data: inputArray }) | |
| }); | |
| if (!submitRes.ok) { | |
| const errText = await submitRes.text(); | |
| return `❌ API call failed (${submitRes.status}): ${errText.substring(0, 300)}`; | |
| } | |
| const submitData = await submitRes.json(); | |
| const eventId = submitData.event_id; | |
| if (!eventId) return '❌ No event_id returned. The Space may not support API calls.'; | |
| const resultUrl = `https://${subdomain}.hf.space/gradio_api/call${apiName}/${eventId}`; | |
| for (let attempt = 0; attempt < 30; attempt++) { | |
| const pollRes = await fetch(resultUrl, { headers }); | |
| const text = await pollRes.text(); | |
| const lines = text.split('\n').filter(l => l.startsWith('data: ')); | |
| if (lines.length > 0) { | |
| const lastLine = lines[lines.length - 1]; | |
| const dataStr = lastLine.replace('data: ', ''); | |
| if (dataStr === '[DONE]') break; | |
| try { | |
| const resultData = JSON.parse(dataStr); | |
| return [ | |
| `✅ **Space API Response** from \`${args.repo_id}${apiName}\``, | |
| '\`\`\`json', | |
| JSON.stringify(resultData, null, 2), | |
| '\`\`\`' | |
| ].join('\n'); | |
| } catch(e) { | |
| if (text.includes('event: complete')) { | |
| const dataMatch = text.match(/data:(\[.*?\]|\{.*\})/s); | |
| if (dataMatch) { | |
| return [ | |
| `✅ **Space API Response** from \`${args.repo_id}${apiName}\``, | |
| '\`\`\`json', dataMatch[1], '\`\`\`' | |
| ].join('\n'); | |
| } | |
| } | |
| } | |
| } | |
| await new Promise(r => setTimeout(r, 1000)); | |
| } | |
| return `⏱️ Result still pending after 30s. Check manually at https://${subdomain}.hf.space`; | |
| } | |
| }, | |
| // ★ BUG #7 FIXED — hf_inference routes through CORS-safe proxy | |
| hf_inference: { | |
| description: 'Run inference on a HuggingFace model using the free Inference API.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| model: { type: 'string', description: 'Model ID (e.g. "gpt2", "meta-llama/Llama-3.2-3B-Instruct")' }, | |
| inputs: { type: 'string', description: 'Input text or JSON string of inputs' }, | |
| parameters: { type: 'string', description: 'Optional JSON string of generation parameters (max_length, temperature, etc.)' }, | |
| task: { type: 'string', description: 'Optional task type (e.g. "text-generation", "image-classification", "automatic-speech-recognition")' } | |
| }, | |
| required: ['model', 'inputs'] | |
| }, | |
| handler: async function(args) { | |
| const params = args.parameters ? (typeof args.parameters === 'string' ? JSON.parse(args.parameters) : args.parameters) : {}; | |
| let inputData; | |
| try { inputData = JSON.parse(args.inputs); } catch(e) { inputData = args.inputs; } | |
| const body = Object.keys(params).length | |
| ? JSON.stringify({ inputs: inputData, parameters: params }) | |
| : JSON.stringify({ inputs: inputData }); | |
| // ★ BUG #7 FIX — Use CORS-safe proxy via main HF API | |
| // Strategy 1: Try POST /api/models/{model}/inference (CORS-friendly) | |
| // Strategy 2: Fall back to direct api-inference.huggingface.co call | |
| try { | |
| const result = await hfInferenceProxy(args.model, body); | |
| return [ | |
| `🧠 **Inference Result — \`${args.model}\`**`, | |
| '\`\`\`json', | |
| JSON.stringify(result, null, 2), | |
| '\`\`\`' | |
| ].join('\n'); | |
| } catch(e) { | |
| // Fallback: try direct inference API call | |
| try { | |
| const headers = { 'Content-Type': 'application/json' }; | |
| const token = getToken(); | |
| if (token) headers['Authorization'] = 'Bearer ' + token; | |
| const url = args.task | |
| ? `${INFERENCE_API_BASE}/pipeline/${args.task}/${args.model}` | |
| : `${INFERENCE_API_BASE}/models/${args.model}`; | |
| const res = await fetch(url, { method: 'POST', headers, body }); | |
| if (!res.ok) { | |
| let msg = ''; | |
| try { const err = await res.json(); msg = err.error || JSON.stringify(err); } catch(e2) { msg = res.statusText; } | |
| if (res.status === 503 && msg.includes('loading')) { | |
| const estimated = msg.match(/(\d+)/); | |
| const time = estimated ? estimated[1] + 's' : 'a moment'; | |
| return `⏳ Model **${args.model}** is loading. Try again in ${time}.`; | |
| } | |
| throw new Error(msg.substring(0, 500)); | |
| } | |
| const result = await res.json(); | |
| return [ | |
| `🧠 **Inference Result — \`${args.model}\`**`, | |
| '\`\`\`json', | |
| JSON.stringify(result, null, 2), | |
| '\`\`\`' | |
| ].join('\n'); | |
| } catch(e2) { | |
| return [ | |
| `❌ **Inference failed** for \`${args.model}\``, | |
| ``, | |
| `**Error:** ${e2.message}`, | |
| ``, | |
| `💡 Try using a Gradio Space that wraps the model instead:`, | |
| ` Use \`hf_call_space\` with a model-serving Space.` | |
| ].join('\n'); | |
| } | |
| } | |
| } | |
| }, | |
| // ── Repo Info ────────────────────────────────────────────────────── | |
| hf_repo_info: { | |
| description: 'Get detailed information about any HF repo (Space, Model, or Dataset).', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Repo ID (e.g. "username/repo-name")' }, | |
| type: { type: 'string', enum: ['space', 'model', 'dataset'], default: 'space', description: 'Repo type' } | |
| }, | |
| required: ['repo_id'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| const type = repoTypePath(args.type || 'space'); | |
| const info = await hfFetch(`/api/${type}/${namespace}/${repo}`); | |
| const lines = [ | |
| `**📦 Repo Info:** \`${args.repo_id}\``, | |
| `**Type:** ${args.type || 'space'}`, | |
| `**Visibility:** ${info.private ? '🔒 Private' : '🌍 Public'}`, | |
| `**Likes:** ⭐ ${info.likes || 0}`, | |
| `**Downloads:** 📥 ${info.downloads || 0}`, | |
| `**Created:** ${info.createdAt ? new Date(info.createdAt).toLocaleDateString() : 'N/A'}`, | |
| `**Last Modified:** ${info.lastModified ? new Date(info.lastModified).toLocaleDateString() : 'N/A'}`, | |
| `**URL:** https://huggingface.co/${args.repo_id}` | |
| ]; | |
| if (info.sdk) lines.push(`**SDK:** ${info.sdk}`); | |
| if (info.pipeline_tag) lines.push(`**Pipeline:** ${info.pipeline_tag}`); | |
| if (info.description) lines.push(`**Description:** ${info.description.substring(0, 300)}`); | |
| if (info.tags && info.tags.length) lines.push(`**Tags:** ${info.tags.join(', ')}`); | |
| return lines.join('\n'); | |
| } | |
| }, | |
| hf_list_files: { | |
| description: 'List files in a repository at a given path.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Repo ID' }, | |
| type: { type: 'string', enum: ['space', 'model', 'dataset'], default: 'space' }, | |
| path: { type: 'string', default: '', description: 'Subdirectory path (optional)' }, | |
| revision: { type: 'string', default: 'main', description: 'Branch/revision' } | |
| }, | |
| required: ['repo_id'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id'; | |
| const [namespace, repo] = parts; | |
| const type = repoTypePath(args.type || 'space'); | |
| const rev = args.revision || 'main'; | |
| const path = args.path || ''; | |
| let info = null; | |
| const isRootDir = !path || path === '.'; | |
| if (isRootDir) { | |
| try { | |
| info = await hfFetch(`/api/${type}/${namespace}/${repo}/tree/${encodeURIComponent(rev)}`); | |
| } catch(e) { | |
| try { | |
| const repoInfo = await hfFetch(`/api/${type}/${namespace}/${repo}`); | |
| if (repoInfo.siblings && repoInfo.siblings.length) { | |
| info = repoInfo.siblings.map(s => ({ | |
| rfilename: s.rfilename, | |
| type: s.type === 'directory' ? 'directory' : 'file', | |
| size: s.size || 0 | |
| })); | |
| } | |
| } catch(e3) { | |
| return `❌ Could not list files: ${e3.message}`; | |
| } | |
| } | |
| } else { | |
| try { | |
| const body = { paths: [path || '.'], expand: false }; | |
| const result = await hfFetch(`/api/${type}/${namespace}/${repo}/paths-info/${rev}`, { | |
| method: 'POST', body: JSON.stringify(body) | |
| }); | |
| info = result; | |
| } catch(e) { | |
| try { | |
| const treePath = path ? encodeURIComponent(path) : ''; | |
| info = await hfFetch(`/api/${type}/${namespace}/${repo}/tree/${encodeURIComponent(rev)}/${treePath}`); | |
| } catch(e2) { | |
| try { | |
| const repoInfo = await hfFetch(`/api/${type}/${namespace}/${repo}`); | |
| if (repoInfo.siblings && repoInfo.siblings.length) { | |
| const prefix = path ? path + '/' : ''; | |
| info = repoInfo.siblings | |
| .filter(s => s.rfilename.startsWith(prefix) && !s.rfilename.slice(prefix.length).includes('/')) | |
| .map(s => ({ | |
| rfilename: s.rfilename, | |
| type: s.type === 'directory' ? 'directory' : 'file', | |
| size: s.size || 0 | |
| })); | |
| } | |
| } catch(e3) { | |
| return `❌ Could not list files: ${e3.message}`; | |
| } | |
| } | |
| } | |
| } | |
| if (!info || (Array.isArray(info) && info.length === 0) || (!Array.isArray(info) && !info.length)) { | |
| return `📁 No files found at \`${path || '/'}\` in \`${args.repo_id}\``; | |
| } | |
| const files = Array.isArray(info) ? info : [info]; | |
| if (!isRootDir && files.length === 1 && files[0].type === 'directory') { | |
| return `📁 **Empty directory** at \`${args.repo_id}/${path || ''}\``; | |
| } | |
| const lines = [`📁 **Files in** \`${args.repo_id}/${path || ''}\` (${rev}):`, '']; | |
| files.forEach(f => { | |
| const icon = f.type === 'directory' ? '📁' : '📄'; | |
| const fname = f.rfilename || f.path || f.name || '?'; | |
| const size = f.size ? ` (${(f.size / 1024).toFixed(1)} KB)` : ''; | |
| lines.push(`${icon} \`${fname}\`${size}`); | |
| }); | |
| return lines.join('\n'); | |
| } | |
| }, | |
| // ── Extended Tools ───────────────────────────────────────────────── | |
| hf_read_file: { | |
| description: 'Read the content of a file from ANY HuggingFace repo (Space, Model, or Dataset), including PRIVATE repos.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Repo ID (e.g. "username/my-space")' }, | |
| path: { type: 'string', description: 'File path in the repo (e.g. "app.py", "config.json")' }, | |
| revision: { type: 'string', default: 'main', description: 'Branch/commit revision' }, | |
| type: { type: 'string', enum: ['space', 'model', 'dataset'], default: 'space', description: 'Repo type' } | |
| }, | |
| required: ['repo_id', 'path'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id. Use "namespace/repo-name"'; | |
| const [namespace, repo] = parts; | |
| const rev = args.revision || 'main'; | |
| const filePath = args.path; | |
| const typePath = repoTypePath(args.type || 'space'); | |
| const rawPath = `/${typePath}/${namespace}/${repo}/raw/${encodeURIComponent(rev)}/${filePath}`; | |
| const content = await hfFetchRaw(rawPath); | |
| const truncated = content.length > 30000 ? content.substring(0, 30000) + '\n\n... (truncated, full length: ' + content.length + ' chars)' : content; | |
| return [ | |
| `📄 **\`${filePath}\`** from \`${args.repo_id}\` (${rev})`, | |
| '', | |
| '\`\`\`', | |
| truncated, | |
| '\`\`\`', | |
| '', | |
| `📊 **File info:** ${content.length} chars` | |
| ].join('\n'); | |
| } | |
| }, | |
| hf_file_exists: { | |
| description: 'Check if a file exists in a HuggingFace repo (including private repos).', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Repo ID (e.g. "username/my-space")' }, | |
| path: { type: 'string', description: 'File path to check (e.g. "app.py", "requirements.txt")' }, | |
| revision: { type: 'string', default: 'main', description: 'Branch/revision' } | |
| }, | |
| required: ['repo_id', 'path'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id. Use "namespace/repo-name"'; | |
| const [namespace, repo] = parts; | |
| const rev = args.revision || 'main'; | |
| const filePath = args.path; | |
| const typePath = repoTypePath(args.type || 'space'); | |
| const { ok, status } = await hfFetchHead(`/${typePath}/${namespace}/${repo}/raw/${encodeURIComponent(rev)}/${filePath}`); | |
| if (ok) { | |
| return `✅ **File exists:** \`${filePath}\` in \`${args.repo_id}\` (${rev})`; | |
| } else if (status === 404) { | |
| return `❌ **File not found:** \`${filePath}\` does not exist in \`${args.repo_id}\` (${rev})`; | |
| } else { | |
| return `⚠️ **Check failed:** HTTP ${status} for \`${filePath}\` in \`${args.repo_id}\``; | |
| } | |
| } | |
| }, | |
| hf_repo_exists: { | |
| description: 'Check if a HuggingFace repository exists (Space, Model, or Dataset). Works for private repos too.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Repo ID (e.g. "username/my-space")' }, | |
| type: { type: 'string', enum: ['space', 'model', 'dataset'], default: 'space', description: 'Repo type' } | |
| }, | |
| required: ['repo_id'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id. Use "namespace/repo-name"'; | |
| const [namespace, repo] = parts; | |
| const type = repoTypePath(args.type || 'space'); | |
| try { | |
| const info = await hfFetch(`/api/${type}/${namespace}/${repo}`); | |
| const vis = info.private ? '🔒 Private' : '🌍 Public'; | |
| return [ | |
| `✅ **Repo exists:** \`${args.repo_id}\``, | |
| `**Type:** ${args.type || 'space'}`, | |
| `**Visibility:** ${vis}`, | |
| `**Likes:** ⭐ ${info.likes || 0}`, | |
| `**Downloads:** 📥 ${info.downloads || 0}`, | |
| `**URL:** https://huggingface.co/${args.repo_id}` | |
| ].join('\n'); | |
| } catch(e) { | |
| if (e.message.includes('404')) { | |
| return `❌ **Repo not found:** \`${args.repo_id}\` does not exist.`; | |
| } | |
| return `⚠️ **Error checking repo:** ${e.message}`; | |
| } | |
| } | |
| }, | |
| hf_list_commits: { | |
| description: 'View the commit history of a HuggingFace repository.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Repo ID (e.g. "username/my-space")' }, | |
| type: { type: 'string', enum: ['space', 'model', 'dataset'], default: 'space', description: 'Repo type' }, | |
| revision: { type: 'string', default: 'main', description: 'Branch/revision to view commits for' }, | |
| limit: { type: 'number', default: 10, description: 'Max commits to show (1-50)' } | |
| }, | |
| required: ['repo_id'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id. Use "namespace/repo-name"'; | |
| const [namespace, repo] = parts; | |
| const type = repoTypePath(args.type || 'space'); | |
| const rev = args.revision || 'main'; | |
| const limit = Math.min(Math.max(args.limit || 10, 1), 50); | |
| const commits = await hfFetch(`/api/${type}/${namespace}/${repo}/commits/${encodeURIComponent(rev)}?limit=${limit}`); | |
| if (!commits || !commits.length) { | |
| return `📭 No commits found for \`${args.repo_id}\` (${rev})`; | |
| } | |
| const lines = [ | |
| `📜 **Recent commits — \`${args.repo_id}\` (${rev})**:`, | |
| '' | |
| ]; | |
| commits.forEach((c, i) => { | |
| const date = c.date ? new Date(c.date).toLocaleString() : 'N/A'; | |
| const shortId = c.id ? c.id.substring(0, 7) : '???????'; | |
| const title = (c.title || c.message || 'No message').substring(0, 100); | |
| const author = c.author || 'unknown'; | |
| lines.push(`${i+1}. \`${shortId}\` — **${title}**`); | |
| lines.push(` 👤 ${author} — 🕐 ${date}`); | |
| }); | |
| return lines.join('\n'); | |
| } | |
| }, | |
| // ★ BUG #2 FIXED — hf_move_file: reads source content first instead of sending content: null | |
| hf_move_file: { | |
| description: 'Rename or move a file in a HuggingFace repository.', | |
| parameters: { | |
| type: 'object', | |
| properties: { | |
| repo_id: { type: 'string', description: 'Repo ID (e.g. "username/my-space")' }, | |
| source_path: { type: 'string', description: 'Current file path (e.g. "old_name.py")' }, | |
| dest_path: { type: 'string', description: 'New file path (e.g. "new_name.py" or "subfolder/new_name.py")' }, | |
| summary: { type: 'string', description: 'Commit message (default: "Move/Rename file")' }, | |
| type: { type: 'string', enum: ['space', 'model', 'dataset'], default: 'space', description: 'Repo type' } | |
| }, | |
| required: ['repo_id', 'source_path', 'dest_path'] | |
| }, | |
| handler: async function(args) { | |
| const parts = args.repo_id.split('/'); | |
| if (parts.length !== 2) return '❌ Invalid repo_id. Use "namespace/repo-name"'; | |
| const [namespace, repo] = parts; | |
| const typePath = repoTypePath(args.type || 'space'); | |
| const rev = 'main'; | |
| // ★ BUG #2 FIX — Read the source file content first | |
| let content = ''; | |
| try { | |
| const rawPath = `/${typePath}/${namespace}/${repo}/raw/${encodeURIComponent(rev)}/${args.source_path}`; | |
| content = await hfFetchRaw(rawPath); | |
| } catch(e) { | |
| return `❌ Could not read source file \`${args.source_path}\`: ${e.message}`; | |
| } | |
| // Commit: add at destination, delete from source | |
| const body = { | |
| summary: args.summary || `Move ${args.source_path} → ${args.dest_path}`, | |
| description: '', | |
| files: [{ | |
| path: args.dest_path, | |
| content: content | |
| }], | |
| deletedEntries: [{ path: args.source_path }] | |
| }; | |
| await hfFetch(`/api/${typePath}/${namespace}/${repo}/commit/${rev}`, { | |
| method: 'POST', | |
| body: JSON.stringify(body) | |
| }); | |
| return [ | |
| `✅ **File moved:** \`${args.source_path}\` → \`${args.dest_path}\` in \`${args.repo_id}\``, | |
| `📝 ${body.summary}`, | |
| ``, | |
| `💡 The Space will rebuild if applicable.` | |
| ].join('\n'); | |
| } | |
| } | |
| }; | |
| // ─── Module Registration ───────────────────────────────────────────── | |
| const toolList = Object.entries(tools).map(([name, def]) => ({ | |
| type: 'function', | |
| function: { | |
| name: name, | |
| description: def.description, | |
| parameters: { | |
| type: 'object', | |
| properties: def.parameters.properties, | |
| required: def.parameters.required || [] | |
| } | |
| } | |
| })); | |
| ModuleSystem.register('huggingface-hub', { | |
| name: 'HuggingFace Hub', | |
| description: 'Full remote control of HuggingFace Spaces and Hub. Create Spaces, upload apps, configure hardware/secrets, run inference, call Gradio APIs, and manage repos — all from the chat.', | |
| tools: toolList, | |
| handleToolCall: async function(toolName, args) { | |
| if (tools[toolName]) { | |
| try { | |
| return await tools[toolName].handler(args); | |
| } catch(e) { | |
| return `❌ **${toolName} error:** ${e.message}`; | |
| } | |
| } | |
| return null; | |
| } | |
| }); | |
| console.log('[HF Module v13 ALL FIXED] Registered with ' + Object.keys(tools).length + ' tools — 7 bugs patched'); | |
| })(); |