@aiaiaichain/agent 0.1.4 → 0.1.5

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

@@ -33,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>;

package/dist/wallet/AgentWallet.js

@@ -8,6 +8,8 @@
  *   Signer:  GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG  (authority)
  */
 import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
 export const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
 export const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
 export const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
@@ -19,14 +21,21 @@ 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);
+    if (data.error) {
+        const msg = data.error.message || 'Unknown RPC error';
+        if (data.error.code === -32005 || msg.includes('rate limit')) {
+            logger.warn('AgentWallet', 'RPC rate limited', { method, code: data.error.code });
+        }
+        throw new Error(msg);
+    }
     return data.result;
 }
 async function getBalance(address) {
@@ -34,7 +43,8 @@ async function getBalance(address) {
         const result = await rpcCall("getBalance", [address]);
         return (result?.value ?? 0) / 1e9;
     }
-    catch {
+    catch (error) {
+        logger.warn('AgentWallet', 'getBalance failed', { address, error: error.message });
         return 0;
     }
 }
@@ -50,7 +60,8 @@ async function getTokenBalance(address, mint) {
             return 0;
         return parseFloat(accounts[0]?.account?.data?.parsed?.info?.tokenAmount?.uiAmount ?? "0");
     }
-    catch {
+    catch (error) {
+        logger.warn('AgentWallet', 'getTokenBalance failed', { address, mint, error: error.message });
         return 0;
     }
 }
@@ -62,6 +73,9 @@ export class AgentWallet {
         if (this.cachedWallets && Date.now() - this.lastFetch < this.cacheDuration) {
             return this.cachedWallets;
         }
+        // Parallel: 3 SOL balances + 6 token balances (9 concurrent queries)
+        const wallets = [COLD_WALLET, ACTION_WALLET, DEPOSIT_WALLET];
+        const mints = [AIAIAI_MINT, USDC_MINT];
         const [coldSol, coldAiai, coldUsdc, actionSol, actionAiai, actionUsdc, depSol, depAiai, depUsdc] = await Promise.all([
             getBalance(COLD_WALLET),
             getTokenBalance(COLD_WALLET, AIAIAI_MINT),
@@ -90,6 +104,17 @@ export class AgentWallet {
     async getDepositWallet() {
         return (await this.getAll()).deposit;
     }
+    // Get live SOL price from PriceFeed
+    async getSolPrice() {
+        try {
+            const { priceFeed } = await import("../tools/PriceFeed.js");
+            const result = await priceFeed.fetchToken("So11111111111111111111111111111111111111112");
+            return parseFloat(result.priceUsd ?? "150");
+        }
+        catch {
+            return 150; // fallback
+        }
+    }
     // ── Tools ───────────────────────────────────────────────────────────────
     getAgentBalanceParams = Type.Object({});
     getDepositBalanceParams = Type.Object({});

package/dist/wallet/ProfitTracker.d.ts

@@ -0,0 +1,30 @@
+/**
+/ProfitTracker.ts - Track cost basis and P&L for agent wallet trades
+ */
+export interface Trade {
+    timestamp: number;
+    type: "buy" | "sell" | "burn";
+    tokenAmount: number;
+    solAmount: number;
+    pricePerToken: number;
+    txSignature?: string;
+}
+export interface ProfitState {
+    trades: Trade[];
+    totalSpent: number;
+    totalReceived: number;
+    avgCostBasis: number;
+}
+export interface PLSummary {
+    avgCostBasis: number;
+    totalSpent: number;
+    totalReceived: number;
+    realizedPL: number;
+    unrealizedPL: number;
+    roi: number;
+}
+export declare function recordTrade(type: "buy" | "sell" | "burn", tokenAmount: number, solAmount: number, txSignature?: string): void;
+export declare function getPLSummary(currentTokenPrice: number): PLSummary;
+export declare function getTradeHistory(): Trade[];
+export declare function exportCSV(): string;
+//# sourceMappingURL=ProfitTracker.d.ts.map

package/dist/wallet/ProfitTracker.js

@@ -0,0 +1,93 @@
+/**
+/ProfitTracker.ts - Track cost basis and P&L for agent wallet trades
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { logger } from "../util/logger.js";
+const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
+const TRACKER_DIR = join(AIAIAI_HOME, ".tracker");
+const TRACKER_FILE = join(TRACKER_DIR, "pl.json");
+function loadState() {
+    try {
+        const raw = readFileSync(TRACKER_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { trades: [], totalSpent: 0, totalReceived: 0, avgCostBasis: 0 };
+    }
+}
+function saveState(state) {
+    try {
+        if (!existsSync(TRACKER_DIR)) {
+            mkdirSync(TRACKER_DIR, { recursive: true, mode: 0o700 });
+        }
+        writeFileSync(TRACKER_FILE, JSON.stringify(state, null, 2), "utf-8");
+    }
+    catch (error) {
+        logger.warn("ProfitTracker", "Failed to save state", { error: error.message });
+    }
+}
+export function recordTrade(type, tokenAmount, solAmount, txSignature) {
+    const state = loadState();
+    const pricePerToken = tokenAmount > 0 ? solAmount / tokenAmount : 0;
+    const trade = {
+        timestamp: Date.now(),
+        type,
+        tokenAmount,
+        solAmount,
+        pricePerToken,
+        txSignature,
+    };
+    state.trades.push(trade);
+    if (type === "buy") {
+        state.totalSpent += solAmount;
+        const totalTokensInvested = state.trades
+            .filter(t => t.type === "buy")
+            .reduce((sum, t) => sum + t.tokenAmount, 0);
+        state.avgCostBasis = totalTokensInvested > 0 ? state.totalSpent / totalTokensInvested : 0;
+    }
+    else if (type === "sell") {
+        state.totalReceived += solAmount;
+    }
+    saveState(state);
+    logger.info("ProfitTracker", "Recorded " + type, { tokenAmount, solAmount, pricePerToken });
+}
+export function getPLSummary(currentTokenPrice) {
+    const state = loadState();
+    const buyTrades = state.trades.filter(t => t.type === "buy");
+    const totalBought = buyTrades.reduce((sum, t) => sum + t.tokenAmount, 0);
+    const totalSoldOrBurned = state.trades
+        .filter(t => t.type === "sell" || t.type === "burn")
+        .reduce((sum, t) => sum + t.tokenAmount, 0);
+    const remainingTokens = totalBought - totalSoldOrBurned;
+    const realizedPL = state.totalReceived - (state.totalSpent * (totalSoldOrBurned / Math.max(totalBought, 1)));
+    const unrealizedPL = remainingTokens * currentTokenPrice;
+    const totalPL = realizedPL + unrealizedPL;
+    const roi = state.totalSpent > 0 ? (totalPL / state.totalSpent) * 100 : 0;
+    return {
+        avgCostBasis: state.avgCostBasis,
+        totalSpent: state.totalSpent,
+        totalReceived: state.totalReceived,
+        realizedPL,
+        unrealizedPL,
+        roi,
+    };
+}
+export function getTradeHistory() {
+    return loadState().trades;
+}
+export function exportCSV() {
+    const state = loadState();
+    const header = "timestamp,type,tokenAmount,solAmount,pricePerToken,txSignature";
+    const rows = state.trades.map(t => t.timestamp + "," + t.type + "," + t.tokenAmount + "," + t.solAmount + "," + t.pricePerToken + "," + (t.txSignature ?? ""));
+    const csv = header + "\n" + rows.join("\n");
+    const csvPath = join(TRACKER_DIR, "pl-export.csv");
+    if (!existsSync(TRACKER_DIR)) {
+        mkdirSync(TRACKER_DIR, { recursive: true, mode: 0o700 });
+    }
+    writeFileSync(csvPath, csv, "utf-8");
+    logger.info("ProfitTracker", "Exported CSV", { path: csvPath });
+    return csvPath;
+}
+//# sourceMappingURL=ProfitTracker.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiaiaichain/agent",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "AIAIAI Chain Agent — Solana-native AI agent for decentralized AI governance. Ticker: $AIAIAI",
   "author": "AIAIAI Foundation",
   "license": "MIT",