@notilens/notilens 0.1.1 → 0.2.2

package/README.md

@@ -1,6 +1,11 @@
 # NotiLens
 
-CLI tool for sending AI agent task lifecycle notifications to [NotiLens](https://www.notilens.com).
+Send notifications from AI agents and any Node.js project to [NotiLens](https://www.notilens.com).
+
+Two ways to use it — pick one or both:
+
+- **CLI** — for shell scripts, bash pipelines, Claude Code hooks, any terminal workflow
+- **SDK** — for Node.js/TypeScript projects (import and call directly in code)
 
 ## Installation
 
@@ -8,89 +13,128 @@ CLI tool for sending AI agent task lifecycle notifications to [NotiLens](https:/
 npm install -g @notilens/notilens
 ```
 
-## Setup
-
-Register your agent with its endpoint and secret from the NotiLens dashboard:
+Or per-project:
 
 ```bash
-notilens add-agent <agent-name> http <endpoint> <secret>
+npm install @notilens/notilens
 ```
 
-**Example:**
-```bash
-notilens add-agent my-agent http https://www.notilens.com/nlapi/nl/v1/notify abc123secret
-```
-
-Config is saved to `~/.notilens_config.json`.
-
 ---
 
-## Usage
+# CLI
 
-### Task Lifecycle
+## Setup
+
+Get your token and secret from the [NotiLens dashboard](https://www.notilens.com).
 
 ```bash
-# Start a task (auto-generates task ID if omitted)
-notilens task.start --agent my-agent --task task_001
+notilens init --agent my-agent --token YOUR_TOKEN --secret YOUR_SECRET
+```
 
-# Mark in progress
-notilens task.in_progress --agent my-agent --task task_001
+This saves credentials to `~/.notilens_config.json`. All future commands read from there — no need to pass token/secret again.
 
-# Complete successfully
-notilens task.complete "Processed 100 records" --agent my-agent --task task_001
+**Multiple agents** (each agent notifies a different topic):
+```bash
+notilens init --agent scraper --token TOKEN_A --secret SECRET_A
+notilens init --agent mailer  --token TOKEN_B --secret SECRET_B
+```
 
-# Report an error (non-terminal, task continues)
-notilens task.error "Connection timeout, will retry" --agent my-agent --task task_001
+**List / remove agents:**
+```bash
+notilens agents
+notilens remove-agent my-agent
+```
 
-# Retry
-notilens task.retry --agent my-agent --task task_001
+---
 
-# Loop iteration
-notilens task.loop "Processing batch 3/10" --agent my-agent --task task_001
+## Commands
 
-# Fail (terminal)
-notilens task.fail "Max retries exceeded" --agent my-agent --task task_001
+### Task Lifecycle
 
-# Timeout (terminal)
-notilens task.timeout "Exceeded 30s limit" --agent my-agent --task task_001
+```bash
+# required: --agent
+# optional: --task (auto-generated if omitted)
+
+notilens task.start    --agent my-agent --task job_001
+notilens task.progress "Fetching data"  --agent my-agent --task job_001
+notilens task.loop     "Step 3 of 10"   --agent my-agent --task job_001
+notilens task.retry    --agent my-agent --task job_001
+notilens task.stop     --agent my-agent --task job_001
+notilens task.complete "All done"       --agent my-agent --task job_001
+notilens task.error    "Step 3 failed"  --agent my-agent --task job_001
+notilens task.fail     "Unrecoverable"  --agent my-agent --task job_001
+notilens task.timeout  "Took too long"  --agent my-agent --task job_001
+notilens task.cancel   "User cancelled" --agent my-agent --task job_001
+notilens task.terminate "Out of memory" --agent my-agent --task job_001
+```
 
-# Cancel (terminal)
-notilens task.cancel "User cancelled" --agent my-agent --task task_001
+### AI Response Events
 
-# Terminate (terminal)
-notilens task.terminate "Out of memory" --agent my-agent --task task_001
+```bash
+notilens ai.response.generate "Summary generated" --agent my-agent --task job_001
+notilens ai.response.fail     "Model unavailable" --agent my-agent --task job_001
 ```
 
-### AI Response Events
+### Input / Human-in-the-loop
 
 ```bash
-notilens ai.response.generate "Summary generated" --agent my-agent --task task_001
-notilens ai.response.fail "Model unavailable" --agent my-agent --task task_001
+notilens input.required "Please confirm the output" --agent my-agent --task job_001
+notilens input.approve  "Confirmed"                 --agent my-agent --task job_001
+notilens input.reject   "Rejected"                  --agent my-agent --task job_001
 ```
 
-### Input Events
+### Generic Event
 
 ```bash
-notilens input.required "Please confirm the output" --agent my-agent --task task_001
-notilens input.approve "User approved" --agent my-agent --task task_001
-notilens input.reject "User rejected" --agent my-agent --task task_001
+notilens emit order.placed "Order #1234" --agent my-agent --meta amount=99.99
+notilens emit disk.space.full "Only 1GB remaining" --agent my-agent --type warning
 ```
 
 ### Metrics
 
-Track token usage and confidence after an AI call:
-
 ```bash
-# set.metrics <prompt_tokens> <completion_tokens> [confidence] --agent ... --task ...
-notilens set.metrics 512 128 0.95 --agent my-agent --task task_001
+notilens set.metrics 512 128 0.95 --agent my-agent --task job_001
+#                    ^   ^   ^
+#                    |   |   confidence score (optional)
+#                    |   completion_tokens
+#                    prompt_tokens
 ```
 
-### Generic Event
-
-Emit any custom event:
+---
 
-```bash
-notilens emit "data.processed" "Ingested 500 rows" --agent my-agent --task task_001
+## Claude Code Hooks Example
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "Task",
+      "hooks": [{
+        "type": "command",
+        "command": "notilens task.start --agent claude --task $TASK_ID"
+      }]
+    }],
+    "PostToolUse": [{
+      "matcher": "Task",
+      "hooks": [{
+        "type": "command",
+        "command": "notilens task.complete \"Task done\" --agent claude --task $TASK_ID"
+      }]
+    }],
+    "Stop": [{
+      "hooks": [{
+        "type": "command",
+        "command": "notilens task.complete \"Session ended\" --agent claude"
+      }]
+    }],
+    "Notification": [{
+      "hooks": [{
+        "type": "command",
+        "command": "notilens input.required \"Claude needs input\" --agent claude"
+      }]
+    }]
+  }
+}
 ```
 
 ---
@@ -99,9 +143,9 @@ notilens emit "data.processed" "Ingested 500 rows" --agent my-agent --task task_
 
 | Flag | Description |
 |------|-------------|
-| `--agent <name>` | Agent name (required) |
+| `--agent <name>` | Agent name **(required)** |
 | `--task <id>` | Task ID (auto-generated if omitted) |
-| `--type` | Override notification type: `info` `success` `warning` `urgent` `important` |
+| `--type` | Override type: `info` `success` `warning` `urgent` |
 | `--meta key=value` | Custom metadata (repeatable) |
 | `--image_url <url>` | Attach an image |
 | `--open_url <url>` | Link to open |
@@ -114,13 +158,12 @@ notilens emit "data.processed" "Ingested 500 rows" --agent my-agent --task task_
 
 ## Notification Types
 
-Events are automatically mapped to notification types:
+Assigned automatically based on the event — can be overridden with `--type`.
 
 | Type | Events |
 |------|--------|
-| `success` | `task.completed`, `response.generated`, `input.approved` |
-| `urgent` | `task.failed`, `task.timeout`, `response.failed` |
-| `important` | `task.error`, `task.terminated` |
+| `success` | `task.completed`, `ai.response.generated`, `input.approved` |
+| `urgent` | `task.failed`, `task.timeout`, `task.error`, `task.terminated`, `ai.response.failed` |
 | `warning` | `task.retrying`, `task.cancelled`, `input.required`, `input.rejected` |
 | `info` | All others |
 
@@ -129,16 +172,10 @@ Events are automatically mapped to notification types:
 ## Full Example
 
 ```bash
-# Register agent
-notilens add-agent summarizer http https://www.notilens.com/nlapi/nl/v1/notify mysecret
+notilens init --agent summarizer --token MY_TOKEN --secret MY_SECRET
 
-# Start task
 notilens task.start --agent summarizer --task job_42
-
-# Update token metrics mid-task
-notilens set.metrics 1024 256 --agent summarizer --task job_42
-
-# Add custom metadata
+notilens set.metrics 1024 256 0.95 --agent summarizer --task job_42
 notilens task.complete "Summary ready" --agent summarizer --task job_42 \
   --meta input_file=report.pdf \
   --meta pages=12 \
@@ -147,6 +184,91 @@ notilens task.complete "Summary ready" --agent summarizer --task job_42 \
 
 ---
 
+# SDK
+
+Use the SDK to send notifications directly from your Node.js or TypeScript code.
+
+## 1. Setup
+
+```typescript
+import { NotiLensAgent } from '@notilens/notilens';
+
+// Option A — pass credentials directly (required on first use)
+const agent = NotiLensAgent.init('my-agent', { token: 'YOUR_TOKEN', secret: 'YOUR_SECRET' });
+
+// Option B — read from environment variables
+// NOTILENS_TOKEN=xxx NOTILENS_SECRET=yyy
+const agent = NotiLensAgent.init('my-agent');
+
+// Option C — read from saved CLI config (~/.notilens_config.json)
+// after running: notilens init --agent my-agent --token TOKEN --secret SECRET
+const agent = NotiLensAgent.init('my-agent');
+```
+
+## 2. Task Lifecycle
+
+```typescript
+const taskId = agent.taskStart('job_001');         // optional: auto-generates ID if omitted
+
+agent.taskProgress('Fetching records', taskId);
+agent.taskLoop('Processing batch 2', taskId);
+agent.taskRetry(taskId);
+agent.taskError('Non-fatal error', taskId);        // task continues
+agent.taskComplete('All done', taskId);            // terminal — clears state
+agent.taskFail('Unrecoverable', taskId);           // terminal
+agent.taskTimeout('Exceeded 30s', taskId);         // terminal
+agent.taskCancel('User cancelled', taskId);        // terminal
+agent.taskTerminate('OOM', taskId);                // terminal
+agent.taskStop(taskId);
+```
+
+## 3. Input / Human-in-the-loop
+
+```typescript
+agent.inputRequired('Please confirm the output', taskId);
+agent.inputApproved('User confirmed', taskId);
+agent.inputRejected('User rejected', taskId);
+```
+
+## 4. AI Response Events
+
+```typescript
+agent.aiResponseGenerated('Summary: the document is about X', taskId);
+agent.aiResponseFailed('Model timeout', taskId);
+```
+
+## 5. Generic Events
+
+```typescript
+// Free-form events for anything beyond task lifecycle
+agent.emit('order.placed', 'Order #1234', { meta: { amount: 99.99 } });
+agent.emit('disk.space.full', 'Only 1GB remaining', { level: 'warning' });
+agent.emit('user.registered', 'New signup', { meta: { plan: 'pro' } });
+```
+
+## Full Example
+
+```typescript
+import { NotiLensAgent } from '@notilens/notilens';
+
+const agent  = NotiLensAgent.init('summarizer', { token: 'TOKEN', secret: 'SECRET' });
+const taskId = agent.taskStart();
+
+try {
+  agent.taskProgress('Fetching PDF', taskId);
+  // ... your logic ...
+  agent.taskComplete('Summary ready', taskId);
+} catch (err) {
+  agent.taskFail((err as Error).message, taskId);
+}
+```
+
+---
+
+## Requirements
+
+- Node.js >= 18.0.0
+
 ## License
 
 MIT — [notilens.com](https://www.notilens.com)

package/dist/agent.d.ts

@@ -0,0 +1,33 @@
+export declare class NotiLensAgent {
+    readonly agent: string;
+    private readonly token;
+    private readonly secret;
+    private constructor();
+    static init(agentName: string, options?: {
+        token?: string;
+        secret?: string;
+    }): NotiLensAgent;
+    taskStart(taskId?: string): string;
+    taskProgress(message: string, taskId: string): void;
+    taskLoop(message: string, taskId: string): void;
+    taskRetry(taskId: string): void;
+    taskError(message: string, taskId: string): void;
+    taskComplete(message: string, taskId: string): void;
+    taskFail(message: string, taskId: string): void;
+    taskTimeout(message: string, taskId: string): void;
+    taskCancel(message: string, taskId: string): void;
+    taskStop(taskId: string): void;
+    taskTerminate(message: string, taskId: string): void;
+    inputRequired(message: string, taskId: string): void;
+    inputApproved(message: string, taskId: string): void;
+    inputRejected(message: string, taskId: string): void;
+    aiResponseGenerated(message: string, taskId: string): void;
+    aiResponseFailed(message: string, taskId: string): void;
+    emit(event: string, message: string, options?: {
+        meta?: Record<string, unknown>;
+        level?: string;
+    }): void;
+    private send;
+    private calcDuration;
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotiLensAgent = void 0;
+const config_1 = require("./config");
+const state_1 = require("./state");
+const notify_1 = require("./notify");
+const SUCCESS_EVENTS = new Set([
+    'task.completed', 'ai.response.generated', 'input.approved',
+]);
+const ACTIONABLE_EVENTS = new Set([
+    'task.error', 'task.failed', 'task.timeout', 'task.retrying', 'task.loop',
+    'ai.response.failed', 'input.required', 'input.rejected',
+]);
+const LEVEL_TO_TYPE = {
+    debug: 'info', info: 'info', warning: 'warning', error: 'urgent', critical: 'urgent',
+};
+function eventType(event, level) {
+    if (SUCCESS_EVENTS.has(event))
+        return 'success';
+    if (['task.failed', 'task.timeout', 'task.error', 'task.terminated', 'ai.response.failed'].includes(event))
+        return 'urgent';
+    if (['task.retrying', 'task.cancelled', 'input.required', 'input.rejected'].includes(event))
+        return 'warning';
+    return LEVEL_TO_TYPE[level] ?? 'info';
+}
+class NotiLensAgent {
+    constructor(agent, token, secret) {
+        this.agent = agent;
+        this.token = token;
+        this.secret = secret;
+    }
+    // ── Factory ──────────────────────────────────────────────────────────────
+    static init(agentName, options) {
+        let token = options?.token ?? process.env.NOTILENS_TOKEN;
+        let secret = options?.secret ?? process.env.NOTILENS_SECRET;
+        if (!token || !secret) {
+            const conf = (0, config_1.getAgentConfig)(agentName);
+            token ?? (token = conf?.token);
+            secret ?? (secret = conf?.secret);
+        }
+        if (!token || !secret) {
+            throw new Error(`NotiLens: token and secret are required. Pass them directly, set ` +
+                `NOTILENS_TOKEN/NOTILENS_SECRET env vars, or run: ` +
+                `notilens init --agent ${agentName} --token TOKEN --secret SECRET`);
+        }
+        return new NotiLensAgent(agentName, token, secret);
+    }
+    // ── Task lifecycle ───────────────────────────────────────────────────────
+    taskStart(taskId) {
+        const id = taskId ?? `task_${Date.now()}`;
+        const sf = (0, state_1.getStateFile)(this.agent, id);
+        (0, state_1.writeState)(sf, { agent: this.agent, task: id, start_time: Date.now(), retry_count: 0, loop_count: 0 });
+        this.send('task.started', 'Task started', id);
+        return id;
+    }
+    taskProgress(message, taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf) });
+        this.send('task.progress', message, taskId);
+    }
+    taskLoop(message, taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        const state = (0, state_1.readState)(sf);
+        const count = (state.loop_count ?? 0) + 1;
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf), loop_count: count });
+        this.send('task.loop', message, taskId);
+    }
+    taskRetry(taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        const state = (0, state_1.readState)(sf);
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf), retry_count: (state.retry_count ?? 0) + 1 });
+        this.send('task.retrying', 'Retrying task', taskId);
+    }
+    taskError(message, taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf), last_error: message });
+        this.send('task.error', message, taskId);
+    }
+    taskComplete(message, taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf) });
+        this.send('task.completed', message, taskId);
+        (0, state_1.deleteState)(sf);
+    }
+    taskFail(message, taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf) });
+        this.send('task.failed', message, taskId);
+        (0, state_1.deleteState)(sf);
+    }
+    taskTimeout(message, taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf) });
+        this.send('task.timeout', message, taskId);
+        (0, state_1.deleteState)(sf);
+    }
+    taskCancel(message, taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf) });
+        this.send('task.cancelled', message, taskId);
+        (0, state_1.deleteState)(sf);
+    }
+    taskStop(taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf) });
+        this.send('task.stopped', 'Task stopped', taskId);
+    }
+    taskTerminate(message, taskId) {
+        const sf = (0, state_1.getStateFile)(this.agent, taskId);
+        (0, state_1.updateState)(sf, { duration_ms: this.calcDuration(sf) });
+        this.send('task.terminated', message, taskId);
+        (0, state_1.deleteState)(sf);
+    }
+    // ── Input events ─────────────────────────────────────────────────────────
+    inputRequired(message, taskId) {
+        this.send('input.required', message, taskId);
+    }
+    inputApproved(message, taskId) {
+        this.send('input.approved', message, taskId);
+    }
+    inputRejected(message, taskId) {
+        this.send('input.rejected', message, taskId);
+    }
+    // ── AI response events ───────────────────────────────────────────────────
+    aiResponseGenerated(message, taskId) {
+        this.send('ai.response.generated', message, taskId);
+    }
+    aiResponseFailed(message, taskId) {
+        this.send('ai.response.failed', message, taskId);
+    }
+    // ── Generic emit ─────────────────────────────────────────────────────────
+    emit(event, message, options) {
+        this.send(event, message, undefined, options?.meta, options?.level);
+    }
+    // ── Internals ────────────────────────────────────────────────────────────
+    send(event, message, taskId, meta = {}, level = 'info') {
+        const title = taskId
+            ? `${this.agent} | ${taskId} | ${event}`
+            : `${this.agent} | ${event}`;
+        const { image_url = '', open_url = '', download_url = '', tags = '', ...restMeta } = meta;
+        const payload = {
+            event,
+            title,
+            message,
+            type: eventType(event, level),
+            agent: this.agent,
+            task_id: taskId ?? '',
+            is_actionable: ACTIONABLE_EVENTS.has(event),
+            image_url,
+            open_url,
+            download_url,
+            tags,
+            ts: Date.now() / 1000,
+            meta: restMeta,
+        };
+        (0, notify_1.sendNotification)(this.token, this.secret, payload).catch(() => {
+            // silent fail
+        });
+    }
+    calcDuration(stateFile) {
+        const state = (0, state_1.readState)(stateFile);
+        return Date.now() - (state.start_time ?? 0);
+    }
+}
+exports.NotiLensAgent = NotiLensAgent;
+//# sourceMappingURL=agent.js.map

package/dist/cli.js

@@ -6,7 +6,6 @@ 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) {
@@ -78,47 +77,29 @@ function parseFlags(args) {
 }
 // ---- 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';
-    }
+    if (['task.completed', 'ai.response.generated', 'input.approved'].includes(event))
+        return 'success';
+    if (['task.failed', 'task.timeout', 'task.error', 'task.terminated', 'ai.response.failed'].includes(event))
+        return 'urgent';
+    if (['task.retrying', 'task.cancelled', 'input.required', 'input.rejected'].includes(event))
+        return 'warning';
+    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',
+        'task.error', 'task.failed', 'task.timeout', 'task.retrying', 'task.loop',
+        'ai.response.failed', 'input.required', 'input.rejected',
     ].includes(event);
 }
 function validateType(t) {
-    return ['info', 'success', 'warning', 'urgent', 'important'].includes(t)
-        ? t
-        : '';
+    return ['info', 'success', 'warning', 'urgent'].includes(t) ? t : '';
 }
 // ---- Core send ----
-async function sendNotify(event, title, message, flags) {
+async function sendNotify(event, message, flags) {
     const conf = (0, config_1.getAgentConfig)(flags.agent);
-    if (!conf?.endpoint || !conf?.secret) {
-        console.error('❌ Agent not configured');
-        return;
+    if (!conf?.token || !conf?.secret) {
+        console.error(`❌ Agent '${flags.agent}' not configured. Run: notilens init --agent ${flags.agent} --token TOKEN --secret SECRET`);
+        process.exit(1);
     }
     const stateFile = (0, state_1.getStateFile)(flags.agent, flags.taskId);
     const state = (0, state_1.readState)(stateFile);
@@ -134,6 +115,7 @@ async function sendNotify(event, title, message, flags) {
         loop_count: state.loop_count ?? 0,
         ...flags.meta,
     };
+    const title = `${flags.agent} | ${flags.taskId} | ${event}`;
     const finalType = validateType(flags.type) || getEventType(event);
     const finalActionable = flags.isActionable !== ''
         ? flags.isActionable === 'true'
@@ -145,19 +127,20 @@ async function sendNotify(event, title, message, flags) {
         type: finalType,
         agent: flags.agent,
         task_id: flags.taskId,
-        meta,
+        is_actionable: finalActionable,
         image_url: flags.imageUrl,
         open_url: flags.openUrl,
         download_url: flags.downloadUrl,
         tags: flags.tags,
-        is_actionable: finalActionable,
+        ts: Date.now() / 1000,
+        meta,
     };
     try {
-        await (0, notify_1.sendNotification)(conf.endpoint, conf.secret, payload);
-        await new Promise(r => setTimeout(r, 300)); // match bash sleep 0.3
+        await (0, notify_1.sendNotification)(conf.token, conf.secret, payload);
+        await new Promise(r => setTimeout(r, 300));
     }
     catch {
-        // Silent fail — mirrors bash curl behaviour
+        // silent fail
     }
 }
 // ---- Duration helper ----
@@ -171,35 +154,62 @@ async function main() {
     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>');
+        case 'init': {
+            let agent = '', token = '', secret = '';
+            for (let i = 0; i < rest.length; i++) {
+                if (rest[i] === '--agent')
+                    agent = rest[++i] ?? '';
+                if (rest[i] === '--token')
+                    token = rest[++i] ?? '';
+                if (rest[i] === '--secret')
+                    secret = rest[++i] ?? '';
+            }
+            if (!agent || !token || !secret) {
+                console.error('Usage: notilens init --agent <name> --token <token> --secret <secret>');
                 process.exit(1);
             }
-            (0, config_1.addAgent)(agent, transport, endpoint, secret);
-            console.log(`✔ Agent '${agent}' added`);
+            (0, config_1.saveAgent)(agent, token, secret);
+            console.log(`✔ Agent '${agent}' saved`);
+            break;
+        }
+        case 'agents': {
+            const agents = (0, config_1.listAgents)();
+            if (!agents.length)
+                console.log('No agents configured.');
+            else
+                agents.forEach(a => console.log(`  ${a}`));
+            break;
+        }
+        case 'remove-agent': {
+            const agent = rest[0];
+            if (!agent) {
+                console.error('Usage: notilens remove-agent <agent>');
+                process.exit(1);
+            }
+            (0, config_1.removeAgent)(agent)
+                ? console.log(`✔ Agent '${agent}' removed`)
+                : console.error(`Agent '${agent}' not found`);
             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,
+                agent: flags.agent, task: flags.taskId,
+                start_time: Date.now(), retry_count: 0, loop_count: 0,
             });
-            await sendNotify('task.started', `${flags.agent} | ${flags.taskId} started`, 'Task started', flags);
+            await sendNotify('task.started', 'Task started', flags);
             console.log(`▶️  Started: ${flags.agent} | ${flags.taskId}`);
             break;
         }
-        case 'task.in_progress': {
+        case 'task.progress': {
+            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.in_progress', `${flags.agent} | ${flags.taskId} running`, 'Task in progress', flags);
-            console.log(`⏳ In Progress: ${flags.agent} | ${flags.taskId}`);
+            await sendNotify('task.progress', msg, flags);
+            console.log(`⏳ Progress: ${flags.agent} | ${flags.taskId}`);
             break;
         }
         case 'task.stop': {
@@ -207,7 +217,7 @@ async function main() {
             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);
+            await sendNotify('task.stopped', 'Task stopped', flags);
             console.log(`⏹  Stopped: ${flags.agent} | ${flags.taskId} (${dur} ms)`);
             break;
         }
@@ -219,7 +229,7 @@ async function main() {
                 duration_ms: calcDuration(stateFile),
                 retry_count: (state.retry_count ?? 0) + 1,
             });
-            await sendNotify('task.retrying', `${flags.agent} | ${flags.taskId} retry`, 'Retrying task', flags);
+            await sendNotify('task.retrying', 'Retrying task', flags);
             console.log(`🔁 Retry: ${flags.agent} | ${flags.taskId}`);
             break;
         }
@@ -231,7 +241,7 @@ async function main() {
             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);
+            await sendNotify('task.loop', msg, flags);
             console.log(`🔄 Loop (${loopCount}): ${flags.agent} | ${flags.taskId}`);
             break;
         }
@@ -241,7 +251,7 @@ async function main() {
             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);
+            await sendNotify('task.error', msg, flags);
             console.error(`❌ Error: ${msg}`);
             break;
         }
@@ -250,8 +260,8 @@ async function main() {
             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.updateState)(stateFile, { duration_ms: calcDuration(stateFile) });
+            await sendNotify('task.failed', msg, flags);
             (0, state_1.deleteState)(stateFile);
             console.log(`💥 Failed: ${flags.agent} | ${flags.taskId}`);
             break;
@@ -261,8 +271,8 @@ async function main() {
             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.updateState)(stateFile, { duration_ms: calcDuration(stateFile) });
+            await sendNotify('task.timeout', msg, flags);
             (0, state_1.deleteState)(stateFile);
             console.log(`⏰ Timeout: ${flags.agent} | ${flags.taskId}`);
             break;
@@ -272,8 +282,8 @@ async function main() {
             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.updateState)(stateFile, { duration_ms: calcDuration(stateFile) });
+            await sendNotify('task.cancelled', msg, flags);
             (0, state_1.deleteState)(stateFile);
             console.log(`🚫 Cancelled: ${flags.agent} | ${flags.taskId}`);
             break;
@@ -283,8 +293,8 @@ async function main() {
             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.updateState)(stateFile, { duration_ms: calcDuration(stateFile) });
+            await sendNotify('task.terminated', msg, flags);
             (0, state_1.deleteState)(stateFile);
             console.log(`⚠️  Terminated: ${flags.agent} | ${flags.taskId}`);
             break;
@@ -295,7 +305,7 @@ async function main() {
             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);
+            await sendNotify('task.completed', msg, flags);
             (0, state_1.deleteState)(stateFile);
             console.log(`✅ Completed: ${flags.agent} | ${flags.taskId}`);
             break;
@@ -317,35 +327,35 @@ async function main() {
             const pos = positionalArgs(rest);
             const msg = pos[0] ?? '';
             const flags = parseFlags(rest);
-            await sendNotify('ai.response.generated', `${flags.agent} | ${flags.taskId} response`, msg, flags);
+            await sendNotify('ai.response.generated', 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);
+            await sendNotify('ai.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);
+            await sendNotify('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);
+            await sendNotify('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);
+            await sendNotify('input.rejected', msg, flags);
             break;
         }
         case 'emit': {
@@ -355,7 +365,7 @@ async function main() {
             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);
+            await sendNotify(event, msg, flags);
             console.log(`📡 Event emitted: ${event}`);
             break;
         }
@@ -368,43 +378,47 @@ async function main() {
 }
 function printUsage() {
     console.log(`Usage:
-  notilens add-agent <agent> <transport> <endpoint> <secret>
+  notilens init --agent <name> --token <token> --secret <secret>
+  notilens agents
+  notilens remove-agent <agent>
 
-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>]
+Task Lifecycle:
+  notilens task.start    --agent <agent> [--task <id>]
+  notilens task.progress "msg"  --agent <agent> [--task <id>]
+  notilens task.loop     "msg"  --agent <agent> [--task <id>]
+  notilens task.retry           --agent <agent> [--task <id>]
+  notilens task.stop            --agent <agent> [--task <id>]
+  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>
+  notilens task.complete "msg"  --agent <agent> [--task <id>]
+
+AI / Input:
+  notilens ai.response.generate "msg" --agent <agent> [--task <id>]
+  notilens ai.response.fail     "msg" --agent <agent> [--task <id>]
+  notilens input.required       "msg" --agent <agent> [--task <id>]
+  notilens input.approve        "msg" --agent <agent> [--task <id>]
+  notilens input.reject         "msg" --agent <agent> [--task <id>]
 
-Generic Event:
+Generic:
   notilens emit <event> "msg" --agent <agent>
 
 Metrics:
   notilens set.metrics <prompt_tokens> <completion_tokens> [confidence] --agent <agent> [--task <id>]
 
 Options:
-  --agent <agent>
+  --agent <name>
   --task <id>
-  --type success|warning|urgent|important|info
-  --meta key=value            (repeatable)
+  --type success|warning|urgent|info
+  --meta key=value        (repeatable)
   --image_url <url>
   --open_url <url>
   --download_url <url>
   --tags "tag1,tag2"
   --is_actionable true|false
-  --confidence <0-100>
+  --confidence <0-1>
 
 Other:
   notilens version`);

package/dist/config.d.ts

@@ -2,5 +2,7 @@ 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;
+export declare function saveAgent(agent: string, token: string, secret: string): void;
+export declare function removeAgent(agent: string): boolean;
+export declare function listAgents(): string[];
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -36,7 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readConfig = readConfig;
 exports.writeConfig = writeConfig;
 exports.getAgentConfig = getAgentConfig;
-exports.addAgent = addAgent;
+exports.saveAgent = saveAgent;
+exports.removeAgent = removeAgent;
+exports.listAgents = listAgents;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -58,9 +60,20 @@ function getAgentConfig(agent) {
     const config = readConfig();
     return config[agent] || null;
 }
-function addAgent(agent, transport, endpoint, secret) {
+function saveAgent(agent, token, secret) {
     const config = readConfig();
-    config[agent] = { transport, endpoint, secret };
+    config[agent] = { token, secret };
     writeConfig(config);
 }
+function removeAgent(agent) {
+    const config = readConfig();
+    if (!config[agent])
+        return false;
+    delete config[agent];
+    writeConfig(config);
+    return true;
+}
+function listAgents() {
+    return Object.keys(readConfig());
+}
 //# sourceMappingURL=config.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { NotiLensAgent } from './agent';
+export { saveAgent, getAgentConfig, removeAgent, listAgents } from './config';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAgents = exports.removeAgent = exports.getAgentConfig = exports.saveAgent = exports.NotiLensAgent = void 0;
+var agent_1 = require("./agent");
+Object.defineProperty(exports, "NotiLensAgent", { enumerable: true, get: function () { return agent_1.NotiLensAgent; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "saveAgent", { enumerable: true, get: function () { return config_1.saveAgent; } });
+Object.defineProperty(exports, "getAgentConfig", { enumerable: true, get: function () { return config_1.getAgentConfig; } });
+Object.defineProperty(exports, "removeAgent", { enumerable: true, get: function () { return config_1.removeAgent; } });
+Object.defineProperty(exports, "listAgents", { enumerable: true, get: function () { return config_1.listAgents; } });
+//# sourceMappingURL=index.js.map

package/dist/notify.d.ts

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

package/dist/notify.js

@@ -35,55 +35,51 @@ var __importStar = (this && this.__importStar) || (function () {
 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 WEBHOOK_URL = 'https://hook.notilens.com/webhook/%s/send';
 const MAX_RETRIES = 2;
 const TIMEOUT_MS = 10000;
-async function attempt(endpoint, secret, body) {
+async function attempt(token, secret, body) {
     return new Promise((resolve, reject) => {
+        const endpoint = WEBHOOK_URL.replace('%s', token);
         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),
+            port: url.port || 443,
             path: url.pathname + url.search,
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
                 'X-NOTILENS-KEY': secret,
-                'User-Agent': `NotiLens-CLI/${VERSION}`,
+                'User-Agent': `NotiLens-SDK/${VERSION}`,
                 'Content-Length': Buffer.byteLength(body),
             },
         };
-        const req = lib.request(options, (res) => {
+        const req = https.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('error', (err) => { clearTimeout(timer); reject(err); });
         req.on('close', () => clearTimeout(timer));
         req.write(body);
         req.end();
     });
 }
-async function sendNotification(endpoint, secret, payload) {
+async function sendNotification(token, secret, payload) {
     const body = JSON.stringify(payload);
     let lastErr;
     for (let i = 0; i <= MAX_RETRIES; i++) {
         try {
-            await attempt(endpoint, secret, body);
+            await attempt(token, secret, body);
             return;
         }
         catch (err) {
             lastErr = err;
-            if (i < MAX_RETRIES) {
-                await new Promise(r => setTimeout(r, 1000)); // 1s retry delay
-            }
+            if (i < MAX_RETRIES)
+                await new Promise(r => setTimeout(r, 1000));
         }
     }
     throw lastErr;

package/dist/types.d.ts

@@ -1,6 +1,5 @@
 export interface AgentConfig {
-    transport: string;
-    endpoint: string;
+    token: string;
     secret: string;
 }
 export interface NotiLensConfig {
@@ -28,14 +27,15 @@ export interface NotifyPayload {
     type: string;
     agent: string;
     task_id: string;
-    meta: Record<string, unknown>;
+    is_actionable: boolean;
     image_url: string;
     open_url: string;
     download_url: string;
     tags: string;
-    is_actionable: boolean;
+    ts: number;
+    meta: Record<string, unknown>;
 }
-export type NotificationType = 'info' | 'success' | 'warning' | 'urgent' | 'important';
+export type NotificationType = 'info' | 'success' | 'warning' | 'urgent';
 export interface ParsedFlags {
     agent: string;
     taskId: string;

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "@notilens/notilens",
-  "version": "0.1.1",
-  "description": "NotiLens CLI — send AI agent task lifecycle notifications",
-  "keywords": ["notilens", "ai-agent", "notifications", "monitoring", "cli"],
+  "version": "0.2.2",
+  "description": "NotiLens SDK + CLI — send AI agent task lifecycle notifications",
+  "keywords": ["notilens", "ai-agent", "notifications", "monitoring", "cli", "sdk"],
   "homepage": "https://www.notilens.com",
   "author": "NotiLens",
   "license": "MIT",
-  "main": "dist/cli.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
     "notilens": "dist/cli.js"
   },
+  "exports": {
+    ".": "./dist/index.js",
+    "./cli": "./dist/cli.js"
+  },
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",