opencandle 0.5.0 → 0.7.0

package/src/providers/twitter.ts

@@ -1,41 +1,11 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import Database from "better-sqlite3";
-import { Scraper, SearchMode } from "@the-convocation/twitter-scraper";
-import { cache, TTL, STALE_LIMIT } from "../infra/cache.js";
+import { cache, STALE_LIMIT, TTL } from "../infra/cache.js";
 import { rateLimiter } from "../infra/rate-limiter.js";
-import { getBrowserProfileDir } from "../infra/opencandle-paths.js";
 import type { TwitterSentimentResult, TwitterTweet } from "../types/sentiment.js";
-
-// ── Cookie extraction ────────────────────────────────────
-
-interface FirefoxCookie {
-  name: string;
-  value: string;
-  domain: string;
-  path: string;
-}
-
-export function readTwitterCookies(profileDir: string): FirefoxCookie[] {
-  const dbPath = join(profileDir, "cookies.sqlite");
-  if (!existsSync(dbPath)) return [];
-
-  const db = new Database(dbPath, { readonly: true });
-  try {
-    const rows = db
-      .prepare(
-        `SELECT name, value, host AS domain, path FROM moz_cookies WHERE host LIKE ? OR host LIKE ?`,
-      )
-      .all("%x.com%", "%twitter.com%") as FirefoxCookie[];
-    return rows;
-  } finally {
-    db.close();
-  }
-}
+import { searchTweets } from "./twitter-cli.js";
 
 // ── Sentiment scoring ────────────────────────────────────
 
-import { BULLISH_TERMS, BEARISH_TERMS } from "../sentiment/keywords.js";
+import { BEARISH_TERMS, BULLISH_TERMS } from "../sentiment/keywords.js";
 
 export function scoreTwitterSentiment(
   tweets: Array<{ text: string; likes: number; retweets: number }>,
@@ -68,7 +38,7 @@ export function scoreTwitterSentiment(
 // ── Query normalization ──────────────────────────────────
 
 export function normalizeQuery(query: string): string {
-  if (/^[A-Z]{1,5}$/.test(query)) return "$" + query;
+  if (/^[A-Z]{1,5}$/.test(query)) return `$${query}`;
   return query;
 }
 
@@ -87,57 +57,16 @@ export async function getTwitterSentiment(
   await rateLimiter.acquire("twitter");
 
   try {
-    const profileDir = getBrowserProfileDir();
-    const cookies = readTwitterCookies(profileDir);
-
-    const authToken = cookies.find((c) => c.name === "auth_token");
-    const ct0 = cookies.find((c) => c.name === "ct0");
-
-    if (!authToken || !ct0) {
-      throw new Error("No Twitter session found.");
-    }
-
-    const scraper = new Scraper();
-    const cookieStrings = cookies.map(
-      (c) => `${c.name}=${c.value}; Domain=${c.domain}; Path=${c.path}`,
-    );
-    await scraper.setCookies(cookieStrings);
-
-    const loggedIn = await scraper.isLoggedIn();
-    if (!loggedIn) {
-      throw new Error("Twitter session expired.");
-    }
-
     const cutoff = new Date(Date.now() - hours * 3_600_000);
-    const tweets: TwitterTweet[] = [];
-    const results = scraper.searchTweets(normalizedQuery, limit, SearchMode.Latest);
-
-    for await (const tweet of results) {
-      const created = tweet.timeParsed ?? new Date(0);
-      if (created < cutoff) continue;
-
-      tweets.push({
-        id: tweet.id ?? "",
-        text: tweet.text?.slice(0, 280) ?? "",
-        author: tweet.username ?? "unknown",
-        likes: tweet.likes ?? 0,
-        retweets: tweet.retweets ?? 0,
-        replies: tweet.replies ?? 0,
-        views: tweet.views ?? null,
-        url: tweet.permanentUrl ?? "",
-        created: created.toISOString(),
-      });
-
-      if (tweets.length >= limit) break;
-    }
+    const tweets: TwitterTweet[] = (await searchTweets(normalizedQuery, limit))
+      .filter((tweet) => new Date(tweet.created) >= cutoff)
+      .slice(0, limit);
 
     // Extract co-mentioned cashtags
     const tickerRegex = /\$([A-Z]{1,5})\b/g;
     const mentionCounts = new Map<string, number>();
     // Exclude the searched ticker itself from co-mentions
-    const searchedTicker = normalizedQuery.startsWith("$")
-      ? normalizedQuery.slice(1)
-      : null;
+    const searchedTicker = normalizedQuery.startsWith("$") ? normalizedQuery.slice(1) : null;
     for (const t of tweets) {
       for (const match of t.text.matchAll(tickerRegex)) {
         const ticker = match[1];

package/src/providers/web-search.ts

@@ -1,15 +1,14 @@
-import { search, searchNews, SafeSearchType, SearchTimeType } from "duck-duck-scrape";
-import type { SearchResult } from "duck-duck-scrape";
-import type { NewsResult } from "duck-duck-scrape";
-import { httpGet, HttpError } from "../infra/http-client.js";
-import { cache, TTL, STALE_LIMIT } from "../infra/cache.js";
-import { rateLimiter } from "../infra/rate-limiter.js";
+import type { NewsResult, SearchResult } from "duck-duck-scrape";
+import { SafeSearchType, SearchTimeType, search, searchNews } from "duck-duck-scrape";
 import { getConfig } from "../config.js";
-import { withFallback } from "./with-fallback.js";
+import { cache, STALE_LIMIT, TTL } from "../infra/cache.js";
+import { HttpError, httpGet } from "../infra/http-client.js";
+import { rateLimiter } from "../infra/rate-limiter.js";
+import type { ProviderResult } from "../runtime/evidence.js";
+import type { WebSearchEnvelope, WebSearchResult } from "../types/sentiment.js";
 import { exaSearch } from "./exa-search.js";
 import { ProviderCredentialError } from "./provider-credential-error.js";
-import type { ProviderResult } from "../runtime/evidence.js";
-import type { WebSearchResult, WebSearchEnvelope } from "../types/sentiment.js";
+import { withFallback } from "./with-fallback.js";
 
 export interface WebSearchOpts {
   category: "news" | "general";
@@ -85,10 +84,7 @@ function ddgCacheKey(query: string, opts: WebSearchOpts): string {
   return `web:ddg:${query}:${opts.category}:${opts.freshness}:${opts.limit}`;
 }
 
-export async function ddgSearch(
-  query: string,
-  opts: WebSearchOpts,
-): Promise<WebSearchEnvelope> {
+export async function ddgSearch(query: string, opts: WebSearchOpts): Promise<WebSearchEnvelope> {
   const key = ddgCacheKey(query, opts);
   const cached = cache.get<WebSearchEnvelope>(key);
   if (cached) return cached;
@@ -139,10 +135,14 @@ const BRAVE_BASE = "https://api.search.brave.com/res/v1";
 
 function mapBraveFreshness(freshness: WebSearchOpts["freshness"]): string {
   switch (freshness) {
-    case "hours": return "ph";
-    case "day": return "pd";
-    case "week": return "pw";
-    case "month": return "pm";
+    case "hours":
+      return "ph";
+    case "day":
+      return "pd";
+    case "week":
+      return "pw";
+    case "month":
+      return "pm";
   }
 }
 
@@ -271,9 +271,16 @@ export async function searchWeb(
         break;
       case "brave":
         if (!config.braveApiKey) {
-          return { status: "unavailable", reason: "BRAVE_API_KEY not configured", provider: "brave_search" };
+          return {
+            status: "unavailable",
+            reason: "BRAVE_API_KEY not configured",
+            provider: "brave_search",
+          };
         }
-        entries.push({ provider: "brave_search", fn: () => braveSearch(normalized, resolved, config.braveApiKey!) });
+        entries.push({
+          provider: "brave_search",
+          fn: () => braveSearch(normalized, resolved, config.braveApiKey!),
+        });
         break;
       case "ddg":
         entries.push({ provider: "ddg", fn: () => ddgSearch(normalized, resolved) });
@@ -285,7 +292,10 @@ export async function searchWeb(
   // Default cascade: Exa → Brave → DDG
   entries.push({ provider: "exa", fn: () => exaSearch(normalized, resolved) });
   if (config.braveApiKey) {
-    entries.push({ provider: "brave_search", fn: () => braveSearch(normalized, resolved, config.braveApiKey!) });
+    entries.push({
+      provider: "brave_search",
+      fn: () => braveSearch(normalized, resolved, config.braveApiKey!),
+    });
   }
   entries.push({ provider: "ddg", fn: () => ddgSearch(normalized, resolved) });
 

package/src/providers/with-fallback.ts

@@ -1,6 +1,6 @@
 import type { ProviderResult } from "../runtime/evidence.js";
-import { wrapProvider } from "./wrap-provider.js";
 import { getProviderTracker } from "../runtime/run-context.js";
+import { wrapProvider } from "./wrap-provider.js";
 
 export interface FallbackEntry<T> {
   provider: string;
@@ -16,11 +16,10 @@ export interface FallbackEntry<T> {
  * provider function (Level B). By the time a provider throws to wrapProvider,
  * it already tried its own stale cache.
  */
-export async function withFallback<T>(
-  entries: FallbackEntry<T>[],
-): Promise<ProviderResult<T>> {
+export async function withFallback<T>(entries: FallbackEntry<T>[]): Promise<ProviderResult<T>> {
   const tracker = getProviderTracker();
   const attempted: string[] = [];
+  const failures: string[] = [];
 
   for (const entry of entries) {
     if (tracker?.isCircuitOpen(entry.provider)) continue;
@@ -28,14 +27,16 @@ export async function withFallback<T>(
 
     const result = await wrapProvider(entry.provider, entry.fn);
     if (result.status === "ok") return result;
+    failures.push(`${entry.provider}: ${result.reason}`);
     // wrapProvider already called recordFailure on the tracker
   }
 
   return {
     status: "unavailable",
-    reason: attempted.length > 0
-      ? `all providers failed: ${attempted.join(", ")}`
-      : `all providers circuit-open: ${entries.map((e) => e.provider).join(", ")}`,
+    reason:
+      attempted.length > 0
+        ? `all providers failed: ${failures.join("; ")}`
+        : `all providers circuit-open: ${entries.map((e) => e.provider).join(", ")}`,
     provider: entries[0]?.provider ?? "unknown",
   };
 }

package/src/providers/wrap-provider.ts

@@ -1,6 +1,8 @@
+import { runWithStaleMetadata } from "../infra/cache.js";
 import type { ProviderResult } from "../runtime/evidence.js";
 import { getProviderTracker } from "../runtime/run-context.js";
-import { cache } from "../infra/cache.js";
+import { InvalidSymbolError } from "./errors.js";
+import { ExternalToolError, ExternalToolNotInstalled } from "./external-tool-error.js";
 import { ProviderCredentialError } from "./provider-credential-error.js";
 
 /**
@@ -17,9 +19,8 @@ import { ProviderCredentialError } from "./provider-credential-error.js";
  * When a run context is active, checks circuit breaker state before
  * calling and records failures after.
  *
- * After a successful provider call, checks if the cache's stale flag
- * was set (meaning the provider fell back to stale cached data internally)
- * and propagates that metadata on the result.
+ * After a successful provider call, propagates stale cache metadata recorded
+ * in the current provider call's async scope.
  */
 export async function wrapProvider<T>(
   providerId: string,
@@ -36,13 +37,12 @@ export async function wrapProvider<T>(
   }
 
   try {
-    const data = await fn();
-    const { stale, cachedAt } = cache.consumeStaleFlag();
+    const { value: data, stale } = await runWithStaleMetadata(fn);
     return {
       status: "ok",
       data,
-      timestamp: stale ? new Date(cachedAt).toISOString() : new Date().toISOString(),
-      stale: stale || undefined,
+      timestamp: stale ? new Date(stale.cachedAt).toISOString() : new Date().toISOString(),
+      stale: stale ? true : undefined,
     };
   } catch (error) {
     // Credential errors are re-thrown so the tool-layer `withCredentialCheck`
@@ -52,9 +52,22 @@ export async function wrapProvider<T>(
     if (error instanceof ProviderCredentialError) {
       throw error;
     }
+    if (isExternalToolSetupError(error)) {
+      return {
+        status: "unavailable",
+        reason: error.message,
+        provider: providerId,
+      };
+    }
+    if (error instanceof InvalidSymbolError) {
+      return {
+        status: "unavailable",
+        reason: error.message,
+        provider: providerId,
+      };
+    }
     tracker?.recordFailure(providerId);
-    const reason =
-      error instanceof Error ? error.message : "unknown_error";
+    const reason = error instanceof Error ? error.message : "unknown_error";
     return {
       status: "unavailable",
       reason,
@@ -62,3 +75,29 @@ export async function wrapProvider<T>(
     };
   }
 }
+
+function isExternalToolSetupError(
+  error: unknown,
+): error is ExternalToolError | ExternalToolNotInstalled {
+  if (error instanceof ExternalToolNotInstalled) return true;
+  if (!(error instanceof ExternalToolError)) return false;
+
+  const code = error.code?.toLowerCase() ?? "";
+  const message = error.message.toLowerCase();
+  return (
+    code.includes("auth") ||
+    code.includes("session") ||
+    code.includes("unauthorized") ||
+    code.includes("expired") ||
+    message.includes("no twitter cookies") ||
+    message.includes("no twitter session") ||
+    message.includes("no reddit cookies") ||
+    message.includes("session missing") ||
+    message.includes("not authenticated") ||
+    message.includes("no cookies") ||
+    message.includes("rdt login") ||
+    message.includes("401") ||
+    message.includes("unauthorized") ||
+    message.includes("expired")
+  );
+}