@blockrun/franklin 3.2.3 → 3.3.0

package/dist/social/x.js

@@ -17,6 +17,8 @@ import { SocialBrowser } from './browser.js';
 import { findRefs, findStaticText, extractArticleBlocks, X_TIME_LINK_PATTERN } from './a11y.js';
 import { computePreKey, hasPreKey, commitPreKey, hasPosted, countPostedToday, logReply, } from './db.js';
 import { detectProduct, generateReply } from './ai.js';
+import { bus } from '../events/bus.js';
+import { makeEvent } from '../events/types.js';
 /**
  * Main entry point. Iterates every search query in config.x.search_queries
  * and processes every visible candidate until the daily target is hit.
@@ -202,6 +204,12 @@ export async function runX(opts) {
                         cost_usd: gen.cost,
                     });
                     commitPreKey('x', handle, preKey);
+                    bus.emit(makeEvent({
+                        type: 'post.published',
+                        source: 'social',
+                        costUsd: gen.cost,
+                        data: { platform: 'x', url: canonicalUrl, text: gen.reply },
+                    }));
                     // Respect the rate-limit / anti-spam delay between successes
                     await browser.waitForTimeout(opts.config.x.min_delay_seconds * 1000);
                 }
@@ -238,7 +246,7 @@ export async function runX(opts) {
  * Enter+Enter), clicks the reply button, confirms the "Your post was sent"
  * banner.
  */
-async function postReply(browser, reply) {
+export async function postReply(browser, reply) {
     // Snapshot and find the reply textbox
     const tree = await browser.snapshot();
     const boxRefs = findRefs(tree, 'textbox', 'Post (your reply|text).*');

package/dist/tools/index.js

@@ -12,6 +12,9 @@ import { webSearchCapability } from './websearch.js';
 import { taskCapability } from './task.js';
 import { imageGenCapability } from './imagegen.js';
 import { askUserCapability } from './askuser.js';
+import { tradingSignalCapability, tradingMarketCapability } from './trading.js';
+import { searchXCapability } from './searchx.js';
+import { postToXCapability } from './posttox.js';
 /** All capabilities available to the runcode agent (excluding sub-agent, which needs config). */
 export const allCapabilities = [
     readCapability,
@@ -25,6 +28,10 @@ export const allCapabilities = [
     taskCapability,
     imageGenCapability,
     askUserCapability,
+    tradingSignalCapability,
+    tradingMarketCapability,
+    searchXCapability,
+    postToXCapability,
 ];
 export { readCapability, writeCapability, editCapability, bashCapability, globCapability, grepCapability, webFetchCapability, webSearchCapability, taskCapability, };
 export { createSubAgentCapability } from './subagent.js';

package/dist/tools/posttox.d.ts

@@ -0,0 +1,7 @@
+/**
+ * PostToX capability — post a reply to a tweet on X.
+ * The agent MUST confirm the reply text with the user before calling this tool.
+ * Requires the pre_key from a SearchX result.
+ */
+import type { CapabilityHandler } from '../agent/types.js';
+export declare const postToXCapability: CapabilityHandler;

package/dist/tools/posttox.js

@@ -0,0 +1,137 @@
+/**
+ * PostToX capability — post a reply to a tweet on X.
+ * The agent MUST confirm the reply text with the user before calling this tool.
+ * Requires the pre_key from a SearchX result.
+ */
+import { checkSocialReady } from '../social/preflight.js';
+import { browserPool } from '../social/browser-pool.js';
+import { extractArticleBlocks, findRefs, findStaticText, X_TIME_LINK_PATTERN, } from '../social/a11y.js';
+import { computePreKey, commitPreKey, hasPosted, logReply } from '../social/db.js';
+import { loadConfig } from '../social/config.js';
+import { postReply } from '../social/x.js';
+import { bus } from '../events/bus.js';
+import { makeEvent } from '../events/types.js';
+async function execute(input, _ctx) {
+    const { pre_key, reply_text, search_query } = input;
+    if (!pre_key || !reply_text || !search_query) {
+        return {
+            output: 'Error: pre_key, reply_text, and search_query are all required',
+            isError: true,
+        };
+    }
+    // ── Preflight: config + login ──────────────────────────────────────────
+    const preflight = await checkSocialReady();
+    if (!preflight.ready) {
+        return {
+            output: `PostToX not ready: ${preflight.reason}`,
+            isError: true,
+        };
+    }
+    const config = loadConfig();
+    const handle = config.handle || 'unknown';
+    let browser;
+    try {
+        browser = await browserPool.getBrowser();
+        // ── Navigate to search results to re-find the target post ────────
+        const searchUrl = `https://x.com/search?q=${encodeURIComponent(search_query)}&src=typed_query&f=live`;
+        await browser.open(searchUrl);
+        await browser.waitForTimeout(3500);
+        const tree = await browser.snapshot();
+        // ── Find the article matching the given pre_key ──────────────────
+        const articles = extractArticleBlocks(tree);
+        let matchedTimeRef = null;
+        for (const article of articles) {
+            const timeRefs = findRefs(article.text, 'link', X_TIME_LINK_PATTERN);
+            if (timeRefs.length === 0)
+                continue;
+            const texts = findStaticText(article.text);
+            const snippet = texts.slice(0, 3).join(' ').trim();
+            if (!snippet)
+                continue;
+            const timeLinkMatch = new RegExp(`\\[${timeRefs[0]}\\]\\s+link:\\s*(.+)`).exec(article.text);
+            const timeText = timeLinkMatch ? timeLinkMatch[1].trim() : '';
+            const candidatePreKey = computePreKey({ snippet, time: timeText });
+            if (candidatePreKey === pre_key) {
+                matchedTimeRef = timeRefs[0];
+                break;
+            }
+        }
+        if (!matchedTimeRef) {
+            return {
+                output: 'Post not found in current results. It may have scrolled off or been deleted.',
+                isError: true,
+            };
+        }
+        // ── Click through to the tweet page ──────────────────────────────
+        await browser.click(matchedTimeRef);
+        await browser.waitForTimeout(3000);
+        const canonicalUrl = await browser.getUrl();
+        // ── Check if already posted to this URL ──────────────────────────
+        if (hasPosted('x', handle, canonicalUrl)) {
+            return {
+                output: `Already replied to this post: ${canonicalUrl}`,
+                isError: true,
+            };
+        }
+        // ── Post the reply ───────────────────────────────────────────────
+        await postReply(browser, reply_text);
+        // ── Record success ───────────────────────────────────────────────
+        commitPreKey('x', handle, pre_key);
+        logReply({
+            platform: 'x',
+            handle,
+            post_url: canonicalUrl,
+            post_title: '',
+            post_snippet: '',
+            reply_text,
+            status: 'posted',
+        });
+        // ── Emit post.published event ────────────────────────────────────
+        await bus.emit(makeEvent({
+            type: 'post.published',
+            source: 'social',
+            data: {
+                platform: 'x',
+                url: canonicalUrl,
+                text: reply_text,
+            },
+        }));
+        return {
+            output: `Reply posted successfully to ${canonicalUrl}`,
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { output: `PostToX error: ${msg}`, isError: true };
+    }
+    finally {
+        browserPool.releaseBrowser();
+    }
+}
+export const postToXCapability = {
+    spec: {
+        name: 'PostToX',
+        description: 'Post a reply to a tweet on X. The agent MUST confirm the reply text with ' +
+            'the user before calling this tool. Requires the pre_key from a SearchX result.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                pre_key: {
+                    type: 'string',
+                    description: 'preKey of the target post (from SearchX results)',
+                },
+                reply_text: {
+                    type: 'string',
+                    description: 'The reply text to post',
+                },
+                search_query: {
+                    type: 'string',
+                    description: 'The original search query (to re-find the post)',
+                },
+            },
+            required: ['pre_key', 'reply_text', 'search_query'],
+        },
+    },
+    execute,
+    concurrent: false,
+};

package/dist/tools/searchx.d.ts

@@ -0,0 +1,7 @@
+/**
+ * SearchX capability — search X (Twitter) for posts matching a query.
+ * Returns candidate posts with snippets and product relevance scores.
+ * Requires social config and X login.
+ */
+import type { CapabilityHandler } from '../agent/types.js';
+export declare const searchXCapability: CapabilityHandler;

package/dist/tools/searchx.js

@@ -0,0 +1,111 @@
+/**
+ * SearchX capability — search X (Twitter) for posts matching a query.
+ * Returns candidate posts with snippets and product relevance scores.
+ * Requires social config and X login.
+ */
+import { checkSocialReady } from '../social/preflight.js';
+import { extractArticleBlocks, findRefs, findStaticText, X_TIME_LINK_PATTERN, } from '../social/a11y.js';
+import { computePreKey, hasPreKey } from '../social/db.js';
+import { detectProduct } from '../social/ai.js';
+import { loadConfig } from '../social/config.js';
+import { browserPool } from '../social/browser-pool.js';
+async function execute(input, _ctx) {
+    const { query, max_results } = input;
+    if (!query) {
+        return { output: 'Error: query is required', isError: true };
+    }
+    const maxResults = Math.min(Math.max(max_results ?? 10, 1), 50);
+    // ── Preflight: config + login ──────────────────────────────────────────
+    const preflight = await checkSocialReady();
+    if (!preflight.ready) {
+        return {
+            output: `SearchX not ready: ${preflight.reason}`,
+            isError: true,
+        };
+    }
+    const config = loadConfig();
+    const handle = config.handle || 'unknown';
+    let browser;
+    try {
+        browser = await browserPool.getBrowser();
+        // ── Navigate to X search ───────────────────────────────────────────
+        const searchUrl = `https://x.com/search?q=${encodeURIComponent(query)}&src=typed_query&f=live`;
+        await browser.open(searchUrl);
+        await browser.waitForTimeout(3500);
+        const tree = await browser.snapshot();
+        // ── Extract articles ───────────────────────────────────────────────
+        const articles = extractArticleBlocks(tree);
+        const candidates = [];
+        for (const article of articles) {
+            if (candidates.length >= maxResults)
+                break;
+            // Find time-link ref (permalink to the tweet)
+            const timeRefs = findRefs(article.text, 'link', X_TIME_LINK_PATTERN);
+            if (timeRefs.length === 0)
+                continue;
+            const timeRef = timeRefs[0];
+            // Extract snippet from static text (first 3 lines)
+            const texts = findStaticText(article.text);
+            const snippet = texts.slice(0, 3).join(' ').trim();
+            if (!snippet || snippet.length < 10)
+                continue;
+            // Extract time text from the ref line
+            const timeLinkMatch = new RegExp(`\\[${timeRef}\\]\\s+link:\\s*(.+)`).exec(article.text);
+            const timeText = timeLinkMatch ? timeLinkMatch[1].trim() : '';
+            // Compute pre-key for dedup
+            const preKey = computePreKey({ snippet, time: timeText });
+            const alreadySeen = hasPreKey('x', handle, preKey);
+            // Product routing (zero-cost keyword score)
+            const product = detectProduct(snippet, config.products);
+            candidates.push({
+                index: candidates.length + 1,
+                snippet,
+                timeText,
+                preKey,
+                productMatch: product?.name ?? null,
+                alreadySeen,
+            });
+        }
+        // ── Format output ──────────────────────────────────────────────────
+        if (candidates.length === 0) {
+            return { output: `No candidate posts found for query: "${query}"` };
+        }
+        const lines = candidates.map((c) => {
+            const seen = c.alreadySeen ? ' [SEEN]' : '';
+            const product = c.productMatch ? ` | product: ${c.productMatch}` : ' | product: none';
+            return (`${c.index}. ${c.snippet.slice(0, 200)}\n` +
+                `   time: ${c.timeText} | pre_key: ${c.preKey}${product}${seen}`);
+        });
+        return {
+            output: `SearchX results for "${query}" (${candidates.length} candidates):\n\n` +
+                lines.join('\n\n'),
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { output: `SearchX error: ${msg}`, isError: true };
+    }
+    finally {
+        browserPool.releaseBrowser();
+    }
+}
+export const searchXCapability = {
+    spec: {
+        name: 'SearchX',
+        description: 'Search X (Twitter) for posts matching a query. Returns candidate posts ' +
+            'with snippets and product relevance scores. Requires social config and X login.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                max_results: {
+                    type: 'number',
+                    description: 'Max posts to return (default 10)',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    execute,
+    concurrent: false,
+};

package/dist/tools/trading.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityHandler } from '../agent/types.js';
+export declare const tradingSignalCapability: CapabilityHandler;
+export declare const tradingMarketCapability: CapabilityHandler;

package/dist/tools/trading.js

@@ -0,0 +1,168 @@
+import { getPrice, getOHLCV, getTrending, getMarketOverview } from '../trading/data.js';
+import { rsi, macd, bollingerBands, volatility } from '../trading/metrics.js';
+import { bus } from '../events/bus.js';
+import { makeEvent } from '../events/types.js';
+function formatUsd(n) {
+    if (n >= 1e12)
+        return `$${(n / 1e12).toFixed(2)}T`;
+    if (n >= 1e9)
+        return `$${(n / 1e9).toFixed(2)}B`;
+    if (n >= 1e6)
+        return `$${(n / 1e6).toFixed(2)}M`;
+    if (n >= 1e3)
+        return `$${(n / 1e3).toFixed(1)}K`;
+    return `$${n.toFixed(2)}`;
+}
+async function executeSignal(input, _ctx) {
+    const { ticker, days = 30 } = input;
+    if (!ticker) {
+        return { output: 'Error: ticker is required', isError: true };
+    }
+    const upper = ticker.toUpperCase();
+    const [priceResult, ohlcvResult] = await Promise.all([
+        getPrice(upper),
+        getOHLCV(upper, days),
+    ]);
+    if (typeof priceResult === 'string') {
+        return { output: `Error fetching price: ${priceResult}`, isError: true };
+    }
+    if (typeof ohlcvResult === 'string') {
+        return { output: `Error fetching OHLCV: ${ohlcvResult}`, isError: true };
+    }
+    const { closes } = ohlcvResult;
+    const rsiResult = rsi(closes);
+    const macdResult = macd(closes);
+    const bbResult = bollingerBands(closes);
+    const volResult = volatility(closes);
+    // Determine overall direction from indicators
+    let bullish = 0;
+    let bearish = 0;
+    if (rsiResult.interpretation === 'oversold')
+        bullish++;
+    if (rsiResult.interpretation === 'overbought')
+        bearish++;
+    if (macdResult.trend === 'bullish')
+        bullish++;
+    if (macdResult.trend === 'bearish')
+        bearish++;
+    if (bbResult.position === 'below')
+        bullish++;
+    if (bbResult.position === 'above')
+        bearish++;
+    const direction = bullish > bearish ? 'bullish' : bearish > bullish ? 'bearish' : 'neutral';
+    const confidence = Math.max(bullish, bearish) / 3;
+    bus.emit(makeEvent({
+        type: 'signal.detected',
+        source: 'trading',
+        data: {
+            asset: upper,
+            direction,
+            confidence,
+            indicators: {
+                rsi: rsiResult.value,
+                macd: macdResult.macd,
+                volatility: volResult.annualized,
+            },
+            summary: `${upper} ${direction} (confidence ${(confidence * 100).toFixed(0)}%)`,
+        },
+    }));
+    const { price, change24h, marketCap, volume24h } = priceResult;
+    const last5 = closes.slice(-5).map(c => c.toFixed(2)).join(', ');
+    const output = [
+        `## ${upper} Signal Report`,
+        '',
+        `**Price:** $${price.toLocaleString()} USD (${change24h > 0 ? '+' : ''}${change24h.toFixed(2)}% 24h)`,
+        `**Market Cap:** ${formatUsd(marketCap)}`,
+        `**24h Volume:** ${formatUsd(volume24h)}`,
+        '',
+        `### Technical Indicators (${days}d lookback)`,
+        `- **RSI(14):** ${rsiResult.value.toFixed(1)} — ${rsiResult.interpretation}`,
+        `- **MACD:** ${macdResult.macd.toFixed(4)} / Signal: ${macdResult.signal.toFixed(4)} / Histogram: ${macdResult.histogram.toFixed(4)} — ${macdResult.trend}`,
+        `- **Bollinger:** Upper ${bbResult.upper.toFixed(2)} / Middle ${bbResult.middle.toFixed(2)} / Lower ${bbResult.lower.toFixed(2)} — Price ${bbResult.position}`,
+        `- **Volatility:** ${(volResult.annualized * 100).toFixed(1)}% annualized — ${volResult.interpretation}`,
+        '',
+        `### Raw Data`,
+        `Closes (last 5): ${last5}`,
+    ].join('\n');
+    return { output };
+}
+export const tradingSignalCapability = {
+    spec: {
+        name: 'TradingSignal',
+        description: 'Get current price, technical indicators (RSI, MACD, Bollinger Bands, volatility), and a signal summary for a cryptocurrency. Returns raw data for the agent to analyze and interpret.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                ticker: { type: 'string', description: 'Cryptocurrency ticker, e.g. "BTC", "ETH"' },
+                days: { type: 'number', description: 'Lookback period for indicators. Default: 30' },
+            },
+            required: ['ticker'],
+        },
+    },
+    execute: executeSignal,
+    concurrent: true,
+};
+async function executeMarket(input, _ctx) {
+    const { action, ticker } = input;
+    if (!action) {
+        return { output: 'Error: action is required', isError: true };
+    }
+    switch (action) {
+        case 'price': {
+            if (!ticker) {
+                return { output: 'Error: ticker is required for price action', isError: true };
+            }
+            const result = await getPrice(ticker.toUpperCase());
+            if (typeof result === 'string') {
+                return { output: `Error: ${result}`, isError: true };
+            }
+            const { price, change24h, marketCap, volume24h } = result;
+            return {
+                output: `${ticker.toUpperCase()}: $${price.toLocaleString()} (${change24h > 0 ? '+' : ''}${change24h.toFixed(2)}% 24h), Market Cap: ${formatUsd(marketCap)}, Volume: ${formatUsd(volume24h)}`,
+            };
+        }
+        case 'trending': {
+            const result = await getTrending();
+            if (typeof result === 'string') {
+                return { output: `Error: ${result}`, isError: true };
+            }
+            const lines = result.map((c, i) => `${i + 1}. ${c.name} (${c.symbol.toUpperCase()})${c.marketCapRank ? ` — #${c.marketCapRank}` : ''}`);
+            return { output: `Trending coins:\n${lines.join('\n')}` };
+        }
+        case 'overview': {
+            const result = await getMarketOverview();
+            if (typeof result === 'string') {
+                return { output: `Error: ${result}`, isError: true };
+            }
+            const header = 'Rank | Coin | Price | 24h Change | Market Cap';
+            const sep = '-----|------|-------|------------|----------';
+            const rows = result.map((c, i) => `${i + 1} | ${c.name} (${c.symbol.toUpperCase()}) | $${c.price.toLocaleString()} | ${c.change24h > 0 ? '+' : ''}${c.change24h.toFixed(2)}% | ${formatUsd(c.marketCap)}`);
+            return { output: `Top 20 by Market Cap:\n${header}\n${sep}\n${rows.join('\n')}` };
+        }
+        default:
+            return { output: `Error: unknown action "${action}". Use: price, trending, overview`, isError: true };
+    }
+}
+export const tradingMarketCapability = {
+    spec: {
+        name: 'TradingMarket',
+        description: 'Get cryptocurrency market data: price lookup, trending coins, or market overview (top 20 by market cap).',
+        input_schema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['price', 'trending', 'overview'],
+                    description: 'What to fetch: price lookup, trending coins, or market overview',
+                },
+                ticker: {
+                    type: 'string',
+                    description: 'Cryptocurrency ticker (required for price action), e.g. "BTC"',
+                },
+            },
+            required: ['action'],
+        },
+    },
+    execute: executeMarket,
+    concurrent: true,
+};

package/dist/trading/config.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Typed config for Franklin's trading subsystem.
+ * Stored at ~/.blockrun/trading-config.json. Default written on first run.
+ */
+export interface TradingConfig {
+    version: 1;
+    watchlist: string[];
+    signals: {
+        rsi_oversold: number;
+        rsi_overbought: number;
+    };
+    model_tier: 'free' | 'cheap' | 'premium';
+}
+export declare const CONFIG_PATH: string;
+/**
+ * Load config from disk. If missing, write defaults and return them.
+ * Returns the parsed config or throws on malformed JSON.
+ */
+export declare function loadTradingConfig(): TradingConfig;
+/**
+ * Persist config back to disk.
+ */
+export declare function saveTradingConfig(cfg: TradingConfig): void;

package/dist/trading/config.js

@@ -0,0 +1,45 @@
+/**
+ * Typed config for Franklin's trading subsystem.
+ * Stored at ~/.blockrun/trading-config.json. Default written on first run.
+ */
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+export const CONFIG_PATH = path.join(os.homedir(), '.blockrun', 'trading-config.json');
+const DEFAULT_CONFIG = {
+    version: 1,
+    watchlist: ['BTC', 'ETH', 'SOL'],
+    signals: {
+        rsi_oversold: 30,
+        rsi_overbought: 70,
+    },
+    model_tier: 'cheap',
+};
+/**
+ * Load config from disk. If missing, write defaults and return them.
+ * Returns the parsed config or throws on malformed JSON.
+ */
+export function loadTradingConfig() {
+    const dir = path.dirname(CONFIG_PATH);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    if (!fs.existsSync(CONFIG_PATH)) {
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2));
+        return { ...DEFAULT_CONFIG };
+    }
+    const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1) {
+        throw new Error(`Unsupported trading config version ${parsed.version} (expected 1)`);
+    }
+    return parsed;
+}
+/**
+ * Persist config back to disk.
+ */
+export function saveTradingConfig(cfg) {
+    const dir = path.dirname(CONFIG_PATH);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+}

package/dist/trading/data.d.ts

@@ -0,0 +1,30 @@
+export interface PriceData {
+    price: number;
+    change24h: number;
+    volume24h: number;
+    marketCap: number;
+}
+export interface OHLCVData {
+    closes: number[];
+    timestamps: number[];
+}
+export interface TrendingCoin {
+    id: string;
+    name: string;
+    symbol: string;
+    marketCapRank: number | null;
+}
+export interface MarketCoin {
+    id: string;
+    symbol: string;
+    name: string;
+    price: number;
+    change24h: number;
+    marketCap: number;
+    volume24h: number;
+}
+export declare function resolveId(ticker: string): string;
+export declare function getPrice(ticker: string): Promise<PriceData | string>;
+export declare function getOHLCV(ticker: string, days?: number): Promise<OHLCVData | string>;
+export declare function getTrending(): Promise<TrendingCoin[] | string>;
+export declare function getMarketOverview(): Promise<MarketCoin[] | string>;