@eightstate/escli 0.5.0

package/dist/services/social.js

@@ -0,0 +1,224 @@
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { buildUsageError } from '../lib/envelope.js';
+import { EscliError } from '../lib/escli-error.js';
+import { callWithRetry } from './credentials.js';
+const TAVILY_API = 'https://api.tavily.com';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const VALID_TIME_RANGES = ['day', 'week', 'month', 'year'];
+const VALID_DEPTHS = ['basic', 'advanced', 'fast', 'ultra-fast'];
+const PLATFORM_DOMAINS = {
+    reddit: ['reddit.com'],
+    x: ['x.com', 'twitter.com'],
+    twitter: ['x.com', 'twitter.com'],
+    tiktok: ['tiktok.com'],
+    linkedin: ['linkedin.com'],
+    instagram: ['instagram.com'],
+    facebook: ['facebook.com'],
+    youtube: ['youtube.com'],
+    combined: ['reddit.com', 'x.com', 'twitter.com', 'tiktok.com', 'linkedin.com', 'instagram.com', 'facebook.com'],
+};
+export function validTimeRanges() {
+    return VALID_TIME_RANGES;
+}
+export function validDepths() {
+    return VALID_DEPTHS;
+}
+export function validPlatforms() {
+    return Object.keys(PLATFORM_DOMAINS);
+}
+export async function searchSocial(options) {
+    const query = options.query.trim();
+    if (!query)
+        throw buildUsageError('search query required', ErrorCode.UsageRequired);
+    const domains = resolveDomains(options.platform);
+    const payload = await socialPayload(options, query, domains);
+    const data = recordValue(payload) ?? {};
+    const results = normalizeResults(data.results, Boolean(options.raw));
+    return {
+        answer: typeof data.answer === 'string' ? data.answer : null,
+        results,
+        platform: options.platform ?? 'combined',
+        query,
+        result_count: results.length,
+        credits: numberOrNull(recordValue(data.usage)?.credits),
+    };
+}
+function resolveDomains(platform) {
+    if (!platform)
+        return [...PLATFORM_DOMAINS.combined];
+    const domains = [];
+    for (const rawPlatform of platform.toLowerCase().split(',')) {
+        const name = rawPlatform.trim();
+        if (!isPlatform(name)) {
+            throw buildUsageError(`unknown platform: ${name}`, ErrorCode.UsageInvalid, { valid: validPlatforms() });
+        }
+        domains.push(...PLATFORM_DOMAINS[name]);
+    }
+    return [...new Set(domains)];
+}
+function isPlatform(value) {
+    return Object.hasOwn(PLATFORM_DOMAINS, value);
+}
+async function socialPayload(options, query, domains) {
+    const request = buildRequestBody(options, query, domains);
+    const explicitKey = process.env.TAVILY_API_KEY;
+    if (explicitKey)
+        return requestTavily(request, { apiKey: explicitKey, fingerprint: 'env' }, options.timeoutSeconds);
+    const response = await callWithRetry('tavily', (key) => requestTavily(request, key, options.timeoutSeconds));
+    if (response !== null)
+        return response;
+    throw new EscliError('no Tavily API key', {
+        code: ErrorCode.AuthRequired,
+        exitCode: ExitCodes.Auth,
+        remediation: { hint: 'Set TAVILY_API_KEY or authenticate with escli auth login.' },
+    });
+}
+function buildRequestBody(options, query, domains) {
+    const body = {
+        query,
+        include_domains: domains,
+        max_results: options.maxResults ?? 10,
+        search_depth: options.depth ?? 'advanced',
+        include_answer: Boolean(options.answer),
+        include_raw_content: Boolean(options.raw),
+        include_images: Boolean(options.images),
+        include_usage: true,
+    };
+    if (options.time)
+        body.time_range = options.time;
+    if (options.country)
+        body.country = options.country;
+    return body;
+}
+async function requestTavily(body, key, timeoutSeconds) {
+    const responseText = await requestText(`${tavilyBaseUrl()}/search`, {
+        method: 'POST',
+        headers: { 'authorization': `Bearer ${key.apiKey}`, 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+        timeoutMs: timeoutMs(timeoutSeconds),
+    });
+    return parseJsonResponse(responseText);
+}
+async function requestText(url, options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method: options.method,
+            headers: options.headers,
+            body: options.body,
+            redirect: 'follow',
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        if (!response.ok)
+            throw httpStatusError(response.status, formatHttpError(response.status, text), text);
+        return text;
+    }
+    catch (error) {
+        if (isHttpStatusError(error))
+            throw mapHttpStatusError(error);
+        if (error instanceof EscliError)
+            throw error;
+        throw mapNetworkError(error);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function parseJsonResponse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new EscliError(`invalid JSON response: ${error instanceof Error ? error.message : String(error)}`, {
+            code: ErrorCode.GateInvalidResponse,
+            exitCode: ExitCodes.Error,
+            details: text,
+        });
+    }
+}
+function normalizeResults(results, includeRawContent) {
+    if (!Array.isArray(results))
+        return [];
+    return results
+        .map((item) => recordValue(item))
+        .filter((item) => Boolean(item))
+        .map((item) => ({
+        title: String(item.title ?? ''),
+        url: String(item.url ?? ''),
+        content: String(item.content ?? ''),
+        score: numberOrNull(item.score),
+        raw_content: includeRawContent ? stringOrNull(item.raw_content) : null,
+    }));
+}
+function tavilyBaseUrl() {
+    if ((typeof __ESCLI_TEST__ === 'undefined' || __ESCLI_TEST__) && process.env.ESCLI_TEST_TAVILY_URL)
+        return process.env.ESCLI_TEST_TAVILY_URL;
+    return TAVILY_API;
+}
+function timeoutMs(timeoutSeconds) {
+    const seconds = timeoutSeconds ?? DEFAULT_TIMEOUT_MS / 1000;
+    return Math.max(1, seconds) * 1000;
+}
+function httpStatusError(status, message, details) {
+    const error = new Error(message);
+    error.status = status;
+    error.details = details;
+    return error;
+}
+function isHttpStatusError(error) {
+    return error instanceof Error && typeof error.status === 'number';
+}
+function mapHttpStatusError(error) {
+    const status = error.status;
+    if (status === 401)
+        return new EscliError(error.message, { code: ErrorCode.ApiUnauthorized, details: error.details });
+    if (status === 403)
+        return new EscliError(error.message, { code: ErrorCode.ApiForbidden, details: error.details });
+    if (status === 404)
+        return new EscliError(error.message, { code: ErrorCode.ApiError, exitCode: ExitCodes.NotFound, details: error.details });
+    if (status === 429)
+        return new EscliError(error.message, { code: ErrorCode.ApiRateLimited, details: error.details });
+    if (status >= 500)
+        return new EscliError(error.message, { code: ErrorCode.ServiceUnavailable, details: error.details });
+    return new EscliError(error.message, { code: ErrorCode.SocialFailed, details: error.details });
+}
+function mapNetworkError(error) {
+    const isAbort = error instanceof Error && error.name === 'AbortError';
+    return new EscliError(isAbort ? 'network error: request timed out' : `network error: ${error instanceof Error ? error.message : String(error)}`, {
+        code: isAbort ? ErrorCode.NetworkTimeout : ErrorCode.NetworkError,
+        details: error instanceof Error ? error.message : error,
+    });
+}
+function formatHttpError(status, body) {
+    const parsed = parseMaybeJson(body);
+    const extracted = extractErrorMessage(parsed) ?? (typeof parsed === 'string' ? parsed : undefined);
+    return extracted ? `API error (${status}): ${extracted}` : `API error (${status})`;
+}
+function parseMaybeJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function extractErrorMessage(body) {
+    const root = recordValue(body);
+    return stringValue(root?.error) ?? stringValue(root?.message) ?? stringValue(recordValue(root?.error)?.message) ?? stringValue(recordValue(root?.detail)?.error);
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function stringOrNull(value) {
+    return typeof value === 'string' ? value : null;
+}
+function numberOrNull(value) {
+    return typeof value === 'number' ? value : null;
+}
+//# sourceMappingURL=social.js.map

package/dist/services/usage.js

@@ -0,0 +1,165 @@
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { EscliError } from '../lib/escli-error.js';
+import { resolveCliToken } from './credentials.js';
+const DEFAULT_GATE_URL = 'https://internal.eightstate.co';
+const DEFAULT_TIMEOUT_MS = 30_000;
+export async function fetchUsage(options) {
+    const token = resolveCliToken();
+    if (!token) {
+        throw new EscliError('not authenticated', {
+            code: ErrorCode.AuthRequired,
+            exitCode: ExitCodes.Auth,
+            remediation: { command: 'escli auth login' },
+        });
+    }
+    const days = normalizeDays(options.days);
+    const service = options.service;
+    const mode = usageMode(options);
+    const request = buildUsageRequest(mode, days, service);
+    const data = await requestUsage(request.path, request.query, token, (options.timeoutSeconds ?? 30) * 1000);
+    if (mode === 'pricing')
+        return data;
+    if (mode === 'daily' || mode === 'service') {
+        return {
+            days,
+            service: service ?? null,
+            start: request.query.start,
+            end: request.query.end,
+            ...data,
+        };
+    }
+    return {
+        days,
+        start: request.query.start,
+        end: request.query.end,
+        ...data,
+    };
+}
+export function normalizeDays(value) {
+    return Math.max(1, Math.trunc(value || 30));
+}
+function usageMode(options) {
+    if (options.pricing)
+        return 'pricing';
+    if (options.daily)
+        return 'daily';
+    if (options.service)
+        return 'service';
+    return 'summary';
+}
+function buildUsageRequest(mode, days, service) {
+    if (mode === 'pricing')
+        return { path: '/api/analytics/pricing', query: {} };
+    const [start, end] = dateRange(days);
+    const query = { start, end };
+    if (service)
+        query.service = service;
+    if (mode === 'daily')
+        return { path: '/api/analytics/by-day', query };
+    if (mode === 'service')
+        return { path: '/api/analytics/by-service', query };
+    return { path: '/api/analytics/summary', query };
+}
+function dateRange(days) {
+    const end = new Date();
+    const start = new Date(end.getTime() - days * 24 * 60 * 60 * 1000);
+    return [start.toISOString(), end.toISOString()];
+}
+async function requestUsage(path, query, token, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs || DEFAULT_TIMEOUT_MS);
+    try {
+        const url = new URL(path, gateUrl());
+        for (const [key, value] of Object.entries(query))
+            url.searchParams.set(key, value);
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: { 'authorization': `Bearer ${token}`, 'accept': 'application/json' },
+            signal: controller.signal,
+        });
+        const body = await parseUsageBody(response);
+        if (!response.ok)
+            throw mapHttpError(response.status, body);
+        const record = recordValue(body);
+        if (!record) {
+            throw new EscliError('invalid JSON response: response was not an object', { code: ErrorCode.GateInvalidResponse, details: body });
+        }
+        return record;
+    }
+    catch (error) {
+        if (error instanceof EscliError)
+            throw error;
+        throw mapNetworkError(error);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function parseUsageBody(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new EscliError(`invalid JSON response: ${error instanceof Error ? error.message : String(error)}`, {
+            code: ErrorCode.GateInvalidResponse,
+            details: text,
+        });
+    }
+}
+function mapHttpError(status, body) {
+    if (status === 401) {
+        return new EscliError('auth failed (401) — re-run: escli auth login', {
+            code: ErrorCode.AuthInvalid,
+            exitCode: ExitCodes.Auth,
+            details: body,
+            remediation: { command: 'escli auth login' },
+        });
+    }
+    if (status === 403) {
+        return new EscliError('forbidden (403)', { code: ErrorCode.AuthForbidden, exitCode: ExitCodes.Auth, details: body });
+    }
+    const message = `API error (${status}): ${extractErrorMessage(body) ?? stringifyBody(body)}`;
+    if (status === 404)
+        return new EscliError(message, { code: ErrorCode.UsageFetchFailed, exitCode: ExitCodes.NotFound, details: body });
+    if (status === 429)
+        return new EscliError(message, { code: ErrorCode.ApiRateLimited, exitCode: ExitCodes.Transient, details: body });
+    if (status >= 500)
+        return new EscliError(message, { code: ErrorCode.ServiceUnavailable, exitCode: ExitCodes.Transient, details: body });
+    return new EscliError(message, { code: ErrorCode.ApiError, details: body });
+}
+function mapNetworkError(error) {
+    const isAbort = error instanceof Error && error.name === 'AbortError';
+    return new EscliError(isAbort ? 'network error: request timed out' : `network error: ${error instanceof Error ? error.message : String(error)}`, {
+        code: isAbort ? ErrorCode.NetworkTimeout : ErrorCode.NetworkError,
+        exitCode: ExitCodes.Transient,
+        details: error instanceof Error ? error.message : error,
+    });
+}
+function extractErrorMessage(body) {
+    const root = recordValue(body);
+    return stringValue(root?.error) ?? stringValue(root?.message) ?? stringValue(recordValue(root?.error)?.message);
+}
+function stringifyBody(body) {
+    if (typeof body === 'string')
+        return body;
+    try {
+        return JSON.stringify(body);
+    }
+    catch {
+        return String(body);
+    }
+}
+function gateUrl() {
+    return process.env.ESCLI_GATE_URL ?? DEFAULT_GATE_URL;
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+//# sourceMappingURL=usage.js.map