voidct 1.0.0

package/src/hub/config.ts

@@ -0,0 +1,42 @@
+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/src/hub/index.ts

@@ -0,0 +1,137 @@
+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();
+
+// Logging middleware (only when --log flag is present)
+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);
+        }
+    }
+});
+
+// Auth middleware for protected routes
+app.use('/api/*', authMiddleware);
+app.use('/project/*', authMiddleware);
+
+// Health check
+app.get('/', (c) => c.text('VoidConnect Hub Running'));
+
+// Status endpoint
+app.get('/api/status', (c) => {
+    return c.json({ status: 'running', device: process.env.HUB_DEVICE_NAME || 'Unknown' });
+});
+
+// List projects
+app.get('/api/projects', async (c) => {
+    const config = await loadConfig();
+    return c.json(config.projects);
+});
+
+// Project proxy
+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 || '3838');
+
+// Start with Cloudflare tunnel or local mode
+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/src/hub/logger.ts

@@ -0,0 +1,53 @@
+import { appendFile } from 'fs/promises';
+
+import { join } from 'path';
+
+const LOG_FILE = join(process.env.HUB_START_DIR || process.cwd(), 'void_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) {
+            // 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 {
+        // Clone response to read body without consuming the original stream
+        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/src/hub/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(["bun", "x", "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);
+
+        // Wait for server to be ready
+        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) {
+                // Server not ready yet
+            }
+            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/src/hub/tunnel.ts

@@ -0,0 +1,46 @@
+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);
+
+                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/src/index.ts

@@ -0,0 +1,312 @@
+#!/usr/bin/env bun
+import {
+  handleRun,
+  handleStart,
+  handleStop,
+  handleRestart,
+  handleAdd,
+  handleRemove,
+  handleStatus,
+  handleConfig,
+  getConfigInfo,
+  type StatusInfo
+} from "./handlers";
+import { checkForUpdates } from "./utils";
+
+const VERSION = "1.0.0";
+
+// ANSI color codes
+const Colors = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  white: "\x1b[37m"
+};
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const flags: Record<string, string | boolean> = {};
+  const positional: string[] = [];
+
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith('--')) {
+        flags[key] = nextArg;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  return { command, flags, positional };
+}
+
+// Print helpers
+function printBox(lines: string[]) {
+  const width = 63;
+  console.log(`${Colors.cyan}┌${'─'.repeat(width)}┐${Colors.reset}`);
+  for (const line of lines) {
+    // Strip ANSI codes to calculate visible length
+    const visibleLen = line.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const padding = width - visibleLen - 2;
+    console.log(`${Colors.cyan}│${Colors.reset}  ${line}${' '.repeat(Math.max(0, padding))}${Colors.cyan}│${Colors.reset}`);
+  }
+  console.log(`${Colors.cyan}└${'─'.repeat(width)}┘${Colors.reset}`);
+}
+
+function printDivider() {
+  console.log(`${Colors.cyan}├${'─'.repeat(63)}┤${Colors.reset}`);
+}
+
+function printSuccess(msg: string) {
+  console.log(`\n${Colors.green}✓${Colors.reset} ${msg}`);
+}
+
+function printError(msg: string) {
+  console.log(`\n${Colors.red}✗${Colors.reset} ${msg}`);
+}
+
+function printWarning(msg: string) {
+  console.log(`\n${Colors.yellow}!${Colors.reset} ${msg}`);
+}
+
+// Display functions
+function showHelp() {
+  console.log(`\n${Colors.cyan}${Colors.bold}VoidConnect CLI v${VERSION}${Colors.reset}`);
+  console.log(`${Colors.dim}CLI tool for managing VoidConnect mobile app servers${Colors.reset}`);
+  console.log();
+  console.log(`${Colors.white}${Colors.bold}Usage:${Colors.reset}`);
+  console.log(`${Colors.dim}  bunx voidct [command] [options]${Colors.reset}`);
+  console.log();
+  console.log(`${Colors.white}${Colors.bold}Commands:${Colors.reset}`);
+  console.log(`${Colors.dim}  run      Run a local project (current directory or --dir)${Colors.reset}`);
+  console.log(`${Colors.dim}  start    Start the server using saved configuration${Colors.reset}`);
+  console.log(`${Colors.dim}  stop     Stop the background server${Colors.reset}`);
+  console.log(`${Colors.dim}  status   Show status dashboard${Colors.reset}`);
+  console.log(`${Colors.dim}  add      Add a project to saved configuration${Colors.reset}`);
+  console.log(`${Colors.dim}  remove   Remove a project from configuration${Colors.reset}`);
+  console.log(`${Colors.dim}  restart  Restart the background server${Colors.reset}`);
+  console.log(`${Colors.dim}  config   Configure device settings${Colors.reset}`);
+  console.log(`${Colors.dim}  update   Check for updates${Colors.reset}`);
+  console.log();
+  console.log(`${Colors.white}${Colors.bold}Quick Start:${Colors.reset}`);
+  console.log(`${Colors.dim}  • Run 'voidct run' to serve the current directory${Colors.reset}`);
+  console.log(`${Colors.dim}  • Use 'voidct add <path>' to save projects${Colors.reset}`);
+  console.log(`${Colors.dim}  • Use 'voidct start' to serve saved projects${Colors.reset}`);
+  console.log();
+  console.log(`${Colors.dim}GitHub: https://github.com/xptea/voidconnect-cli${Colors.reset}`);
+  console.log();
+}
+
+function showStatus(status: StatusInfo) {
+  console.log();
+  printBox([
+    `${Colors.bold}${Colors.white}VoidConnect Status Dashboard${Colors.reset}`,
+  ]);
+
+  console.log(`${Colors.cyan}├${'─'.repeat(63)}┤${Colors.reset}`);
+  console.log(`${Colors.cyan}│${Colors.reset}  Device: ${Colors.white}${status.deviceName}${Colors.reset}`);
+
+  const statusText = status.running
+    ? `${Colors.green}Running${Colors.reset} (PID: ${status.pid})`
+    : `${Colors.red}Offline${Colors.reset}`;
+  console.log(`${Colors.cyan}│${Colors.reset}  Status: ${statusText}`);
+  console.log(`${Colors.cyan}│${Colors.reset}  Port: ${Colors.white}${status.port ?? 3838}${Colors.reset}`);
+  console.log(`${Colors.cyan}└${'─'.repeat(63)}┘${Colors.reset}`);
+
+  console.log();
+  console.log(`${Colors.white}${Colors.bold}Configured Projects:${Colors.reset}`);
+  if (status.projects.length === 0) {
+    console.log(`${Colors.dim}  No projects configured.${Colors.reset}`);
+  } else {
+    for (const p of status.projects) {
+      console.log(`  • ${Colors.cyan}${p.name}${Colors.reset}: ${p.path}`);
+    }
+  }
+
+  console.log();
+  console.log(`${Colors.white}${Colors.bold}Available Commands:${Colors.reset}`);
+  console.log(`${Colors.dim}  run      --dir, --cf, --port   Run local project${Colors.reset}`);
+  console.log(`${Colors.dim}  start    --cf, --bg, --port    Start server${Colors.reset}`);
+  console.log(`${Colors.dim}  stop                           Stop server${Colors.reset}`);
+  console.log(`${Colors.dim}  restart                        Restart server${Colors.reset}`);
+  console.log(`${Colors.dim}  add      <path> [--name]       Add a project${Colors.reset}`);
+  console.log(`${Colors.dim}  remove   <name>                Remove a project${Colors.reset}`);
+  console.log(`${Colors.dim}  config                         Configure settings${Colors.reset}`);
+  console.log(`${Colors.dim}  update                         Check for updates${Colors.reset}`);
+  console.log();
+}
+
+function showConfig(config: ReturnType<typeof getConfigInfo>) {
+  console.log();
+  console.log(`${Colors.cyan}${Colors.bold}Current Configuration:${Colors.reset}`);
+  console.log(`${Colors.white}  Device name: ${config.device_name}${Colors.reset}`);
+  console.log(`${Colors.white}  Password: ${config.password_hash ? 'Set' : 'Not set'}${Colors.reset}`);
+  console.log(`${Colors.white}  Port: ${config.port ?? 'Default (3838)'}${Colors.reset}`);
+  console.log();
+  console.log(`${Colors.dim}To change settings, use:${Colors.reset}`);
+  console.log(`${Colors.dim}  --device-name <name>  Change device name${Colors.reset}`);
+  console.log(`${Colors.dim}  --password <pwd>      Set password${Colors.reset}`);
+  console.log(`${Colors.dim}  --no-password         Remove password${Colors.reset}`);
+  console.log(`${Colors.dim}  --port <port>         Set default port${Colors.reset}`);
+  console.log();
+}
+
+function showAddSuccess(projectName: string) {
+  printSuccess(`Project '${projectName}' has been saved!`);
+  console.log();
+  printBox([
+    `${Colors.yellow}Next Steps:${Colors.reset}`,
+    `• Run ${Colors.bold}bunx voidct start${Colors.reset} to start all projects`,
+    `• Run ${Colors.bold}bunx voidct status${Colors.reset} to see projects`,
+  ]);
+  console.log();
+}
+
+// Main function
+async function main() {
+  const { command, flags, positional } = parseArgs();
+
+  try {
+    switch (command) {
+      case 'run': {
+        const result = await handleRun({
+          dir: flags.dir as string | undefined,
+          cf: !!flags.cf,
+          port: flags.port ? parseInt(flags.port as string) : undefined
+        });
+        if (result.success) {
+          printSuccess(result.message);
+        } else {
+          printError(result.message);
+        }
+        break;
+      }
+
+      case 'start': {
+        const result = await handleStart({
+          cf: !!flags.cf,
+          bg: !!flags.bg,
+          port: flags.port ? parseInt(flags.port as string) : undefined,
+          log: !!flags.log
+        });
+        if (result.success) {
+          printSuccess(result.message);
+        } else {
+          printError(result.message);
+        }
+        break;
+      }
+
+      case 'stop': {
+        const result = await handleStop();
+        if (result.success) {
+          printSuccess(result.message);
+        } else {
+          printError(result.message);
+        }
+        break;
+      }
+
+      case 'restart': {
+        const result = await handleRestart();
+        if (result.success) {
+          printSuccess(result.message);
+        } else {
+          printError(result.message);
+        }
+        break;
+      }
+
+      case 'add': {
+        const path = positional[0];
+        if (!path) {
+          printError("Please provide a path: voidct add <path>");
+        } else {
+          const result = await handleAdd(path, flags.name as string | undefined);
+          if (result.success) {
+            const projectName = result.message.match(/Project '(.+)' has been saved/)?.[1] || path;
+            showAddSuccess(projectName);
+          } else {
+            printError(result.message);
+          }
+        }
+        break;
+      }
+
+      case 'remove': {
+        const name = positional[0];
+        if (!name) {
+          printError("Please provide a project name: voidct remove <name>");
+        } else {
+          const result = await handleRemove(name);
+          if (result.success) {
+            printSuccess(result.message);
+          } else {
+            printError(result.message);
+          }
+        }
+        break;
+      }
+
+      case 'status': {
+        const status = await handleStatus();
+        showStatus(status);
+        break;
+      }
+
+      case 'config': {
+        if (Object.keys(flags).length > 0) {
+          const result = await handleConfig({
+            deviceName: flags['device-name'] as string | undefined,
+            password: flags['no-password'] ? null : flags.password as string | undefined,
+            port: flags.port ? parseInt(flags.port as string) : undefined
+          });
+          if (result.success) {
+            printSuccess(result.message);
+          } else {
+            printError(result.message);
+          }
+        } else {
+          const config = getConfigInfo();
+          showConfig(config);
+        }
+        break;
+      }
+
+      case 'update': {
+        console.log(`\n${Colors.dim}Checking for updates...${Colors.reset}`);
+        const update = await checkForUpdates(VERSION);
+        if (update.hasUpdate && update.version) {
+          printWarning(`Update available! v${VERSION} → v${update.version}`);
+          console.log(`${Colors.dim}Download: ${update.url}${Colors.reset}`);
+        } else {
+          printSuccess(`Already up to date (v${VERSION})`);
+        }
+        console.log();
+        break;
+      }
+
+      default:
+        showHelp();
+    }
+  } catch (err: any) {
+    printError(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();