@aiaiaichain/agent 0.1.4 → 0.1.6

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.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";

package/dist/wallet/ActionFeed.js

@@ -1,22 +1,27 @@
 /**
  * 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 } 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 +51,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 {
@@ -56,71 +63,91 @@ export class ActionFeed {
             ]);
             if (!tx || !tx.meta)
                 return;
-            const preBalances = tx.meta.preTokenBalances ?? [];
-            const postBalances = tx.meta.postTokenBalances ?? [];
-            // Find AIAIAI balance changes for the action wallet
-            for (const post of postBalances) {
-                if (post.mint !== AIAIAI_MINT)
-                    continue;
-                if (post.owner !== ACTION_WALLET)
-                    continue;
-                const pre = preBalances.find((p) => p.accountIndex === post.accountIndex && p.mint === AIAIAI_MINT);
-                const preAmt = pre ? parseFloat(pre.uiTokenAmount?.uiAmount ?? "0") : 0;
-                const postAmt = parseFloat(post.uiTokenAmount?.uiAmount ?? "0");
-                const diff = postAmt - preAmt;
-                // Skip negligible changes
-                if (Math.abs(diff) < 0.000001)
-                    continue;
-                // Positive diff = tokens came IN = BUY
-                // Negative diff = tokens went OUT = BURN
-                const type = diff > 0 ? "buy" : "burn";
-                const amount = Math.abs(diff);
-                const usdValue = amount * this._price;
-                // Fee: 0.5% of action value
-                const fee = usdValue * 0.005;
-                if (type === "buy") {
-                    this.fees.buyFees += fee;
+            // Parse inner instructions for Pump.fun Buy + BurnChecked on AIAIAI
+            const innerInstructions = tx.meta.innerInstructions ?? [];
+            let buyAmount = 0;
+            let burnAmount = 0;
+            for (const inner of innerInstructions) {
+                for (const ix of (inner.instructions ?? [])) {
+                    // Pump.fun Buy: transferChecked of AIAIAI from pool to hot wallet
+                    if (ix.parsed?.type === "transferChecked" &&
+                        ix.parsed.info?.mint === AIAIAI_MINT) {
+                        const amt = parseFloat(ix.parsed.info?.tokenAmount?.uiAmount ?? "0");
+                        if (amt > 1)
+                            buyAmount += amt;
+                    }
+                    // Burn: burnChecked of AIAIAI
+                    if (ix.parsed?.type === "burnChecked" &&
+                        ix.parsed.info?.mint === AIAIAI_MINT) {
+                        const amt = parseFloat(ix.parsed.info?.tokenAmount?.uiAmount ?? "0");
+                        if (amt > 0)
+                            burnAmount += amt;
+                    }
                 }
-                else {
-                    this.fees.burnFees += fee;
+            }
+            // Fallback: scan token balance changes for any AIAIAI account
+            if (buyAmount === 0 && burnAmount === 0) {
+                const preBalances = tx.meta.preTokenBalances ?? [];
+                const postBalances = tx.meta.postTokenBalances ?? [];
+                for (const post of postBalances) {
+                    if (post.mint !== AIAIAI_MINT)
+                        continue;
+                    const pre = preBalances.find((p) => p.accountIndex === post.accountIndex && p.mint === AIAIAI_MINT);
+                    const preAmt = pre ? parseFloat(pre.uiTokenAmount?.uiAmount ?? "0") : 0;
+                    const postAmt = parseFloat(post.uiTokenAmount?.uiAmount ?? "0");
+                    const diff = postAmt - preAmt;
+                    if (Math.abs(diff) < 0.000001)
+                        continue;
+                    if (diff > 0)
+                        buyAmount += diff;
+                    else
+                        burnAmount += Math.abs(diff);
                 }
+            }
+            // Record
+            if (buyAmount > 0) {
+                const usdValue = buyAmount * this._price;
+                const fee = usdValue * 0.005;
+                this.fees.buyFees += fee;
                 this.fees.total = this.fees.buyFees + this.fees.burnFees;
-                const action = {
-                    id: signature.slice(0, 8),
-                    type,
-                    amount,
-                    token: "AIAIAI",
-                    usdValue,
+                this.actions.unshift({
+                    id: signature.slice(0, 10),
+                    type: "buy", amount: buyAmount, token: "AIAIAI", usdValue,
                     timestamp: (tx.blockTime ?? Math.floor(Date.now() / 1000)) * 1000,
                     signature,
-                };
-                this.actions.unshift(action);
+                });
             }
-            // Keep only last 50
-            if (this.actions.length > 50)
-                this.actions = this.actions.slice(0, 50);
+            if (burnAmount > 0) {
+                const usdValue = burnAmount * this._price;
+                const fee = usdValue * 0.005;
+                this.fees.burnFees += fee;
+                this.fees.total = this.fees.buyFees + this.fees.burnFees;
+                this.actions.unshift({
+                    id: signature.slice(0, 10) + "-b",
+                    type: "burn", amount: burnAmount, token: "AIAIAI", usdValue,
+                    timestamp: (tx.blockTime ?? Math.floor(Date.now() / 1000)) * 1000,
+                    signature,
+                });
+            }
+            if (this.actions.length > 100)
+                this.actions = this.actions.slice(0, 100);
+        }
+        catch (error) {
+            logger.debug('ActionFeed', 'Failed to parse tx', { error: error.message });
         }
-        catch { /* skip this tx */ }
     }
     setPrice(p) {
         if (p > 0)
             this._price = p;
     }
-    getActions() {
-        return [...this.actions];
-    }
-    getRecentActions(limit = 10) {
-        return this.actions.slice(0, limit);
-    }
-    getFees() {
-        return { ...this.fees };
-    }
+    getActions() { return [...this.actions]; }
+    getRecentActions(limit = 10) { return this.actions.slice(0, limit); }
+    getFees() { return { ...this.fees }; }
     getActionSummary() {
         const buys = this.actions.filter(a => a.type === "buy");
         const burns = this.actions.filter(a => a.type === "burn");
         return {
-            buys: buys.length,
-            burns: burns.length,
+            buys: buys.length, burns: burns.length,
             totalBought: buys.reduce((s, a) => s + a.amount, 0),
             totalBurned: burns.reduce((s, a) => s + a.amount, 0),
         };
@@ -138,32 +165,26 @@ export class ActionFeed {
                 content: [{
                         type: "text",
                         text: [
-                            "No agent buy/burn actions detected yet.",
-                            "",
-                            `Action wallet: ${ACTION_WALLET}`,
-                            "The agent buys and burns $AIAIAI. Actions appear here when detected on-chain.",
+                            "No buy/burn actions detected yet.",
+                            `Action wallet: ${ACTION_WALLET.slice(0, 8)}…${ACTION_WALLET.slice(-6)}`,
+                            "Actions appear when the agent buys and burns $AIAIAI via Pump.fun.",
                         ].join("\n"),
                     }],
             };
         }
-        const lines = actions.map(a => {
-            const icon = a.type === "buy" ? "↗" : "🔥";
-            const time = new Date(a.timestamp).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
-            return `  ${icon} ${time}  ${a.type.toUpperCase().padEnd(6)} ${a.amount.toLocaleString()} $AIAIAI  ($${a.usdValue.toFixed(2)})`;
-        });
         const summary = this.getActionSummary();
-        return {
-            content: [{
-                    type: "text",
-                    text: [
-                        `Agent Actions (last ${actions.length})`,
-                        `  Buys: ${summary.buys} (${summary.totalBought.toLocaleString()} $AIAIAI)`,
-                        `  Burns: ${summary.burns} (${summary.totalBurned.toLocaleString()} $AIAIAI)`,
-                        ``,
-                        ...lines,
-                    ].join("\n"),
-                }],
-        };
+        const lines = [
+            `🔄 Recent Actions (${actions.length})`,
+            `  Buys: ${summary.buys} (${summary.totalBought.toLocaleString()} $AIAIAI)`,
+            `  Burns: ${summary.burns} (${summary.totalBurned.toLocaleString()} $AIAIAI)`,
+            "",
+            ...actions.map(a => {
+                const icon = a.type === "buy" ? "↗" : "🔥";
+                const time = new Date(a.timestamp).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+                return `  ${icon} ${time}  ${a.type.toUpperCase().padEnd(4)} ${a.amount.toLocaleString()} $AIAIAI  ($${a.usdValue.toFixed(2)})`;
+            }),
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
     }
     async getFeesTool() {
         const f = this.getFees();
@@ -171,7 +192,7 @@ export class ActionFeed {
             content: [{
                     type: "text",
                     text: [
-                        `Agent Fees (0.5% per action)`,
+                        `💵 Agent Fees (0.5% per action)`,
                         `  Buy fees:   $${f.buyFees.toFixed(4)}`,
                         `  Burn fees:  $${f.burnFees.toFixed(4)}`,
                         `  ─────────────────────`,

package/dist/wallet/AgentWallet.d.ts

@@ -8,9 +8,10 @@
  *   Signer:  GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG  (authority)
  */
 import type { ToolResult } from "../api/ExtensionAPI.js";
-export declare const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
-export declare const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
+export declare const ACTION_WALLET = "GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG";
+export declare const HOT_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
 export declare const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
+export declare const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
 export declare const SIGNER = "GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG";
 export declare const AIAIAI_MINT = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
 export declare const AIAIAI_TOKEN = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
@@ -23,6 +24,7 @@ export interface WalletBalance {
 export interface AgentWallets {
     cold: WalletBalance;
     action: WalletBalance;
+    hot: WalletBalance;
     deposit: WalletBalance;
 }
 export declare class AgentWallet {
@@ -33,6 +35,8 @@ export declare class AgentWallet {
     getColdWallet(): Promise<WalletBalance>;
     getActionWallet(): Promise<WalletBalance>;
     getDepositWallet(): Promise<WalletBalance>;
+    getSolPrice(): Promise<number>;
+    getHotWallet(): Promise<WalletBalance>;
     getAgentBalanceParams: import("@sinclair/typebox").TObject<{}>;
     getDepositBalanceParams: import("@sinclair/typebox").TObject<{}>;
     getAgentBalanceTool(): Promise<ToolResult>;