voidct 1.0.0

package/README.md

@@ -0,0 +1,99 @@
+# VoidConnect CLI
+
+CLI tool for managing VoidConnect mobile app servers. Built with [OpenTUI](https://github.com/nicholasgriffintn/opentui) for beautiful terminal interfaces.
+
+## Installation
+
+```bash
+bunx voidct
+```
+
+## Quick Start
+
+```bash
+# Serve the current directory
+bunx voidct run
+
+# Add a project to your saved list
+bunx voidct add /path/to/project --name "My Project"
+
+# Start serving all saved projects
+bunx voidct start
+
+# Check status
+bunx voidct status
+```
+
+## Commands
+
+| Command | Arguments | Description |
+|---------|-----------|-------------|
+| `run` | `--dir <path>`, `--cf`, `--port <port>` | Run a local project (foreground) |
+| `start` | `--cf`, `--bg`, `--port <port>`, `--log` | Start server with saved projects |
+| `stop` | | Stop the background server |
+| `restart` | | Restart the server |
+| `status` | | Show status dashboard |
+| `add` | `<path>` `[--name <name>]` | Add a project path |
+| `remove` | `<name>` | Remove a project |
+| `config` | `--device-name`, `--password`, `--port` | Configure device settings |
+| `update` | | Check for updates |
+
+## Flags
+
+### Global Flags
+- `--cf` - Enable Cloudflare tunnel for external access
+- `--port <port>` - Specify a custom port (default: 3838)
+
+### Start Command Flags
+- `--bg` - Run server in background mode
+- `--log` - Enable traffic logging to `void_traffic.log` in the current directory
+
+### Config Command Flags
+- `--device-name <name>` - Set the device name shown to mobile clients
+- `--password <pwd>` - Set a password for authentication
+- `--no-password` - Remove password protection
+
+## Configuration
+
+Configuration is stored in `~/.voidconnect/hub_config.json` and includes:
+- Device name
+- Password (optional)
+- Default port
+- Saved projects list
+
+## Architecture
+
+```
+src/
+├── index.tsx          # Main CLI entry (OpenTUI/React UI)
+├── config.ts          # Configuration management
+├── handlers.ts        # Command handlers
+├── utils.ts           # Utility functions
+└── hub/               # Hub server
+    ├── index.ts       # Hono web server
+    ├── auth.ts        # Authentication middleware
+    ├── config.ts      # Hub config loader
+    ├── logger.ts      # Traffic logging
+    ├── process_manager.ts  # OpenCode process management
+    └── tunnel.ts      # Cloudflare tunnel integration
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development mode
+bun run dev
+
+# Run the CLI directly
+bun run src/index.tsx [command]
+
+# Run the hub server directly
+bun run src/hub/index.ts
+```
+
+## License
+
+MIT

package/bun.lock

@@ -0,0 +1,41 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 0,
+  "workspaces": {
+    "": {
+      "name": "react",
+      "dependencies": {
+        "hono": "^4.0.0",
+        "qrcode-terminal": "^0.12.0",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+        "@types/qrcode-terminal": "^0.12.2",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.2.20", "", { "dependencies": { "bun-types": "1.2.20" } }, "sha512-dX3RGzQ8+KgmMw7CsW4xT5ITBSCrSbfHc36SNT31EOUg/LA9JWq0VDdEXDRSe1InVWpd2yLUM1FUF/kEOyTzYA=="],
+
+    "@types/node": ["@types/node@24.3.0", "", { "dependencies": { "undici-types": "~7.10.0" } }, "sha512-aPTXCrfwnDLj4VvXrm+UUCQjNEvJgNA8s5F1cvwQU+3KNltTOkBm1j30uNLyqqPNe7gE3KFzImYoZEfLhp4Yow=="],
+
+    "@types/qrcode-terminal": ["@types/qrcode-terminal@0.12.2", "", {}, "sha512-v+RcIEJ+Uhd6ygSQ0u5YYY7ZM+la7GgPbs0V/7l/kFs2uO4S8BcIUEMoP7za4DNIqNnUD5npf0A/7kBhrCKG5Q=="],
+
+    "@types/react": ["@types/react@19.1.11", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-lr3jdBw/BGj49Eps7EvqlUaoeA0xpj3pc0RoJkHpYaCHkVK7i28dKyImLQb3JVlqs3aYSXf7qYuWOW/fgZnTXQ=="],
+
+    "bun-types": ["bun-types@1.2.20", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-pxTnQYOrKvdOwyiyd/7sMt9yFOenN004Y6O4lCcCUoKVej48FS5cvTw9geRaEcB9TsDZaJKAxPTVvi8tFsVuXA=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
+    "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.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A=="],
+
+    "undici-types": ["undici-types@7.10.0", "", {}, "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="],
+  }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "voidct",
+  "version": "1.0.0",
+  "description": "CLI tool for managing VoidConnect mobile app servers",
+  "module": "src/index.ts",
+  "type": "module",
+  "bin": {
+    "voidct": "./src/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run --watch src/index.ts",
+    "start": "bun run src/index.ts",
+    "hub": "bun run src/hub/index.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/qrcode-terminal": "^0.12.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "hono": "^4.0.0",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xptea/voidconnect-cli"
+  },
+  "keywords": [
+    "cli",
+    "voidconnect",
+    "mobile",
+    "server",
+    "tunnel"
+  ],
+  "author": "xptea",
+  "license": "MIT"
+}

package/src/config.ts

@@ -0,0 +1,131 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+
+export interface ProjectConfig {
+    name: string;
+    path: string;
+}
+
+export interface HubConfig {
+    device_name: string;
+    password_hash: string | null;
+    port: number | null;
+    projects: ProjectConfig[];
+}
+
+export interface ServerState {
+    cf: boolean;
+    bg: boolean;
+}
+
+export function getConfigDir(): string {
+    const dir = join(homedir(), '.voidconnect');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+
+export function getConfigPath(): string {
+    return join(getConfigDir(), 'hub_config.json');
+}
+
+export function getPidPath(): string {
+    return join(getConfigDir(), 'server.pid');
+}
+
+export function getStatePath(): string {
+    return join(getConfigDir(), 'server.state');
+}
+
+export function loadConfig(): HubConfig {
+    const path = getConfigPath();
+    if (!existsSync(path)) {
+        return {
+            device_name: 'VoidConnect Hub',
+            password_hash: null,
+            port: null,
+            projects: []
+        };
+    }
+    try {
+        const content = readFileSync(path, 'utf-8');
+        return JSON.parse(content) as HubConfig;
+    } catch {
+        return {
+            device_name: 'VoidConnect Hub',
+            password_hash: null,
+            port: null,
+            projects: []
+        };
+    }
+}
+
+export function saveConfig(config: HubConfig): void {
+    const path = getConfigPath();
+    writeFileSync(path, JSON.stringify(config, null, 2));
+}
+
+export function saveState(state: ServerState): void {
+    const path = getStatePath();
+    writeFileSync(path, JSON.stringify(state));
+}
+
+export function loadState(): ServerState | null {
+    const path = getStatePath();
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(path, 'utf-8');
+        return JSON.parse(content) as ServerState;
+    } catch {
+        return null;
+    }
+}
+
+export function addProject(pathStr: string, name?: string): string {
+    const config = loadConfig();
+    const fs = require('fs');
+    const path = require('path');
+
+    const absolutePath = path.resolve(pathStr);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`Invalid path '${pathStr}': Directory does not exist`);
+    }
+
+    // Clean path (remove \\?\ prefix on Windows)
+    let cleanPath = absolutePath;
+    if (cleanPath.startsWith('\\\\?\\')) {
+        cleanPath = cleanPath.slice(4);
+    }
+
+    const projectName = name || path.basename(cleanPath);
+
+    // Check if project with same path exists
+    const existing = config.projects.find(p => p.path === cleanPath);
+    if (existing) {
+        existing.name = projectName;
+    } else {
+        config.projects.push({
+            name: projectName,
+            path: cleanPath
+        });
+    }
+
+    saveConfig(config);
+    return projectName;
+}
+
+export function removeProject(name: string): boolean {
+    const config = loadConfig();
+    const originalLen = config.projects.length;
+    config.projects = config.projects.filter(p => p.name !== name);
+
+    if (config.projects.length < originalLen) {
+        saveConfig(config);
+        return true;
+    }
+    return false;
+}

package/src/handlers.ts

@@ -0,0 +1,357 @@
+import { spawn, spawnSync } from 'bun';
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { resolve, basename, dirname, join } from 'path';
+import {
+    loadConfig,
+    saveConfig,
+    saveState,
+    loadState,
+    addProject,
+    removeProject,
+    getPidPath,
+    getStatePath,
+    type HubConfig
+} from './config';
+import { isPortAvailable, findAvailablePort, isServerRunning, killServer, cleanupServerFiles } from './utils';
+
+export interface RunOptions {
+    dir?: string;
+    cf?: boolean;
+    port?: number;
+}
+
+export interface StartOptions {
+    cf?: boolean;
+    bg?: boolean;
+    port?: number;
+    log?: boolean;
+}
+
+export async function handleRun(options: RunOptions): Promise<{ success: boolean; message: string }> {
+    const { running, pid } = isServerRunning();
+    if (running && pid) {
+        return {
+            success: false,
+            message: `A server is already running (PID: ${pid}). Stop it first with 'voidct stop'.`
+        };
+    }
+
+    // Determine project path
+    const projectPath = options.dir ? resolve(options.dir) : process.cwd();
+
+    if (!existsSync(projectPath)) {
+        return {
+            success: false,
+            message: `Invalid directory '${projectPath}': Directory does not exist`
+        };
+    }
+
+    const projectName = basename(projectPath);
+    const config = loadConfig();
+    const requestedPort = options.port ?? config.port ?? 3838;
+
+    let port = requestedPort;
+    if (!(await isPortAvailable(port))) {
+        port = await findAvailablePort(port + 1);
+    }
+
+    const hubPath = getHubPath();
+    if (!hubPath) {
+        return {
+            success: false,
+            message: 'Hub directory not found'
+        };
+    }
+
+    await ensureHubDependencies(hubPath);
+
+    const args = ['run', join(hubPath, 'index.ts')];
+    if (options.cf) {
+        args.push('--cf');
+    }
+
+    const env: Record<string, string> = {
+        ...process.env as Record<string, string>,
+        HUB_PROJECT_PATH: projectPath,
+        HUB_PROJECT_NAME: projectName,
+        HUB_DEVICE_NAME: config.device_name,
+        PORT: port.toString()
+    };
+
+    if (config.password_hash) {
+        env.HUB_PASSWORD = config.password_hash;
+    }
+
+    const child = spawn(['bun', ...args], {
+        cwd: hubPath,
+        env,
+        stdout: 'inherit',
+        stderr: 'inherit'
+    });
+
+    writeFileSync(getPidPath(), child.pid.toString());
+
+    // Wait for process to exit
+    await child.exited;
+    cleanupServerFiles();
+
+    return {
+        success: true,
+        message: `Running project "${projectName}" on port ${port}`
+    };
+}
+
+export async function handleStart(options: StartOptions): Promise<{ success: boolean; message: string }> {
+    // Save state for restart
+    saveState({ cf: options.cf ?? false, bg: options.bg ?? false });
+
+    const { running, pid } = isServerRunning();
+    if (running && pid) {
+        return {
+            success: false,
+            message: `A server is already running (PID: ${pid}). Stop it first with 'voidct stop'.`
+        };
+    }
+
+    const config = loadConfig();
+    if (config.projects.length === 0) {
+        return {
+            success: false,
+            message: "No projects configured. Add a project first with 'voidct add <path>'."
+        };
+    }
+
+    const requestedPort = options.port ?? config.port ?? 3838;
+    let port = requestedPort;
+    if (!(await isPortAvailable(port))) {
+        port = await findAvailablePort(port + 1);
+    }
+
+    const hubPath = getHubPath();
+    if (!hubPath) {
+        return {
+            success: false,
+            message: 'Hub directory not found'
+        };
+    }
+
+    await ensureHubDependencies(hubPath);
+
+    const args = ['run', join(hubPath, 'index.ts')];
+    if (options.cf) {
+        args.push('--cf');
+    }
+    if (options.log) {
+        args.push('--log');
+    }
+
+    const env: Record<string, string> = {
+        ...process.env as Record<string, string>,
+        HUB_DEVICE_NAME: config.device_name,
+        HUB_START_DIR: process.cwd(),
+        PORT: port.toString()
+    };
+
+    if (config.password_hash) {
+        env.HUB_PASSWORD = config.password_hash;
+    }
+
+    if (options.bg) {
+        // Background mode
+        const child = spawn(['bun', ...args], {
+            cwd: hubPath,
+            env,
+            stdout: 'pipe',
+            stderr: 'pipe'
+        });
+
+        writeFileSync(getPidPath(), child.pid.toString());
+
+        // Wait for server to output URL
+        const reader = child.stdout.getReader();
+        const decoder = new TextDecoder();
+
+        let output = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            output += decoder.decode(value);
+            console.log(decoder.decode(value));
+
+            if (output.includes('URL: http')) {
+                break;
+            }
+        }
+
+        return {
+            success: true,
+            message: `Server started in background (PID: ${child.pid}) on port ${port}`
+        };
+    }
+
+    // Foreground mode
+    const child = spawn(['bun', ...args], {
+        cwd: hubPath,
+        env,
+        stdout: 'inherit',
+        stderr: 'inherit'
+    });
+
+    writeFileSync(getPidPath(), child.pid.toString());
+    await child.exited;
+    cleanupServerFiles();
+
+    return {
+        success: true,
+        message: `Server stopped`
+    };
+}
+
+export async function handleStop(): Promise<{ success: boolean; message: string }> {
+    const { running, pid } = isServerRunning();
+
+    if (!running || !pid) {
+        return {
+            success: false,
+            message: 'Server is not running'
+        };
+    }
+
+    if (killServer(pid)) {
+        cleanupServerFiles();
+        return {
+            success: true,
+            message: `Server (PID: ${pid}) stopped successfully`
+        };
+    }
+
+    return {
+        success: false,
+        message: `Failed to stop server (PID: ${pid})`
+    };
+}
+
+export async function handleRestart(): Promise<{ success: boolean; message: string }> {
+    const state = loadState();
+    const cf = state?.cf ?? false;
+    const bg = state?.bg ?? false;
+
+    await handleStop();
+    await new Promise(r => setTimeout(r, 500));
+    return handleStart({ cf, bg });
+}
+
+export async function handleAdd(path: string, name?: string): Promise<{ success: boolean; message: string }> {
+    try {
+        const savedName = addProject(path, name);
+        return {
+            success: true,
+            message: `Project '${savedName}' has been saved!`
+        };
+    } catch (e) {
+        return {
+            success: false,
+            message: `Failed to add project: ${e}`
+        };
+    }
+}
+
+export async function handleRemove(name: string): Promise<{ success: boolean; message: string }> {
+    if (removeProject(name)) {
+        return {
+            success: true,
+            message: `Project '${name}' removed successfully`
+        };
+    }
+    return {
+        success: false,
+        message: `Project '${name}' not found`
+    };
+}
+
+export interface StatusInfo {
+    deviceName: string;
+    running: boolean;
+    pid: number | null;
+    projects: Array<{ name: string; path: string }>;
+    port: number | null;
+}
+
+export async function handleStatus(): Promise<StatusInfo> {
+    const config = loadConfig();
+    const { running, pid } = isServerRunning();
+
+    return {
+        deviceName: config.device_name,
+        running,
+        pid,
+        projects: config.projects,
+        port: config.port
+    };
+}
+
+export interface ConfigOptions {
+    deviceName?: string;
+    password?: string | null;
+    port?: number | null;
+}
+
+export async function handleConfig(options: ConfigOptions): Promise<{ success: boolean; message: string }> {
+    const config = loadConfig();
+
+    if (options.deviceName !== undefined) {
+        config.device_name = options.deviceName;
+    }
+    if (options.password !== undefined) {
+        config.password_hash = options.password;
+    }
+    if (options.port !== undefined) {
+        config.port = options.port;
+    }
+
+    saveConfig(config);
+    return {
+        success: true,
+        message: 'Configuration updated successfully'
+    };
+}
+
+export function getConfigInfo(): HubConfig {
+    return loadConfig();
+}
+
+function getHubPath(): string | null {
+    // Check various locations for the hub
+    const execPath = process.argv[1] || '';
+    const possiblePaths = [
+        join(dirname(execPath), 'hub'),
+        join(dirname(execPath), '..', 'hub'),
+        join(process.cwd(), 'src', 'hub'),
+        join(process.cwd(), 'hub'),
+    ];
+
+    for (const p of possiblePaths) {
+        if (existsSync(join(p, 'index.ts'))) {
+            return p;
+        }
+    }
+
+    return null;
+}
+
+async function ensureHubDependencies(hubPath: string): Promise<void> {
+    const nodeModules = join(hubPath, '..', 'node_modules');
+    if (!existsSync(nodeModules)) {
+        console.log('First run detected. Installing dependencies...');
+        const result = spawnSync(['bun', 'install'], {
+            cwd: join(hubPath, '..'),
+            stdout: 'inherit',
+            stderr: 'inherit'
+        });
+        if (result.exitCode !== 0) {
+            throw new Error('Failed to install dependencies');
+        }
+        console.log('Dependencies installed.\n');
+    }
+}

package/src/hub/auth.ts

@@ -0,0 +1,18 @@
+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();
+}