termhub-p2p 1.0.0

package/dist/daemon/worker.js

@@ -0,0 +1,44 @@
+import WebTorrent from 'webtorrent';
+import { getRepositories, initStorage } from '../utils/storage.js';
+import path from 'path';
+import fs from 'fs-extra';
+import os from 'os';
+const PID_FILE = path.join(os.homedir(), '.termhub', 'daemon.pid');
+async function runDaemon() {
+    await initStorage();
+    const client = new WebTorrent();
+    const activeHashes = new Set();
+    console.log('TermHub Daemon started...');
+    // Function to seed all repositories from storage
+    async function syncRepositories() {
+        const repos = await getRepositories();
+        for (const repo of repos) {
+            if (!activeHashes.has(repo.infoHash)) {
+                if (repo.path && await fs.pathExists(repo.path)) {
+                    console.log(`Daemon: Seeding ${repo.name}...`);
+                    client.seed(repo.path, { name: repo.name }, (torrent) => {
+                        activeHashes.add(torrent.infoHash);
+                        console.log(`Daemon: ${repo.name} is now online.`);
+                    });
+                }
+            }
+        }
+    }
+    // Initial sync
+    await syncRepositories();
+    // Watch for changes in the repositories file
+    const reposFilePath = path.join(os.homedir(), '.termhub', 'repositories.json');
+    fs.watchFile(reposFilePath, async () => {
+        console.log('Daemon: Config changed, re-syncing...');
+        await syncRepositories();
+    });
+    // Keep process alive
+    setInterval(() => {
+        const totalUpload = client.ratio;
+        console.log(`Daemon Heartbeat: Seeding ${client.torrents.length} repos. Ratio: ${totalUpload}`);
+    }, 60000);
+}
+runDaemon().catch(err => {
+    console.error('Daemon Error:', err);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { publish } from './commands/publish.js';
+import { push } from './commands/push.js';
+import { setUsername } from './commands/name.js';
+import { download } from './commands/download.js';
+import { list } from './commands/list.js';
+import { search } from './commands/search.js';
+import { explore } from './commands/explore.js';
+import { ui } from './commands/ui.js';
+import { status } from './commands/status.js';
+import { daemonManager } from './commands/daemon.js';
+import { star } from './commands/star.js';
+const program = new Command();
+console.log(chalk.bold.cyan(`
+  _____                   _   _       _     
+ |_   _|__ _ __ _ __ ___ | | | |_   _| |__  
+   | |/ _ \\ '__| '_ \` _ \\| |_| | | | | '_ \\ 
+   | |  __/ |  | | | | | |  _  | |_| | |_) |
+   |_|\\___|_|  |_| |_| |_|_| |_|\\__,_|_.__/ 
+                                            
+   ${chalk.italic('The Decentralized Terminal Hub')}
+`));
+program
+    .name('termhub')
+    .description('GitHub for the terminal - P2P File Sharing')
+    .version('1.0.0');
+program
+    .command('publish')
+    .description('Publish a file or directory to TermHub')
+    .argument('<path>', 'path to the file or directory')
+    .action(publish);
+program
+    .command('push')
+    .description('Publish the current directory respecting .gitignore')
+    .action(push);
+program
+    .command('name')
+    .description('Set your decentralized handle')
+    .argument('<username>', 'desired username')
+    .action(setUsername);
+program
+    .command('download')
+    .description('Download a repository from TermHub')
+    .argument('<magnet>', 'magnet link or info hash')
+    .option('-o, --output <path>', 'output directory', '.')
+    .action(download);
+program
+    .command('list')
+    .description('List your published repositories')
+    .action(list);
+program
+    .command('search')
+    .description('Search for repositories in the global registry')
+    .argument('<query>', 'search query')
+    .action(search);
+program
+    .command('explore')
+    .description('Explore the global registry interactively')
+    .action(explore);
+program
+    .command('ui')
+    .description('Open the TermHub Web Dashboard')
+    .action(ui);
+program
+    .command('daemon')
+    .description('Manage the background seeding daemon')
+    .argument('<action>', 'start, stop, or status')
+    .action(daemonManager);
+program
+    .command('status')
+    .description('Show local node status and metrics')
+    .action(status);
+program
+    .command('star')
+    .description('Star a repository or list your stars')
+    .argument('[name]', 'repository name')
+    .argument('[magnet]', 'magnet link')
+    .action(star);
+program.parse();

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+export interface Repository {
+    name: string;
+    infoHash: string;
+    magnetURI: string;
+    path?: string;
+    description?: string;
+    author?: string;
+    timestamp?: string;
+}
+export interface Star {
+    name: string;
+    magnet: string;
+    timestamp: string;
+}

package/dist/types/index.js

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

package/dist/ui/public/index.html

@@ -0,0 +1,255 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>/th/ - TermHub Registry</title>
+    <style>
+        body {
+            background-color: #ffffee;
+            color: #800000;
+            font-family: arial,helvetica,sans-serif;
+            font-size: 10pt;
+            margin: 0;
+            padding: 10px;
+        }
+        header {
+            display: flex;
+            justify-content: space-between;
+            align-items: flex-end;
+            padding: 10px 20px;
+            border-bottom: 2px solid #d9bfb7;
+            margin-bottom: 20px;
+        }
+        .header-left {
+            text-align: left;
+        }
+        h1 {
+            font-family: "Trebuchet MS",tahoma,arial,helvetica,sans-serif;
+            font-size: 24pt;
+            letter-spacing: -2px;
+            margin: 0;
+            line-height: 1;
+        }
+        .banner {
+            color: #af0a0f;
+            font-weight: bold;
+            font-size: 10pt;
+            margin-top: 5px;
+        }
+        .post {
+            background-color: #f0e0d6;
+            border: 1px solid #d9bfb7;
+            display: table;
+            padding: 5px;
+            margin-bottom: 10px;
+            width: 100%;
+            max-width: 800px;
+            margin-left: auto;
+            margin-right: auto;
+        }
+        .post-header {
+            font-weight: bold;
+            margin-bottom: 5px;
+            border-bottom: 1px solid #d9bfb7;
+        }
+        .post-id {
+            color: #117743;
+            font-weight: normal;
+        }
+        .name {
+            color: #117743;
+            font-weight: bold;
+        }
+        .subject {
+            color: #0f0c5d;
+            font-weight: bold;
+        }
+        .magnet-btn {
+            color: #0000ee;
+            text-decoration: underline;
+            cursor: pointer;
+            background: none;
+            border: none;
+            padding: 0;
+            font-size: 9pt;
+        }
+        .magnet-btn:hover { color: #ff0000; }
+        
+        .section-title {
+            background-color: #e04000;
+            color: white;
+            padding: 2px 10px;
+            font-weight: bold;
+            text-align: center;
+            margin: 20px auto;
+            width: fit-content;
+        }
+        
+        .nav {
+            font-size: 9pt;
+            text-align: center;
+            margin-bottom: 10px;
+        }
+        .nav a { color: #34345c; text-decoration: none; }
+        .nav a:hover { color: #ff0000; }
+
+        .footer {
+            font-size: 8pt;
+            color: #706b5e;
+            text-align: center;
+            margin-top: 30px;
+        }
+    </style>
+</head>
+<body>
+    <header>
+        <div class="header-left">
+            <h1>TermHub</h1>
+        </div>
+        <div class="nav">
+            [<a href="#" onclick="switchView('my')">My Files</a>] 
+            [<a href="#" onclick="switchView('explore')">Explore</a>] 
+            [<a href="#" onclick="switchView('status')">Status</a>]
+        </div>
+    </header>
+
+    <div class="section-title">Public Repositories</div>
+    <div id="content-area">
+        <!-- Posts will appear here -->
+        <div class="post">
+            <div class="post-header">System Notification</div>
+            Connecting to Gun.js nodes...
+        </div>
+    </div>
+
+    <div class="footer">
+        - TermHub v1.0.0 - 
+        <br>
+        All files are P2P. No centralized hosting.
+    </div>
+
+    <script>
+        async function loadStatus() {
+            const res = await fetch('/api/status');
+            const data = await res.json();
+            const area = document.getElementById('content-area');
+            
+            // Stats summary post
+            const statsPost = `
+                <div class="post">
+                    <div class="post-header">Node Information</div>
+                    <span class="subject">Current Handle:</span> <span class="name" style="font-size: 1.2rem;">${data.username}</span><br>
+                    <span class="subject">Status:</span> Connected to Mesh<br>
+                    <span class="subject">Local Repos:</span> ${data.publishedCount}<br>
+                    <hr style="border: 0; border-top: 1px solid #d9bfb7; margin: 10px 0;">
+                    <span class="subject">Change Handle:</span> 
+                    <input type="text" id="new-name" placeholder="new_handle" style="font-size: 8pt;">
+                    [<a href="#" onclick="updateName()">Update</a>]
+                </div>
+            `;
+            
+            // Only update if we are in "Status" view or it's the first load
+            if (activeView === 'status') {
+                area.innerHTML = statsPost;
+            }
+        }
+
+        let activeView = 'explore';
+
+        async function updateName() {
+            const name = document.getElementById('new-name').value;
+            if (!name) return;
+            
+            const res = await fetch('/api/config', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ username: name })
+            });
+            
+            if (res.ok) {
+                alert('Identity updated to ' + name);
+                loadStatus();
+            } else {
+                const err = await res.json();
+                alert('Error: ' + err.error);
+            }
+        }
+
+        async function loadMyRepos() {
+            activeView = 'my';
+            const res = await fetch('/api/repositories');
+            const data = await res.json();
+            const area = document.getElementById('content-area');
+            area.innerHTML = '';
+            
+            if (data.length === 0) area.innerHTML = '<div class="post">No files published yet.</div>';
+
+            data.reverse().forEach(repo => {
+                const post = document.createElement('div');
+                post.className = 'post';
+                post.innerHTML = `
+                    <div class="post-header">
+                        <span class="subject">${repo.name}</span> 
+                        <span class="name">${repo.author || 'Anonymous'}</span> 
+                        <span class="post-id">No.${repo.infoHash.substring(0,8)}</span>
+                    </div>
+                    <div class="body">
+                        File Hash: ${repo.infoHash}<br>
+                        Location: ${repo.path}<br>
+                        <button class="magnet-btn" onclick="copy('${repo.magnetURI}')">Copy Magnet</button>
+                    </div>
+                `;
+                area.appendChild(post);
+            });
+        }
+
+        async function loadExplore() {
+            activeView = 'explore';
+            const area = document.getElementById('content-area');
+            area.innerHTML = '<div class="post">Searching P2P network...</div>';
+            
+            try {
+                const res = await fetch('/api/explore');
+                const data = await res.json();
+                area.innerHTML = '';
+                
+                if (data.length === 0) area.innerHTML = '<div class="post">No files found on this relay. Try refreshing in a few seconds.</div>';
+
+                data.forEach(repo => {
+                    const post = document.createElement('div');
+                    post.className = 'post';
+                    post.innerHTML = `
+                        <div class="post-header">
+                            <span class="subject">${repo.name}</span> 
+                            <span class="name">${repo.author || 'Anonymous'}</span> 
+                            <span class="post-id">No.${repo.infoHash.substring(0,8)}</span>
+                        </div>
+                        <div class="body">
+                            Published: ${new Date(repo.timestamp).toLocaleString()}<br><br>
+                            <button class="magnet-btn" onclick="copy('${repo.magnetURI}')">Copy Magnet</button>
+                        </div>
+                    `;
+                    area.appendChild(post);
+                });
+            } catch (err) {
+                area.innerHTML = '<div class="post">Error connecting to network.</div>';
+            }
+        }
+
+        function switchView(view) {
+            activeView = view;
+            if (view === 'status') loadStatus();
+            if (view === 'my') loadMyRepos();
+            if (view === 'explore') loadExplore();
+        }
+
+        function copy(m) {
+            navigator.clipboard.writeText(m);
+            alert('Magnet copied to clipboard!');
+        }
+
+        // Default view
+        loadExplore();
+    </script>
+</body>
+</html>

package/dist/utils/p2p-registry.d.ts

@@ -0,0 +1,9 @@
+import { Repository } from '../types/index.js';
+export declare function addToRegistry(repoData: Repository): Promise<void>;
+export declare function searchInRegistry(query: string): Promise<Repository[]>;
+export declare function getAllFromRegistry(): Promise<Repository[]>;
+export declare function checkNameAvailability(name: string, myPublicKey: string): Promise<{
+    available: boolean;
+    owner: boolean;
+}>;
+export declare function claimUsername(name: string, token: string): Promise<void>;

package/dist/utils/p2p-registry.js

@@ -0,0 +1,130 @@
+import { finalizeEvent, Relay } from 'nostr-tools';
+import { getConfig } from './storage.js';
+import WebSocket from 'ws';
+// @ts-ignore
+global.WebSocket = WebSocket;
+const RELAYS = [
+    'wss://relay.damus.io',
+    'wss://nos.lol',
+    'wss://relay.nostr.band',
+    'wss://offchain.pub'
+];
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+    return bytes;
+}
+export async function addToRegistry(repoData) {
+    const { privateKey, username } = await getConfig();
+    const event = finalizeEvent({
+        kind: 1,
+        created_at: Math.floor(Date.now() / 1000),
+        tags: [
+            ['t', 'termhub-repo'],
+            ['h', repoData.infoHash],
+            ['m', repoData.magnetURI],
+            ['n', repoData.name],
+            ['a', username]
+        ],
+        content: `Published TermHub Repository: ${repoData.name}\nMagnet: ${repoData.magnetURI}`,
+    }, hexToBytes(privateKey));
+    await Promise.allSettled(RELAYS.map(async (url) => {
+        try {
+            const relay = await Relay.connect(url);
+            await relay.publish(event);
+            relay.close();
+        }
+        catch (e) { }
+    }));
+}
+export async function searchInRegistry(query) {
+    const results = [];
+    const seenHashes = new Set();
+    const filters = [{
+            kinds: [1],
+            '#t': ['termhub-repo'],
+            limit: 50
+        }];
+    for (const url of RELAYS) {
+        try {
+            const relay = await Relay.connect(url);
+            await new Promise((resolve) => {
+                const sub = relay.subscribe(filters, {
+                    onevent(event) {
+                        const infoHash = event.tags.find((t) => t[0] === 'h')?.[1];
+                        const magnetURI = event.tags.find((t) => t[0] === 'm')?.[1];
+                        const name = event.tags.find((t) => t[0] === 'n')?.[1];
+                        const author = event.tags.find((t) => t[0] === 'a')?.[1];
+                        if (infoHash && magnetURI && name && !seenHashes.has(infoHash)) {
+                            if (name.toLowerCase().includes(query.toLowerCase())) {
+                                seenHashes.add(infoHash);
+                                results.push({
+                                    name,
+                                    infoHash,
+                                    magnetURI,
+                                    author: author || 'Anonymous',
+                                    timestamp: (event.created_at * 1000).toString()
+                                });
+                            }
+                        }
+                    },
+                    oneose() {
+                        sub.close();
+                        resolve();
+                    }
+                });
+                // Safety timeout
+                setTimeout(() => {
+                    sub.close();
+                    resolve();
+                }, 3000);
+            });
+            relay.close();
+        }
+        catch (err) { }
+    }
+    return results;
+}
+export async function getAllFromRegistry() {
+    return searchInRegistry('');
+}
+export async function checkNameAvailability(name, myPublicKey) {
+    const filters = [{
+            kinds: [1],
+            '#t': ['termhub-repo'],
+            '#a': [name],
+            limit: 10
+        }];
+    for (const url of RELAYS) {
+        try {
+            const relay = await Relay.connect(url);
+            const isAvailable = await new Promise((resolve) => {
+                let found = false;
+                let owner = false;
+                const sub = relay.subscribe(filters, {
+                    onevent(event) {
+                        found = true;
+                        if (event.pubkey === myPublicKey)
+                            owner = true;
+                    },
+                    oneose() {
+                        sub.close();
+                        resolve(!found || owner);
+                    }
+                });
+                setTimeout(() => {
+                    sub.close();
+                    resolve(true);
+                }, 2000);
+            });
+            relay.close();
+            if (!isAvailable)
+                return { available: false, owner: false };
+        }
+        catch (err) { }
+    }
+    return { available: true, owner: false };
+}
+export async function claimUsername(name, token) { }

package/dist/utils/stars.d.ts

@@ -0,0 +1,4 @@
+import { Star } from '../types/index.js';
+export declare function initStars(): Promise<void>;
+export declare function starRepository(name: string, magnet: string): Promise<boolean>;
+export declare function getStars(): Promise<Star[]>;

package/dist/utils/stars.js

@@ -0,0 +1,23 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.termhub');
+const STARS_FILE = path.join(CONFIG_DIR, 'stars.json');
+export async function initStars() {
+    await fs.ensureDir(CONFIG_DIR);
+    if (!(await fs.pathExists(STARS_FILE))) {
+        await fs.writeJson(STARS_FILE, []);
+    }
+}
+export async function starRepository(name, magnet) {
+    const stars = await fs.readJson(STARS_FILE);
+    if (!stars.find(s => s.magnet === magnet)) {
+        stars.push({ name, magnet, timestamp: new Date().toISOString() });
+        await fs.writeJson(STARS_FILE, stars);
+        return true;
+    }
+    return false;
+}
+export async function getStars() {
+    return await fs.readJson(STARS_FILE);
+}

package/dist/utils/storage.d.ts

@@ -0,0 +1,14 @@
+import { Repository } from '../types/index.js';
+export declare function initStorage(): Promise<void>;
+export declare function getConfig(): Promise<{
+    username: string;
+    privateKey: string;
+    publicKey: string;
+}>;
+export declare function setConfig(config: {
+    username: string;
+    privateKey: string;
+    publicKey: string;
+}): Promise<void>;
+export declare function saveRepository(repo: Repository): Promise<void>;
+export declare function getRepositories(): Promise<Repository[]>;

package/dist/utils/storage.js

@@ -0,0 +1,42 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { generateSecretKey, getPublicKey } from 'nostr-tools/pure';
+const CONFIG_DIR = path.join(os.homedir(), '.termhub');
+const REPOS_FILE = path.join(CONFIG_DIR, 'repositories.json');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+// Helper to convert Uint8Array to Hex string
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+export async function initStorage() {
+    await fs.ensureDir(CONFIG_DIR);
+    if (!(await fs.pathExists(REPOS_FILE))) {
+        await fs.writeJson(REPOS_FILE, []);
+    }
+    if (!(await fs.pathExists(CONFIG_FILE))) {
+        const sk = generateSecretKey();
+        const pk = getPublicKey(sk);
+        await fs.writeJson(CONFIG_FILE, {
+            username: 'Anonymous',
+            privateKey: bytesToHex(sk),
+            publicKey: pk
+        });
+    }
+}
+export async function getConfig() {
+    return await fs.readJson(CONFIG_FILE);
+}
+export async function setConfig(config) {
+    await fs.writeJson(CONFIG_FILE, config);
+}
+export async function saveRepository(repo) {
+    const repos = await getRepositories();
+    repos.push(repo);
+    await fs.writeJson(REPOS_FILE, repos);
+}
+export async function getRepositories() {
+    return await fs.readJson(REPOS_FILE);
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "termhub-p2p",
+  "version": "1.0.0",
+  "description": "Decentralized Terminal Hub - P2P file sharing and registry.",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "termhub": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"require('fs-extra').copySync('src/ui/public', 'dist/ui/public')\"",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "p2p",
+    "nostr",
+    "webtorrent",
+    "cli",
+    "share"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "enquirer": "^2.4.1",
+    "express": "^5.2.1",
+    "fs-extra": "^11.3.4",
+    "globby": "^16.2.0",
+    "ignore": "^7.0.5",
+    "nostr-tools": "^2.23.3",
+    "open": "^11.0.0",
+    "ora": "^9.3.0",
+    "webtorrent": "^2.8.5",
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@noble/hashes": "^2.2.0",
+    "@types/express": "^5.0.6",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.6.0",
+    "@types/webtorrent": "^0.110.1",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
+  }
+}