onenotif 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Notifier.js

@@ -0,0 +1,72 @@
+import chalk from 'chalk';
+
+export class NotifierUI {
+  constructor(config = {}) {
+    this.notifications = [];
+    this.maxNotifications = config.maxNotifications || 20;
+    this.separator = '─'.repeat(60);
+    this.showWelcome();
+  }
+
+  showWelcome() {
+    console.clear();
+    console.log(chalk.cyan.bold('╔════════════════════════════════════════════════════════════╗'));
+    console.log(chalk.cyan.bold('║') + '            ' + chalk.white.bold('OneNotif') + ' - Notification Viewer            ' + chalk.cyan.bold('║'));
+    console.log(chalk.cyan.bold('╚════════════════════════════════════════════════════════════╝'));
+    console.log(chalk.gray('Waiting for notifications...\n'));
+  }
+
+  formatTime(date) {
+    return date.toLocaleTimeString('en-US', { hour12: false });
+  }
+
+  display(notification) {
+    const isNew = !this.notifications.includes(notification);
+
+    // Add to history
+    this.notifications.push(notification);
+    if (this.notifications.length > this.maxNotifications) {
+      this.notifications.shift();
+    }
+
+    console.log('');
+    console.log(chalk.gray(this.separator));
+
+    // Source badge
+    const sourceBadge = this.getSourceColor(notification.source);
+    const timeStr = this.formatTime(notification.timestamp);
+    console.log(sourceBadge(' ' + notification.source + ' ') + chalk.gray(' · ') + chalk.gray(timeStr));
+
+    // Title
+    if (notification.title) {
+      console.log(chalk.white.bold('  ' + notification.title));
+    }
+
+    // Content
+    if (notification.content) {
+      console.log(chalk.gray('  ' + notification.content));
+    }
+
+    // From info
+    if (notification.from) {
+      console.log(chalk.dim('  from: @' + notification.from));
+    }
+
+    console.log(chalk.gray(this.separator));
+
+    // If it's a status message, show differently
+    if (notification.type === 'status') {
+      console.log(chalk.cyan('  ' + notification.content || notification.message));
+    }
+  }
+
+  getSourceColor(source) {
+    const colors = {
+      'Telegram': chalk.bgRed,
+      'Webhook': chalk.bgBlue,
+      'Email': chalk.bgGreen,
+      'System': chalk.bgYellow
+    };
+    return colors[source] || chalk.bgGray;
+  }
+}

package/README.md

@@ -0,0 +1,90 @@
+# OneNotif
+
+Simple terminal notification viewer for Telegram and other sources.
+
+## Installation
+
+```bash
+npm install -g onenotif
+```
+
+Requires Node.js 18 or higher.
+
+## Setup
+
+1. Create a Telegram bot:
+   - Open Telegram and search for @BotFather
+   - Send `/newbot` and follow the instructions
+   - Copy the bot token
+
+2. Get your Telegram ID:
+   - Search for @userinfobot in Telegram
+   - It will show your user ID
+
+3. Configure:
+
+Create a config file at `~/.onenotif/config.json`:
+```json
+{
+  "sources": {
+    "telegram": {
+      "enabled": true,
+      "botToken": "YOUR_BOT_TOKEN",
+      "allowedUsers": ["your_telegram_id"]
+    }
+  }
+}
+```
+
+Or set environment variable:
+```bash
+export ONENOTIF_TELEGRAM_TOKEN="your_bot_token"
+```
+
+## Usage
+
+Start the app:
+```bash
+onenotif
+```
+
+Send messages to your bot on Telegram - they'll appear in your terminal!
+
+```
+────────────────────────────────────────────────────────────
+ Telegram  · 14:32:15
+  John
+  Hello from Telegram!
+  from @username
+────────────────────────────────────────────────────────────
+```
+
+## Development
+
+```bash
+git clone https://github.com/yourusername/onenotif.git
+cd onenotif
+npm install
+npm start
+```
+
+## Adding More Sources
+
+Create a new source class in `sources/` that extends `BaseSource`:
+
+```js
+import { BaseSource } from './BaseSource.js';
+
+export class MySource extends BaseSource {
+  async start() {
+    // Your implementation
+    // Call this.emit({ title, content, timestamp }) when notification arrives
+  }
+}
+```
+
+Then add it to `cli.js`.
+
+## License
+
+MIT

package/cli.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import { config as loadEnv } from 'dotenv';
+import { readFileSync, existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import chalk from 'chalk';
+import { TelegramSource } from './sources/TelegramSource.js';
+import { WebhookSource } from './sources/WebhookSource.js';
+import { NotifierUI } from './Notifier.js';
+
+loadEnv();
+
+// Get the directory where this script is located
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Load config - try multiple paths in order
+let config = {
+  sources: {
+    telegram: { enabled: true },
+    webhook: { enabled: false }
+  },
+  display: { maxNotifications: 20 }
+};
+
+const configPaths = [
+  process.env.CONFIG_PATH,
+  join(homedir(), '.onenotif', 'config.json'),
+  join(__dirname, 'config.json'),
+  './config.json'
+].filter(Boolean);
+
+for (const path of configPaths) {
+  if (existsSync(path)) {
+    try {
+      config = { ...config, ...JSON.parse(readFileSync(path, 'utf-8')) };
+      break;
+    } catch (err) {
+      // Continue to next path
+    }
+  }
+}
+
+// Initialize UI
+const ui = new NotifierUI(config.display);
+const sources = [];
+
+// Initialize Telegram
+if (config.sources?.telegram?.enabled) {
+  const tgConfig = {
+    botToken: config.sources.telegram.botToken || process.env.ONENOTIF_TELEGRAM_TOKEN || process.env.TELEGRAM_BOT_TOKEN,
+    allowedUsers: config.sources.telegram.allowedUsers || []
+  };
+
+  if (tgConfig.botToken) {
+    const telegram = new TelegramSource(tgConfig);
+    telegram.onNotification((notif) => ui.display(notif));
+    sources.push(telegram);
+  } else {
+    ui.display({
+      source: 'System',
+      type: 'error',
+      title: 'Telegram',
+      content: 'Set TELEGRAM_BOT_TOKEN env var or add botToken to config.json',
+      timestamp: new Date()
+    });
+  }
+}
+
+// Initialize Webhook
+if (config.sources?.webhook?.enabled) {
+  const webhook = new WebhookSource({
+    port: config.sources.webhook.port || 3000
+  });
+  webhook.onNotification((notif) => ui.display(notif));
+  sources.push(webhook);
+}
+
+// Start all sources
+console.log(chalk.gray('Starting notification sources...\n'));
+
+for (const source of sources) {
+  try {
+    await source.start();
+  } catch (err) {
+    ui.display({
+      source: 'System',
+      type: 'error',
+      title: source.name,
+      content: err.message,
+      timestamp: new Date()
+    });
+  }
+}
+
+// Keep running
+console.log(chalk.green('\n✓ All sources started. Press Ctrl+C to exit.\n'));
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  console.log(chalk.yellow('\n\nShutting down...'));
+  for (const source of sources) {
+    await source.stop();
+  }
+  process.exit(0);
+});

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "onenotif",
+  "version": "0.1.0",
+  "description": "Simple terminal notification viewer for Telegram and other sources",
+  "type": "module",
+  "main": "cli.js",
+  "bin": {
+    "onenotif": "./cli.js"
+  },
+  "exports": {
+    ".": "./cli.js",
+    "./sources": "./sources/index.js"
+  },
+  "scripts": {
+    "start": "node cli.js",
+    "dev": "node --watch cli.js",
+    "test": "node cli.js"
+  },
+  "keywords": [
+    "notification",
+    "telegram",
+    "terminal",
+    "cli",
+    "notifier",
+    "alerts",
+    "webhook"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "cli.js",
+    "Notifier.js",
+    "sources/",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/techbruwh/onenotif"
+  },
+  "homepage": "https://github.com/techbruwh/onenotif",
+  "bugs": "https://github.com/techbruwh/onenotif/issues",
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "grammy": "^1.21.1",
+    "chalk": "^5.3.0"
+  },
+  "devDependencies": {}
+}

package/sources/BaseSource.js

@@ -0,0 +1,32 @@
+// Base class for notification sources
+export class BaseSource {
+  constructor(name, config) {
+    this.name = name;
+    this.config = config;
+    this.callbacks = [];
+  }
+
+  // Override this in subclasses
+  async start() {
+    throw new Error(`${this.name}: start() not implemented`);
+  }
+
+  async stop() {
+    // Override if needed
+  }
+
+  // Register callback for new notifications
+  onNotification(callback) {
+    this.callbacks.push(callback);
+  }
+
+  // Notify all listeners
+  emit(notification) {
+    for (const cb of this.callbacks) {
+      cb({
+        source: this.name,
+        ...notification
+      });
+    }
+  }
+}

package/sources/TelegramSource.js

@@ -0,0 +1,65 @@
+import { Bot } from 'grammy';
+import { BaseSource } from './BaseSource.js';
+
+export class TelegramSource extends BaseSource {
+  constructor(config) {
+    super('Telegram', config);
+    this.bot = null;
+  }
+
+  async start() {
+    if (!this.config.botToken) {
+      console.error('Telegram: No botToken provided');
+      return;
+    }
+
+    this.bot = new Bot(this.config.botToken);
+
+    this.bot.command('start', (ctx) => this.handleStart(ctx));
+    this.bot.command('help', (ctx) => this.handleHelp(ctx));
+
+    // Listen for any text message
+    this.bot.on('message:text', (ctx) => this.handleMessage(ctx));
+
+    // Start polling
+    await this.bot.start();
+    this.emit({ type: 'status', message: '✅ Telegram bot started' });
+  }
+
+  handleStart(ctx) {
+    ctx.reply('Welcome to OneNotif! Send me any message and it will appear in your terminal.');
+  }
+
+  handleHelp(ctx) {
+    ctx.reply('Commands: /start, /help. Any message you send will be shown in the terminal.');
+  }
+
+  handleMessage(ctx) {
+    const allowedUsers = this.config.allowedUsers || [];
+
+    // Check if user is allowed
+    if (allowedUsers.length > 0 && !allowedUsers.includes(String(ctx.from.id))) {
+      ctx.reply('Sorry, you are not authorized to use this bot.');
+      return;
+    }
+
+    const notification = {
+      type: 'message',
+      title: ctx.from.first_name || ctx.from.username || 'User',
+      content: ctx.message.text,
+      timestamp: new Date(),
+      from: ctx.from.username || ctx.from.id
+    };
+
+    this.emit(notification);
+
+    // Send read receipt (optional)
+    // ctx.reply('📨 Notification received!');
+  }
+
+  async stop() {
+    if (this.bot) {
+      await this.bot.stop();
+    }
+  }
+}

package/sources/WebhookSource.js

@@ -0,0 +1,57 @@
+import { BaseSource } from './BaseSource.js';
+
+export class WebhookSource extends BaseSource {
+  constructor(config) {
+    super('Webhook', config);
+    this.server = null;
+  }
+
+  async start() {
+    const http = await import('http');
+
+    this.server = http.createServer((req, res) => {
+      if (req.method === 'POST' && req.url === '/webhook') {
+        let body = '';
+
+        req.on('data', (chunk) => {
+          body += chunk.toString();
+        });
+
+        req.on('end', () => {
+          try {
+            const data = JSON.parse(body);
+
+            this.emit({
+              type: 'webhook',
+              title: data.title || 'Webhook',
+              content: data.message || data.content || JSON.stringify(data),
+              timestamp: new Date()
+            });
+
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'received' }));
+          } catch (err) {
+            res.writeHead(400);
+            res.end('Invalid JSON');
+          }
+        });
+      } else {
+        res.writeHead(404);
+        res.end('Not found');
+      }
+    });
+
+    this.server.listen(this.config.port || 3000, () => {
+      this.emit({
+        type: 'status',
+        message: `✅ Webhook server listening on port ${this.config.port || 3000}`
+      });
+    });
+  }
+
+  async stop() {
+    if (this.server) {
+      this.server.close();
+    }
+  }
+}

package/sources/index.js

@@ -0,0 +1,3 @@
+export { BaseSource } from './BaseSource.js';
+export { TelegramSource } from './TelegramSource.js';
+export { WebhookSource } from './WebhookSource.js';