@notilens/notilens 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,416 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("./config");
+const state_1 = require("./state");
+const notify_1 = require("./notify");
+const VERSION = require('../package.json').version;
+// ---- Arg helpers ----
+/** Split args into positional (before first --flag) and the full list for flag parsing. */
+function positionalArgs(args) {
+    const result = [];
+    for (const a of args) {
+        if (a.startsWith('--'))
+            break;
+        result.push(a);
+    }
+    return result;
+}
+function parseFlags(args) {
+    const flags = {
+        agent: '',
+        taskId: '',
+        type: '',
+        meta: {},
+        imageUrl: '',
+        openUrl: '',
+        downloadUrl: '',
+        tags: '',
+        isActionable: '',
+        confidenceScore: 0,
+    };
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case '--agent':
+                flags.agent = args[++i] ?? '';
+                break;
+            case '--task':
+                flags.taskId = args[++i] ?? '';
+                break;
+            case '--type':
+                flags.type = args[++i] ?? '';
+                break;
+            case '--image_url':
+                flags.imageUrl = args[++i] ?? '';
+                break;
+            case '--open_url':
+                flags.openUrl = args[++i] ?? '';
+                break;
+            case '--download_url':
+                flags.downloadUrl = args[++i] ?? '';
+                break;
+            case '--tags':
+                flags.tags = args[++i] ?? '';
+                break;
+            case '--is_actionable':
+                flags.isActionable = args[++i] ?? '';
+                break;
+            case '--confidence':
+                flags.confidenceScore = parseFloat(args[++i] ?? '0') || 0;
+                break;
+            case '--meta': {
+                const kv = args[++i] ?? '';
+                const eq = kv.indexOf('=');
+                if (eq !== -1)
+                    flags.meta[kv.slice(0, eq)] = kv.slice(eq + 1);
+                break;
+            }
+        }
+    }
+    if (!flags.agent) {
+        console.error('❌ --agent is required');
+        process.exit(1);
+    }
+    if (!flags.taskId) {
+        flags.taskId = `task_${Date.now()}`;
+    }
+    return flags;
+}
+// ---- Event type / actionable mapping ----
+function getEventType(event) {
+    switch (event) {
+        case 'task.completed':
+        case 'response.generated':
+        case 'input.approved':
+            return 'success';
+        case 'task.failed':
+        case 'task.timeout':
+        case 'response.failed':
+        case 'validation.failed':
+            return 'urgent';
+        case 'task.error':
+        case 'task.terminated':
+        case 'guardrail.triggered':
+            return 'important';
+        case 'task.retrying':
+        case 'task.cancelled':
+        case 'input.required':
+        case 'input.rejected':
+            return 'warning';
+        default:
+            return 'info';
+    }
+}
+function getActionableDefault(event) {
+    return [
+        'task.error', 'task.failed', 'task.timeout', 'task.retrying',
+        'ai.response.failed', 'ai.validation.failed', 'ai.guardrail.triggered',
+        'input.required', 'input.rejected',
+    ].includes(event);
+}
+function validateType(t) {
+    return ['info', 'success', 'warning', 'urgent', 'important'].includes(t)
+        ? t
+        : '';
+}
+// ---- Core send ----
+async function sendNotify(event, title, message, flags) {
+    const conf = (0, config_1.getAgentConfig)(flags.agent);
+    if (!conf?.endpoint || !conf?.secret) {
+        console.error('❌ Agent not configured');
+        return;
+    }
+    const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+    const state = (0, state_1.readState)(stateFile);
+    const promptTokens = state.prompt_tokens ?? 0;
+    const completionTokens = state.completion_tokens ?? 0;
+    const meta = {
+        duration_ms: state.duration_ms ?? 0,
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens,
+        retry_count: state.retry_count ?? 0,
+        confidence_score: flags.confidenceScore,
+        loop_count: state.loop_count ?? 0,
+        ...flags.meta,
+    };
+    const finalType = validateType(flags.type) || getEventType(event);
+    const finalActionable = flags.isActionable !== ''
+        ? flags.isActionable === 'true'
+        : getActionableDefault(event);
+    const payload = {
+        event,
+        title,
+        message,
+        type: finalType,
+        agent: flags.agent,
+        task_id: flags.taskId,
+        meta,
+        image_url: flags.imageUrl,
+        open_url: flags.openUrl,
+        download_url: flags.downloadUrl,
+        tags: flags.tags,
+        is_actionable: finalActionable,
+    };
+    try {
+        await (0, notify_1.sendNotification)(conf.endpoint, conf.secret, payload);
+        await new Promise(r => setTimeout(r, 300)); // match bash sleep 0.3
+    }
+    catch {
+        // Silent fail — mirrors bash curl behaviour
+    }
+}
+// ---- Duration helper ----
+function calcDuration(stateFile) {
+    const state = (0, state_1.readState)(stateFile);
+    return Date.now() - (state.start_time ?? 0);
+}
+// ---- Commands ----
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    const rest = args.slice(1);
+    switch (command) {
+        case 'add-agent': {
+            const [agent, transport, endpoint, secret] = rest;
+            if (!agent || !transport || !endpoint || !secret) {
+                console.error('Usage: notilens add-agent <agent> <transport> <endpoint> <secret>');
+                process.exit(1);
+            }
+            (0, config_1.addAgent)(agent, transport, endpoint, secret);
+            console.log(`✔ Agent '${agent}' added`);
+            break;
+        }
+        case 'task.start': {
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.writeState)(stateFile, {
+                agent: flags.agent,
+                task: flags.taskId,
+                start_time: Date.now(),
+                retry_count: 0,
+            });
+            await sendNotify('task.started', `${flags.agent} | ${flags.taskId} started`, 'Task started', flags);
+            console.log(`▶️  Started: ${flags.agent} | ${flags.taskId}`);
+            break;
+        }
+        case 'task.in_progress': {
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.updateState)(stateFile, { duration_ms: calcDuration(stateFile) });
+            await sendNotify('task.in_progress', `${flags.agent} | ${flags.taskId} running`, 'Task in progress', flags);
+            console.log(`⏳ In Progress: ${flags.agent} | ${flags.taskId}`);
+            break;
+        }
+        case 'task.stop': {
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            const dur = calcDuration(stateFile);
+            (0, state_1.updateState)(stateFile, { duration_ms: dur });
+            await sendNotify('task.stopped', `${flags.agent} | ${flags.taskId} stopped`, 'Task stopped', flags);
+            console.log(`⏹  Stopped: ${flags.agent} | ${flags.taskId} (${dur} ms)`);
+            break;
+        }
+        case 'task.retry': {
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            const state = (0, state_1.readState)(stateFile);
+            (0, state_1.updateState)(stateFile, {
+                duration_ms: calcDuration(stateFile),
+                retry_count: (state.retry_count ?? 0) + 1,
+            });
+            await sendNotify('task.retrying', `${flags.agent} | ${flags.taskId} retry`, 'Retrying task', flags);
+            console.log(`🔁 Retry: ${flags.agent} | ${flags.taskId}`);
+            break;
+        }
+        case 'task.loop': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            const state = (0, state_1.readState)(stateFile);
+            const loopCount = (state.loop_count ?? 0) + 1;
+            (0, state_1.updateState)(stateFile, { duration_ms: calcDuration(stateFile), loop_count: loopCount });
+            await sendNotify('task.loop', `${flags.agent} | ${flags.taskId} loop #${loopCount}`, msg, flags);
+            console.log(`🔄 Loop (${loopCount}): ${flags.agent} | ${flags.taskId}`);
+            break;
+        }
+        case 'task.error': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.updateState)(stateFile, { duration_ms: calcDuration(stateFile), last_error: msg });
+            await sendNotify('task.error', `${flags.agent} | ${flags.taskId} error`, msg, flags);
+            console.error(`❌ Error: ${msg}`);
+            break;
+        }
+        case 'task.fail': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.updateState)(stateFile, { duration_ms: calcDuration(stateFile), failed: true });
+            await sendNotify('task.failed', `${flags.agent} | ${flags.taskId} failed`, msg, flags);
+            (0, state_1.deleteState)(stateFile);
+            console.log(`💥 Failed: ${flags.agent} | ${flags.taskId}`);
+            break;
+        }
+        case 'task.timeout': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.updateState)(stateFile, { duration_ms: calcDuration(stateFile), timeout: true });
+            await sendNotify('task.timeout', `${flags.agent} | ${flags.taskId} timeout`, msg, flags);
+            (0, state_1.deleteState)(stateFile);
+            console.log(`⏰ Timeout: ${flags.agent} | ${flags.taskId}`);
+            break;
+        }
+        case 'task.cancel': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.updateState)(stateFile, { duration_ms: calcDuration(stateFile), cancelled: true });
+            await sendNotify('task.cancelled', `${flags.agent} | ${flags.taskId} cancelled`, msg, flags);
+            (0, state_1.deleteState)(stateFile);
+            console.log(`🚫 Cancelled: ${flags.agent} | ${flags.taskId}`);
+            break;
+        }
+        case 'task.terminate': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.updateState)(stateFile, { duration_ms: calcDuration(stateFile), terminated: true });
+            await sendNotify('task.terminated', `${flags.agent} | ${flags.taskId} terminated`, msg, flags);
+            (0, state_1.deleteState)(stateFile);
+            console.log(`⚠️  Terminated: ${flags.agent} | ${flags.taskId}`);
+            break;
+        }
+        case 'task.complete': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.updateState)(stateFile, { duration_ms: calcDuration(stateFile) });
+            await sendNotify('task.completed', `${flags.agent} | ${flags.taskId} workflow`, msg, flags);
+            (0, state_1.deleteState)(stateFile);
+            console.log(`✅ Completed: ${flags.agent} | ${flags.taskId}`);
+            break;
+        }
+        case 'set.metrics': {
+            const pos = positionalArgs(rest);
+            const flags = parseFlags(rest);
+            const prompt = parseInt(pos[0] ?? '0') || 0;
+            const completion = parseInt(pos[1] ?? '0') || 0;
+            const conf = parseFloat(pos[2] ?? '0') || 0;
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.updateState)(stateFile, { prompt_tokens: prompt, completion_tokens: completion });
+            if (conf)
+                flags.confidenceScore = conf;
+            console.log(`📊 Metrics set: tokens(${prompt}/${completion}) confidence(${conf})`);
+            break;
+        }
+        case 'ai.response.generate': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            await sendNotify('ai.response.generated', `${flags.agent} | ${flags.taskId} response`, msg, flags);
+            break;
+        }
+        case 'ai.response.fail': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            await sendNotify('ai.response.failed', `${flags.agent} | ${flags.taskId} response failed`, msg, flags);
+            break;
+        }
+        case 'input.required': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            await sendNotify('input.required', `${flags.agent} | ${flags.taskId} input required`, msg, flags);
+            break;
+        }
+        case 'input.approve': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            await sendNotify('input.approved', `${flags.agent} | ${flags.taskId} input approved`, msg, flags);
+            break;
+        }
+        case 'input.reject': {
+            const pos = positionalArgs(rest);
+            const msg = pos[0] ?? '';
+            const flags = parseFlags(rest);
+            await sendNotify('input.rejected', `${flags.agent} | ${flags.taskId} input rejected`, msg, flags);
+            break;
+        }
+        case 'emit': {
+            const pos = positionalArgs(rest);
+            const event = pos[0] ?? '';
+            const msg = pos[1] ?? '';
+            const flags = parseFlags(rest.slice(2));
+            const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
+            (0, state_1.updateState)(stateFile, { duration_ms: calcDuration(stateFile) });
+            await sendNotify(event, `${flags.agent} | ${flags.taskId} ${event}`, msg, flags);
+            console.log(`📡 Event emitted: ${event}`);
+            break;
+        }
+        case 'version':
+            console.log(`NotiLens v${VERSION}`);
+            break;
+        default:
+            printUsage();
+    }
+}
+function printUsage() {
+    console.log(`Usage:
+  notilens add-agent <agent> <transport> <endpoint> <secret>
+
+Core Commands:
+  notilens task.start --agent <agent> [--task <id>]
+  notilens task.in_progress --agent <agent> [--task <id>]
+  notilens task.stop --agent <agent> [--task <id>]
+  notilens task.retry --agent <agent> [--task <id>]
+  notilens task.loop "msg" --agent <agent>
+  notilens task.error "msg" --agent <agent> [--task <id>]
+  notilens task.fail "msg" --agent <agent> [--task <id>]
+  notilens task.timeout "msg" --agent <agent> [--task <id>]
+  notilens task.cancel "msg" --agent <agent> [--task <id>]
+  notilens task.terminate "msg" --agent <agent> [--task <id>]
+  notilens task.complete "msg" --agent <agent> [--task <id>]
+  notilens ai.response.generate "msg" --agent <agent>
+  notilens ai.response.fail "msg" --agent <agent>
+  notilens input.required "msg" --agent <agent>
+  notilens input.approve "msg" --agent <agent>
+  notilens input.reject "msg" --agent <agent>
+
+Generic Event:
+  notilens emit <event> "msg" --agent <agent>
+
+Metrics:
+  notilens set.metrics <prompt_tokens> <completion_tokens> [confidence] --agent <agent> [--task <id>]
+
+Options:
+  --agent <agent>
+  --task <id>
+  --type success|warning|urgent|important|info
+  --meta key=value            (repeatable)
+  --image_url <url>
+  --open_url <url>
+  --download_url <url>
+  --tags "tag1,tag2"
+  --is_actionable true|false
+  --confidence <0-100>
+
+Other:
+  notilens version`);
+}
+main().catch(err => {
+    console.error(err.message);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+import { AgentConfig, NotiLensConfig } from './types';
+export declare function readConfig(): NotiLensConfig;
+export declare function writeConfig(config: NotiLensConfig): void;
+export declare function getAgentConfig(agent: string): AgentConfig | null;
+export declare function addAgent(agent: string, transport: string, endpoint: string, secret: string): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+exports.getAgentConfig = getAgentConfig;
+exports.addAgent = addAgent;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const CONFIG_FILE = path.join(os.homedir(), '.notilens_config.json');
+function readConfig() {
+    if (!fs.existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeConfig(config) {
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getAgentConfig(agent) {
+    const config = readConfig();
+    return config[agent] || null;
+}
+function addAgent(agent, transport, endpoint, secret) {
+    const config = readConfig();
+    config[agent] = { transport, endpoint, secret };
+    writeConfig(config);
+}
+//# sourceMappingURL=config.js.map

package/dist/notify.d.ts

@@ -0,0 +1,3 @@
+import { NotifyPayload } from './types';
+export declare function sendNotification(endpoint: string, secret: string, payload: NotifyPayload): Promise<void>;
+//# sourceMappingURL=notify.d.ts.map

package/dist/notify.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendNotification = sendNotification;
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const VERSION = require('../package.json').version;
+const MAX_RETRIES = 2;
+const TIMEOUT_MS = 10000;
+async function attempt(endpoint, secret, body) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(endpoint);
+        const lib = url.protocol === 'https:' ? https : http;
+        const options = {
+            hostname: url.hostname,
+            port: url.port || (url.protocol === 'https:' ? 443 : 80),
+            path: url.pathname + url.search,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-NOTILENS-KEY': secret,
+                'User-Agent': `NotiLens-CLI/${VERSION}`,
+                'Content-Length': Buffer.byteLength(body),
+            },
+        };
+        const req = lib.request(options, (res) => {
+            res.resume();
+            resolve();
+        });
+        const timer = setTimeout(() => {
+            req.destroy(new Error('Request timeout'));
+        }, TIMEOUT_MS);
+        req.on('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        req.on('close', () => clearTimeout(timer));
+        req.write(body);
+        req.end();
+    });
+}
+async function sendNotification(endpoint, secret, payload) {
+    const body = JSON.stringify(payload);
+    let lastErr;
+    for (let i = 0; i <= MAX_RETRIES; i++) {
+        try {
+            await attempt(endpoint, secret, body);
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            if (i < MAX_RETRIES) {
+                await new Promise(r => setTimeout(r, 1000)); // 1s retry delay
+            }
+        }
+    }
+    throw lastErr;
+}
+//# sourceMappingURL=notify.js.map

package/dist/state.d.ts

@@ -0,0 +1,7 @@
+import { TaskState } from './types';
+export declare function getStateFile(agent: string, taskId: string): string;
+export declare function readState(stateFile: string): TaskState;
+export declare function writeState(stateFile: string, state: TaskState): void;
+export declare function updateState(stateFile: string, updates: Partial<TaskState>): void;
+export declare function deleteState(stateFile: string): void;
+//# sourceMappingURL=state.d.ts.map

package/dist/state.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateFile = getStateFile;
+exports.readState = readState;
+exports.writeState = writeState;
+exports.updateState = updateState;
+exports.deleteState = deleteState;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+function getStateFile(agent, taskId) {
+    const user = os.userInfo().username;
+    return path.join(os.tmpdir(), `notilens_${user}_${agent}_${taskId}.json`);
+}
+function readState(stateFile) {
+    if (!fs.existsSync(stateFile))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeState(stateFile, state) {
+    fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+}
+function updateState(stateFile, updates) {
+    const state = readState(stateFile);
+    writeState(stateFile, { ...state, ...updates });
+}
+function deleteState(stateFile) {
+    if (fs.existsSync(stateFile)) {
+        fs.unlinkSync(stateFile);
+    }
+}
+//# sourceMappingURL=state.js.map

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+export interface AgentConfig {
+    transport: string;
+    endpoint: string;
+    secret: string;
+}
+export interface NotiLensConfig {
+    [agent: string]: AgentConfig;
+}
+export interface TaskState {
+    agent?: string;
+    task?: string;
+    start_time?: number;
+    retry_count?: number;
+    loop_count?: number;
+    duration_ms?: number;
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    last_error?: string;
+    failed?: boolean;
+    timeout?: boolean;
+    cancelled?: boolean;
+    terminated?: boolean;
+}
+export interface NotifyPayload {
+    event: string;
+    title: string;
+    message: string;
+    type: string;
+    agent: string;
+    task_id: string;
+    meta: Record<string, unknown>;
+    image_url: string;
+    open_url: string;
+    download_url: string;
+    tags: string;
+    is_actionable: boolean;
+}
+export type NotificationType = 'info' | 'success' | 'warning' | 'urgent' | 'important';
+export interface ParsedFlags {
+    agent: string;
+    taskId: string;
+    type: string;
+    meta: Record<string, string>;
+    imageUrl: string;
+    openUrl: string;
+    downloadUrl: string;
+    tags: string;
+    isActionable: string;
+    confidenceScore: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@notilens/notilens",
+  "version": "0.1.0",
+  "description": "NotiLens CLI — send AI agent task lifecycle notifications",
+  "keywords": ["notilens", "ai-agent", "notifications", "monitoring", "cli"],
+  "homepage": "https://www.notilens.com",
+  "author": "NotiLens",
+  "license": "MIT",
+  "main": "dist/cli.js",
+  "bin": {
+    "notilens": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "ts-node src/cli.ts"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  }
+}