robopark 2.8.35 → 3.0.0

package/dist/robopark/serve.js

@@ -0,0 +1,285 @@
+/**
+ * RoboPark — `robopark serve`.
+ *
+ * Starts the RoboPark scheduler (Python FastAPI) and the web UI in one pass.
+ * The scheduler lives next to this package in `scheduler/main.py`.
+ *
+ *   robopark serve --port 8080
+ *   robopark serve --gateway ws://infinibot:18789 --gateway-token <token>
+ */
+import chalk from 'chalk';
+import { spawn, execSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function pkgDir() {
+    try {
+        // dist/robopark/serve.js -> dist/robopark -> dist -> project root
+        return dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+    }
+    catch {
+        return process.cwd();
+    }
+}
+function findScheduler() {
+    const candidates = [
+        // When robopark serve is invoked via the robopark wrapper, the wrapper
+        // imports infinicode/robopark, so this code runs from inside the
+        // infinicode package. The scheduler Python files are shipped there.
+        join(pkgDir(), 'packages', 'robopark', 'scheduler', 'main.py'),
+        // Fallbacks for local checkout / when robopark is installed standalone.
+        join(pkgDir(), 'scheduler', 'main.py'),
+        join(process.cwd(), 'packages', 'robopark', 'scheduler', 'main.py'),
+        join(process.cwd(), 'scheduler', 'main.py'),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    // Last resort: resolve the installed infinicode package and look next to it.
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const req = require('module').createRequire(fileURLToPath(import.meta.url));
+        const pkgMain = req.resolve('infinicode/package.json');
+        const p = join(dirname(pkgMain), 'packages', 'robopark', 'scheduler', 'main.py');
+        if (existsSync(p))
+            return p;
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function findPython() {
+    // On Windows the canonical interpreter is usually `python` (from the Microsoft
+    // Store / python.org installer); `python3` is common on Linux/macOS. Prefer the
+    // platform-specific name first, then fall back to the other conventions.
+    const names = process.platform === 'win32'
+        ? ['python', 'python3', 'python3.12', 'python3.11', 'python3.10', 'py']
+        : ['python3.12', 'python3.11', 'python3.10', 'python3', 'python'];
+    for (const name of names) {
+        try {
+            execSync(`${name} --version`, { stdio: 'ignore' });
+            return name;
+        }
+        catch {
+            continue;
+        }
+    }
+    // Nothing verified; return the most likely name so the user sees the actual
+    // ENOENT/"not found" error from the OS rather than a silent fallback.
+    return process.platform === 'win32' ? 'python' : 'python3';
+}
+function resolveSchedulerDataDir(explicit) {
+    if (explicit)
+        return explicit;
+    if (process.env.SCHEDULER_DATA_DIR)
+        return process.env.SCHEDULER_DATA_DIR;
+    const stable = join(homedir(), '.robopark', 'scheduler');
+    const stableDb = join(stable, 'scheduler.db');
+    if (existsSync(stableDb))
+        return stable;
+    // Older releases stored data beside whichever npm installation launched
+    // the scheduler. Local, global and npx installs therefore created separate
+    // databases. Migrate the largest existing DB once into stable user storage.
+    const legacyCandidates = [join(pkgDir(), '..', 'data')];
+    if (process.platform === 'win32' && process.env.APPDATA) {
+        legacyCandidates.push(join(process.env.APPDATA, 'npm', 'node_modules', 'data'));
+    }
+    const legacy = legacyCandidates
+        .filter((candidate, index, all) => all.indexOf(candidate) === index)
+        .filter(candidate => existsSync(join(candidate, 'scheduler.db')))
+        .sort((a, b) => statSync(join(b, 'scheduler.db')).size - statSync(join(a, 'scheduler.db')).size)[0];
+    mkdirSync(stable, { recursive: true });
+    if (legacy) {
+        cpSync(legacy, stable, { recursive: true, force: false, errorOnExist: false });
+        console.log(chalk.yellow(`  migrated scheduler data: ${legacy} -> ${stable}`));
+    }
+    return stable;
+}
+/** Resolve the actual infinicode CLI entry point so `robopark setup --start`
+ *  works even when global bins are not on PATH.
+ *
+ *  Returns the node executable path and the path to `bin/infinicode.js` inside
+ *  the installed `infinicode` package. We avoid spawning the bare `infinicode`
+ *  command because npm's `.cmd` shim is not reliably resolvable by Node's
+ *  `spawn` without `shell: true` on Windows, and shell concatenation triggers
+ *  a deprecation warning when args are passed.
+ */
+export async function resolveInfinicodeBin() {
+    try {
+        // When running from the infinicode package itself, the CLI entry is nearby.
+        const local = join(pkgDir(), 'bin', 'infinicode.js');
+        if (existsSync(local))
+            return { node: process.execPath, script: local };
+    }
+    catch { /* ignore */ }
+    try {
+        // When running from the robopark wrapper, resolve infinicode from npm.
+        const { createRequire } = await import('node:module');
+        // createRequire expects a file path, not a file:// URL.
+        const require = createRequire(fileURLToPath(import.meta.url));
+        const pkgMain = require.resolve('infinicode/package.json');
+        const candidate = join(dirname(pkgMain), 'bin', 'infinicode.js');
+        if (existsSync(candidate))
+            return { node: process.execPath, script: candidate };
+    }
+    catch { /* ignore */ }
+    return null;
+}
+export async function roboparkServe(opts) {
+    const schedulerPath = findScheduler();
+    if (!schedulerPath) {
+        console.log(chalk.red('  ✗ could not find scheduler/main.py'));
+        console.log(chalk.dim('    make sure robopark is installed from npm, not a partial checkout.'));
+        process.exit(1);
+    }
+    const port = opts.port ? parseInt(opts.port, 10) : 8080;
+    const host = opts.host ?? '0.0.0.0';
+    const python = findPython();
+    const schedulerDir = dirname(schedulerPath);
+    const requirements = join(schedulerDir, 'requirements.txt');
+    const dataDir = resolveSchedulerDataDir(opts.dataDir);
+    // Ensure scheduler Python dependencies are installed before starting.
+    if (existsSync(requirements)) {
+        console.log(chalk.dim('  ensuring scheduler Python deps…'));
+        try {
+            execSync(`${python} -m pip install -r "${requirements}" --user --quiet`, { stdio: 'pipe' });
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  ⚠ pip install failed: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk.dim('    continuing; scheduler may fail if deps are missing.'));
+        }
+    }
+    const env = {
+        ...process.env,
+        SCHEDULER_HOST: host,
+        SCHEDULER_PORT: String(port),
+        SCHEDULER_DATA_DIR: dataDir,
+    };
+    if (opts.gateway)
+        env.INFINIBOT_GATEWAY_URL = opts.gateway;
+    if (opts.gatewayToken)
+        env.INFINIBOT_GATEWAY_TOKEN = opts.gatewayToken;
+    if (opts.gatewayPassword)
+        env.INFINIBOT_GATEWAY_PASSWORD = opts.gatewayPassword;
+    console.log(chalk.bold('\n  robopark serve'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  scheduler: ${chalk.cyan(schedulerPath)}`);
+    console.log(`  python:    ${chalk.cyan(python)}`);
+    console.log(`  listen:    ${chalk.cyan(`${host}:${port}`)}`);
+    console.log(`  data:      ${chalk.cyan(dataDir)}`);
+    if (opts.gateway)
+        console.log(`  gateway:   ${chalk.cyan(opts.gateway)}`);
+    console.log();
+    const proc = spawn(python, ['main.py'], {
+        cwd: dirname(schedulerPath),
+        env,
+        stdio: opts.foreground ? 'pipe' : 'ignore',
+        detached: !opts.foreground,
+    });
+    let ready = false;
+    proc.stdout?.on('data', (d) => {
+        const line = d.toString().trim();
+        if (line)
+            console.log(chalk.dim('  [scheduler] ' + line));
+        if (/Uvicorn running|Application startup complete/i.test(line)) {
+            ready = true;
+            printUrl(port);
+        }
+    });
+    proc.stderr?.on('data', (d) => {
+        const line = d.toString().trim();
+        if (line)
+            console.log(chalk.yellow('  [scheduler] ' + line));
+    });
+    proc.on('error', (err) => {
+        console.log(chalk.red(`  ✗ scheduler failed to start: ${err.message}`));
+        process.exit(1);
+    });
+    proc.on('exit', (code) => {
+        if (!ready && code !== 0) {
+            console.log(chalk.red(`  ✗ scheduler exited ${code ?? ''}`));
+            process.exit(code ?? 1);
+        }
+    });
+    if (opts.foreground) {
+        process.on('SIGINT', () => {
+            console.log(chalk.dim('\n  stopping scheduler…'));
+            try {
+                proc.kill('SIGINT');
+            }
+            catch { /* ignore */ }
+        });
+        proc.on('exit', (code, signal) => {
+            if (signal)
+                process.exit(1);
+            process.exit(code ?? 1);
+        });
+        if (opts.open !== false) {
+            await openDashboard(host, port);
+        }
+    }
+    else {
+        // Detached mode: let the user walk away. The process keeps running.
+        proc.unref();
+        if (opts.open !== false) {
+            await openDashboard(host, port);
+        }
+        printUrl(port);
+        console.log(chalk.dim('  running in background. Use Task Manager / systemctl / launchctl to stop.'));
+    }
+}
+function printUrl(port) {
+    const url = `http://localhost:${port}`;
+    console.log(chalk.bold(`  dashboard: ${chalk.cyan(url)}`));
+}
+/** Quick health check: is the scheduler responding? */
+export async function schedulerHealthy(url, timeoutMs = 3000) {
+    try {
+        const res = await fetch(`${url.replace(/\/$/, '')}/api/settings`, { signal: AbortSignal.timeout(timeoutMs) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function dashboardUrl(host, port) {
+    // 0.0.0.0/:: are bind addresses, not useful browser destinations.
+    const browserHost = host === '0.0.0.0' || host === '::' ? 'localhost' : host;
+    const formattedHost = browserHost.includes(':') && !browserHost.startsWith('[')
+        ? `[${browserHost}]`
+        : browserHost;
+    return `http://${formattedHost}:${port}/`;
+}
+function openBrowser(url) {
+    // Use detached platform-native launchers so robopark serve remains usable
+    // from terminals and does not inherit browser stdio or lifecycle.
+    const command = process.platform === 'win32'
+        ? 'cmd.exe'
+        : process.platform === 'darwin'
+            ? 'open'
+            : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    try {
+        spawn(command, args, { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+    }
+    catch (err) {
+        console.log(chalk.yellow(`  ⚠ could not open browser: ${err instanceof Error ? err.message : String(err)}`));
+    }
+}
+async function openDashboard(host, port) {
+    const url = dashboardUrl(host, port);
+    const deadline = Date.now() + 10_000;
+    let healthy = false;
+    while (Date.now() < deadline) {
+        if (await schedulerHealthy(url, 500)) {
+            healthy = true;
+            break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    if (!healthy) {
+        console.log(chalk.yellow('  ⚠ scheduler did not answer within 10s; opening the dashboard anyway.'));
+    }
+    openBrowser(url);
+}

package/dist/robopark/server-add.js

@@ -0,0 +1,114 @@
+/**
+ * RoboPark — `robopark server add`.
+ *
+ * Registers a LiveKit server with the RoboPark scheduler via
+ * `POST /api/servers`, wrapping the curl call operators previously had to
+ * hand-type.
+ *
+ * Usage:
+ *   robopark server add --id livekit-hub-docker --url ws://100.x.y.z:7880
+ *   robopark server add --id livekit-hub-docker --url ws://100.x.y.z:7880 \
+ *     --api-key devkey --api-secret secret --scheduler-url http://100.x.y.z:8080
+ *
+ * If --scheduler-url is omitted, it is derived from --hub-url (or discovery)
+ * the same way `robopark setup-livekit` does: hub host on port 8080.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { discoverContext } from './discovery.js';
+const DEFAULT_SCHEDULER_PORT = 8080;
+const DEV_API_KEY = 'devkey';
+const DEV_API_SECRET = 'secret';
+function loadMeshToken() {
+    const paths = [
+        join(homedir(), '.robopark', 'mesh.token'),
+        join(homedir(), '.config', 'infinicode-nodejs', 'config.json'),
+        join(homedir(), '.infinicode-nodejs', 'config.json'),
+        join(homedir(), 'AppData', 'Roaming', 'infinicode-nodejs', 'Config', 'config.json'),
+    ];
+    for (const p of paths) {
+        if (!existsSync(p))
+            continue;
+        try {
+            if (p.endsWith('mesh.token'))
+                return readFileSync(p, 'utf8').trim();
+            const cfg = JSON.parse(readFileSync(p, 'utf8'));
+            if (cfg.federation?.token)
+                return cfg.federation.token;
+        }
+        catch { /* ignore */ }
+    }
+    return process.env.ROBOPARK_MESH_TOKEN;
+}
+async function postServer(schedulerUrl, body) {
+    const url = `${schedulerUrl.replace(/\/$/, '')}/api/servers`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`${res.status}: ${text || res.statusText}`);
+    }
+}
+export async function roboparkServerAdd(opts) {
+    const ctx = await discoverContext();
+    const hubUrl = opts.hubUrl ?? (ctx.hub ? `http://${ctx.hub.ip}:${ctx.meshPort ?? 47913}` : undefined);
+    // Kept for parity with setup-livekit's discovery flow, even though the
+    // scheduler's /api/servers endpoint itself is unauthenticated today.
+    void (opts.token ?? ctx.meshToken ?? loadMeshToken());
+    const schedulerUrl = opts.schedulerUrl ?? (hubUrl ? hubUrl.replace(/:\d+$/, `:${DEFAULT_SCHEDULER_PORT}`) : undefined);
+    console.log(chalk.bold('\n  robopark server add'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    if (!schedulerUrl) {
+        console.log(chalk.red('  ✗ no scheduler URL. Pass --scheduler-url or --hub-url, or run robopark setup first.'));
+        process.exit(1);
+    }
+    if (!opts.id) {
+        console.log(chalk.red('  ✗ --id is required (unique server id, e.g. livekit-hub-docker).'));
+        process.exit(1);
+    }
+    if (!opts.url) {
+        console.log(chalk.red('  ✗ --url is required (LiveKit ws:// URL, e.g. ws://100.x.y.z:7880).'));
+        process.exit(1);
+    }
+    let apiKey = opts.apiKey;
+    let apiSecret = opts.apiSecret;
+    if (!apiKey || !apiSecret) {
+        console.log(chalk.yellow(`  ⚠ --api-key/--api-secret not provided; defaulting to LiveKit --dev credentials ('${DEV_API_KEY}'/'${DEV_API_SECRET}')`));
+        apiKey = apiKey ?? DEV_API_KEY;
+        apiSecret = apiSecret ?? DEV_API_SECRET;
+    }
+    const body = {
+        id: opts.id,
+        name: opts.name ?? opts.id,
+        url: opts.url,
+        webhook_url: opts.webhookUrl ?? opts.url.replace(/^wss?/, 'http'),
+        api_key: apiKey,
+        api_secret: apiSecret,
+        gpu_name: 'none',
+        gpu_vram_mb: 0,
+        max_sessions: opts.maxSessions ? parseInt(opts.maxSessions, 10) : 8,
+        status: 'online',
+    };
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
+    console.log(`  id:        ${chalk.cyan(body.id)}`);
+    console.log(`  url:       ${chalk.cyan(body.url)}`);
+    console.log();
+    try {
+        await postServer(schedulerUrl, body);
+        console.log(chalk.green(`  ✓ registered LiveKit server '${body.id}' with scheduler`));
+        console.log(chalk.dim(`    name:         ${body.name}`));
+        console.log(chalk.dim(`    url:          ${body.url}`));
+        console.log(chalk.dim(`    webhook_url:  ${body.webhook_url}`));
+        console.log(chalk.dim(`    api_key:      ${body.api_key}`));
+        console.log(chalk.dim(`    max_sessions: ${body.max_sessions}`));
+    }
+    catch (e) {
+        console.log(chalk.red(`  ✗ failed to register server: ${e.message}`));
+        process.exit(1);
+    }
+}