felo-ai 0.2.5 → 0.2.7

package/src/cli.js

@@ -1,13 +1,15 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
-import { createRequire } from 'module';
-import { Command } from 'commander';
-import { search } from './search.js';
-import { slides } from './slides.js';
-import * as config from './config.js';
+import { createRequire } from "module";
+import { Command } from "commander";
+import { search } from "./search.js";
+import { slides } from "./slides.js";
+import { webFetch } from "./webFetch.js";
+import { youtubeSubtitling } from "./youtubeSubtitling.js";
+import * as config from "./config.js";
 
 const require = createRequire(import.meta.url);
-const pkg = require('../package.json');
+const pkg = require("../package.json");
 
 /** Delay (ms) before process.exit to let Windows libuv finish handle cleanup. */
 const EXIT_DELAY_MS = 50;
@@ -22,13 +24,13 @@ function flushStdioThenExit(code) {
   const doExit = () => setTimeout(() => process.exit(code), EXIT_DELAY_MS);
   const flushStderr = () => {
     if (process.stderr?.writable && !process.stderr.destroyed) {
-      process.stderr.write('', () => doExit());
+      process.stderr.write("", () => doExit());
     } else {
       doExit();
     }
   };
   if (process.stdout?.writable && !process.stdout.destroyed) {
-    process.stdout.write('', () => flushStderr());
+    process.stdout.write("", () => flushStderr());
   } else {
     flushStderr();
   }
@@ -37,17 +39,17 @@ function flushStdioThenExit(code) {
 const program = new Command();
 
 program
-  .name('felo')
-  .description('Felo AI CLI - real-time search from the terminal')
+  .name("felo")
+  .description("Felo AI CLI - real-time search from the terminal")
   .version(pkg.version);
 
 program
-  .command('search')
-  .description('Search for current information (weather, news, docs, etc.)')
-  .argument('<query>', 'search query')
-  .option('-j, --json', 'output raw JSON')
-  .option('-v, --verbose', 'show query analysis and sources')
-  .option('-t, --timeout <seconds>', 'request timeout in seconds', '60')
+  .command("search")
+  .description("Search for current information (weather, news, docs, etc.)")
+  .argument("<query>", "search query")
+  .option("-j, --json", "output raw JSON")
+  .option("-v, --verbose", "show query analysis and sources")
+  .option("-t, --timeout <seconds>", "request timeout in seconds", "60")
   .action(async (query, opts) => {
     const timeoutMs = parseInt(opts.timeout, 10) * 1000;
     const code = await search(query, {
@@ -60,13 +62,26 @@ program
   });
 
 program
-  .command('slides')
-  .description('Generate PPT/slides from a prompt (async task, outputs live doc URL when done)')
-  .argument('<query>', 'PPT generation prompt (e.g. "Felo, 2 pages" or "Introduction to React")')
-  .option('-j, --json', 'output raw JSON with task_id and live_doc_url')
-  .option('-v, --verbose', 'show polling status')
-  .option('-t, --timeout <seconds>', 'request timeout in seconds for each API call', '60')
-  .option('--poll-timeout <seconds>', 'max seconds to wait for task completion', '1200')
+  .command("slides")
+  .description(
+    "Generate PPT/slides from a prompt (async task, outputs live doc URL when done)"
+  )
+  .argument(
+    "<query>",
+    'PPT generation prompt (e.g. "Felo, 2 pages" or "Introduction to React")'
+  )
+  .option("-j, --json", "output raw JSON with task_id and live_doc_url")
+  .option("-v, --verbose", "show polling status")
+  .option(
+    "-t, --timeout <seconds>",
+    "request timeout in seconds for each API call",
+    "60"
+  )
+  .option(
+    "--poll-timeout <seconds>",
+    "max seconds to wait for task completion",
+    "1200"
+  )
   .action(async (query, opts) => {
     const timeoutMs = parseInt(opts.timeout, 10) * 1000;
     const pollTimeoutMs = parseInt(opts.pollTimeout, 10) * 1000 || 1_200_000;
@@ -81,97 +96,156 @@ program
   });
 
 const configCmd = program
-  .command('config')
-  .description('Manage persisted config (e.g. FELO_API_KEY). Stored in ~/.felo/config.json');
+  .command("config")
+  .description(
+    "Manage persisted config (e.g. FELO_API_KEY). Stored in ~/.felo/config.json"
+  );
 
 configCmd
-  .command('set <key> <value>')
-  .description('Set a config value (e.g. felo config set FELO_API_KEY your-key)')
+  .command("set <key> <value>")
+  .description(
+    "Set a config value (e.g. felo config set FELO_API_KEY your-key)"
+  )
   .action(async (key, value) => {
     try {
       await config.setConfig(key, value);
       console.log(`Set ${key}`);
       flushStdioThenExit(0);
     } catch (e) {
-      console.error('Error:', e.message);
+      console.error("Error:", e.message);
       flushStdioThenExit(1);
     }
   });
 
 configCmd
-  .command('get <key>')
-  .description('Get a config value (sensitive keys are masked)')
+  .command("get <key>")
+  .description("Get a config value (sensitive keys are masked)")
   .action(async (key) => {
     try {
       const value = await config.getConfigValue(key);
       if (value === undefined || value === null) {
-        console.log('(not set)');
+        console.log("(not set)");
       } else {
         console.log(config.maskValueForDisplay(key, value));
       }
       flushStdioThenExit(0);
     } catch (e) {
-      console.error('Error:', e.message);
+      console.error("Error:", e.message);
       flushStdioThenExit(1);
     }
   });
 
 configCmd
-  .command('list')
-  .description('List all config keys (values are hidden)')
+  .command("list")
+  .description("List all config keys (values are hidden)")
   .action(async () => {
     try {
       const c = await config.listConfig();
       const keys = Object.keys(c);
       if (keys.length === 0) {
-        console.log('No config set. Use: felo config set FELO_API_KEY <key>');
+        console.log("No config set. Use: felo config set FELO_API_KEY <key>");
       } else {
         keys.forEach((k) => console.log(k));
       }
       flushStdioThenExit(0);
     } catch (e) {
-      console.error('Error:', e.message);
+      console.error("Error:", e.message);
       flushStdioThenExit(1);
     }
   });
 
 configCmd
-  .command('unset <key>')
-  .description('Remove a config value')
+  .command("unset <key>")
+  .description("Remove a config value")
   .action(async (key) => {
     try {
       await config.unsetConfig(key);
       console.log(`Unset ${key}`);
       flushStdioThenExit(0);
     } catch (e) {
-      console.error('Error:', e.message);
+      console.error("Error:", e.message);
       flushStdioThenExit(1);
     }
   });
 
 configCmd
-  .command('path')
-  .description('Show config file path')
+  .command("path")
+  .description("Show config file path")
   .action(() => {
     console.log(config.getConfigPath());
     flushStdioThenExit(0);
   });
 
 program
-  .command('summarize')
-  .description('Summarize text or URL (coming when API is available)')
-  .argument('[input]', 'text or URL to summarize')
+  .command("web-fetch")
+  .description("Fetch webpage content from a URL (markdown, text, or html)")
+  .requiredOption("-u, --url <url>", "page URL to fetch")
+  .option(
+    "-f, --format <format>",
+    "output format: html, text, markdown",
+    "markdown"
+  )
+  .option(
+    "--target-selector <selector>",
+    "CSS selector for target element only"
+  )
+  .option(
+    "--wait-for-selector <selector>",
+    "wait for selector before fetching"
+  )
+  .option("--readability", "use readability (main content only)")
+  .option("--crawl-mode <mode>", "crawl mode: fast or fine", "fast")
+  .option("-t, --timeout <seconds>", "request timeout in seconds", "60")
+  .option("-j, --json", "output full API response as JSON")
+  .action(async (opts) => {
+    const timeoutMs = parseInt(opts.timeout, 10) * 1000;
+    const code = await webFetch({
+      url: opts.url,
+      format: opts.format,
+      targetSelector: opts.targetSelector,
+      waitForSelector: opts.waitForSelector,
+      readability: opts.readability,
+      crawlMode: opts.crawlMode,
+      timeoutMs: Number.isNaN(timeoutMs) ? 60000 : timeoutMs,
+      json: opts.json,
+    });
+    process.exitCode = code;
+    flushStdioThenExit(code);
+  });
+
+program
+  .command("youtube-subtitling")
+  .description("Fetch YouTube video subtitles/captions by video URL or ID")
+  .requiredOption("-v, --video-code <url-or-id>", "YouTube video URL or video ID (e.g. https://youtube.com/watch?v=ID)")
+  .option("-l, --language <code>", "Subtitle language (e.g. en, zh-CN)")
+  .option("--with-time", "Include start/duration per segment")
+  .option("-j, --json", "Output full API response as JSON")
+  .action(async (opts) => {
+    const code = await youtubeSubtitling({
+      videoCode: opts.videoCode,
+      language: opts.language,
+      withTime: opts.withTime,
+      json: opts.json,
+    });
+    process.exitCode = code;
+    flushStdioThenExit(code);
+  });
+
+program
+  .command("summarize")
+  .description("Summarize text or URL (coming when API is available)")
+  .argument("[input]", "text or URL to summarize")
   .action(() => {
-    console.error('summarize: not yet implemented. Use felo search for now.');
+    console.error("summarize: not yet implemented. Use felo search for now.");
     flushStdioThenExit(1);
   });
 
 program
-  .command('translate')
-  .description('Translate text (coming when API is available)')
-  .argument('[text]', 'text to translate')
+  .command("translate")
+  .description("Translate text (coming when API is available)")
+  .argument("[text]", "text to translate")
   .action(() => {
-    console.error('translate: not yet implemented. Use felo search for now.');
+    console.error("translate: not yet implemented. Use felo search for now.");
     flushStdioThenExit(1);
   });
 

package/src/webFetch.js

@@ -0,0 +1,148 @@
+import { getApiKey, NO_KEY_MESSAGE } from './search.js';
+import * as config from './config.js';
+
+const DEFAULT_API_BASE = 'https://openapi.felo.ai';
+const DEFAULT_TIMEOUT_MS = 60_000;
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPINNER_INTERVAL_MS = 80;
+const STATUS_PAD = 56;
+
+function startSpinner(message) {
+  const start = Date.now();
+  let i = 0;
+  const id = setInterval(() => {
+    const elapsed = Math.floor((Date.now() - start) / 1000);
+    const line = `${message} ${SPINNER_FRAMES[i % SPINNER_FRAMES.length]} ${elapsed}s`;
+    process.stderr.write(`\r${line.padEnd(STATUS_PAD, ' ')}`);
+    i += 1;
+  }, SPINNER_INTERVAL_MS);
+  return id;
+}
+
+function stopSpinner(id) {
+  if (id != null) clearInterval(id);
+  process.stderr.write(`\r${' '.repeat(STATUS_PAD)}\r`);
+}
+
+async function getApiBase() {
+  let base = process.env.FELO_API_BASE?.trim();
+  if (!base) {
+    const v = await config.getConfigValue('FELO_API_BASE');
+    base = typeof v === 'string' ? v.trim() : '';
+  }
+  return (base || DEFAULT_API_BASE).replace(/\/$/, '');
+}
+
+function getMessage(payload) {
+  return payload?.message || payload?.error || payload?.msg || payload?.code || 'Unknown error';
+}
+
+function stringifyContent(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  if (typeof content === 'object') {
+    if (content.markdown) return content.markdown;
+    if (content.text) return content.text;
+    if (content.html) return content.html;
+    return JSON.stringify(content, null, 2);
+  }
+  return String(content);
+}
+
+async function fetchContent(apiBase, apiKey, body, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${apiBase}/v2/web/extract`, {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    let data = {};
+    try {
+      data = await res.json();
+    } catch {
+      data = {};
+    }
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${getMessage(data)}`);
+    const code = data.code;
+    const hasData = data?.data != null;
+    const successCodes = [0, 200];
+    const ok =
+      successCodes.includes(Number(code)) ||
+      code === undefined ||
+      code === null ||
+      (hasData && res.ok);
+    if (!ok) throw new Error(getMessage(data));
+    return data;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Run web fetch and print result. Returns exit code (0 or 1).
+ * @param {Object} opts - { url, format, targetSelector, waitForSelector, readability, timeoutMs, json }
+ */
+export async function webFetch(opts) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    console.error(NO_KEY_MESSAGE.trim());
+    return 1;
+  }
+  if (!opts?.url || typeof opts.url !== 'string' || !opts.url.trim()) {
+    process.stderr.write('ERROR: URL is required and must be a non-empty string.\n');
+    return 1;
+  }
+
+  const apiBase = await getApiBase();
+  const timeoutMs = Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0
+    ? opts.timeoutMs
+    : DEFAULT_TIMEOUT_MS;
+
+  const shortUrl = opts.url.length > 45 ? opts.url.slice(0, 42) + '...' : opts.url;
+  const spinnerId = startSpinner(`Fetching ${shortUrl}`);
+
+  const body = {
+    url: opts.url,
+    output_format: opts.format || 'markdown',
+    crawl_mode: opts.crawlMode || 'fast',
+    with_readability: Boolean(opts.readability),
+    timeout: timeoutMs,
+  };
+  if (opts.targetSelector) body.target_selector = opts.targetSelector;
+  if (opts.waitForSelector) body.wait_for_selector = opts.waitForSelector;
+
+  try {
+    const payload = await fetchContent(apiBase, apiKey, body, timeoutMs);
+    const content = payload?.data?.content;
+
+    if (opts.json) {
+      console.log(JSON.stringify(payload, null, 2));
+      return 0;
+    }
+
+    const out = stringifyContent(content);
+    const isEmpty = out == null || String(out).trim() === '';
+    if (isEmpty) {
+      process.stderr.write(
+        `No content fetched from ${opts.url}. The page may be empty, blocked, or the selector did not match.\n`
+      );
+      return 1;
+    }
+    console.log(out);
+    return 0;
+  } catch (err) {
+    process.stderr.write(
+      `Web fetch failed for ${opts.url}: ${err?.message || err}\n`
+    );
+    return 1;
+  } finally {
+    stopSpinner(spinnerId);
+  }
+}

package/src/youtubeSubtitling.js

@@ -0,0 +1,179 @@
+import { getApiKey, NO_KEY_MESSAGE } from './search.js';
+import * as config from './config.js';
+
+const DEFAULT_API_BASE = 'https://openapi.felo.ai';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPINNER_INTERVAL_MS = 80;
+const STATUS_PAD = 52;
+
+function startSpinner(message) {
+  const start = Date.now();
+  let i = 0;
+  const id = setInterval(() => {
+    const elapsed = Math.floor((Date.now() - start) / 1000);
+    const line = `${message} ${SPINNER_FRAMES[i % SPINNER_FRAMES.length]} ${elapsed}s`;
+    process.stderr.write(`\r${line.padEnd(STATUS_PAD, ' ')}`);
+    i += 1;
+  }, SPINNER_INTERVAL_MS);
+  return id;
+}
+
+function stopSpinner(id) {
+  if (id != null) clearInterval(id);
+  process.stderr.write(`\r${' '.repeat(STATUS_PAD)}\r`);
+}
+
+/** Extract video ID from a YouTube URL or return the string if it looks like a plain ID. Returns null if invalid. */
+function extractVideoId(urlOrId) {
+  const s = typeof urlOrId === 'string' ? urlOrId.trim() : '';
+  if (!s) return null;
+  try {
+    if (s.startsWith('http://') || s.startsWith('https://')) {
+      const u = new URL(s);
+      if (u.hostname === 'youtu.be') return u.pathname.slice(1).split('?')[0] || null;
+      if (u.hostname === 'www.youtube.com' || u.hostname === 'youtube.com') {
+        if (u.pathname === '/watch') return u.searchParams.get('v');
+        const m = u.pathname.match(/^\/(?:embed|v)\/([a-zA-Z0-9_-]{10,12})/);
+        if (m) return m[1];
+        return u.searchParams.get('v');
+      }
+    }
+    if (/^[a-zA-Z0-9_-]{10,12}$/.test(s)) return s;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function getApiBase() {
+  let base = process.env.FELO_API_BASE?.trim();
+  if (!base) {
+    const v = await config.getConfigValue('FELO_API_BASE');
+    base = typeof v === 'string' ? v.trim() : '';
+  }
+  return (base || DEFAULT_API_BASE).replace(/\/$/, '');
+}
+
+function getMessage(payload) {
+  return payload?.message || payload?.error || payload?.msg || payload?.code || 'Unknown error';
+}
+
+function formatContents(contents, withTime) {
+  if (!Array.isArray(contents) || contents.length === 0) return '';
+  return contents
+    .map((c) => {
+      if (withTime && (c.start != null || c.duration != null)) {
+        const start = Number(c.start);
+        const dur = Number(c.duration);
+        const startSec = Number.isFinite(start) ? start : 0;
+        const durSec = Number.isFinite(dur) ? dur : 0;
+        return `[${startSec.toFixed(2)}s, +${durSec.toFixed(2)}s] ${c.text ?? ''}`;
+      }
+      return c.text ?? '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+async function fetchSubtitling(apiBase, apiKey, params, timeoutMs) {
+  const url = `${apiBase}/v2/youtube/subtitling?${params.toString()}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+      },
+      signal: controller.signal,
+    });
+    let data = {};
+    try {
+      data = await res.json();
+    } catch {
+      data = {};
+    }
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${getMessage(data)}`);
+    const code = data.code;
+    const hasData = data?.data != null;
+    const successCodes = [0, 200];
+    const ok =
+      successCodes.includes(Number(code)) ||
+      code === undefined ||
+      code === null ||
+      (hasData && res.ok);
+    if (!ok) throw new Error(getMessage(data));
+    return data;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Run YouTube subtitling and print result. Returns exit code (0 or 1).
+ * @param {Object} opts - { videoCode, language, withTime, json }
+ */
+export async function youtubeSubtitling(opts) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    console.error(NO_KEY_MESSAGE.trim());
+    return 1;
+  }
+  const raw = opts?.videoCode != null ? String(opts.videoCode).trim() : '';
+  if (!raw) {
+    process.stderr.write('ERROR: YouTube video URL or video ID is required.\n');
+    return 1;
+  }
+  const videoCode = extractVideoId(raw);
+  if (!videoCode) {
+    process.stderr.write('ERROR: Invalid YouTube URL or video ID. Use a link (e.g. https://youtube.com/watch?v=ID) or an 11-character video ID.\n');
+    return 1;
+  }
+
+  const apiBase = await getApiBase();
+  const timeoutMs =
+    Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0 ? opts.timeoutMs : DEFAULT_TIMEOUT_MS;
+
+  const spinnerId = startSpinner(`Fetching subtitles ${videoCode}`);
+
+  const params = new URLSearchParams({ video_code: videoCode });
+  if (opts.language && String(opts.language).trim()) params.set('language', String(opts.language).trim());
+  if (opts.withTime) params.set('with_time', 'true');
+
+  try {
+    const payload = await fetchSubtitling(apiBase, apiKey, params, timeoutMs);
+    const data = payload?.data ?? {};
+    const title = data?.title ?? '';
+    const contents = data?.contents ?? [];
+
+    if (opts.json) {
+      console.log(JSON.stringify(payload, null, 2));
+      return 0;
+    }
+
+    const text = formatContents(contents, opts.withTime);
+    const isEmpty = !text || text.trim() === '';
+
+    if (isEmpty) {
+      process.stderr.write(
+        `No subtitles found for video ${videoCode}. The video may have no captions or the language is not available.\n`
+      );
+      return 1;
+    }
+
+    if (title) {
+      console.log(`# ${title}\n`);
+    }
+    console.log(text);
+    return 0;
+  } catch (err) {
+    process.stderr.write(
+      `YouTube subtitling failed for ${videoCode}: ${err?.message || err}\n`
+    );
+    return 1;
+  } finally {
+    stopSpinner(spinnerId);
+  }
+}