@aiaiaichain/agent 0.1.3 → 0.1.5

package/dist/util/logger.js

@@ -0,0 +1,43 @@
+/**
+ * src/util/logger.ts — Structured logging with levels for AIAIAI Agent
+ */
+const LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+function getMinLevel() {
+    const env = process.env.AIAIAI_LOG_LEVEL?.toLowerCase();
+    if (env && env in LEVEL_PRIORITY)
+        return env;
+    return 'info';
+}
+function shouldLog(level) {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[getMinLevel()];
+}
+function formatMessage(level, context, message, meta) {
+    const ts = new Date().toISOString();
+    const prefix = `[${ts}] [${level.toUpperCase()}] [${context}]`;
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
+    return `${prefix} ${message}${metaStr}`;
+}
+export const logger = {
+    debug(context, message, meta) {
+        if (shouldLog('debug'))
+            console.error(formatMessage('debug', context, message, meta));
+    },
+    info(context, message, meta) {
+        if (shouldLog('info'))
+            console.error(formatMessage('info', context, message, meta));
+    },
+    warn(context, message, meta) {
+        if (shouldLog('warn'))
+            console.error(formatMessage('warn', context, message, meta));
+    },
+    error(context, message, meta) {
+        if (shouldLog('error'))
+            console.error(formatMessage('error', context, message, meta));
+    },
+};
+//# sourceMappingURL=logger.js.map

package/dist/util/processManager.d.ts

@@ -0,0 +1,5 @@
+export declare class ProcessManager {
+    static setupGlobalHandlers(): void;
+    static shutdown(exitCode: number): void;
+}
+//# sourceMappingURL=processManager.d.ts.map

package/dist/util/processManager.js

@@ -0,0 +1,39 @@
+/**
+ * Process management utilities for AIAIAI Agent
+ */
+import { safeLog } from "./safeLog.js";
+export class ProcessManager {
+    static setupGlobalHandlers() {
+        // Handle uncaught exceptions
+        process.on('uncaughtException', (error) => {
+            safeLog('[UNCAUGHT_EXCEPTION] ' + error.message);
+            if (error.stack) {
+                safeLog('[STACK_TRACE] ' + error.stack);
+            }
+            // Gracefully shutdown
+            this.shutdown(1);
+        });
+        // Handle unhandled promises
+        process.on('unhandledRejection', (reason, promise) => {
+            safeLog('[UNHANDLED_REJECTION] ' + reason?.message || String(reason));
+            // Attempt graceful shutdown
+            this.shutdown(1);
+        });
+        // Handle graceful shutdown signals
+        process.on('SIGTERM', () => {
+            safeLog('[SIGTERM] Received shutdown signal');
+            this.shutdown(0);
+        });
+        process.on('SIGINT', () => {
+            safeLog('[SIGINT] Received shutdown signal');
+            this.shutdown(0);
+        });
+    }
+    static shutdown(exitCode) {
+        // Allow cleanup time
+        setTimeout(() => {
+            process.exit(exitCode);
+        }, 100);
+    }
+}
+//# sourceMappingURL=processManager.js.map

package/dist/util/resilientFetch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * src/util/resilientFetch.ts - Resilient HTTP client with timeout, retry, circuit breaker
+ */
+export interface FetchOptions {
+    timeout?: number;
+    retries?: number;
+    backoffMs?: number;
+    onRetry?: (attempt: number, error: Error) => void;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+}
+export interface CircuitState {
+    failures: number;
+    lastFailureTime: number;
+    state: "closed" | "open" | "half-open";
+}
+export declare function resilientFetch(url: string, options?: FetchOptions): Promise<Response>;
+export declare function isReachable(url: string, timeout?: number): Promise<boolean>;
+//# sourceMappingURL=resilientFetch.d.ts.map

package/dist/util/resilientFetch.js

@@ -0,0 +1,94 @@
+/**
+ * src/util/resilientFetch.ts - Resilient HTTP client with timeout, retry, circuit breaker
+ */
+const circuits = new Map();
+const CIRCUIT_THRESHOLD = 3;
+const CIRCUIT_RESET_MS = 60_000;
+function getCircuit(key) {
+    let c = circuits.get(key);
+    if (!c) {
+        c = { failures: 0, lastFailureTime: 0, state: "closed" };
+        circuits.set(key, c);
+    }
+    return c;
+}
+function canExecute(key) {
+    const c = getCircuit(key);
+    if (c.state === "closed")
+        return true;
+    if (c.state === "open" && Date.now() - c.lastFailureTime > CIRCUIT_RESET_MS) {
+        c.state = "half-open";
+        return true;
+    }
+    return c.state === "half-open";
+}
+function recordSuccess(key) {
+    const c = getCircuit(key);
+    c.failures = 0;
+    c.state = "closed";
+}
+function recordFailure(key) {
+    const c = getCircuit(key);
+    c.failures++;
+    c.lastFailureTime = Date.now();
+    if (c.failures >= CIRCUIT_THRESHOLD) {
+        c.state = "open";
+    }
+}
+export async function resilientFetch(url, options = {}) {
+    const { timeout = 8_000, retries = 2, backoffMs = 1_000, onRetry, method = "GET", headers, body, signal: externalSignal, } = options;
+    const circuitKey = new URL(url).hostname;
+    if (!canExecute(circuitKey)) {
+        throw new Error("Circuit open for " + circuitKey + " - service unavailable, retry later");
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        // Combine external abort signal with timeout
+        if (externalSignal) {
+            if (externalSignal.aborted)
+                controller.abort();
+            else
+                externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
+        }
+        try {
+            const response = await fetch(url, {
+                signal: controller.signal,
+                method,
+                headers,
+                body,
+            });
+            clearTimeout(timer);
+            if (!response.ok) {
+                throw new Error("HTTP " + response.status + ": " + response.statusText);
+            }
+            recordSuccess(circuitKey);
+            return response;
+        }
+        catch (error) {
+            clearTimeout(timer);
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < retries) {
+                onRetry?.(attempt + 1, lastError);
+                const delay = backoffMs * Math.pow(2, attempt);
+                await new Promise((r) => setTimeout(r, delay));
+            }
+        }
+    }
+    recordFailure(circuitKey);
+    throw lastError;
+}
+export async function isReachable(url, timeout = 5_000) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(timer);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=resilientFetch.js.map

package/dist/util/responseCache.d.ts

@@ -0,0 +1,27 @@
+/**
+ * src/util/responseCache.ts — TTL-based response cache for external APIs
+ */
+/**
+ * Get cached value or undefined if expired/missing.
+ */
+export declare function getCached<T>(key: string): T | undefined;
+/**
+ * Set value in cache with TTL (default 60s).
+ */
+export declare function setCache<T>(key: string, data: T, ttlMs?: number): void;
+/**
+ * Get or compute: return cached value, or compute, cache, and return.
+ */
+export declare function getOrCompute<T>(key: string, compute: () => Promise<T>, ttlMs?: number): Promise<T>;
+/**
+ * Clear all cached values.
+ */
+export declare function clearCache(): void;
+/**
+ * Get cache stats for diagnostics.
+ */
+export declare function cacheStats(): {
+    size: number;
+    entries: string[];
+};
+//# sourceMappingURL=responseCache.d.ts.map

package/dist/util/responseCache.js

@@ -0,0 +1,54 @@
+/**
+ * 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).
+ */
+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.
+ */
+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.
+ */
+export function clearCache() {
+    cache.clear();
+}
+/**
+ * Get cache stats for diagnostics.
+ */
+export function cacheStats() {
+    return { size: cache.size, entries: [...cache.keys()] };
+}
+//# sourceMappingURL=responseCache.js.map

package/dist/util/safeLog.d.ts

@@ -1,8 +1,7 @@
 /**
- * safeLog — wraps console.log/error/warn to avoid corrupting Ink TUI output.
+ * src/util/safeLog.ts — Intercepts console output, masks secrets, routes to file
  */
-export declare function wireNotify(fn: (msg: string) => void): void;
-declare function safeLogFn(...args: unknown[]): void;
-export declare const safeLog: typeof safeLogFn;
-export {};
+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,38 +1,76 @@
 /**
- * safeLog — wraps console.log/error/warn to avoid corrupting Ink TUI output.
+ * src/util/safeLog.ts — Intercepts console output, masks secrets, routes to file
  */
-const queue = [];
-let notifyFn = null;
-let scheduled = false;
-export function wireNotify(fn) {
-    notifyFn = fn;
-    // Drain any queued messages
-    if (queue.length > 0) {
-        for (const msg of queue)
-            fn(msg);
-        queue.length = 0;
+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
+];
+const SENSITIVE_ENV_NAMES = [
+    '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;
+}
+function ensureLogDir() {
+    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 */ }
 }
-function safeLogFn(...args) {
-    const msg = args.map(a => (typeof a === "string" ? a : JSON.stringify(a))).join(" ");
-    if (notifyFn) {
-        notifyFn(msg);
+export function wireNotify(fn) {
+    // Wire to notification callback if provided
+    if (fn) {
+        // placeholder for notification integration
     }
-    else {
-        queue.push(msg);
-        if (!scheduled) {
-            scheduled = true;
-            process.nextTick(() => {
-                // If no notifyFn registered by next tick, just write to stderr
-                if (!notifyFn && queue.length > 0) {
-                    for (const m of queue)
-                        process.stderr.write(m + "\n");
-                    queue.length = 0;
-                }
-                scheduled = false;
-            });
-        }
+}
+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');
+}
+// 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`);
+    };
 }
-export const safeLog = safeLogFn;
 //# sourceMappingURL=safeLog.js.map

package/dist/util/scheduler.d.ts

@@ -0,0 +1,14 @@
+/**
+ * src/util/scheduler.ts — Centralized interval scheduler with pause/resume
+ */
+export declare function addTask(name: string, intervalMs: number, fn: () => void): void;
+export declare function removeTask(name: string): void;
+export declare function pauseTask(name: string): void;
+export declare function resumeTask(name: string): void;
+export declare function pauseAll(): void;
+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

@@ -0,0 +1,75 @@
+/**
+ * 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 });
+    }
+}
+export function removeTask(name) {
+    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;
+}
+export function resumeTask(name) {
+    const task = tasks.find(t => t.name === name);
+    if (task)
+        task.paused = false;
+}
+export function pauseAll() {
+    tasks.forEach(t => (t.paused = true));
+}
+export function resumeAll() {
+    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;
+    };
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/util/webhooks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * src/util/webhooks.ts — Discord & Telegram notification webhooks.
+ * Configure via ~/.aiaiai/.env with WEBHOOK_DISCORD and/or WEBHOOK_TELEGRAM.
+ */
+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

@@ -0,0 +1,75 @@
+/**
+ * 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;
+}
+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;
+    }
+}
+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;
+    }
+}
+function extractTelegramChatId(url) {
+    // URL format: https://api.telegram.org/bot<TOKEN>/sendMessage?chat_id=<ID>
+    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");
+    }
+}
+export function hasWebhooks() {
+    return !!(getWebhookUrl("discord") || getWebhookUrl("telegram"));
+}
+//# sourceMappingURL=webhooks.js.map

package/dist/wallet/ActionFeed.js

@@ -5,18 +5,22 @@
  */
 import { Type } from "@sinclair/typebox";
 import { ACTION_WALLET, AIAIAI_MINT } from "./AgentWallet.js";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
 function getRpcUrl() {
     return process.env.SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
 }
 async function rpcCall(method, params = []) {
-    const response = await fetch(getRpcUrl(), {
+    const response = await resilientFetch(getRpcUrl(), {
+        timeout: 15_000,
+        retries: 2,
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
     });
     const data = await response.json();
     if (data.error)
-        throw new Error(data.error.message);
+        throw new Error(data.error.message || 'Unknown RPC error');
     return data.result;
 }
 export class ActionFeed {
@@ -46,7 +50,9 @@ export class ActionFeed {
                 this.lastSignature = signatures[0].signature;
             }
         }
-        catch { /* non-fatal */ }
+        catch (error) {
+            logger.debug('ActionFeed', 'refresh failed', { error: error.message });
+        }
     }
     async processTransaction(signature) {
         try {
@@ -100,7 +106,9 @@ export class ActionFeed {
             if (this.actions.length > 50)
                 this.actions = this.actions.slice(0, 50);
         }
-        catch { /* skip this tx */ }
+        catch (error) {
+            logger.debug('ActionFeed', 'Failed to parse tx', { error: error.message });
+        }
     }
     setPrice(p) {
         if (p > 0)

package/dist/wallet/AgentWallet.d.ts

@@ -13,6 +13,7 @@ export declare const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjn
 export declare const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
 export declare const SIGNER = "GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG";
 export declare const AIAIAI_MINT = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
+export declare const AIAIAI_TOKEN = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
 export interface WalletBalance {
     address: string;
     sol: number;
@@ -32,6 +33,7 @@ export declare class AgentWallet {
     getColdWallet(): Promise<WalletBalance>;
     getActionWallet(): Promise<WalletBalance>;
     getDepositWallet(): Promise<WalletBalance>;
+    getSolPrice(): Promise<number>;
     getAgentBalanceParams: import("@sinclair/typebox").TObject<{}>;
     getDepositBalanceParams: import("@sinclair/typebox").TObject<{}>;
     getAgentBalanceTool(): Promise<ToolResult>;