voidconnect 0.1.13 → 0.1.15

package/hub/README.md

@@ -0,0 +1,15 @@
+# hub
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.5. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/hub/bun.lock

@@ -0,0 +1,37 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "hub",
+      "dependencies": {
+        "@types/qrcode-terminal": "^0.12.2",
+        "hono": "^4.11.4",
+        "qrcode-terminal": "^0.12.0",
+      },
+      "devDependencies": {
+        "@types/bun": "^1.3.5",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.5", "", { "dependencies": { "bun-types": "1.3.5" } }, "sha512-RnygCqNrd3srIPEWBd5LFeUYG7plCoH2Yw9WaZGyNmdTEei+gWaHqydbaIRkIkcbXwhBT94q78QljxN0Sk838w=="],
+
+    "@types/node": ["@types/node@25.0.8", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-powIePYMmC3ibL0UJ2i2s0WIbq6cg6UyVFQxSCpaPxxzAaziRfimGivjdF943sSGV6RADVbk0Nvlm5P/FB44Zg=="],
+
+    "@types/qrcode-terminal": ["@types/qrcode-terminal@0.12.2", "", {}, "sha512-v+RcIEJ+Uhd6ygSQ0u5YYY7ZM+la7GgPbs0V/7l/kFs2uO4S8BcIUEMoP7za4DNIqNnUD5npf0A/7kBhrCKG5Q=="],
+
+    "bun-types": ["bun-types@1.3.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw=="],
+
+    "hono": ["hono@4.11.4", "", {}, "sha512-U7tt8JsyrxSRKspfhtLET79pU8K+tInj5QZXs1jSugO1Vq5dFj3kmZsRldo29mTBfcjDRVRXrEZ6LS63Cog9ZA=="],
+
+    "qrcode-terminal": ["qrcode-terminal@0.12.0", "", { "bin": { "qrcode-terminal": "./bin/qrcode-terminal.js" } }, "sha512-EXtzRZmC+YGmGlDFbXKxQiMZNwCLEO6BANKXG4iCtSIM0yqc/pappSx3RIKr4r0uh5JsBckOXeKrB3Iz7mdQpQ=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
+  }
+}

package/hub/index.ts

@@ -0,0 +1 @@
+console.log("Hello via Bun!");

package/hub/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "hub",
+  "module": "index.ts",
+  "type": "module",
+  "private": true,
+  "devDependencies": {
+    "@types/bun": "^1.3.5"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts"
+  },
+  "dependencies": {
+    "@types/qrcode-terminal": "^0.12.2",
+    "hono": "^4.11.4",
+    "qrcode-terminal": "^0.12.0"
+  }
+}

package/hub/src/auth.ts

@@ -0,0 +1,19 @@
+
+import { type Context, type Next } from 'hono';
+
+export async function authMiddleware(c: Context, next: Next) {
+    const hubPassword = process.env.HUB_PASSWORD;
+
+    if (!hubPassword) {
+        await next();
+        return;
+    }
+
+    const authHeader = c.req.header('Authorization');
+
+    if (!authHeader || authHeader !== `Bearer ${hubPassword}`) {
+        return c.json({ error: 'Unauthorized' }, 401);
+    }
+
+    await next();
+}

package/hub/src/config.ts

@@ -0,0 +1,43 @@
+
+import { join } from 'path';
+import { homedir } from 'os';
+
+export interface ProjectConfig {
+    name: string;
+    path: string;
+}
+
+export interface HubConfig {
+    device_name: string;
+    password_hash: string | null;
+    projects: ProjectConfig[];
+}
+
+export async function loadConfig(): Promise<HubConfig> {
+    // Check for local run mode (single project via environment variable)
+    const projectPath = process.env.HUB_PROJECT_PATH;
+    const projectName = process.env.HUB_PROJECT_NAME;
+
+    if (projectPath && projectName) {
+        return {
+            device_name: process.env.HUB_DEVICE_NAME || 'VoidConnect Hub',
+            password_hash: process.env.HUB_PASSWORD || null,
+            projects: [{ name: projectName, path: projectPath }]
+        };
+    }
+
+    // Normal mode: load from config file
+    const configPath = join(homedir(), '.voidconnect', 'hub_config.json');
+    const file = Bun.file(configPath);
+
+    if (await file.exists()) {
+        const content = await file.json();
+        return content as HubConfig;
+    }
+
+    return {
+        device_name: 'VoidConnect Hub',
+        password_hash: null,
+        projects: []
+    };
+}

package/hub/src/index.ts

@@ -0,0 +1,131 @@
+
+import { Hono } from 'hono';
+import { loadConfig } from './config';
+import { authMiddleware } from './auth';
+import { processManager } from './process_manager';
+import qrcode from 'qrcode-terminal';
+import { networkInterfaces } from 'os';
+import { logTraffic, formatRequest, formatResponse } from './logger';
+
+const app = new Hono();
+
+app.use('*', async (c, next) => {
+    if (process.argv.includes('--log')) {
+        try {
+            await logTraffic('INCOMING_REQUEST', await formatRequest(c.req.raw));
+        } catch (e) {
+            console.error('Error logging request:', e);
+        }
+    }
+
+    await next();
+
+    if (process.argv.includes('--log')) {
+        try {
+            await logTraffic('OUTGOING_RESPONSE', await formatResponse(c.res));
+        } catch (e) {
+            console.error('Error logging response:', e);
+        }
+    }
+});
+
+app.use('/api/*', authMiddleware);
+app.use('/project/*', authMiddleware);
+
+app.get('/', (c) => c.text('VoidConnect Hub Running'));
+
+app.get('/api/status', (c) => {
+    return c.json({ status: 'running', device: process.env.HUB_DEVICE_NAME || 'Unknown' });
+});
+
+app.get('/api/projects', async (c) => {
+    const config = await loadConfig();
+    return c.json(config.projects);
+});
+
+app.all('/project/:name/*', async (c) => {
+    const name = c.req.param('name');
+    const config = await loadConfig();
+    const project = config.projects.find(p => p.name === name);
+
+    if (!project) {
+        return c.text('Project not found', 404);
+    }
+
+    try {
+        const port = await processManager.startProject(project.name, project.path);
+
+        const path = c.req.path.replace(`/project/${name}`, '') || '/';
+
+        const targetUrlObj = new URL(`http://127.0.0.1:${port}${path}`);
+
+        const originalUrl = new URL(c.req.url);
+        originalUrl.searchParams.forEach((value, key) => {
+            targetUrlObj.searchParams.set(key, value);
+        });
+
+        targetUrlObj.searchParams.set('directory', project.path);
+
+        const targetUrl = targetUrlObj.toString();
+
+        const newReq = new Request(targetUrl, {
+            method: c.req.method,
+            headers: c.req.header(),
+            body: c.req.raw.body,
+        });
+
+        if (process.argv.includes('--log')) {
+            await logTraffic('PROXY_REQUEST_OUTGOING', await formatRequest(newReq));
+        }
+        const response = await fetch(newReq);
+        if (process.argv.includes('--log')) {
+            await logTraffic('PROXY_RESPONSE_INCOMING', await formatResponse(response));
+        }
+
+        return response;
+    } catch (e) {
+        console.error(`[Proxy] Error:`, e);
+        return c.text(`Global Error: ${e}`, 500);
+    }
+});
+
+const port = parseInt(process.env.PORT || '3000');
+
+if (process.argv.includes('--tunnel') || process.argv.includes('--cf')) {
+    import('./tunnel').then(({ startTunnel }) => {
+        startTunnel(port);
+    });
+} else {
+    (async () => {
+        const nets = networkInterfaces();
+        let localIp = 'localhost';
+
+        for (const name of Object.keys(nets)) {
+            const interfaces = nets[name];
+            if (interfaces) {
+                for (const net of interfaces) {
+                    if (net.family === 'IPv4' && !net.internal) {
+                        localIp = net.address;
+                        break;
+                    }
+                }
+            }
+            if (localIp !== 'localhost') break;
+        }
+
+        const config = await loadConfig();
+        const name = process.env.HUB_DEVICE_NAME || config.device_name || 'My PC';
+        const url = `http://${localIp}:${port}`;
+
+        console.log('\n');
+        qrcode.generate(JSON.stringify({ name, url }), { small: true });
+        console.log(`\nHub Online: ${name}`);
+        console.log(`URL: ${url}\n`);
+    })();
+}
+
+const server = Bun.serve({
+    port,
+    fetch: app.fetch,
+    idleTimeout: 255,
+});

package/hub/src/logger.ts

@@ -0,0 +1,53 @@
+
+import { appendFile } from 'fs/promises';
+import { join } from 'path';
+
+const LOG_FILE = join(process.cwd(), 'hub_traffic.log');
+
+export async function logTraffic(type: string, data: any) {
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] [${type}]\n${JSON.stringify(data, null, 2)}\n\n--------------------------------------------------\n\n`;
+    try {
+        await appendFile(LOG_FILE, logEntry);
+    } catch (err) {
+        console.error('Failed to write to log file:', err);
+    }
+}
+
+export async function formatRequest(req: Request) {
+    let body = '(empty)';
+    try {
+        if (req.body) {
+            // we clone to not consume the stream needed for processing
+            body = await req.clone().text();
+        }
+    } catch (e) {
+        body = `(stream/error reading body: ${e})`;
+    }
+
+    return {
+        url: req.url,
+        method: req.method,
+        headers: Object.fromEntries(req.headers.entries()),
+        body
+    };
+}
+
+export async function formatResponse(res: Response) {
+    let body = '(empty)';
+    try {
+        // Cloning response to read body without consuming the original stream being sent to client
+        if (res.body) {
+            body = await res.clone().text();
+        }
+    } catch (e) {
+        body = `(stream/error reading body: ${e})`;
+    }
+
+    return {
+        status: res.status,
+        statusText: res.statusText,
+        headers: Object.fromEntries(res.headers.entries()),
+        body
+    };
+}

package/hub/src/process_manager.ts

@@ -0,0 +1,62 @@
+
+import { spawn } from 'bun';
+
+export class ProcessManager {
+    private processes: Map<string, any> = new Map();
+    private ports: Map<string, number> = new Map();
+    private startPort = 4100;
+
+    constructor() { }
+
+    async startProject(name: string, path: string): Promise<number> {
+
+        if (this.ports.has(name)) {
+            const existingPort = this.ports.get(name)!;
+            return existingPort;
+        }
+
+        const port = this.startPort + this.processes.size;
+
+        const p = spawn(["opencode", "serve", "--port", port.toString(), "--hostname", "0.0.0.0"], {
+            cwd: path,
+            env: { ...process.env, OPENCODE_CLIENT: 'mobile' },
+            stdout: 'ignore',
+            stderr: 'ignore',
+        });
+
+        this.processes.set(name, p);
+        this.ports.set(name, port);
+
+        let attempts = 0;
+        const maxAttempts = 50;
+
+        while (attempts < maxAttempts) {
+            try {
+                const healthRes = await fetch(`http://127.0.0.1:${port}/global/health`);
+                if (healthRes.ok) {
+                    break;
+                }
+            } catch (e) {
+            }
+            await new Promise(r => setTimeout(r, 100));
+            attempts++;
+        }
+
+        if (attempts >= maxAttempts) {
+            console.error(`[ProcessManager] WARNING: Project ${name} may not have started correctly on port ${port}`);
+        }
+
+        return port;
+    }
+
+    async stopAll() {
+        for (const [name, p] of this.processes) {
+            console.log(`Stopping ${name}...`);
+            p.kill();
+        }
+        this.processes.clear();
+        this.ports.clear();
+    }
+}
+
+export const processManager = new ProcessManager();

package/hub/src/tunnel.ts

@@ -0,0 +1,49 @@
+
+import { spawn } from 'bun';
+import qrcode from 'qrcode-terminal';
+import { loadConfig } from './config';
+
+export async function startTunnel(port: number): Promise<string> {
+    console.log(`Starting Cloudflare tunnel...`);
+
+    const proc = spawn(["cloudflared", "tunnel", "--url", `http://localhost:${port}`], {
+        stdout: 'pipe',
+        stderr: 'pipe',
+    });
+
+    return new Promise((resolve, reject) => {
+        let found = false;
+
+        const reader = proc.stderr.getReader();
+        const decoder = new TextDecoder();
+
+        async function read() {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+
+                const text = decoder.decode(value);
+                // Silence output unless debug needed
+                // console.log(text); 
+
+                const match = text.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
+                if (match && !found) {
+                    found = true;
+                    const url = match[0];
+                    const config = await loadConfig();
+                    const name = config.device_name;
+
+                    console.log('\n');
+                    qrcode.generate(JSON.stringify({ name, url }), { small: true });
+                    console.log(`\nHub Online: ${name}`);
+                    console.log(`URL: ${url}\n`);
+
+                    resolve(url);
+                }
+            }
+            if (!found) reject("Failed to get tunnel URL");
+        }
+
+        read();
+    });
+}

package/hub/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "voidconnect",
-    "version": "0.1.13",
+    "version": "0.1.15",
     "description": "NPM wrapper for voidconnect-cli",
     "bin": {
         "voidconnect": "bin/voidconnect.js"