@aiaiaichain/agent 0.1.5 → 0.1.7

package/dist/util/responseCache.js

@@ -1,54 +1,45 @@
-/**
- * src/util/responseCache.ts — TTL-based response cache for external APIs
- */
+
 const cache = new Map();
 const DEFAULT_TTL_MS = 60_000;
-/**
- * Get cached value or undefined if expired/missing.
- */
+
 export function getCached(key) {
-    const entry = cache.get(key);
-    if (!entry)
-        return undefined;
-    if (Date.now() > entry.expiresAt) {
-        cache.delete(key);
-        return undefined;
-    }
-    return entry.data;
-}
-/**
- * Set value in cache with TTL (default 60s).
- */
+const entry = cache.get(key);
+if (!entry)
+return undefined;
+if (Date.now() > entry.expiresAt) {
+cache.delete(key);
+return undefined;
+}
+return entry.data;
+}
+
 export function setCache(key, data, ttlMs = DEFAULT_TTL_MS) {
-    cache.set(key, { data, expiresAt: Date.now() + ttlMs });
-    // Evict oldest if cache grows too large
-    if (cache.size > 200) {
-        const firstKey = cache.keys().next().value;
-        if (firstKey)
-            cache.delete(firstKey);
-    }
-}
-/**
- * Get or compute: return cached value, or compute, cache, and return.
- */
+cache.set(key, { data, expiresAt: Date.now() + ttlMs });
+
+if (cache.size > 200) {
+const keys = [...cache.keys()];
+const toEvict = Math.ceil(keys.length * 0.2);
+for (let i = 0; i < toEvict; i++) {
+const idx = Math.floor(Math.random() * keys.length);
+cache.delete(keys[idx]);
+keys.splice(idx, 1);
+}
+}
+}
+
 export async function getOrCompute(key, compute, ttlMs = DEFAULT_TTL_MS) {
-    const cached = getCached(key);
-    if (cached !== undefined)
-        return cached;
-    const result = await compute();
-    setCache(key, result, ttlMs);
-    return result;
-}
-/**
- * Clear all cached values.
- */
+const cached = getCached(key);
+if (cached !== undefined)
+return cached;
+const result = await compute();
+setCache(key, result, ttlMs);
+return result;
+}
+
 export function clearCache() {
-    cache.clear();
+cache.clear();
 }
-/**
- * Get cache stats for diagnostics.
- */
+
 export function cacheStats() {
-    return { size: cache.size, entries: [...cache.keys()] };
+return { size: cache.size, entries: [...cache.keys()] };
 }
-//# sourceMappingURL=responseCache.js.map

package/dist/util/rpc.d.ts

@@ -0,0 +1,16 @@
+/**
+ * #55: Fallback RPC endpoints
+ * #177: Multiple RPC endpoint support
+ * #184: RPC benchmark on startup
+ */
+export interface RpcEndpoint {
+    url: string;
+    name: string;
+    priority: number;
+}
+export declare function getEndpoints(): RpcEndpoint[];
+export declare function getCurrentEndpoint(): RpcEndpoint;
+export declare function getRpcUrl(): string;
+export declare function setEndpoints(endpoints: RpcEndpoint[]): void;
+export declare function benchmarkEndpoints(): Promise<void>;
+export declare function rpcCall(method: string, params?: unknown[]): Promise<any>;

package/dist/util/rpc.js

@@ -0,0 +1,69 @@
+
+import { resilientFetch } from './resilientFetch.js';
+import { errorAggregator } from './errors.js';
+const DEFAULT_ENDPOINTS = [
+{ url: 'https://api.mainnet-beta.solana.com', name: 'Solana Public', priority: 1 },
+{ url: 'https://rpc.ankr.com/solana', name: 'Ankr', priority: 2 },
+{ url: 'https://solana-api.projectserum.com', name: 'ProjectSerum', priority: 3 },
+];
+let _endpoints = [...DEFAULT_ENDPOINTS];
+let _currentEndpoint = _endpoints[0];
+export function getEndpoints() {
+return [..._endpoints];
+}
+export function getCurrentEndpoint() {
+return _currentEndpoint;
+}
+export function getRpcUrl() {
+return _currentEndpoint.url;
+}
+export function setEndpoints(endpoints) {
+_endpoints = endpoints.sort((a, b) => a.priority - b.priority);
+_currentEndpoint = _endpoints[0];
+}
+export async function benchmarkEndpoints() {
+const results = [];
+for (const ep of _endpoints) {
+const start = Date.now();
+try {
+await resilientFetch(`${ep.url}`, {
+timeout: 5_000,
+retries: 0,
+method: 'POST',
+headers: { 'Content-Type': 'application/json' },
+body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getHealth', params: [] }),
+});
+results.push({ endpoint: ep, latency: Date.now() - start });
+}
+catch {
+results.push({ endpoint: ep, latency: Infinity });
+}
+}
+results.sort((a, b) => a.latency - b.latency);
+if (results[0].latency < Infinity) {
+_currentEndpoint = results[0].endpoint;
+}
+}
+export async function rpcCall(method, params = []) {
+const body = JSON.stringify({ jsonrpc: '2.0', id: Date.now(), method, params });
+const response = await resilientFetch(_currentEndpoint.url, {
+timeout: 15_000,
+retries: 2,
+method: 'POST',
+headers: { 'Content-Type': 'application/json' },
+body,
+});
+const data = await response.json();
+if (data.error) {
+errorAggregator.record({
+name: 'RpcError',
+message: data.error.message || 'Unknown RPC error',
+code: 'RPC_ERROR',
+context: { method, code: data.error.code },
+timestamp: Date.now(),
+recoverable: false,
+});
+throw new Error(data.error.message || 'Unknown RPC error');
+}
+return data.result;
+}

package/dist/util/safeLog.d.ts

@@ -4,4 +4,3 @@
 export declare function wireNotify(fn?: (msg: string) => void): void;
 export declare function safeLog(...args: unknown[]): void;
 export declare function installSafeLogging(): void;
-//# sourceMappingURL=safeLog.d.ts.map

package/dist/util/safeLog.js

@@ -1,76 +1,75 @@
-/**
- * src/util/safeLog.ts — Intercepts console output, masks secrets, routes to file
- */
+
 import { existsSync, appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), '.aiaiai');
 const LOG_DIR = join(AIAIAI_HOME, '.logs');
 const LOG_FILE = join(LOG_DIR, 'agent.log');
-// Patterns that indicate sensitive values
+
 const SENSITIVE_PATTERNS = [
-    /sk-[a-zA-Z0-9]{20,}/g, // API keys
-    /[A-Za-z0-9]{32,}/g, // Hex keys
-    /Bearer\s+[A-Za-z0-9\-._~+/]+/g, // Bearer tokens
-    /api[_-]?key["\s:=]+["']?[^\s"']+/gi, // Key assignments
-    /secret["\s:=]+["']?[^\s"']+/gi, // Secrets
+/sk-[a-zA-Z0-9]{20,}/g, 
+/[A-Za-z0-9]{32,}/g, 
+/Bearer\s+[A-Za-z0-9\-._~+/]+/g, 
+/api[_-]?key["\s:=]+["']?[^\s"']+/gi, 
+/secret["\s:=]+["']?[^\s"']+/gi, 
+/[A-Z0-9]{40,}/g, 
 ];
 const SENSITIVE_ENV_NAMES = [
-    'OPENROUTER_API_KEY', 'ANTHROPIC_API_KEY', 'CRYPTOPANIC_API_KEY',
-    'GMGN_API_KEY', 'SOLANA_RPC_URL', 'HELIUS_API_KEY', 'PRIVY_KEY',
+'OPENROUTER_API_KEY', 'ANTHROPIC_API_KEY', 'CRYPTOPANIC_API_KEY',
+'GMGN_API_KEY', 'SOLANA_RPC_URL', 'HELIUS_API_KEY', 'PRIVY_KEY',
 ];
 const REDACTED = '[REDACTED]';
 function maskSensitive(text) {
-    let masked = text;
-    for (const pattern of SENSITIVE_PATTERNS) {
-        masked = masked.replace(pattern, (match) => {
-            // Keep first 4 chars for identification
-            if (match.length > 8)
-                return match.slice(0, 4) + '…' + REDACTED;
-            return REDACTED;
-        });
-    }
-    return masked;
+let masked = text;
+for (const pattern of SENSITIVE_PATTERNS) {
+masked = masked.replace(pattern, (match) => {
+
+if (match.length > 8)
+return match.slice(0, 4) + '…' + REDACTED;
+return REDACTED;
+});
+}
+return masked;
 }
 function ensureLogDir() {
-    if (!existsSync(LOG_DIR)) {
-        mkdirSync(LOG_DIR, { recursive: true, mode: 0o700 });
-    }
+if (!existsSync(LOG_DIR)) {
+mkdirSync(LOG_DIR, { recursive: true, mode: 0o700 });
+}
 }
 function writeToFile(text) {
-    try {
-        ensureLogDir();
-        appendFileSync(LOG_FILE, text + '\n', { encoding: 'utf-8' });
-    }
-    catch { /* non-fatal — prevents logging failures from crashing agent */ }
+try {
+ensureLogDir();
+appendFileSync(LOG_FILE, text + '\n', { encoding: 'utf-8' });
+}
+catch {  }
 }
 export function wireNotify(fn) {
-    // Wire to notification callback if provided
-    if (fn) {
-        // placeholder for notification integration
-    }
+
+if (fn) {
+
+}
 }
 export function safeLog(...args) {
-    const raw = args.map(a => typeof a === 'string' ? a : String(a)).join(' ');
-    const masked = maskSensitive(raw);
-    const timestamp = new Date().toISOString();
-    const line = `[${timestamp}] ${masked}`;
-    try {
-        writeToFile(line);
-    }
-    catch { /* non-fatal */ }
-    process.stdout.write(line + '\n');
+const raw = args.map(a => typeof a === 'string' ? a : String(a)).join(' ');
+const masked = maskSensitive(raw);
+const timestamp = new Date().toISOString();
+const line = `[${timestamp}] ${masked}`;
+try {
+writeToFile(line);
+}
+catch {  }
+
+process.stdout.write(line + '\n');
 }
-// Override console methods
+
 export function installSafeLogging() {
-    console.log = (...args) => safeLog(...args);
-    console.warn = (...args) => {
-        const masked = maskSensitive(args.map(String).join(' '));
-        process.stderr.write(`[WARN] ${masked}\n`);
-    };
-    console.error = (...args) => {
-        const masked = maskSensitive(args.map(String).join(' '));
-        process.stderr.write(`[ERROR] ${masked}\n`);
-    };
+console.log = (...args) => safeLog(...args);
+console.warn = (...args) => {
+const masked = maskSensitive(args.map(String).join(' '));
+process.stderr.write(`[WARN] ${masked}\n`);
+};
+console.error = (...args) => {
+const masked = maskSensitive(args.map(String).join(' '));
+process.stderr.write(`[ERROR] ${masked}\n`);
+};
 }
-//# sourceMappingURL=safeLog.js.map

package/dist/util/scheduler.d.ts

@@ -11,4 +11,3 @@ export declare function resumeAll(): void;
  * Start the scheduler loop. Returns a stop function.
  */
 export declare function startScheduler(): () => void;
-//# sourceMappingURL=scheduler.d.ts.map

package/dist/util/scheduler.js

@@ -1,75 +1,70 @@
-/**
- * src/util/scheduler.ts — Centralized interval scheduler with pause/resume
- */
+
 const MAX_TASKS = 50;
 const tasks = [];
 let running = false;
 export function addTask(name, intervalMs, fn) {
-    // Replace existing task with same name
-    const existing = tasks.findIndex(t => t.name === name);
-    if (existing >= 0) {
-        tasks[existing] = { name, intervalMs, fn, lastRun: 0, paused: false };
-    }
-    else {
-        if (tasks.length >= MAX_TASKS) {
-            // Evict oldest non-paused task
-            const evictIdx = tasks.findIndex(t => !t.paused);
-            if (evictIdx >= 0)
-                tasks.splice(evictIdx, 1);
-            else
-                return; // All tasks paused, refuse to add
-        }
-        tasks.push({ name, intervalMs, fn, lastRun: 0, paused: false });
-    }
+
+const existing = tasks.findIndex(t => t.name === name);
+if (existing >= 0) {
+tasks[existing] = { name, intervalMs, fn, lastRun: 0, paused: false };
+}
+else {
+if (tasks.length >= MAX_TASKS) {
+
+const evictIdx = tasks.findIndex(t => !t.paused);
+if (evictIdx >= 0)
+tasks.splice(evictIdx, 1);
+else
+return; 
+}
+tasks.push({ name, intervalMs, fn, lastRun: 0, paused: false });
+}
 }
 export function removeTask(name) {
-    const idx = tasks.findIndex(t => t.name === name);
-    if (idx >= 0)
-        tasks.splice(idx, 1);
+const idx = tasks.findIndex(t => t.name === name);
+if (idx >= 0)
+tasks.splice(idx, 1);
 }
 export function pauseTask(name) {
-    const task = tasks.find(t => t.name === name);
-    if (task)
-        task.paused = true;
+const task = tasks.find(t => t.name === name);
+if (task)
+task.paused = true;
 }
 export function resumeTask(name) {
-    const task = tasks.find(t => t.name === name);
-    if (task)
-        task.paused = false;
+const task = tasks.find(t => t.name === name);
+if (task)
+task.paused = false;
 }
 export function pauseAll() {
-    tasks.forEach(t => (t.paused = true));
+tasks.forEach(t => (t.paused = true));
 }
 export function resumeAll() {
-    tasks.forEach(t => (t.paused = false));
+tasks.forEach(t => (t.paused = false));
 }
-/**
- * Start the scheduler loop. Returns a stop function.
- */
+
 export function startScheduler() {
-    if (running)
-        return () => { };
-    running = true;
-    const tick = () => {
-        if (!running)
-            return;
-        const now = Date.now();
-        for (const task of tasks) {
-            if (task.paused)
-                continue;
-            if (now - task.lastRun >= task.intervalMs) {
-                task.lastRun = now;
-                try {
-                    task.fn();
-                }
-                catch { /* task errors don't crash scheduler */ }
-            }
-        }
-        setTimeout(tick, 1000);
-    };
-    tick();
-    return () => {
-        running = false;
-    };
+if (running)
+return () => { };
+running = true;
+const tick = () => {
+if (!running)
+return;
+const now = Date.now();
+for (const task of tasks) {
+if (task.paused)
+continue;
+if (now - task.lastRun >= task.intervalMs) {
+task.lastRun = now;
+try {
+task.fn();
+}
+catch {  }
+}
+}
+setTimeout(tick, 1000);
+};
+tick();
+return () => {
+running = false;
+};
 }
-//# sourceMappingURL=scheduler.js.map

package/dist/util/webhooks.d.ts

@@ -6,4 +6,3 @@ export declare function sendDiscord(message: string): Promise<boolean>;
 export declare function sendTelegram(message: string): Promise<boolean>;
 export declare function notify(message: string): Promise<void>;
 export declare function hasWebhooks(): boolean;
-//# sourceMappingURL=webhooks.d.ts.map

package/dist/util/webhooks.js

@@ -1,75 +1,71 @@
-/**
- * src/util/webhooks.ts — Discord & Telegram notification webhooks.
- * Configure via ~/.aiaiai/.env with WEBHOOK_DISCORD and/or WEBHOOK_TELEGRAM.
- */
+
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { logger } from "./logger.js";
 const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
 function getWebhookUrl(service) {
-    const envFile = join(AIAIAI_HOME, ".env");
-    if (!existsSync(envFile))
-        return null;
-    const content = readFileSync(envFile, "utf-8");
-    const key = service === "discord" ? "WEBHOOK_DISCORD" : "WEBHOOK_TELEGRAM";
-    const match = new RegExp(`^${key}=(.+)$`, "m").exec(content);
-    return match?.[1] ?? null;
+const envFile = join(AIAIAI_HOME, ".env");
+if (!existsSync(envFile))
+return null;
+const content = readFileSync(envFile, "utf-8");
+const key = service === "discord" ? "WEBHOOK_DISCORD" : "WEBHOOK_TELEGRAM";
+const match = new RegExp(`^${key}=(.+)$`, "m").exec(content);
+return match?.[1] ?? null;
 }
 export async function sendDiscord(message) {
-    const url = getWebhookUrl("discord");
-    if (!url)
-        return false;
-    try {
-        const res = await fetch(url, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ content: `🤖 **AIAIAI Agent**\n${message}` }),
-        });
-        return res.ok;
-    }
-    catch (error) {
-        logger.warn("Webhooks", "Discord send failed", { error: error.message });
-        return false;
-    }
+const url = getWebhookUrl("discord");
+if (!url)
+return false;
+try {
+const res = await fetch(url, {
+method: "POST",
+headers: { "Content-Type": "application/json" },
+body: JSON.stringify({ content: `🤖 **AIAIAI Agent**\n${message}` }),
+});
+return res.ok;
+}
+catch (error) {
+logger.warn("Webhooks", "Discord send failed", { error: error.message });
+return false;
+}
 }
 export async function sendTelegram(message) {
-    const url = getWebhookUrl("telegram");
-    if (!url)
-        return false;
-    // Telegram Bot API format: https://api.telegram.org/bot<TOKEN>/sendMessage
-    try {
-        const res = await fetch(url, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                chat_id: extractTelegramChatId(url),
-                text: `🤖 AIAIAI Agent\n${message}`,
-                parse_mode: "HTML",
-            }),
-        });
-        return res.ok;
-    }
-    catch (error) {
-        logger.warn("Webhooks", "Telegram send failed", { error: error.message });
-        return false;
-    }
+const url = getWebhookUrl("telegram");
+if (!url)
+return false;
+
+try {
+const res = await fetch(url, {
+method: "POST",
+headers: { "Content-Type": "application/json" },
+body: JSON.stringify({
+chat_id: extractTelegramChatId(url),
+text: `🤖 AIAIAI Agent\n${message}`,
+parse_mode: "HTML",
+}),
+});
+return res.ok;
+}
+catch (error) {
+logger.warn("Webhooks", "Telegram send failed", { error: error.message });
+return false;
+}
 }
 function extractTelegramChatId(url) {
-    // URL format: https://api.telegram.org/bot<TOKEN>/sendMessage?chat_id=<ID>
-    const match = /chat_id=([^&]+)/.exec(url);
-    return match?.[1] ?? "";
+
+const match = /chat_id=([^&]+)/.exec(url);
+return match?.[1] ?? "";
 }
 export async function notify(message) {
-    const [discordOk, telegramOk] = await Promise.all([
-        sendDiscord(message),
-        sendTelegram(message),
-    ]);
-    if (!discordOk && !telegramOk) {
-        logger.debug("Webhooks", "No webhooks configured or all failed");
-    }
+const [discordOk, telegramOk] = await Promise.all([
+sendDiscord(message),
+sendTelegram(message),
+]);
+if (!discordOk && !telegramOk) {
+logger.debug("Webhooks", "No webhooks configured or all failed");
+}
 }
 export function hasWebhooks() {
-    return !!(getWebhookUrl("discord") || getWebhookUrl("telegram"));
+return !!(getWebhookUrl("discord") || getWebhookUrl("telegram"));
 }
-//# sourceMappingURL=webhooks.js.map

package/dist/wallet/ActionFeed.d.ts

@@ -1,7 +1,8 @@
 /**
  * ActionFeed — reads agent wallet activity via public RPC.
- * Only tracks AIAIAI token transfers. Classifies as buy or burn.
- * Fees are calculated as a percentage of each action.
+ * Parses Pump.fun Buy + BurnChecked events from inner instructions.
+ * Checks the ACTION wallet (GmFrDZT...) for transaction signatures.
+ * Fees are calculated as 0.5% of each action's USD value.
  */
 import type { ToolResult } from "../api/ExtensionAPI.js";
 export type ActionType = "buy" | "burn";
@@ -46,4 +47,3 @@ export declare class ActionFeed {
     getFeesTool(): Promise<ToolResult>;
 }
 export declare const actionFeed: ActionFeed;
-//# sourceMappingURL=ActionFeed.d.ts.map