lumabrowser 1.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+PROPRIETARY SOFTWARE LICENSE
+Copyright (c) 2026 LumaBrowser. All rights reserved.
+
+This software and associated documentation files (the "Software") are the
+proprietary property of the copyright holder. The Software is provided solely
+for testing and evaluation purposes.
+
+RESTRICTIONS:
+- You may NOT distribute, sublicense, or sell copies of the Software.
+- You may NOT modify, merge, or create derivative works based on the Software.
+- You may NOT use the Software for commercial purposes without a separate
+  commercial license agreement.
+- You may NOT reverse engineer, decompile, or disassemble the Software.
+
+The Software is provided "AS IS", without warranty of any kind, express or
+implied. In no event shall the copyright holder be liable for any claim,
+damages, or other liability arising from the use of the Software.
+
+For commercial licensing inquiries, please contact the copyright holder.

package/README.md

@@ -0,0 +1,60 @@
+# LumaBrowser
+
+> A multi-tab browser with built-in AI automation, web notification interception, and a plugin architecture. Controllable locally or remotely via REST API and MCP (Model Context Protocol).
+
+## Install & Run
+
+```bash
+npx lumabrowser start
+```
+
+That's it. The first run downloads the right build for your OS from the [official GitHub Releases](https://github.com/amurgola/notification2webhookbrowser/releases), caches it under `~/.lumabrowser/`, and launches it.
+
+Subsequent runs launch from cache — no re-download unless you ask for one.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `npx lumabrowser start` | Launch LumaBrowser (installs on first run). |
+| `npx lumabrowser update` | Force re-download of the latest release. |
+| `npx lumabrowser version` | Print the installed LumaBrowser version. |
+| `npx lumabrowser uninstall` | Remove the cached installation. |
+| `npx lumabrowser help` | Show all commands. |
+
+## Global install
+
+If you'd rather not type `npx` every time:
+
+```bash
+npm install -g lumabrowser
+lumabrowser start
+```
+
+## Platform support
+
+| OS | Asset type |
+|---|---|
+| Windows (x64) | Portable `.exe` |
+| macOS (Intel / Apple Silicon) | `.app` bundle extracted from `.zip` |
+| Linux (x64) | `.AppImage` |
+
+## What you get
+
+- **Multi-tab Electron browser** with system tray integration.
+- **REST API** (`http://localhost:3000`) for programmatic control.
+- **MCP server** so Claude Desktop and other AI tools can drive the browser.
+- **Web notification interception** — any page's `Notification(...)` calls get forwarded to a webhook.
+- **Network watcher** — URL patterns trigger webhooks when matching responses fire.
+- **AI chat sidebar** that can navigate, click, fill forms, and take screenshots.
+- **Local WebGPU LLMs** (Qwen 2.5) for private inference — no API keys required.
+- **Extension system** with runtime enable/disable and zip-based installation.
+
+## Learn more
+
+- Docs & downloads: [lumabyte.com](https://lumabyte.com)
+- Source & issues: [github.com/amurgola/notification2webhookbrowser](https://github.com/amurgola/notification2webhookbrowser)
+
+## License
+
+Proprietary — see [LICENSE](./LICENSE).

package/bin/lumabrowser.js

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, execSync } = require('child_process');
+
+const REPO = 'amurgola/notification2webhookbrowser';
+const CACHE_DIR = path.join(os.homedir(), '.lumabrowser');
+const STATE_FILE = path.join(CACHE_DIR, 'install.json');
+const USER_AGENT = 'lumabrowser-cli';
+
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+const log = (m) => process.stdout.write(m + '\n');
+const info = (m) => process.stdout.write(`${CYAN}${m}${RESET}\n`);
+const ok = (m) => process.stdout.write(`${GREEN}${m}${RESET}\n`);
+const warn = (m) => process.stdout.write(`${YELLOW}${m}${RESET}\n`);
+const err = (m) => process.stderr.write(`${RED}${m}${RESET}\n`);
+
+function printHelp() {
+  log(`
+${CYAN}LumaBrowser${RESET} — browser with notification interception and AI automation
+
+${YELLOW}Usage:${RESET}
+  npx lumabrowser ${DIM}[command]${RESET}
+
+${YELLOW}Commands:${RESET}
+  start         Launch LumaBrowser (downloads on first run) ${DIM}[default]${RESET}
+  update        Force re-download of the latest version
+  uninstall     Remove the cached LumaBrowser installation
+  version       Print the installed LumaBrowser version
+  help          Show this message
+
+${YELLOW}Examples:${RESET}
+  ${DIM}# First run — downloads and launches${RESET}
+  npx lumabrowser start
+
+  ${DIM}# Pull the newest release${RESET}
+  npx lumabrowser update
+
+${YELLOW}Cache directory:${RESET} ${DIM}${CACHE_DIR}${RESET}
+${YELLOW}Docs:${RESET}          ${DIM}https://lumabyte.com${RESET}
+`);
+}
+
+function readState() {
+  try { return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); }
+  catch { return null; }
+}
+
+function writeState(data) {
+  fs.mkdirSync(CACHE_DIR, { recursive: true });
+  fs.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2));
+}
+
+function httpRequest(url, { json = false } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, {
+      headers: {
+        'User-Agent': USER_AGENT,
+        'Accept': json ? 'application/vnd.github+json' : '*/*'
+      }
+    }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        return httpRequest(res.headers.location, { json }).then(resolve, reject);
+      }
+      if (res.statusCode !== 200) {
+        res.resume();
+        return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+      }
+      if (json) {
+        let body = '';
+        res.setEncoding('utf8');
+        res.on('data', (c) => body += c);
+        res.on('end', () => {
+          try { resolve(JSON.parse(body)); }
+          catch (e) { reject(e); }
+        });
+      } else {
+        resolve(res);
+      }
+    });
+    req.on('error', reject);
+    req.setTimeout(30_000, () => req.destroy(new Error('Request timed out')));
+  });
+}
+
+function downloadFile(url, destPath, label) {
+  return new Promise((resolve, reject) => {
+    const tmpPath = destPath + '.downloading';
+    const file = fs.createWriteStream(tmpPath);
+    let downloaded = 0;
+    let total = 0;
+    let lastPrint = 0;
+
+    httpRequest(url)
+      .then((res) => {
+        total = parseInt(res.headers['content-length'] || '0', 10);
+        res.on('data', (chunk) => {
+          downloaded += chunk.length;
+          const now = Date.now();
+          if (now - lastPrint > 250) {
+            lastPrint = now;
+            const mb = (downloaded / 1024 / 1024).toFixed(1);
+            const totalMb = (total / 1024 / 1024).toFixed(1);
+            const pct = total ? Math.floor((downloaded / total) * 100) : 0;
+            const bar = renderBar(pct);
+            process.stdout.write(`\r${CYAN}${label}${RESET} ${bar} ${mb}/${totalMb} MB (${pct}%)   `);
+          }
+        });
+        res.pipe(file);
+        file.on('finish', () => {
+          file.close(() => {
+            process.stdout.write('\r' + ' '.repeat(80) + '\r');
+            fs.renameSync(tmpPath, destPath);
+            resolve();
+          });
+        });
+        file.on('error', reject);
+      })
+      .catch((e) => {
+        file.close();
+        try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+        reject(e);
+      });
+  });
+}
+
+function renderBar(pct) {
+  const width = 20;
+  const filled = Math.floor((pct / 100) * width);
+  return '[' + '#'.repeat(filled) + '-'.repeat(width - filled) + ']';
+}
+
+function pickAsset(assets) {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const patterns = {
+    win32: [
+      /portable.*\.exe$/i,
+      /win.*portable.*\.exe$/i,
+      /lumabrowser[^/]*\.exe$/i
+    ],
+    darwin: [
+      arch === 'arm64'
+        ? /(mac|osx|darwin).*arm64.*\.zip$/i
+        : /(mac|osx|darwin).*(x64|x86_64).*\.zip$/i,
+      /(mac|osx|darwin).*\.zip$/i
+    ],
+    linux: [
+      /\.AppImage$/i
+    ]
+  }[platform] || [];
+
+  for (const pattern of patterns) {
+    const match = assets.find((a) => pattern.test(a.name));
+    if (match) return match;
+  }
+  return null;
+}
+
+async function fetchLatestRelease() {
+  return httpRequest(`https://api.github.com/repos/${REPO}/releases/latest`, { json: true });
+}
+
+async function install({ force = false } = {}) {
+  info('Checking GitHub for the latest LumaBrowser release…');
+  const release = await fetchLatestRelease();
+  const asset = pickAsset(release.assets || []);
+  if (!asset) {
+    throw new Error(
+      `No compatible LumaBrowser asset found for ${process.platform}/${process.arch} in release ${release.tag_name}.\n` +
+      `Available assets: ${(release.assets || []).map((a) => a.name).join(', ') || '(none)'}`
+    );
+  }
+
+  const current = readState();
+  if (!force && current && current.version === release.tag_name && current.executable && fs.existsSync(current.executable)) {
+    return current;
+  }
+
+  fs.mkdirSync(CACHE_DIR, { recursive: true });
+  const downloadPath = path.join(CACHE_DIR, asset.name);
+  ok(`Downloading LumaBrowser ${release.tag_name} — ${asset.name}`);
+  await downloadFile(asset.browser_download_url, downloadPath, 'Downloading');
+
+  const executable = prepareExecutable(downloadPath);
+  const record = {
+    version: release.tag_name,
+    asset: asset.name,
+    executable,
+    installedAt: new Date().toISOString()
+  };
+  writeState(record);
+  ok(`Installed LumaBrowser ${release.tag_name}`);
+  return record;
+}
+
+function prepareExecutable(archivePath) {
+  const p = process.platform;
+
+  if (p === 'win32') {
+    return archivePath;
+  }
+
+  if (p === 'linux') {
+    try { fs.chmodSync(archivePath, 0o755); } catch { /* ignore */ }
+    return archivePath;
+  }
+
+  if (p === 'darwin') {
+    const extractDir = path.join(CACHE_DIR, 'app');
+    fs.rmSync(extractDir, { recursive: true, force: true });
+    fs.mkdirSync(extractDir, { recursive: true });
+    try {
+      execSync(`ditto -x -k "${archivePath}" "${extractDir}"`, { stdio: 'inherit' });
+    } catch (e) {
+      throw new Error(`Failed to extract ${archivePath}: ${e.message}`);
+    }
+    const appBundle = fs.readdirSync(extractDir).find((n) => n.endsWith('.app'));
+    if (!appBundle) {
+      throw new Error('No .app bundle found in downloaded archive.');
+    }
+    const appPath = path.join(extractDir, appBundle);
+    try { execSync(`xattr -dr com.apple.quarantine "${appPath}"`); } catch { /* best effort */ }
+    return appPath;
+  }
+
+  throw new Error(`Unsupported platform: ${p}`);
+}
+
+function launchApp(executable, extraArgs) {
+  const p = process.platform;
+  if (p === 'darwin') {
+    const child = spawn('open', ['-a', executable, '--args', ...extraArgs], { stdio: 'ignore', detached: true });
+    child.unref();
+    return;
+  }
+  const child = spawn(executable, extraArgs, { stdio: 'ignore', detached: true });
+  child.unref();
+}
+
+async function cmdStart(extraArgs) {
+  const current = readState();
+  let record;
+  if (current && current.executable && fs.existsSync(current.executable)) {
+    record = current;
+  } else {
+    record = await install({ force: false });
+  }
+  ok(`Launching LumaBrowser ${record.version}…`);
+  launchApp(record.executable, extraArgs);
+  log(`${DIM}Tip: run \`npx lumabrowser update\` to pull the newest release.${RESET}`);
+}
+
+function cmdUninstall() {
+  if (!fs.existsSync(CACHE_DIR)) {
+    log('Nothing to uninstall.');
+    return;
+  }
+  fs.rmSync(CACHE_DIR, { recursive: true, force: true });
+  ok('Removed cached LumaBrowser installation.');
+}
+
+function cmdVersion() {
+  const current = readState();
+  if (current) {
+    log(`LumaBrowser ${current.version}`);
+    log(`${DIM}  asset:      ${current.asset}${RESET}`);
+    log(`${DIM}  executable: ${current.executable}${RESET}`);
+    log(`${DIM}  installed:  ${current.installedAt}${RESET}`);
+  } else {
+    log('LumaBrowser is not yet installed.');
+    log(`${DIM}Run \`npx lumabrowser start\` to install and launch.${RESET}`);
+  }
+}
+
+async function main() {
+  const [, , rawCmd, ...extraArgs] = process.argv;
+  const cmd = (rawCmd || 'start').toLowerCase();
+
+  try {
+    switch (cmd) {
+      case 'start':
+        await cmdStart(extraArgs);
+        break;
+      case 'install':
+        await install({ force: false });
+        break;
+      case 'update':
+      case 'upgrade':
+        await install({ force: true });
+        break;
+      case 'uninstall':
+      case 'remove':
+        cmdUninstall();
+        break;
+      case 'version':
+      case '--version':
+      case '-v':
+        cmdVersion();
+        break;
+      case 'help':
+      case '--help':
+      case '-h':
+      default:
+        if (rawCmd && !['help', '--help', '-h'].includes(cmd)) {
+          warn(`Unknown command: ${rawCmd}`);
+        }
+        printHelp();
+        break;
+    }
+  } catch (e) {
+    err(`lumabrowser: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "lumabrowser",
+  "version": "1.0.0",
+  "description": "CLI launcher for LumaBrowser — a multi-tab browser with notification interception and AI-driven automation.",
+  "bin": {
+    "lumabrowser": "bin/lumabrowser.js"
+  },
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "lumabrowser",
+    "browser",
+    "electron",
+    "automation",
+    "notifications",
+    "webhook",
+    "mcp",
+    "ai"
+  ],
+  "homepage": "https://lumabyte.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amurgola/notification2webhookbrowser.git"
+  },
+  "bugs": {
+    "url": "https://github.com/amurgola/notification2webhookbrowser/issues"
+  },
+  "author": "Andrew Murgola",
+  "license": "SEE LICENSE IN LICENSE",
+  "engines": {
+    "node": ">=18"
+  }
+}