mortgram-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const spawner_1 = require("./lib/spawner");
+const config_1 = require("./lib/config");
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+// Load environment variables from the parent directory if possible, or current
+dotenv_1.default.config({ path: path_1.default.join(process.cwd(), "..", ".env.local") });
+dotenv_1.default.config(); // Fallback to current dir
+const program = new commander_1.Command();
+program
+    .name("mortgram")
+    .description("MORTGRAM Observer CLI - Zero-code observability wrapper")
+    .version("1.0.0");
+program
+    .command("login <key>")
+    .description("Authenticate your terminal with your MORTGRAM API Key")
+    .action((key) => {
+    (0, config_1.saveConfig)(key);
+    console.log("MORTGRAM: Authentication successful. Key saved to ~/.mortgramrc");
+});
+program
+    .command("run <command...>")
+    .description("Run an agent command with MORTGRAM observability")
+    .action(async (commandParts) => {
+    const fullCommand = commandParts.join(" ");
+    console.log(`MORTGRAM: Wrapping command: "${fullCommand}"`);
+    await (0, spawner_1.spawnAgent)(fullCommand);
+});
+program.parse();

package/dist/lib/config.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveConfig = saveConfig;
+exports.loadConfig = loadConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_FILE = path_1.default.join(os_1.default.homedir(), ".mortgramrc");
+function saveConfig(key) {
+    const config = { api_key: key };
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function loadConfig() {
+    if (fs_1.default.existsSync(CONFIG_FILE)) {
+        try {
+            const content = fs_1.default.readFileSync(CONFIG_FILE, "utf-8");
+            const config = JSON.parse(content);
+            return config.api_key || null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    return null;
+}

package/dist/lib/guard.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackUsage = trackUsage;
+exports.checkBudget = checkBudget;
+exports.getCurrentSpend = getCurrentSpend;
+const chalk_1 = __importDefault(require("chalk"));
+const MODEL_COSTS = {
+    "gpt-4o": 0.03, // per 1k input/output avg
+    "gpt-4-turbo": 0.02,
+    "claude-3-opus": 0.045
+};
+let currentSpend = 0.0;
+const SESSION_BUDGET = parseFloat(process.env.MG_SESSION_BUDGET || "1.00"); // default $1
+function trackUsage(logLine) {
+    // Regex for: "Using model: gpt-4o" or "Token usage: 500"
+    // This is a naive implementation for demo purposes
+    // Check for model usage
+    for (const [model, cost] of Object.entries(MODEL_COSTS)) {
+        if (logLine.includes(model)) {
+            // Assume an average specific cost per interaction for now
+            // In a real app, we'd parse exact token counts
+            const estimatedCost = 0.002; // $0.002 per interaction
+            currentSpend += estimatedCost;
+            console.log(chalk_1.default.yellow(`MORTGRAM: +$${estimatedCost.toFixed(4)} (Spend: $${currentSpend.toFixed(4)})`));
+        }
+    }
+}
+function checkBudget(childProcess) {
+    if (currentSpend > SESSION_BUDGET) {
+        console.log(chalk_1.default.red.bold(`\n!!! MORTGRAM FINANCIAL GUARDRAIL !!!`));
+        console.log(chalk_1.default.red(`Session budget of $${SESSION_BUDGET} exceeded.`));
+        console.log(chalk_1.default.red(`Terminating process immediately.`));
+        childProcess.kill('SIGKILL');
+        process.exit(1);
+    }
+}
+function getCurrentSpend() {
+    return currentSpend;
+}

package/dist/lib/logger.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ingestLog = ingestLog;
+const axios_1 = __importDefault(require("axios"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const config_1 = require("./config");
+// ensure env is loaded
+dotenv_1.default.config();
+const API_KEY = process.env.MG_LIVE_KEY || (0, config_1.loadConfig)();
+const API_URL = process.env.MORTGRAM_API_URL || "http://localhost:3000/api/ingest";
+const AGENT_ID = process.env.MG_AGENT_ID || "cli-agent";
+async function ingestLog(type, content, metadata = {}) {
+    if (!API_KEY)
+        return;
+    try {
+        await axios_1.default.post(API_URL, {
+            agent_id: AGENT_ID,
+            type,
+            content,
+            metadata
+        }, {
+            headers: {
+                "Authorization": `Bearer ${API_KEY}`,
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    catch (error) {
+        // Silently fail to not disrupt the agent
+        // console.error("MORTGRAM: Ingest failed", error.message);
+    }
+}

package/dist/lib/neural.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startNeuralLink = startNeuralLink;
+const ably_1 = __importDefault(require("ably"));
+const chalk_1 = __importDefault(require("chalk"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const ABLY_KEY = process.env.ABLY_API_KEY;
+const AGENT_ID = process.env.MG_AGENT_ID || "cli-agent";
+let client = null;
+async function startNeuralLink(childProcess) {
+    if (!ABLY_KEY) {
+        console.warn(chalk_1.default.yellow("MORTGRAM: No ABLY_API_KEY found. Neural link disabled."));
+        return { close: () => { } };
+    }
+    client = new ably_1.default.Realtime(ABLY_KEY);
+    const channel = client.channels.get(`control:${AGENT_ID}`);
+    await channel.subscribe("KILL", (message) => {
+        console.log(chalk_1.default.bgRed.white.bold("\n!!! MORTGRAM NEURAL LINK: KILL SIGNAL RECEIVED !!!\n"));
+        childProcess.kill('SIGKILL');
+        process.exit(0);
+    });
+    console.log(chalk_1.default.blue(`MORTGRAM: Neural Link active on channel control:${AGENT_ID}`));
+    return {
+        close: () => {
+            if (client)
+                client.close();
+        }
+    };
+}

package/dist/lib/spawner.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnAgent = spawnAgent;
+const child_process_1 = require("child_process");
+const logger_1 = require("./logger");
+const guard_1 = require("./guard");
+const vitals_1 = require("./vitals");
+const neural_1 = require("./neural");
+const chalk_1 = __importDefault(require("chalk"));
+let childProcess = null;
+async function spawnAgent(command) {
+    console.log(chalk_1.default.green("MORTGRAM: Initializing Observer..."));
+    // Parse command string into cmd and args
+    // crude parsing, careful with quotes
+    const parts = command.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+    if (parts.length === 0)
+        return;
+    const cmd = parts[0];
+    if (!cmd)
+        return;
+    const args = parts.slice(1).map(arg => arg.replace(/^"|"$/g, ''));
+    childProcess = (0, child_process_1.spawn)(cmd, args, {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        shell: true,
+        env: { ...process.env, MORTGRAM_WRAPPED: "true" }
+    });
+    // Neural Link (Kill Switch)
+    const neural = await (0, neural_1.startNeuralLink)(childProcess);
+    // Vitals Monitor
+    const vitalsInterval = (0, vitals_1.startVitals)(childProcess);
+    // Stdout Interception
+    childProcess.stdout.on('data', (data) => {
+        const line = data.toString();
+        process.stdout.write(line); // Pass through
+        // Analyze
+        analyzeLog(line);
+    });
+    // Stderr Interception
+    childProcess.stderr.on('data', (data) => {
+        const line = data.toString();
+        process.stderr.write(line); // Pass through
+        analyzeLog(line, true);
+    });
+    childProcess.on('close', (code) => {
+        console.log(chalk_1.default.gray(`MORTGRAM: Child process exited with code ${code}`));
+        clearInterval(vitalsInterval);
+        neural.close();
+        process.exit(code);
+    });
+}
+function analyzeLog(content, isError = false) {
+    // 1. Ingest
+    if (content.includes("Thought:") || content.includes("Action:") || content.includes("Error:")) {
+        let type = "log";
+        if (content.includes("Thought:"))
+            type = "thought";
+        if (content.includes("Action:"))
+            type = "action";
+        if (isError)
+            type = "error";
+        (0, logger_1.ingestLog)(type, content.trim());
+    }
+    // 2. Financial Guard
+    // Detect model usage, e.g. "Using gpt-4o"
+    (0, guard_1.trackUsage)(content);
+    (0, guard_1.checkBudget)(childProcess);
+}

package/dist/lib/vitals.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startVitals = startVitals;
+const pidusage_1 = __importDefault(require("pidusage"));
+const axios_1 = __importDefault(require("axios"));
+const guard_1 = require("./guard");
+const dotenv_1 = __importDefault(require("dotenv"));
+const config_1 = require("./config");
+dotenv_1.default.config();
+const API_KEY = process.env.MG_LIVE_KEY || (0, config_1.loadConfig)();
+const API_URL = process.env.MORTGRAM_API_URL ? `${process.env.MORTGRAM_API_URL}/heartbeat` : "http://localhost:3000/api/cron/heartbeat";
+// Note: reusing cron heartbeat or creating a specific agent heartbeat endpoint?
+// For CLI, we likely want a direct ingestion endpoint or use the log ingestion with type "heartbeat"
+const INGEST_URL = process.env.MORTGRAM_API_URL || "http://localhost:3000/api/ingest";
+const AGENT_ID = process.env.MG_AGENT_ID || "cli-agent";
+function startVitals(childProcess) {
+    const interval = setInterval(async () => {
+        if (!childProcess || childProcess.killed)
+            return;
+        try {
+            const stats = await (0, pidusage_1.default)(childProcess.pid);
+            const spend = (0, guard_1.getCurrentSpend)();
+            // Send heartbeat log
+            if (API_KEY) {
+                await axios_1.default.post(INGEST_URL, {
+                    agent_id: AGENT_ID,
+                    type: "status", // Special type for heartbeat/status
+                    content: `Heartbeat: CPU ${stats.cpu.toFixed(1)}% | MEM ${(stats.memory / 1024 / 1024).toFixed(0)}MB | $${spend.toFixed(4)}`,
+                    metadata: {
+                        cpu: stats.cpu,
+                        memory: stats.memory,
+                        spend: spend,
+                        status: "online"
+                    }
+                }, {
+                    headers: { "Authorization": `Bearer ${API_KEY}` }
+                });
+            }
+        }
+        catch (err) {
+            // pidusage might fail if process dies quickly
+        }
+    }, 30000); // 30s
+    return interval;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "mortgram-cli",
+  "version": "1.0.0",
+  "description": "Zero-code observability wrapper for AI agents",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "observability",
+    "agent",
+    "cli"
+  ],
+  "author": "MORTGRAM",
+  "license": "ISC",
+  "dependencies": {
+    "ably": "^2.17.1",
+    "axios": "^1.13.5",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.3",
+    "dotenv": "^17.2.4",
+    "pidusage": "^4.0.1",
+    "strip-ansi": "^6.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.2",
+    "@types/pidusage": "^2.0.5",
+    "typescript": "^5.9.3"
+  },
+  "bin": {
+    "mortgram": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}