felo-ai 0.2.0

package/src/slides.js

@@ -0,0 +1,228 @@
+import { getApiKey, fetchWithTimeoutAndRetry, NO_KEY_MESSAGE } from './search.js';
+
+const DEFAULT_API_BASE = 'https://openapi.felo.ai';
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+const POLL_INTERVAL_MS = 3000;
+const MAX_POLL_TIMEOUT_MS = 600_000; // 10 minutes max wait
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const STATUS_LINE_PAD = 50;
+
+/** API base URL (default https://openapi.felo.ai). Override via FELO_API_BASE env or config if needed. */
+async function getApiBase() {
+  let base = process.env.FELO_API_BASE?.trim();
+  if (!base) {
+    const { getConfigValue } = await import('./config.js');
+    const v = await getConfigValue('FELO_API_BASE');
+    base = typeof v === 'string' ? v.trim() : '';
+  }
+  const normalized = (base || DEFAULT_API_BASE).replace(/\/$/, '');
+  return normalized;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** Write a single overwritable status line: spinner + elapsed. Call clearStatusLine() before next stdout. */
+function writeStatusLine(spinnerFrame, elapsedSec) {
+  const s = `Generating slides... ${spinnerFrame} ${elapsedSec}s`;
+  const padded = s.padEnd(STATUS_LINE_PAD, ' ');
+  process.stderr.write(`\r${padded}`);
+}
+
+function clearStatusLine() {
+  process.stderr.write(`\r${' '.repeat(STATUS_LINE_PAD)}\r`);
+}
+
+/**
+ * Create a PPT task. Returns { task_id, livedoc_short_id, ppt_business_id } or throws.
+ * Uses fetchWithTimeoutAndRetry for 5xx retry (per PPT Task API error codes).
+ */
+async function createPptTask(apiKey, query, timeoutMs, apiBase) {
+  const url = `${apiBase}/v2/ppts`;
+  const res = await fetchWithTimeoutAndRetry(
+    url,
+    {
+      method: 'POST',
+      headers: {
+        'Accept': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ query: query.trim() }),
+    },
+    timeoutMs
+  );
+
+  const data = await res.json().catch(() => ({}));
+
+  if (data.status === 'error') {
+    const msg = data.message || data.code || 'Unknown error';
+    throw new Error(msg);
+  }
+
+  if (!res.ok) {
+    const msg = data.message || data.error || res.statusText || `HTTP ${res.status}`;
+    throw new Error(msg);
+  }
+
+  const payload = data.data;
+  if (!payload || !payload.task_id) {
+    throw new Error('Unexpected response: missing task_id');
+  }
+
+  return payload;
+}
+
+/**
+ * Get task historical info. Returns { task_status, live_doc_url? } or throws.
+ * Uses fetchWithTimeoutAndRetry for 5xx retry (per PPT Task API error codes).
+ */
+async function getTaskHistorical(apiKey, taskId, timeoutMs, apiBase) {
+  const url = `${apiBase}/v2/tasks/${encodeURIComponent(taskId)}/historical`;
+  const res = await fetchWithTimeoutAndRetry(
+    url,
+    {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    },
+    timeoutMs
+  );
+
+  const data = await res.json().catch(() => ({}));
+
+  if (data.status === 'error') {
+    const msg = data.message || data.code || 'Unknown error';
+    throw new Error(msg);
+  }
+
+  if (!res.ok) {
+    const msg = data.message || data.error || res.statusText || `HTTP ${res.status}`;
+    throw new Error(msg);
+  }
+
+  const payload = data.data;
+  if (!payload) {
+    throw new Error('Unexpected response: missing data');
+  }
+
+  return {
+    task_status: payload.task_status,
+    live_doc_url: payload.live_doc_url,
+  };
+}
+
+/**
+ * Run slides: create PPT task, poll until terminal state, output URL or error.
+ * @returns {Promise<number>} exit code (0 success, 1 failure)
+ */
+export async function slides(query, options = {}) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    console.error(NO_KEY_MESSAGE.trim());
+    return 1;
+  }
+
+  const requestTimeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const pollTimeoutMs = options.pollTimeoutMs ?? MAX_POLL_TIMEOUT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
+
+  try {
+    const apiBase = await getApiBase();
+
+    process.stderr.write('Creating PPT task...\n');
+
+    const createResult = await createPptTask(apiKey, query, requestTimeoutMs, apiBase);
+    const taskId = createResult.task_id;
+
+    if (options.json && options.verbose) {
+      process.stderr.write(`Task ID: ${taskId}\n`);
+    }
+
+    const useLiveStatus =
+      process.stderr.isTTY && !options.verbose && !options.json;
+    if (!useLiveStatus) {
+      process.stderr.write('Generating slides (this may take a minute)...\n');
+    }
+
+    const startTime = Date.now();
+    let lastStatus;
+    let spinIndex = 0;
+    if (useLiveStatus) writeStatusLine(SPINNER_FRAMES[0], 0);
+
+    while (Date.now() - startTime < pollTimeoutMs) {
+      await sleep(pollIntervalMs);
+
+      const historical = await getTaskHistorical(apiKey, taskId, requestTimeoutMs, apiBase);
+      lastStatus = historical.task_status;
+
+      if (useLiveStatus) {
+        const elapsed = Math.floor((Date.now() - startTime) / 1000);
+        spinIndex = (spinIndex + 1) % SPINNER_FRAMES.length;
+        writeStatusLine(SPINNER_FRAMES[spinIndex], elapsed);
+      }
+
+      // Doc: historical returns task_status "COMPLETED"; polling section also mentions "SUCCESS"
+      const done = historical.task_status === 'COMPLETED' || historical.task_status === 'SUCCESS';
+      if (done) {
+        if (useLiveStatus) clearStatusLine();
+        const url = historical.live_doc_url;
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                status: 'ok',
+                data: {
+                  task_id: taskId,
+                  task_status: historical.task_status,
+                  live_doc_url: url,
+                  livedoc_short_id: createResult.livedoc_short_id,
+                  ppt_business_id: createResult.ppt_business_id,
+                },
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          if (url) {
+            console.log(url);
+          } else {
+            if (useLiveStatus) clearStatusLine();
+            console.error('Error: Completed but no live_doc_url in response');
+            return 1;
+          }
+        }
+        return 0;
+      }
+
+      if (
+        historical.task_status === 'FAILED' ||
+        historical.task_status === 'ERROR' ||
+        (historical.task_status !== 'RUNNING' && historical.task_status !== 'PENDING')
+      ) {
+        if (useLiveStatus) clearStatusLine();
+        console.error(`Error: Task finished with status: ${historical.task_status}`);
+        return 1;
+      }
+
+      if (options.verbose) {
+        process.stderr.write(`  Status: ${historical.task_status}\n`);
+      }
+    }
+
+    if (useLiveStatus) clearStatusLine();
+    console.error(
+      `Error: Timed out after ${pollTimeoutMs / 1000}s. Last status: ${lastStatus ?? 'unknown'}`
+    );
+    return 1;
+  } catch (err) {
+    if (process.stderr.isTTY && !options.verbose && !options.json) clearStatusLine();
+    console.error('Error:', err.message || err);
+    return 1;
+  }
+}

package/tests/config.test.js

@@ -0,0 +1,78 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+const tmpDir = path.join(os.tmpdir(), `felo-test-${Date.now()}`);
+const testConfigFile = path.join(tmpDir, 'config.json');
+process.env.FELO_CONFIG_FILE = testConfigFile;
+
+import * as config from '../src/config.js';
+
+after(async () => {
+  delete process.env.FELO_CONFIG_FILE;
+  await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+});
+
+describe('config', () => {
+  it('getConfig returns {} when file does not exist', async () => {
+    const c = await config.getConfig();
+    assert.deepStrictEqual(c, {});
+  });
+
+  it('setConfig and getConfigValue', async () => {
+    await config.setConfig('FELO_API_KEY', 'fk-secret-123');
+    const v = await config.getConfigValue('FELO_API_KEY');
+    assert.strictEqual(v, 'fk-secret-123');
+  });
+
+  it('listConfig returns all keys', async () => {
+    await config.setConfig('OTHER', 'value');
+    const c = await config.listConfig();
+    assert.ok('FELO_API_KEY' in c);
+    assert.ok('OTHER' in c);
+  });
+
+  it('unsetConfig removes key', async () => {
+    await config.unsetConfig('OTHER');
+    const v = await config.getConfigValue('OTHER');
+    assert.strictEqual(v, undefined);
+  });
+
+  it('getConfigPath returns configured path', () => {
+    assert.strictEqual(config.getConfigPath(), testConfigFile);
+  });
+
+  it('getConfig returns {} and warns on invalid JSON', async () => {
+    await config.setConfig('X', '1');
+    await fs.writeFile(testConfigFile, 'not json {', 'utf-8');
+    let writeCalls = 0;
+    const orig = process.stderr.write;
+    process.stderr.write = () => { writeCalls++; };
+    const c = await config.getConfig();
+    process.stderr.write = orig;
+    assert.deepStrictEqual(c, {});
+    assert.ok(writeCalls >= 1);
+  });
+
+  describe('maskValueForDisplay', () => {
+    it('masks FELO_API_KEY when value long enough', () => {
+      const val = 'fk-abc123xyz789';
+      assert.strictEqual(config.maskValueForDisplay('FELO_API_KEY', val), 'fk-a...z789');
+    });
+
+    it('does not mask short value', () => {
+      assert.strictEqual(config.maskValueForDisplay('FELO_API_KEY', 'short'), 'short');
+    });
+
+    it('does not mask non-sensitive key', () => {
+      assert.strictEqual(config.maskValueForDisplay('LOG_LEVEL', 'debug'), 'debug');
+    });
+
+    it('returns value for undefined/null', () => {
+      assert.strictEqual(config.maskValueForDisplay('X', undefined), undefined);
+      assert.strictEqual(config.maskValueForDisplay('X', null), null);
+    });
+  });
+});

package/tests/search.test.js

@@ -0,0 +1,100 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import path from 'path';
+import os from 'os';
+import fs from 'fs/promises';
+
+const tmpDir = path.join(os.tmpdir(), `felo-test-search-${Date.now()}`);
+const testConfigFile = path.join(tmpDir, 'config.json');
+process.env.FELO_CONFIG_FILE = testConfigFile;
+
+import { getApiKey, fetchWithTimeoutAndRetry } from '../src/search.js';
+import * as config from '../src/config.js';
+
+after(async () => {
+  delete process.env.FELO_API_KEY;
+  delete process.env.FELO_CONFIG_FILE;
+  await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+});
+
+before(async () => {
+  await fs.mkdir(path.dirname(testConfigFile), { recursive: true });
+});
+
+describe('getApiKey', () => {
+  it('returns env FELO_API_KEY when set', async () => {
+    process.env.FELO_API_KEY = 'env-key';
+    const key = await getApiKey();
+    assert.strictEqual(key, 'env-key');
+  });
+
+  it('returns key from config when env not set', async () => {
+    delete process.env.FELO_API_KEY;
+    await config.setConfig('FELO_API_KEY', 'config-key');
+    const key = await getApiKey();
+    assert.strictEqual(key, 'config-key');
+  });
+
+  it('returns empty string when neither set', async () => {
+    delete process.env.FELO_API_KEY;
+    await config.unsetConfig('FELO_API_KEY');
+    const key = await getApiKey();
+    assert.strictEqual(key, '');
+  });
+
+  it('env wins over config', async () => {
+    process.env.FELO_API_KEY = 'env-wins';
+    await config.setConfig('FELO_API_KEY', 'config-key');
+    const key = await getApiKey();
+    assert.strictEqual(key, 'env-wins');
+  });
+});
+
+describe('fetchWithTimeoutAndRetry', () => {
+  it('returns response on 200', async () => {
+    const res = { ok: true, status: 200 };
+    let callCount = 0;
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = () => { callCount++; return Promise.resolve(res); };
+    try {
+      const out = await fetchWithTimeoutAndRetry('https://example.com', {}, 10_000);
+      assert.strictEqual(out, res);
+      assert.strictEqual(callCount, 1);
+    } finally {
+      globalThis.fetch = origFetch;
+    }
+  });
+
+  it('retries on 500 then succeeds', async () => {
+    const res200 = { ok: true, status: 200 };
+    const res500 = { ok: false, status: 502 };
+    let callCount = 0;
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = () => {
+      callCount++;
+      return Promise.resolve(callCount === 1 ? res500 : res200);
+    };
+    try {
+      const out = await fetchWithTimeoutAndRetry('https://example.com', {}, 10_000);
+      assert.strictEqual(out, res200);
+      assert.strictEqual(callCount, 2);
+    } finally {
+      globalThis.fetch = origFetch;
+    }
+  });
+
+  it('throws on timeout (AbortError)', async () => {
+    const origFetch = globalThis.fetch;
+    const abortErr = new Error('The operation was aborted');
+    abortErr.name = 'AbortError';
+    globalThis.fetch = () => Promise.reject(abortErr);
+    try {
+      await assert.rejects(
+        async () => fetchWithTimeoutAndRetry('https://example.com', {}, 5000),
+        (err) => err.message && err.message.includes('timed out')
+      );
+    } finally {
+      globalThis.fetch = origFetch;
+    }
+  });
+});