@aiaiaichain/agent 0.1.5 → 0.1.7

package/dist/core/AgentDir.d.ts

@@ -3,8 +3,8 @@
  * Created on first run. Contains config, memory, sessions, skills.
  */
 export declare class AgentDir {
+    static getInstance(): typeof AgentDir;
     static init(): void;
     static path(...parts: string[]): string;
     static getHome(): string;
 }
-//# sourceMappingURL=AgentDir.d.ts.map

package/dist/core/AgentDir.js

@@ -1,17 +1,14 @@
-/**
- * AgentDir — manages the AIAIAI home directory (~/.aiaiai/)
- * Created on first run. Contains config, memory, sessions, skills.
- */
+
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
 const HOME = process.env.AIAIAI_HOME ?? resolve(homedir(), '.aiaiai');
 const DIRS = [
-    'config',
-    'memory',
-    'checkpoints',
-    'sessions',
-    'skills',
+'config',
+'memory',
+'checkpoints',
+'sessions',
+'skills',
 ];
 const AIAIAI_MD_CONTENT = `# AIAIAI Chain Agent
 
@@ -40,35 +37,44 @@ aiaiaichain config  — show configuration
 aiaiaichain price   — show $AIAIAI token price
 \`\`\`
 `;
+
+let _initialized = false;
+let _homePath = "";
 export class AgentDir {
-    static init() {
-        if (!existsSync(HOME))
-            mkdirSync(HOME, { recursive: true });
-        for (const dir of DIRS) {
-            const full = resolve(HOME, dir);
-            if (!existsSync(full))
-                mkdirSync(full, { recursive: true });
-        }
-        const mdPath = resolve(HOME, 'AIAIAI.md');
-        if (!existsSync(mdPath))
-            writeFileSync(mdPath, AIAIAI_MD_CONTENT, 'utf-8');
-        const histPath = resolve(HOME, 'history.jsonl');
-        if (!existsSync(histPath))
-            writeFileSync(histPath, '', 'utf-8');
-        const settingsPath = resolve(HOME, 'settings.json');
-        if (!existsSync(settingsPath)) {
-            writeFileSync(settingsPath, JSON.stringify({
-                theme: 'dark',
-                autoSave: true,
-                activeChain: 'solana',
-            }, null, 2), 'utf-8');
-        }
-    }
-    static path(...parts) {
-        return resolve(HOME, ...parts);
-    }
-    static getHome() {
-        return HOME;
-    }
+static getInstance() {
+return AgentDir;
+}
+static init() {
+if (_initialized)
+return;
+if (!existsSync(HOME))
+mkdirSync(HOME, { recursive: true });
+for (const dir of DIRS) {
+const full = resolve(HOME, dir);
+if (!existsSync(full))
+mkdirSync(full, { recursive: true });
+}
+const mdPath = resolve(HOME, 'AIAIAI.md');
+if (!existsSync(mdPath))
+writeFileSync(mdPath, AIAIAI_MD_CONTENT, 'utf-8');
+const histPath = resolve(HOME, 'history.jsonl');
+if (!existsSync(histPath))
+writeFileSync(histPath, '', 'utf-8');
+const settingsPath = resolve(HOME, 'settings.json');
+if (!existsSync(settingsPath)) {
+writeFileSync(settingsPath, JSON.stringify({
+theme: 'dark',
+autoSave: true,
+activeChain: 'solana',
+}, null, 2), 'utf-8');
+}
+_initialized = true;
+_homePath = HOME;
+}
+static path(...parts) {
+return resolve(HOME, ...parts);
+}
+static getHome() {
+return HOME;
+}
 }
-//# sourceMappingURL=AgentDir.js.map

package/dist/core/ChainConfig.d.ts

@@ -16,4 +16,3 @@ export declare function getPrimaryChain(): ChainInfo;
 export declare function getEnabledChains(): ChainInfo[];
 export declare function getChain(name: string): ChainInfo | undefined;
 export declare function getSupportedChains(): string[];
-//# sourceMappingURL=ChainConfig.d.ts.map

package/dist/core/ChainConfig.js

@@ -1,65 +1,61 @@
-/**
- * ChainConfig — single source of truth for supported chains.
- * Solana is the default/primary chain. EVM chains are available but disabled by default.
- */
+
 export const CHAINS = {
-    solana: {
-        name: 'solana',
-        symbol: 'SOL',
-        chainId: 101,
-        rpcUrl: process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com',
-        explorerUrl: 'https://solscan.io',
-        enabled: true,
-        primary: true,
-    },
-    ethereum: {
-        name: 'ethereum',
-        symbol: 'ETH',
-        chainId: 1,
-        rpcUrl: 'https://eth-mainnet.g.alchemy.com/v2/',
-        explorerUrl: 'https://etherscan.io',
-        enabled: false,
-        primary: false,
-    },
-    bsc: {
-        name: 'bsc',
-        symbol: 'BNB',
-        chainId: 56,
-        rpcUrl: 'https://bsc-dataseed.binance.org',
-        explorerUrl: 'https://bscscan.com',
-        enabled: false,
-        primary: false,
-    },
-    base: {
-        name: 'base',
-        symbol: 'ETH',
-        chainId: 8453,
-        rpcUrl: 'https://mainnet.base.org',
-        explorerUrl: 'https://basescan.org',
-        enabled: false,
-        primary: false,
-    },
-    arbitrum: {
-        name: 'arbitrum',
-        symbol: 'ETH',
-        chainId: 42161,
-        rpcUrl: 'https://arb1.arbitrum.io/rpc',
-        explorerUrl: 'https://arbiscan.io',
-        enabled: false,
-        primary: false,
-    },
+solana: {
+name: 'solana',
+symbol: 'SOL',
+chainId: 101,
+rpcUrl: process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com',
+explorerUrl: 'https://solscan.io',
+enabled: true,
+primary: true,
+},
+ethereum: {
+name: 'ethereum',
+symbol: 'ETH',
+chainId: 1,
+rpcUrl: 'https://eth-mainnet.g.alchemy.com/v2/',
+explorerUrl: 'https://etherscan.io',
+enabled: false,
+primary: false,
+},
+bsc: {
+name: 'bsc',
+symbol: 'BNB',
+chainId: 56,
+rpcUrl: 'https://bsc-dataseed.binance.org',
+explorerUrl: 'https://bscscan.com',
+enabled: false,
+primary: false,
+},
+base: {
+name: 'base',
+symbol: 'ETH',
+chainId: 8453,
+rpcUrl: 'https://mainnet.base.org',
+explorerUrl: 'https://basescan.org',
+enabled: false,
+primary: false,
+},
+arbitrum: {
+name: 'arbitrum',
+symbol: 'ETH',
+chainId: 42161,
+rpcUrl: 'https://arb1.arbitrum.io/rpc',
+explorerUrl: 'https://arbiscan.io',
+enabled: false,
+primary: false,
+},
 };
 export function getPrimaryChain() {
-    const primary = Object.values(CHAINS).find(c => c.primary);
-    return primary ?? CHAINS.solana;
+const primary = Object.values(CHAINS).find(c => c.primary);
+return primary ?? CHAINS.solana;
 }
 export function getEnabledChains() {
-    return Object.values(CHAINS).filter(c => c.enabled);
+return Object.values(CHAINS).filter(c => c.enabled);
 }
 export function getChain(name) {
-    return CHAINS[name];
+return CHAINS[name];
 }
 export function getSupportedChains() {
-    return Object.keys(CHAINS);
+return Object.keys(CHAINS);
 }
-//# sourceMappingURL=ChainConfig.js.map

package/dist/core/EnvLoader.d.ts

@@ -5,6 +5,10 @@ export declare class EnvLoader {
     private cache;
     private envPath;
     constructor();
+    /**
+     * #24: Validate .env file permissions on startup
+     */
+    private validatePermissions;
     private load;
     get(key: string, defaultValue?: string): string | undefined;
     getRequired(key: string): string;
@@ -15,4 +19,3 @@ export declare class EnvLoader {
     reload(): void;
 }
 export declare const env: EnvLoader;
-//# sourceMappingURL=EnvLoader.d.ts.map

package/dist/core/EnvLoader.js

@@ -1,90 +1,103 @@
-/**
- * EnvLoader — loads/writes environment variables from ~/.aiaiai/.env
- */
+
 import { existsSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
 import { resolve } from "node:path";
 import { homedir } from "node:os";
 export class EnvLoader {
-    cache = {};
-    envPath;
-    constructor() {
-        const home = process.env.AIAIAI_HOME ?? resolve(homedir(), '.aiaiai');
-        this.envPath = resolve(home, ".env");
-        this.load();
-    }
-    load() {
-        if (existsSync(this.envPath)) {
-            const content = readFileSync(this.envPath, "utf-8");
-            for (const line of content.split("\n")) {
-                const trimmed = line.trim();
-                if (!trimmed || trimmed.startsWith("#"))
-                    continue;
-                const eqIdx = trimmed.indexOf("=");
-                if (eqIdx === -1)
-                    continue;
-                const key = trimmed.slice(0, eqIdx).trim();
-                const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
-                if (key)
-                    this.cache[key] = value;
-            }
-        }
-        for (const key of Object.keys(process.env)) {
-            const value = process.env[key];
-            if (value !== undefined)
-                this.cache[key] = value;
-        }
-    }
-    get(key, defaultValue) {
-        return this.cache[key] ?? defaultValue;
-    }
-    getRequired(key) {
-        const value = this.get(key);
-        if (!value)
-            throw new Error(`Required env var ${key} is not set`);
-        return value;
-    }
-    has(key) {
-        return this.cache[key] !== undefined && this.cache[key].trim() !== "";
-    }
-    /** Write a key=value to the .env file and update cache */
-    set(key, value) {
-        const content = existsSync(this.envPath) ? readFileSync(this.envPath, "utf-8") : "";
-        const lines = content.split("\n");
-        let found = false;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            if (line.startsWith(`${key}=`)) {
-                lines[i] = `${key}=${value}`;
-                found = true;
-                break;
-            }
-        }
-        if (!found) {
-            if (content && !content.endsWith("\n"))
-                lines.push("");
-            lines.push(`${key}=${value}`);
-        }
-        const newContent = lines.join("\n") + "\n";
-        writeFileSync(this.envPath, newContent, "utf-8");
-        try {
-            chmodSync(this.envPath, 0o600);
-        }
-        catch { /* non-fatal */ }
-        this.cache[key] = value;
-        process.env[key] = value;
-    }
-    getAll() {
-        const result = {};
-        for (const [key, value] of Object.entries(this.cache)) {
-            if (value !== undefined)
-                result[key] = value;
-        }
-        return result;
-    }
-    reload() {
-        this.cache = {};
-        this.load();
-    }
+cache = {};
+envPath;
+constructor() {
+const home = process.env.AIAIAI_HOME ?? resolve(homedir(), '.aiaiai');
+this.envPath = resolve(home, ".env");
+this.load();
+this.validatePermissions();
+}
+
+validatePermissions() {
+try {
+if (!existsSync(this.envPath))
+return;
+const { statSync } = require('node:fs');
+const stats = statSync(this.envPath);
+const mode = stats.mode & 0o777;
+
+if (mode & 0o077) {
+console.warn(`⚠️  .env file has overly permissive permissions (${mode.toString(8)}). Run: chmod 600 ${this.envPath}`);
+}
+}
+catch {  }
+}
+load() {
+if (existsSync(this.envPath)) {
+const content = readFileSync(this.envPath, "utf-8");
+for (const line of content.split("\n")) {
+const trimmed = line.trim();
+if (!trimmed || trimmed.startsWith("#"))
+continue;
+const eqIdx = trimmed.indexOf("=");
+if (eqIdx === -1)
+continue;
+const key = trimmed.slice(0, eqIdx).trim();
+const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+if (key)
+this.cache[key] = value;
+}
+}
+for (const key of Object.keys(process.env)) {
+const value = process.env[key];
+if (value !== undefined)
+this.cache[key] = value;
+}
+}
+get(key, defaultValue) {
+return this.cache[key] ?? defaultValue;
+}
+getRequired(key) {
+const value = this.get(key);
+if (!value)
+throw new Error(`Required env var ${key} is not set`);
+return value;
+}
+has(key) {
+return this.cache[key] !== undefined && this.cache[key].trim() !== "";
+}
+
+set(key, value) {
+const content = existsSync(this.envPath) ? readFileSync(this.envPath, "utf-8") : "";
+const lines = content.split("\n");
+let found = false;
+for (let i = 0; i < lines.length; i++) {
+const line = lines[i].trim();
+if (line.startsWith(`${key}=`)) {
+lines[i] = `${key}=${value}`;
+found = true;
+break;
+}
+}
+if (!found) {
+if (content && !content.endsWith("\n"))
+lines.push("");
+lines.push(`${key}=${value}`);
+}
+const newContent = lines.join("\n") + "\n";
+writeFileSync(this.envPath, newContent, "utf-8");
+try {
+chmodSync(this.envPath, 0o600);
+}
+catch {  }
+this.cache[key] = value;
+process.env[key] = value;
+}
+getAll() {
+const result = {};
+for (const [key, value] of Object.entries(this.cache)) {
+if (value !== undefined)
+result[key] = value;
+}
+return result;
+}
+reload() {
+this.cache = {};
+this.load();
+}
 }
 export const env = new EnvLoader();
-//# sourceMappingURL=EnvLoader.js.map

package/dist/core/SystemMonitor.d.ts

@@ -29,4 +29,3 @@ export declare class SystemMonitor {
     resetApiCounter(): number;
 }
 export declare const systemMonitor: SystemMonitor;
-//# sourceMappingURL=SystemMonitor.d.ts.map

package/dist/core/SystemMonitor.js

@@ -1,89 +1,76 @@
-/**
- * SystemMonitor — tracks CPU, RAM, network, and agent stats.
- * Uses Node.js built-in modules only (no external deps).
- */
-import { cpus, totalmem, freemem, uptime } from 'node:os';
+
+import { totalmem, freemem, uptime } from 'node:os';
 import { logger } from '../util/logger.js';
+
+let lastCpuUsage = process.cpuUsage();
 export class SystemMonitor {
-    apiCallCount = 0;
-    prevCpuTimes = { idle: 0, total: 0 };
-    /** Track an API call */
-    trackApiCall() {
-        this.apiCallCount++;
-    }
-    /** Get current system stats */
-    getStats(tokenCount = 0) {
-        return {
-            cpuPercent: this.getCpuPercent(),
-            ramPercent: this.getRamPercent(),
-            ramUsed: this.formatBytes(totalmem() - freemem()),
-            ramTotal: this.formatBytes(totalmem()),
-            uptime: this.formatUptime(uptime()),
-            ...this.getNetStats(),
-            apiCallsPerMin: this.apiCallCount,
-            tokensUsed: tokenCount,
-        };
-    }
-    getCpuPercent() {
-        try {
-            const cpuInfo = cpus();
-            let totalIdle = 0, totalTick = 0;
-            for (const cpu of cpuInfo) {
-                for (const type in cpu.times) {
-                    totalTick += cpu.times[type];
-                }
-                totalIdle += cpu.times.idle;
-            }
-            const idle = totalIdle / cpuInfo.length;
-            const total = totalTick / cpuInfo.length;
-            // Delta-based: compare against previous sample
-            const nowIdle = idle, nowTotal = total;
-            if (this.prevCpuTimes.total > 0) {
-                const idleDelta = nowIdle - this.prevCpuTimes.idle;
-                const totalDelta = nowTotal - this.prevCpuTimes.total;
-                this.prevCpuTimes = { idle: nowIdle, total: nowTotal };
-                if (totalDelta <= 0)
-                    return 0;
-                return Math.round((1 - idleDelta / totalDelta) * 100);
-            }
-            this.prevCpuTimes = { idle: nowIdle, total: nowTotal };
-            return 0;
-        }
-        catch (error) {
-            logger.debug('SystemMonitor', 'CPU measurement failed', { error: error.message });
-            return 0;
-        }
-    }
-    getRamPercent() {
-        const used = totalmem() - freemem();
-        return Math.round((used / totalmem()) * 100);
-    }
-    getNetStats() {
-        // Node.js doesn't expose per-interface byte counters without native addons.
-        // Return N/A rather than pretending zeros are real data.
-        return { netUp: 'N/A', netDown: 'N/A' };
-    }
-    formatBytes(bytes) {
-        if (bytes === 0)
-            return '0 B';
-        const k = 1024;
-        const sizes = ['B', 'KB', 'MB', 'GB'];
-        const i = Math.floor(Math.log(bytes) / Math.log(k));
-        return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
-    }
-    formatUptime(seconds) {
-        const h = Math.floor(seconds / 3600);
-        const m = Math.floor((seconds % 3600) / 60);
-        if (h > 0)
-            return `${h}h ${m}m`;
-        return `${m}m`;
-    }
-    /** Reset API call counter (call every minute) */
-    resetApiCounter() {
-        const count = this.apiCallCount;
-        this.apiCallCount = 0;
-        return count;
-    }
+apiCallCount = 0;
+prevCpuTimes = { idle: 0, total: 0 };
+
+trackApiCall() {
+this.apiCallCount++;
+}
+
+getStats(tokenCount = 0) {
+return {
+cpuPercent: this.getCpuPercent(),
+ramPercent: this.getRamPercent(),
+ramUsed: this.formatBytes(totalmem() - freemem()),
+ramTotal: this.formatBytes(totalmem()),
+uptime: this.formatUptime(uptime()),
+...this.getNetStats(),
+apiCallsPerMin: this.apiCallCount,
+tokensUsed: tokenCount,
+};
+}
+getCpuPercent() {
+try {
+
+const currentUsage = process.cpuUsage();
+const userDelta = currentUsage.user - lastCpuUsage.user;
+const systemDelta = currentUsage.system - lastCpuUsage.system;
+lastCpuUsage = currentUsage;
+
+
+const totalDelta = userDelta + systemDelta;
+
+const pct = Math.min(100, Math.round((totalDelta / 10_000_000) * 100));
+return pct;
+}
+catch (error) {
+logger.debug('SystemMonitor', 'CPU measurement failed', { error: error.message });
+return 0;
+}
+}
+getRamPercent() {
+const used = totalmem() - freemem();
+return Math.round((used / totalmem()) * 100);
+}
+getNetStats() {
+
+
+return { netUp: 'N/A', netDown: 'N/A' };
+}
+formatBytes(bytes) {
+if (bytes === 0)
+return '0 B';
+const k = 1024;
+const sizes = ['B', 'KB', 'MB', 'GB'];
+const i = Math.floor(Math.log(bytes) / Math.log(k));
+return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+}
+formatUptime(seconds) {
+const h = Math.floor(seconds / 3600);
+const m = Math.floor((seconds % 3600) / 60);
+if (h > 0)
+return `${h}h ${m}m`;
+return `${m}m`;
+}
+
+resetApiCounter() {
+const count = this.apiCallCount;
+this.apiCallCount = 0;
+return count;
+}
 }
 export const systemMonitor = new SystemMonitor();
-//# sourceMappingURL=SystemMonitor.js.map

package/dist/index.d.ts

@@ -58,4 +58,3 @@ export { recordTrade, getPLSummary, getTradeHistory, exportCSV } from "./wallet/
 export type { Trade, ProfitState, PLSummary } from "./wallet/ProfitTracker.js";
 export { scanTokenSecurityTool } from "./tools/TokenSecurityScanner.js";
 export type { TokenSecurityResult } from "./tools/TokenSecurityScanner.js";
-//# sourceMappingURL=index.d.ts.map