robopark 3.1.1 → 3.2.0

package/README.md

@@ -24,12 +24,22 @@ On the gateway:
 robopark --password '<activation-password>' gateway start --public-url https://robopark.example.com
 ```
 
-`gateway start` owns both RoboPark surfaces:
-
-- Full Park Control Center: port 47913
+`gateway start` owns the complete stable ROBOVOICE frontend and RoboPark
+services:
+
+- Full ROBOVOICE stable frontend: port 47913
+- Park Control Center: `/robopark` or `/robopark-control.html`
+- Voice operations: `/voice`
+- Voice tester: `/voice-tester`
+- Managed character joins: `/voice-join.html`
 - Private scheduler/API service: port 8080
+- Private control compatibility adapter: port 47914
 
-InfiniCode is not required to render or operate the Park UI.
+The frontend is the prebuilt production output from
+`MrYungCEO/ROBOVOICE-main` stable, including its React application, Next API
+routes, static Park operator UI, native microphone handling, live room/camera
+discovery, transcript surfaces, settings, setup, and device operations.
+InfiniCode is not required to render or operate any RoboPark surface.
 
 The gateway prints a complete connection command. Run it once on a device:
 
@@ -82,7 +92,7 @@ RoboPark owns device connectivity, camera/audio, sessions, transcripts, and the
 operator gateway. InfiniCode is an optional management/orchestration layer and
 is not a runtime dependency.
 
-The 3.0 artifact deliberately preserves the current scheduler, Pi client,
+The 3.2 artifact deliberately preserves the current scheduler, Pi client,
 ElevenLabs conversation worker, camera/vision service, screen relay, motor
 bridge, configuration filenames, and service names. Existing enrolled robots
 are grandfathered on upgrade and continue using their current device identity

package/dist/robopark/frontend-service.js

@@ -0,0 +1,80 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function packageRoot() {
+    return dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+}
+export function frontendServerPath() {
+    return join(packageRoot(), 'ui', 'standalone', 'server.js');
+}
+async function waitForFrontend(port, child) {
+    const deadline = Date.now() + 60_000;
+    let lastError = 'not responding';
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null) {
+            throw new Error(`ROBOVOICE frontend exited before readiness (code ${child.exitCode})`);
+        }
+        try {
+            const response = await fetch(`http://127.0.0.1:${port}/fed/ui-build`, {
+                signal: AbortSignal.timeout(1_500),
+            });
+            if (response.ok) {
+                const body = await response.json();
+                if (body.source === 'robovoice-control' && body.build)
+                    return;
+                lastError = `unexpected UI owner ${JSON.stringify(body)}`;
+            }
+            else {
+                lastError = `HTTP ${response.status}`;
+            }
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+        }
+        await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    throw new Error(`ROBOVOICE frontend did not become healthy on port ${port}: ${lastError}`);
+}
+export async function startFrontendService(opts) {
+    const server = frontendServerPath();
+    if (!existsSync(server)) {
+        throw new Error('packaged ROBOVOICE stable frontend is missing; reinstall robopark');
+    }
+    const root = dirname(server);
+    const child = spawn(process.execPath, [server], {
+        cwd: root,
+        windowsHide: true,
+        stdio: ['ignore', 'inherit', 'inherit'],
+        env: {
+            ...process.env,
+            NODE_ENV: 'production',
+            HOSTNAME: opts.host,
+            PORT: String(opts.port),
+            ROBOPARK_CONTROL_URL: `http://127.0.0.1:${opts.adapterPort}`,
+            ROBOPARK_SCHEDULER_URL: `http://127.0.0.1:${opts.schedulerPort}`,
+            SCHEDULER_URL: `http://127.0.0.1:${opts.schedulerPort}`,
+            V2_SCHEDULER_URL: `http://127.0.0.1:${opts.schedulerPort}`,
+            NEXT_PUBLIC_LIVEKIT_URL: process.env.NEXT_PUBLIC_LIVEKIT_URL || 'auto',
+        },
+    });
+    try {
+        await waitForFrontend(opts.port, child);
+        return child;
+    }
+    catch (error) {
+        try {
+            child.kill('SIGTERM');
+        }
+        catch { /* already stopped */ }
+        throw error;
+    }
+}
+export function stopFrontendService(child) {
+    if (!child || child.exitCode !== null)
+        return;
+    try {
+        child.kill('SIGTERM');
+    }
+    catch { /* already stopped */ }
+}

package/dist/robopark/serve.js

@@ -255,11 +255,11 @@ 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'
+        ? 'explorer.exe'
         : process.platform === 'darwin'
             ? 'open'
             : 'xdg-open';
-    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    const args = [url];
     try {
         spawn(command, args, { detached: true, stdio: 'ignore', windowsHide: true }).unref();
     }

package/dist/robopark/standalone.js

@@ -8,6 +8,7 @@ import { registerAutoStart } from './auto-start.js';
 import { findPython, findSchedulerPath, prepareRobotPython } from './python-env.js';
 import { roboparkServe, schedulerHealthy } from './serve.js';
 import { startControlServer } from './control-server.js';
+import { startFrontendService, stopFrontendService } from './frontend-service.js';
 import { activateFromPairing } from './access.js';
 const STATE_DIR = process.env.ROBOPARK_HOME
     ? resolve(process.env.ROBOPARK_HOME)
@@ -150,6 +151,7 @@ export async function connectDevice(token, opts = {}) {
         deviceToken: enrolled.device_token,
         name,
         connectedAt: new Date().toISOString(),
+        controlPort: pairing.controlPort,
     };
     atomicJson(CONNECTION_PATH, connection);
     writeFileSync(join(STATE_DIR, 'device_token'), connection.deviceToken, { encoding: 'utf8', mode: 0o600 });
@@ -196,6 +198,56 @@ function positiveInteger(value, fallback, label) {
         throw new Error(`${label} must be a positive integer`);
     return parsed;
 }
+function openBrowser(url) {
+    // Use detached platform-native launchers so this CLI remains usable from
+    // terminals and does not inherit browser stdio or lifecycle.
+    const command = process.platform === 'win32'
+        ? 'explorer.exe'
+        : process.platform === 'darwin'
+            ? 'open'
+            : 'xdg-open';
+    // Do not route URLs through cmd.exe. Character links contain "&"; cmd
+    // treats each query parameter after the first as a separate shell command,
+    // causing the browser to receive an incomplete join link.
+    const args = [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)}`));
+    }
+}
+/**
+ * Opens the character-specific ElevenLabs voice-join page (served by the Park
+ * Control Center, not the scheduler) for the device just configured. Best
+ * effort only: a browser-less robot host or an unreachable control server
+ * must never fail `robopark start`/`robopark connect`.
+ */
+async function openCharacterCallPage(connection, character) {
+    try {
+        const preset = await jsonRequest(`${connection.schedulerUrl}/api/character-presets/${encodeURIComponent(character)}`, {});
+        if (!preset.elevenlabs_agent_id) {
+            console.log(chalk.yellow(`  ⚠ character "${character}" has no ElevenLabs agent configured; not opening a call page.`));
+            return;
+        }
+        const controlPort = connection.controlPort ?? 47913;
+        const controlHost = new URL(connection.schedulerUrl).hostname;
+        const params = new URLSearchParams({
+            character,
+            agent_id: preset.elevenlabs_agent_id,
+            mode: 'production',
+            robot: connection.deviceId,
+        });
+        if (preset.elevenlabs_branch_id)
+            params.set('branch_id', preset.elevenlabs_branch_id);
+        const url = `http://${controlHost}:${controlPort}/voice-join.html?${params.toString()}`;
+        console.log(`  call page: ${chalk.cyan(url)}`);
+        openBrowser(url);
+    }
+    catch (err) {
+        console.log(chalk.yellow(`  ⚠ could not open the character call page: ${err instanceof Error ? err.message : String(err)}`));
+    }
+}
 export async function startDevice(opts) {
     const connection = readConnection();
     const desired = {
@@ -216,6 +268,9 @@ export async function startDevice(opts) {
     }
     await updateDeviceConfiguration(desired);
     atomicJson(DESIRED_PATH, desired);
+    if (desired.character) {
+        await openCharacterCallPage(connection, desired.character);
+    }
     if (opts.foreground) {
         await superviseDevice(DESIRED_PATH);
         return;
@@ -424,20 +479,37 @@ export async function gatewayStart(opts) {
     }
     const schedulerUrl = localPublicUrl(host, port, opts.publicUrl);
     const healthUrl = `http://127.0.0.1:${port}`;
+    const controlHealthUrl = `http://127.0.0.1:${controlPort}/fed/ui-build`;
     const deadline = Date.now() + 30_000;
-    while (!(await schedulerHealthy(healthUrl, 1_000))) {
-        if (Date.now() >= deadline)
-            throw new Error(`gateway did not become healthy at ${schedulerUrl}`);
+    let schedulerReady = false;
+    let controlReady = false;
+    while (!schedulerReady || !controlReady) {
+        [schedulerReady, controlReady] = await Promise.all([
+            schedulerHealthy(healthUrl, 1_000),
+            fetch(controlHealthUrl, { signal: AbortSignal.timeout(1_000) })
+                .then(async (response) => {
+                if (!response.ok)
+                    return false;
+                const body = await response.json();
+                return body.owner === 'robopark' || body.source === 'robovoice-control';
+            })
+                .catch(() => false),
+        ]);
+        if (Date.now() >= deadline) {
+            throw new Error(`gateway did not become healthy (scheduler ${port}: ${schedulerReady ? 'ready' : 'down'}, `
+                + `Control Center ${controlPort}: ${controlReady ? 'ready' : 'down'})`);
+        }
         await wait(500);
     }
-    const token = await createGatewayTokenAt(healthUrl, schedulerUrl);
+    const token = await createGatewayTokenAt(healthUrl, schedulerUrl, controlPort);
     const controlHost = new URL(schedulerUrl).hostname;
-    console.log(`  Park Control Center: ${chalk.cyan(`http://${controlHost}:${controlPort}/`)}`);
+    console.log(`  Park Control Center: ${chalk.cyan(`http://${controlHost}:${controlPort}/robopark`)}`);
+    console.log(`  Voice operations:    ${chalk.cyan(`http://${controlHost}:${controlPort}/voice`)}`);
     console.log(chalk.bold('\n  Connect a device'));
     console.log(`  ${chalk.cyan(`robopark connect ${token}`)}`);
     console.log(chalk.dim('  This pairing token expires in 24 hours. Connected devices keep their own durable credentials.\n'));
 }
-async function createGatewayTokenAt(localUrl, publicUrl) {
+async function createGatewayTokenAt(localUrl, publicUrl, controlPort) {
     await jsonRequest(`${localUrl}/api/settings`, {
         method: 'PUT',
         headers: { 'content-type': 'application/json' },
@@ -449,6 +521,7 @@ async function createGatewayTokenAt(localUrl, publicUrl) {
         schedulerUrl: publicUrl,
         enrollmentToken: result.enrollment_token,
         expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+        controlPort,
     });
     atomicJson(GATEWAY_PATH, { schedulerUrl: publicUrl, pairingToken: pairing, createdAt: new Date().toISOString() });
     return pairing;
@@ -456,14 +529,26 @@ async function createGatewayTokenAt(localUrl, publicUrl) {
 export async function runGatewayService(opts) {
     const schedulerPort = positiveInteger(opts.port, 8080, 'port');
     const controlPort = positiveInteger(opts.controlPort, 47913, 'control port');
+    const adapterPort = controlPort + 1;
     const host = opts.host ?? '0.0.0.0';
     const control = await startControlServer({
         host,
-        port: controlPort,
+        port: adapterPort,
         schedulerUrl: `http://127.0.0.1:${schedulerPort}`,
     });
-    console.log(`  Park Control Center listening on ${host}:${controlPort}`);
+    let frontend;
     try {
+        frontend = await startFrontendService({
+            host,
+            port: controlPort,
+            adapterPort,
+            schedulerPort,
+        });
+        console.log(`  ROBOVOICE stable frontend listening on ${host}:${controlPort}`);
+        console.log(`  RoboPark control adapter listening on ${host}:${adapterPort}`);
+        const frontendExit = new Promise(resolve => {
+            frontend?.once('exit', () => resolve('frontend-exit'));
+        });
         await roboparkServe({
             port: String(schedulerPort),
             host,
@@ -471,8 +556,21 @@ export async function runGatewayService(opts) {
             open: false,
             foreground: true,
         });
+        // roboparkServe wires the scheduler child's lifecycle handlers and then
+        // returns once it has launched. Keep this outer gateway process alive so
+        // the sibling Control Center server is not closed by the finally block.
+        const shutdown = new Promise(resolve => {
+            const stop = () => resolve('shutdown');
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+        const ended = await Promise.race([shutdown, frontendExit]);
+        if (ended === 'frontend-exit') {
+            throw new Error('ROBOVOICE stable frontend stopped unexpectedly');
+        }
     }
     finally {
+        stopFrontendService(frontend);
         control.close();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robopark",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "Standalone packaged RoboPark control center and supervised robot runtime.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "bin/robopark.js",
     "dist",
+    "ui",
     "scripts/windows-shim-fix.cjs",
     "scheduler",
     "pi-client",
@@ -29,16 +30,42 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@livekit/components-react": "^2.9.15",
+    "@livekit/protocol": "^1.40.0",
+    "@phosphor-icons/react": "^2.1.8",
+    "@picovoice/porcupine-web": "^4.0.0",
+    "@picovoice/web-voice-processor": "^4.0.9",
+    "@radix-ui/react-select": "^2.2.5",
+    "@radix-ui/react-slot": "^1.2.3",
+    "@radix-ui/react-toggle": "^1.1.9",
+    "@radix-ui/react-tooltip": "^1.2.8",
+    "buffer-image-size": "^0.6.4",
+    "class-variance-authority": "^0.7.1",
     "chalk": "^5.3.0",
+    "clsx": "^2.1.1",
     "commander": "^12.1.0",
     "conf": "^12.0.0",
     "execa": "^9.3.0",
-    "livekit-client": "^2.20.1"
+    "jose": "^6.0.12",
+    "livekit-client": "^2.20.1",
+    "livekit-server-sdk": "^2.13.2",
+    "mime": "^4.0.7",
+    "motion": "^12.16.0",
+    "next": "15.5.21",
+    "next-themes": "^0.4.6",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "sonner": "^2.0.7",
+    "tailwind-merge": "^3.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.14.0",
     "typescript": "^5.4.5"
   },
+  "overrides": {
+    "postcss": "8.5.23",
+    "sharp": "0.35.3"
+  },
   "keywords": [
     "robopark",
     "fleet",
@@ -53,6 +80,11 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/MrYungCEO/infinicode"
+    "url": "https://github.com/MrYungCEO/ROBOVOICE-main"
+  },
+  "roboparkBuild": {
+    "uiSourceBranch": "stable",
+    "uiSourceCommit": "be4ecb0",
+    "uiBuild": "production-native-microphone-20260725-8"
   }
 }

package/ui/ROBOVOICE_BUILD.json

@@ -0,0 +1,9 @@
+{
+  "repository": "https://github.com/MrYungCEO/ROBOVOICE-main",
+  "branch": "stable",
+  "commit": "be4ecb0",
+  "control_ui_build": "production-native-microphone-20260725-8",
+  "next_build_version": "15.5.7",
+  "next_runtime_version": "15.5.21",
+  "packaged_at": "2026-07-26"
+}

package/ui/standalone/.next/BUILD_ID

@@ -0,0 +1 @@
+T3eGaQUuZNb6rhEStcouc