termhub-p2p 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TermHub
+
+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/README.md

@@ -0,0 +1,82 @@
+# TermHub 🚀
+
+**TermHub** is a decentralized terminal hub for P2P file sharing, often described as "GitHub for the terminal." It leverages WebTorrent to enable seamless publishing and downloading of files and directories directly from your command line.
+
+---
+
+## 🌟 Features
+
+- **Decentralized**: No central server for file hosting; everything is shared via P2P.
+- **Simple CLI**: Intuitive commands inspired by Git and GitHub.
+- **Fast & Lightweight**: Built with Node.js and WebTorrent.
+- **Global Registry**: Search and discover shared repositories.
+- **Star System**: Keep track of your favorite P2P repositories.
+
+---
+
+## 📦 Installation
+
+To install TermHub globally, use npm:
+
+```bash
+npm install -g termhub
+```
+
+---
+
+## 🚀 Usage
+
+### Publish a Repository
+Share a file or directory with the world:
+```bash
+termhub publish ./my-awesome-project
+```
+
+### Download a Repository
+Download using a magnet link or info hash:
+```bash
+termhub download <magnet-link-or-hash> -o ./destination
+```
+
+### Search
+Find repositories in the global registry:
+```bash
+termhub search "cool-project"
+```
+
+### List Published Items
+See what you have shared:
+```bash
+termhub list
+```
+
+### Star Repositories
+Star a repository to save it for later:
+```bash
+termhub star "project-name" <magnet-link>
+```
+Or list your stars:
+```bash
+termhub star
+```
+
+---
+
+## 🛠️ Tech Stack
+
+- **Node.js**: Runtime environment.
+- **WebTorrent**: P2P engine.
+- **Commander.js**: CLI framework.
+- **Chalk & Ora**: Beautiful terminal UI/UX.
+
+---
+
+## 📄 License
+
+This project is licensed under the **ISC License**. See the [LICENSE](LICENSE) file for details.
+
+---
+
+<p align="center">
+  Made with ❤️ for the Terminal community.
+</p>

package/dist/commands/daemon.d.ts

@@ -0,0 +1 @@
+export declare function daemonManager(action: string): Promise<void>;

package/dist/commands/daemon.js

@@ -0,0 +1,56 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs-extra';
+import os from 'os';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PID_FILE = path.join(os.homedir(), '.termhub', 'daemon.pid');
+const LOG_FILE = path.join(os.homedir(), '.termhub', 'daemon.log');
+export async function daemonManager(action) {
+    if (action === 'start') {
+        if (await fs.pathExists(PID_FILE)) {
+            console.log(chalk.yellow('⚠️  Daemon is already running (or PID file exists).'));
+            return;
+        }
+        console.log(chalk.blue('🚀 Starting TermHub Daemon in background...'));
+        // Path to the worker entry point in dist
+        const workerPath = path.join(__dirname, '..', 'daemon', 'worker.js');
+        const out = await fs.open(LOG_FILE, 'a');
+        const err = await fs.open(LOG_FILE, 'a');
+        const subprocess = spawn('node', [workerPath], {
+            detached: true,
+            stdio: ['ignore', out, err]
+        });
+        await fs.writeFile(PID_FILE, subprocess.pid?.toString() || '');
+        subprocess.unref();
+        console.log(chalk.green('✅ Daemon launched! All your published files are now being seeded in background.'));
+        console.log(chalk.gray(`Logs: ${LOG_FILE}`));
+    }
+    else if (action === 'stop') {
+        if (!(await fs.pathExists(PID_FILE))) {
+            console.log(chalk.red('❌ Daemon is not running.'));
+            return;
+        }
+        const pid = parseInt(await fs.readFile(PID_FILE, 'utf8'));
+        try {
+            process.kill(pid);
+            console.log(chalk.green('🛑 Daemon stopped.'));
+        }
+        catch (e) {
+            console.log(chalk.yellow('⚠️  Could not kill process. It might have already exited.'));
+        }
+        await fs.remove(PID_FILE);
+    }
+    else if (action === 'status') {
+        const isRunning = await fs.pathExists(PID_FILE);
+        if (isRunning) {
+            const pid = await fs.readFile(PID_FILE, 'utf8');
+            console.log(chalk.green(`● TermHub Daemon is RUNNING (PID: ${pid})`));
+            console.log(chalk.gray(`Seeding your global repositories.`));
+        }
+        else {
+            console.log(chalk.red('○ TermHub Daemon is OFFLINE'));
+        }
+    }
+}

package/dist/commands/download.d.ts

@@ -0,0 +1,5 @@
+interface DownloadOptions {
+    output: string;
+}
+export declare function download(magnet: string, options: DownloadOptions): Promise<void>;
+export {};

package/dist/commands/download.js

@@ -0,0 +1,64 @@
+import WebTorrent from 'webtorrent';
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import fs from 'fs-extra';
+const GLOBAL_TRACKERS = [
+    'udp://tracker.leechers-paradise.org:6969',
+    'udp://tracker.coppersurfer.tk:6969',
+    'udp://tracker.opentrackr.org:1337',
+    'udp://explodie.org:6969',
+    'wss://tracker.btorrent.xyz',
+    'wss://tracker.openwebtorrent.com',
+    'wss://tracker.webtorrent.dev'
+];
+export async function download(magnet, options) {
+    const client = new WebTorrent();
+    const spinner = ora('Connecting to peers...').start();
+    const outputPath = path.resolve(options.output);
+    try {
+        await fs.ensureDir(outputPath);
+        // Add trackers to the magnet if they are missing
+        let finalMagnet = magnet;
+        if (!finalMagnet.includes('tr=')) {
+            GLOBAL_TRACKERS.forEach(tr => {
+                finalMagnet += `&tr=${encodeURIComponent(tr)}`;
+            });
+        }
+        client.add(finalMagnet, { path: outputPath, announce: GLOBAL_TRACKERS }, (torrent) => {
+            spinner.text = `Found metadata. Downloading ${chalk.cyan(torrent.name)}...`;
+            torrent.on('download', () => {
+                const progress = (torrent.progress * 100).toFixed(1);
+                const downloaded = (torrent.downloaded / 1024 / 1024).toFixed(2);
+                const speed = (torrent.downloadSpeed / 1024 / 1024).toFixed(2);
+                spinner.text = `Downloading ${chalk.cyan(torrent.name)}: ${chalk.green(progress + '%')} (${downloaded} MB) | Speed: ${speed} MB/s | Peers: ${torrent.numPeers}`;
+            });
+            torrent.on('done', () => {
+                spinner.succeed(chalk.green(`Download complete: ${chalk.bold(torrent.name)}`));
+                console.log(`${chalk.yellow('Location:')} ${path.join(outputPath, torrent.name)}`);
+                process.exit(0);
+            });
+            torrent.on('error', (err) => {
+                spinner.fail(chalk.red('Torrent error occurred.'));
+                console.error(err);
+                process.exit(1);
+            });
+            torrent.on('wire', (wire) => {
+                // New peer connected!
+                spinner.text = `New peer found (${wire.remoteAddress}). Starting transfer...`;
+            });
+        });
+        // Timeout if no peers found in 30 seconds
+        setTimeout(() => {
+            const torrent = client.torrents[0];
+            if (torrent && torrent.numPeers === 0) {
+                spinner.warn(chalk.yellow('No peers found for a while. Are you sure someone is seeding this file?'));
+            }
+        }, 30000);
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to start download.'));
+        console.error(error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/explore.d.ts

@@ -0,0 +1 @@
+export declare function explore(): Promise<void>;

package/dist/commands/explore.js

@@ -0,0 +1,62 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import pkg from 'enquirer';
+const { Select } = pkg;
+import { getAllFromRegistry } from '../utils/p2p-registry.js';
+import { download } from './download.js';
+export async function explore() {
+    const spinner = ora('Exploring decentralized registry...').start();
+    const repos = await getAllFromRegistry();
+    if (repos.length === 0) {
+        spinner.fail(chalk.red('No repositories found in the network.'));
+        process.exit(0);
+    }
+    spinner.succeed(chalk.green(`Found ${repos.length} repositories.`));
+    const choices = repos.map(repo => ({
+        name: repo.infoHash,
+        message: `${chalk.bold.cyan(repo.name)} ${chalk.gray('- ' + repo.description)}`,
+        value: repo
+    }));
+    const prompt = new Select({
+        name: 'repository',
+        message: 'Select a repository to view details or download:',
+        choices: choices
+    });
+    try {
+        const selectedHash = await prompt.run();
+        const selectedRepo = repos.find(r => r.infoHash === selectedHash);
+        if (selectedRepo) {
+            console.log('\n' + chalk.bold.yellow('--- Repository Details ---'));
+            console.log(`${chalk.cyan('Name:')} ${selectedRepo.name}`);
+            console.log(`${chalk.cyan('Description:')} ${selectedRepo.description}`);
+            console.log(`${chalk.cyan('Author:')} ${selectedRepo.author}`);
+            console.log(`${chalk.cyan('Magnet:')} ${chalk.magenta(selectedRepo.magnetURI)}`);
+            console.log(chalk.bold.yellow('--------------------------\n'));
+            const actionPrompt = new Select({
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'download', message: '📥 Download now' },
+                    { name: 'copy', message: '📋 Copy Magnet Link' },
+                    { name: 'cancel', message: '❌ Cancel' }
+                ]
+            });
+            const action = await actionPrompt.run();
+            if (action === 'download') {
+                await download(selectedRepo.magnetURI, { output: '.' });
+            }
+            else if (action === 'copy') {
+                console.log(chalk.green('\nMagnet link copied to console! (Copy-paste manually for now)'));
+                console.log(selectedRepo.magnetURI);
+                process.exit(0);
+            }
+            else {
+                process.exit(0);
+            }
+        }
+    }
+    catch (err) {
+        // User cancelled (Ctrl+C)
+        process.exit(0);
+    }
+}

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function list(): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import { getRepositories, initStorage } from '../utils/storage.js';
+export async function list() {
+    await initStorage();
+    const repos = await getRepositories();
+    if (repos.length === 0) {
+        console.log(chalk.yellow('You haven\'t published any repositories yet.'));
+        process.exit(0);
+    }
+    console.log(chalk.bold.cyan('\nYour Published Repositories:\n'));
+    repos.forEach((repo, index) => {
+        console.log(`${chalk.green(index + 1 + '.')} ${chalk.bold(repo.name)}`);
+        console.log(`   ${chalk.gray('Hash:')} ${repo.infoHash}`);
+        console.log(`   ${chalk.gray('Path:')} ${repo.path}`);
+        console.log(`   ${chalk.gray('Magnet:')} ${chalk.magenta(repo.magnetURI.substring(0, 60) + '...')}`);
+        console.log('');
+    });
+    process.exit(0);
+}

package/dist/commands/name.d.ts

@@ -0,0 +1 @@
+export declare function setUsername(name: string): Promise<void>;

package/dist/commands/name.js

@@ -0,0 +1,30 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { setConfig, getConfig, initStorage } from '../utils/storage.js';
+import { checkNameAvailability, claimUsername } from '../utils/p2p-registry.js';
+export async function setUsername(name) {
+    await initStorage();
+    const spinner = ora('Checking name availability in the decentralized mesh...').start();
+    // Validation
+    const nameRegex = /^[a-zA-Z0-9_]{3,20}$/;
+    if (!nameRegex.test(name)) {
+        spinner.fail(chalk.red('❌ Invalid username!'));
+        console.log(chalk.yellow('Rules: Between 3-20 chars, alphanumeric and underscores only.'));
+        process.exit(1);
+    }
+    const { publicKey } = await getConfig();
+    const { available, owner } = await checkNameAvailability(name, publicKey);
+    if (!available) {
+        spinner.fail(chalk.red(`❌ The name "${chalk.bold(name)}" is already taken by another user.`));
+        process.exit(1);
+    }
+    if (!owner) {
+        spinner.text = 'Claiming name...';
+        await claimUsername(name, publicKey);
+    }
+    const config = await getConfig();
+    config.username = name;
+    await setConfig(config);
+    spinner.succeed(chalk.green(`✅ Identity updated! Your handle is now: ${chalk.bold(name)}`));
+    process.exit(0);
+}

package/dist/commands/publish.d.ts

@@ -0,0 +1,3 @@
+export declare function publish(input: string | string[], options?: {
+    name?: string;
+}): Promise<void>;

package/dist/commands/publish.js

@@ -0,0 +1,62 @@
+import WebTorrent from 'webtorrent';
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import { saveRepository, initStorage, getConfig } from '../utils/storage.js';
+import { addToRegistry } from '../utils/p2p-registry.js';
+const GLOBAL_TRACKERS = [
+    'udp://tracker.leechers-paradise.org:6969',
+    'udp://tracker.coppersurfer.tk:6969',
+    'udp://tracker.opentrackr.org:1337',
+    'udp://explodie.org:6969',
+    'wss://tracker.btorrent.xyz',
+    'wss://tracker.openwebtorrent.com',
+    'wss://tracker.webtorrent.dev'
+];
+export async function publish(input, options = {}) {
+    await initStorage();
+    const { username } = await getConfig();
+    const client = new WebTorrent();
+    const displayName = Array.isArray(input) ? `${input.length} files` : input;
+    const spinner = ora(`Preparing to publish ${chalk.cyan(displayName)}...`).start();
+    try {
+        const seedPath = Array.isArray(input) ? input : path.resolve(input);
+        const seedOptions = {
+            name: options.name,
+            announce: GLOBAL_TRACKERS
+        };
+        client.seed(seedPath, seedOptions, async (torrent) => {
+            spinner.succeed(chalk.green('Repository published successfully!'));
+            const repoData = {
+                name: torrent.name,
+                infoHash: torrent.infoHash,
+                magnetURI: torrent.magnetURI,
+                path: Array.isArray(input) ? process.cwd() : path.resolve(input),
+                author: username
+            };
+            await saveRepository(repoData);
+            // Add to decentralized P2P registry
+            spinner.start(chalk.blue('Announcing to decentralized registry...'));
+            await addToRegistry(repoData);
+            spinner.succeed(chalk.green('Announced to global registry!'));
+            console.log('\n' + chalk.bold('Repository Details:'));
+            console.log(`${chalk.yellow('Name:')} ${torrent.name}`);
+            console.log(`${chalk.yellow('Info Hash:')} ${torrent.infoHash}`);
+            console.log(`${chalk.yellow('Magnet Link:')} \n${chalk.magenta(torrent.magnetURI)}`);
+            console.log('\n' + chalk.blue('Keep this terminal open to continue seeding your repository.'));
+            console.log(chalk.gray('Press Ctrl+C to stop seeding.'));
+            torrent.on('upload', () => {
+                process.stdout.write(`\r${chalk.green('↑')} Uploaded: ${chalk.white((torrent.uploaded / 1024 / 1024).toFixed(2))} MB | Peers: ${torrent.numPeers}`);
+            });
+            torrent.on('wire', (wire) => {
+                // Track when a downloader connects
+                console.log(chalk.gray(`\n[Peer Connected: ${wire.remoteAddress}]`));
+            });
+        });
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to publish repository.'));
+        console.error(error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/push.d.ts

@@ -0,0 +1 @@
+export declare function push(): Promise<void>;

package/dist/commands/push.js

@@ -0,0 +1,24 @@
+import { globby } from 'globby';
+import path from 'path';
+import chalk from 'chalk';
+import { publish } from './publish.js';
+export async function push() {
+    const currentDir = process.cwd();
+    console.log(chalk.bold.blue(`\n🚀 TermHub Push: ${path.basename(currentDir)}`));
+    // Get all files recursively, respecting .gitignore
+    const allFiles = await globby('**/*', {
+        cwd: currentDir,
+        dot: true,
+        gitignore: true,
+    });
+    if (allFiles.length === 0) {
+        console.log(chalk.red('❌ No files found to push!'));
+        process.exit(1);
+    }
+    console.log(chalk.gray(`📦 Found ${allFiles.length} files (ignoring items in .gitignore).`));
+    // Convert relative globby paths to absolute paths for WebTorrent
+    const absoluteFiles = allFiles.map(file => path.join(currentDir, file));
+    // Name the repository after the current directory
+    const repoName = path.basename(currentDir);
+    await publish(absoluteFiles, { name: repoName });
+}

package/dist/commands/search.d.ts

@@ -0,0 +1 @@
+export declare function search(query: string): Promise<void>;

package/dist/commands/search.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { searchInRegistry } from '../utils/p2p-registry.js';
+export async function search(query) {
+    const spinner = ora(`Searching decentralized registry for ${chalk.cyan(query)}...`).start();
+    const results = await searchInRegistry(query);
+    if (results.length === 0) {
+        spinner.fail(chalk.red(`No repositories found matching "${query}"`));
+        console.log(chalk.gray('Tip: Make sure you are connected to the internet and give the network a few seconds to discover peers.'));
+        process.exit(0);
+    }
+    spinner.succeed(chalk.green(`Found ${results.length} repositories in the P2P network:`));
+    console.log('');
+    results.forEach(repo => {
+        console.log(`${chalk.bold.cyan(repo.name)}`);
+        console.log(`${chalk.white(repo.description)}`);
+        console.log(`${chalk.gray('Magnet:')} ${chalk.magenta(repo.magnetURI)}`);
+        if (repo.timestamp) {
+            console.log(`${chalk.gray('Timestamp:')} ${new Date(repo.timestamp).toLocaleString()}`);
+        }
+        console.log('');
+    });
+    process.exit(0);
+}

package/dist/commands/star.d.ts

@@ -0,0 +1 @@
+export declare function star(name?: string, magnet?: string): Promise<void>;

package/dist/commands/star.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { starRepository, initStars, getStars } from '../utils/stars.js';
+export async function star(name, magnet) {
+    await initStars();
+    if (!name || !magnet) {
+        // If no args, list stars
+        const stars = await getStars();
+        if (stars.length === 0) {
+            console.log(chalk.yellow('You haven\'t starred any repositories yet.'));
+            process.exit(0);
+        }
+        console.log(chalk.bold.yellow('\nYour Starred Repositories:\n'));
+        stars.forEach((s) => {
+            console.log(`${chalk.yellow('★')} ${chalk.bold(s.name)}`);
+            console.log(`   ${chalk.gray('Magnet:')} ${chalk.magenta(s.magnet)}`);
+            console.log('');
+        });
+        process.exit(0);
+    }
+    const success = await starRepository(name, magnet);
+    if (success) {
+        console.log(chalk.green(`Successfully starred ${chalk.bold(name)}!`));
+    }
+    else {
+        console.log(chalk.yellow(`You already starred ${chalk.bold(name)}.`));
+    }
+    process.exit(0);
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import { getRepositories, initStorage } from '../utils/storage.js';
+import { initStars, getStars } from '../utils/stars.js';
+import os from 'os';
+export async function status() {
+    await initStorage();
+    await initStars();
+    const repos = await getRepositories();
+    const stars = await getStars();
+    console.log(chalk.bold.cyan('\n📊 TermHub Node Status\n'));
+    // General Stats
+    console.log(chalk.yellow('--- Global Metrics ---'));
+    console.log(`${chalk.white('Total Published:')} ${repos.length}`);
+    console.log(`${chalk.white('Total Stars:')}     ${stars.length}`);
+    console.log('');
+    // Local Storage Metrics
+    console.log(chalk.yellow('--- Local Identity ---'));
+    console.log(`${chalk.white('Config Path:')}      ${os.homedir()}/.termhub`);
+    if (repos.length > 0) {
+        console.log('\n' + chalk.yellow('--- Top Repositories ---'));
+        // List top 3 recent ones
+        repos.slice(-3).reverse().forEach(repo => {
+            console.log(`${chalk.green('●')} ${chalk.bold(repo.name)} ${chalk.gray('(' + repo.infoHash.substring(0, 8) + '...)')}`);
+        });
+    }
+    console.log('\n' + chalk.blue('P2P Health: ') + chalk.green('Active'));
+    console.log(chalk.gray('Discovery:  ') + chalk.white('Nostr Relay Mesh'));
+    process.exit(0);
+}

package/dist/commands/ui.d.ts

@@ -0,0 +1 @@
+export declare function ui(): Promise<void>;

package/dist/commands/ui.js

@@ -0,0 +1,71 @@
+import express from 'express';
+import open from 'open';
+import chalk from 'chalk';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getRepositories, getConfig, setConfig } from '../utils/storage.js';
+import { getAllFromRegistry, checkNameAvailability } from '../utils/p2p-registry.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export async function ui() {
+    const app = express();
+    const PORT = 3000;
+    // Serve static files from the build directory
+    const publicPath = path.join(__dirname, '..', 'ui', 'public');
+    app.use(express.static(publicPath));
+    app.use(express.json());
+    // API Endpoints
+    app.get('/api/status', async (req, res) => {
+        const repos = await getRepositories();
+        const config = await getConfig();
+        res.json({
+            status: 'active',
+            publishedCount: repos.length,
+            nodeVersion: process.version,
+            username: config.username
+        });
+    });
+    app.get('/api/config', async (req, res) => {
+        const config = await getConfig();
+        res.json(config);
+    });
+    app.post('/api/config', async (req, res) => {
+        const { username } = req.body;
+        const { publicKey, privateKey } = await getConfig();
+        // Validation
+        const nameRegex = /^[a-zA-Z0-9_]{3,20}$/;
+        if (!nameRegex.test(username)) {
+            return res.status(400).json({ error: 'Invalid username' });
+        }
+        const { available, owner } = await checkNameAvailability(username, publicKey);
+        if (!available) {
+            return res.status(400).json({ error: 'Name already taken by another user' });
+        }
+        await setConfig({ username, publicKey, privateKey });
+        res.json({ success: true });
+    });
+    app.get('/api/repositories', async (req, res) => {
+        const repos = await getRepositories();
+        res.json(repos);
+    });
+    app.get('/api/explore', async (req, res) => {
+        try {
+            const repos = await getAllFromRegistry();
+            res.json(repos);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to fetch registry' });
+        }
+    });
+    // Start Server
+    app.listen(PORT, async () => {
+        console.log(chalk.bold.cyan(`\n🖥️  TermHub Dashboard is running!`));
+        console.log(chalk.white(`Local URL: `) + chalk.underline.blue(`http://localhost:${PORT}`));
+        console.log(chalk.gray(`Press Ctrl+C to stop the server.\n`));
+        try {
+            await open(`http://localhost:${PORT}`);
+        }
+        catch (err) {
+            console.log(chalk.yellow('Could not open browser automatically. Please open the URL manually.'));
+        }
+    });
+}

package/dist/daemon/worker.d.ts

@@ -0,0 +1 @@
+export {};