infinicode 2.8.108 → 2.8.114

package/scripts/integrate-robovoice-control-center.mjs

@@ -0,0 +1,423 @@
+#!/usr/bin/env node
+
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+const repoRoot = path.resolve(import.meta.dirname, '..');
+const targetRoot = path.resolve(process.argv[2] || path.join(repoRoot, '..', 'ROBOVOICE-main'));
+const frontendRoot = path.join(targetRoot, 'frontend');
+
+if (!existsSync(path.join(frontendRoot, 'package.json'))) {
+  throw new Error(`RoboVoice frontend not found at ${frontendRoot}`);
+}
+
+async function write(file, contents) {
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, contents, 'utf8');
+}
+
+async function copy(source, destination) {
+  await mkdir(path.dirname(destination), { recursive: true });
+  await copyFile(source, destination);
+}
+
+function extractDashboard(source) {
+  const prefix = 'export const DASHBOARD_HTML = `';
+  const start = source.indexOf(prefix);
+  const end = source.lastIndexOf('`;');
+  if (start < 0 || end < start) {
+    throw new Error('Could not extract DASHBOARD_HTML from the canonical dashboard source');
+  }
+  return source.slice(start + prefix.length, end);
+}
+
+function installNativeVoicePage(html) {
+  const voiceStart = '<div class="rp-sub" id="rp-sub-voice">';
+  const historyStart = '<div class="rp-sub" id="rp-sub-history">';
+  const start = html.indexOf(voiceStart);
+  const end = html.indexOf(historyStart, start);
+  if (start < 0 || end < 0) {
+    throw new Error('Canonical dashboard voice panel markers were not found');
+  }
+
+  const insertAt = start + voiceStart.length;
+  const nativeVoice = `
+    <div class="rv-native-shell">
+      <div class="rv-native-head">
+        <div><div class="eyebrow">Native RoboVoice runtime</div><div class="title">Voice calls &amp; settings</div></div>
+        <span class="chip ok"><b>DIRECT</b> no scheduler in media path</span>
+      </div>
+      <iframe class="rv-native-frame" src="/voice" title="RoboVoice calls and settings" allow="camera; microphone; display-capture; autoplay; clipboard-write"></iframe>
+    </div>
+    <div hidden aria-hidden="true">`;
+
+  html = html.slice(0, insertAt) + nativeVoice + html.slice(insertAt, end) + '</div>\n' + html.slice(end);
+  html = html.replace('>Voice Call</button>', '>Voice &amp; Settings</button>');
+  html = html.replace(
+    '</style>',
+    `.rv-native-shell{min-height:calc(100vh - 190px);display:flex;flex-direction:column;gap:.65rem}
+.rv-native-head{display:flex;align-items:center;justify-content:space-between;gap:1rem;padding:.8rem 1rem;border:1px solid var(--glass-border);border-radius:13px;background:var(--panel)}
+.rv-native-head .title{font-family:var(--display);font-size:1.35rem;color:var(--gold-pale)}
+.rv-native-frame{display:block;width:100%;min-height:760px;flex:1;border:1px solid var(--glass-border);border-radius:16px;background:#050504;box-shadow:var(--shadow)}
+@media(max-width:760px){.rv-native-frame{min-height:820px}.rv-native-head{align-items:flex-start;flex-direction:column}}
+</style>`
+  );
+  return html.replace(
+    '<meta name="robopark-ui-build"',
+    '<meta name="robovoice-control-center" content="native-v1">\n<meta name="robopark-ui-build"'
+  );
+}
+
+const sourceDashboard = path.join(repoRoot, 'src', 'kernel', 'federation', 'dashboard-html.ts');
+const builtDashboard = path.join(repoRoot, 'dist', 'kernel', 'federation', 'dashboard-html.js');
+const dashboardPath = existsSync(sourceDashboard) ? sourceDashboard : builtDashboard;
+if (!existsSync(dashboardPath)) {
+  throw new Error('Canonical dashboard is missing. Run the Infinicode build before integrating RoboVoice.');
+}
+const dashboardSource = await readFile(dashboardPath, 'utf8');
+const dashboard = installNativeVoicePage(extractDashboard(dashboardSource));
+
+const currentRootPage = path.join(frontendRoot, 'app', '(app)', 'page.tsx');
+const nativeVoicePage = path.join(frontendRoot, 'app', '(app)', 'voice', 'page.tsx');
+if (!existsSync(nativeVoicePage)) {
+  await copy(currentRootPage, nativeVoicePage);
+}
+
+await write(
+  currentRootPage,
+  `import { redirect } from 'next/navigation';
+
+export default function Page() {
+  redirect('/robopark-control.html');
+}
+`
+);
+await write(path.join(frontendRoot, 'public', 'robopark-control.html'), dashboard);
+
+const robotRegistrySource = `export type RoboVoiceRobot = {
+  id: string;
+  name: string;
+  deviceId: string;
+  host: string;
+  visionPort: number;
+  audioPort: number;
+  aliases: string[];
+};
+
+const DEFAULT_ROBOTS: RoboVoiceRobot[] = [
+  {
+    id: 'bmw',
+    name: 'BMW',
+    deviceId: 'dev_0422e545',
+    host: process.env.ROBOVOICE_BMW_HOST || '192.168.0.178',
+    visionPort: 5000,
+    audioPort: 8000,
+    aliases: ['bmw', 'dev_0422e545'],
+  },
+];
+
+function configuredRobots(): RoboVoiceRobot[] {
+  const raw = process.env.ROBOVOICE_ROBOTS_JSON;
+  if (!raw) return DEFAULT_ROBOTS;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) throw new Error('expected a JSON array');
+    return parsed.map((robot) => ({
+      id: String(robot.id || robot.name).toLowerCase(),
+      name: String(robot.name || robot.id),
+      deviceId: String(robot.deviceId || robot.device_id || robot.id),
+      host: String(robot.host || robot.ip),
+      visionPort: Number(robot.visionPort || robot.vision_port || 5000),
+      audioPort: Number(robot.audioPort || robot.audio_port || 8000),
+      aliases: Array.from(new Set([robot.id, robot.name, robot.deviceId, robot.device_id, ...(robot.aliases || [])].filter(Boolean).map(String))),
+    }));
+  } catch (error) {
+    console.error('Invalid ROBOVOICE_ROBOTS_JSON:', error);
+    return DEFAULT_ROBOTS;
+  }
+}
+
+export function listRoboVoiceRobots() {
+  return configuredRobots();
+}
+
+export function resolveRoboVoiceRobot(reference: string) {
+  const wanted = decodeURIComponent(reference).trim().toLowerCase();
+  return configuredRobots().find((robot) =>
+    [robot.id, robot.name, robot.deviceId, ...robot.aliases]
+      .some((value) => String(value).toLowerCase() === wanted)
+  );
+}
+`;
+await write(path.join(frontendRoot, 'lib', 'robovoice-robot-registry.ts'), robotRegistrySource);
+
+const proxySource = `import type { NextRequest } from 'next/server';
+
+const CONTROL_URL = process.env.ROBOPARK_CONTROL_URL || 'http://host.docker.internal:47913';
+const CONTROL_TOKEN = process.env.ROBOPARK_CONTROL_TOKEN || '';
+const HOP_BY_HOP = new Set(['connection','keep-alive','proxy-authenticate','proxy-authorization','te','trailers','transfer-encoding','upgrade','content-length']);
+
+export async function proxyRoboParkControl(request: NextRequest, upstreamPath: string) {
+  const incoming = new URL(request.url);
+  incoming.searchParams.delete('token');
+  const target = new URL(upstreamPath + incoming.search, CONTROL_URL);
+  const headers = new Headers(request.headers);
+  headers.delete('host');
+  headers.delete('cookie');
+  headers.delete('content-length');
+  if (CONTROL_TOKEN) headers.set('authorization', 'Bearer ' + CONTROL_TOKEN);
+  const method = request.method.toUpperCase();
+  const controller = new AbortController();
+  const connectTimer = setTimeout(() => controller.abort(), 7000);
+  let upstream: Response;
+  try {
+    upstream = await fetch(target, {
+      method,
+      headers,
+      body: method === 'GET' || method === 'HEAD' ? undefined : request.body,
+      cache: 'no-store',
+      redirect: 'manual',
+      signal: controller.signal,
+      duplex: method === 'GET' || method === 'HEAD' ? undefined : 'half',
+    } as RequestInit & { duplex?: 'half' });
+  } catch (error) {
+    clearTimeout(connectTimer);
+    const detail = error instanceof Error ? error.message : String(error);
+    return Response.json(
+      { ok: false, error: 'RoboPark control upstream unavailable', detail, upstream: target.origin },
+      { status: 502, headers: { 'cache-control': 'no-store' } }
+    );
+  }
+  // The timer protects connection establishment only. Once headers arrive,
+  // MJPEG and SSE bodies must remain open for unattended operation.
+  clearTimeout(connectTimer);
+  const responseHeaders = new Headers();
+  upstream.headers.forEach((value, key) => {
+    if (!HOP_BY_HOP.has(key.toLowerCase())) responseHeaders.set(key, value);
+  });
+  responseHeaders.set('cache-control', 'no-store');
+  responseHeaders.set('x-robopark-control-source', target.origin);
+  return new Response(upstream.body, {
+    status: upstream.status,
+    statusText: upstream.statusText,
+    headers: responseHeaders,
+  });
+}
+`;
+await write(path.join(frontendRoot, 'lib', 'robopark-control-proxy.ts'), proxySource);
+
+const fedRoute = `import type { NextRequest } from 'next/server';
+import { proxyRoboParkControl } from '@/lib/robopark-control-proxy';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+type RouteContext = { params: Promise<{ path: string[] }> };
+async function handler(request: NextRequest, context: RouteContext) {
+  const { path } = await context.params;
+  return proxyRoboParkControl(request, '/fed/' + path.map(encodeURIComponent).join('/'));
+}
+export { handler as GET, handler as POST, handler as PUT, handler as PATCH, handler as DELETE };
+`;
+await write(path.join(frontendRoot, 'app', 'fed', '[...path]', 'route.ts'), fedRoute);
+
+const cameraRoute = `import type { NextRequest } from 'next/server';
+import { proxyRoboParkControl } from '@/lib/robopark-control-proxy';
+import { resolveRoboVoiceRobot } from '@/lib/robovoice-robot-registry';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+type RouteContext = { params: Promise<{ robotId: string }> };
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  const { robotId } = await context.params;
+  const robot = resolveRoboVoiceRobot(robotId);
+  if (!robot) {
+    return proxyRoboParkControl(request, '/fed/media/robots/' + encodeURIComponent(robotId) + '/video_feed');
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 3500);
+  try {
+    const target = 'http://' + robot.host + ':' + robot.visionPort + '/video_feed';
+    const upstream = await fetch(target, { cache: 'no-store', signal: controller.signal });
+    clearTimeout(timer);
+    if (!upstream.ok || !upstream.body) throw new Error('RoboVision returned ' + upstream.status);
+    const headers = new Headers();
+    headers.set('content-type', upstream.headers.get('content-type') || 'multipart/x-mixed-replace; boundary=frame');
+    headers.set('cache-control', 'no-store, no-cache, must-revalidate');
+    headers.set('x-robovoice-media-source', 'direct-robovision');
+    headers.set('x-robovoice-robot', robot.id);
+    return new Response(upstream.body, { status: 200, headers });
+  } catch (error) {
+    clearTimeout(timer);
+    console.warn('Direct RoboVision relay failed for ' + robot.id + ', using control fallback:', error);
+    return proxyRoboParkControl(request, '/fed/media/robots/' + encodeURIComponent(robotId) + '/video_feed');
+  }
+}
+`;
+await write(path.join(frontendRoot, 'app', 'fed', 'media', 'robots', '[robotId]', 'video_feed', 'route.ts'), cameraRoute);
+
+const nativeStreamRoute = `import { AccessToken, RoomServiceClient, type VideoGrant } from 'livekit-server-sdk';
+import type { NextRequest } from 'next/server';
+import { resolveRoboVoiceRobot } from '@/lib/robovoice-robot-registry';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+type RouteContext = { params: Promise<{ robotId: string }> };
+
+function publicLiveKitUrl(request: NextRequest) {
+  const explicit = process.env.LIVEKIT_PUBLIC_URL || process.env.NEXT_PUBLIC_LIVEKIT_URL;
+  if (explicit && explicit !== 'auto') return explicit;
+  const forwardedProto = request.headers.get('x-forwarded-proto');
+  const host = request.headers.get('host') || 'localhost';
+  const hostname = host.split(':')[0];
+  if (hostname.endsWith('.ts.net')) return 'wss://' + hostname;
+  if (forwardedProto === 'https' || request.url.startsWith('https://')) return 'wss://' + host;
+  return 'ws://' + hostname + ':7880';
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  const { robotId } = await context.params;
+  const robot = resolveRoboVoiceRobot(robotId);
+  if (!robot) return Response.json({ active: false, reason: 'robot_not_registered' }, { status: 404 });
+  const key = process.env.LIVEKIT_API_KEY;
+  const secret = process.env.LIVEKIT_API_SECRET;
+  if (!key || !secret) return Response.json({ active: false, reason: 'livekit_credentials_missing' }, { status: 503 });
+  const stableRoom = 'robopark-' + robot.deviceId;
+  let room = stableRoom;
+  let discovered = false;
+  try {
+    const internal = (process.env.LIVEKIT_URL || 'http://livekit:7880').replace(/^ws:/, 'http:').replace(/^wss:/, 'https:');
+    const service = new RoomServiceClient(internal, key, secret, { requestTimeout: 2500 });
+    const rooms = await service.listRooms();
+    const candidates = rooms.filter((candidate) => candidate.name === stableRoom || candidate.name.startsWith(stableRoom + '-'));
+    candidates.sort((a, b) => Number(b.creationTime || 0) - Number(a.creationTime || 0));
+    const stable = candidates.find((candidate) => candidate.name === stableRoom && candidate.numParticipants > 0);
+    const selected = stable || candidates.find((candidate) => candidate.numParticipants > 0) || candidates[0];
+    if (selected) {
+      room = selected.name;
+      discovered = true;
+    }
+  } catch (error) {
+    console.warn('LiveKit room discovery unavailable; using stable robot room:', error);
+  }
+  const token = new AccessToken(key, secret, {
+    identity: 'viewer:' + robot.deviceId + ':' + crypto.randomUUID().slice(0, 8),
+    name: 'RoboPark Control monitor',
+    ttl: '15m',
+  });
+  const grant: VideoGrant = { room, roomJoin: true, canSubscribe: true, canPublish: false, canPublishData: false };
+  token.addGrant(grant);
+  return Response.json({
+    active: true,
+    url: publicLiveKitUrl(request),
+    token: await token.toJwt(),
+    room,
+    robot_id: robot.deviceId,
+    source: 'robovoice-native',
+    room_discovered: discovered,
+  }, { headers: { 'cache-control': 'no-store' } });
+}
+`;
+await write(path.join(frontendRoot, 'app', 'robopark', 'api', 'robots', '[robotId]', 'stream', 'route.ts'), nativeStreamRoute);
+
+const mediaHealthRoute = `import { resolveRoboVoiceRobot } from '@/lib/robovoice-robot-registry';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+type RouteContext = { params: Promise<{ robotId: string }> };
+
+async function probe(url: string) {
+  const started = Date.now();
+  try {
+    const response = await fetch(url, { cache: 'no-store', signal: AbortSignal.timeout(2500) });
+    return { ok: response.ok, status: response.status, latency_ms: Date.now() - started };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error), latency_ms: Date.now() - started };
+  }
+}
+
+export async function GET(_: Request, context: RouteContext) {
+  const { robotId } = await context.params;
+  const robot = resolveRoboVoiceRobot(robotId);
+  if (!robot) return Response.json({ ok: false, error: 'robot not registered' }, { status: 404 });
+  const [vision, audio] = await Promise.all([
+    probe('http://' + robot.host + ':' + robot.visionPort + '/api/media/inventory'),
+    probe('http://' + robot.host + ':' + robot.audioPort + '/devices'),
+  ]);
+  return Response.json({ ok: vision.ok && audio.ok, robot, vision, audio, room: 'robopark-' + robot.deviceId }, { status: vision.ok && audio.ok ? 200 : 503 });
+}
+`;
+await write(path.join(frontendRoot, 'app', 'api', 'robovoice', 'robots', '[robotId]', 'media-health', 'route.ts'), mediaHealthRoute);
+
+const productRoute = `import type { NextRequest } from 'next/server';
+import { proxyRoboParkControl } from '@/lib/robopark-control-proxy';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+type RouteContext = { params: Promise<{ path: string[] }> };
+async function handler(request: NextRequest, context: RouteContext) {
+  const { path } = await context.params;
+  return proxyRoboParkControl(request, '/robopark/' + path.map(encodeURIComponent).join('/'));
+}
+export { handler as GET, handler as POST, handler as PUT, handler as PATCH, handler as DELETE };
+`;
+await write(path.join(frontendRoot, 'app', 'robopark', '[...path]', 'route.ts'), productRoute);
+await write(
+  path.join(frontendRoot, 'app', 'robopark', 'page.tsx'),
+  `import { redirect } from 'next/navigation';
+
+export default function RoboParkPage() {
+  redirect('/robopark-control.html#robopark');
+}
+`
+);
+
+for (const image of ['bmw.png', 'jaguar.png', 'panda.png', 'tesla.png', 'volt.png']) {
+  await copy(path.join(repoRoot, 'static', 'robopark', image), path.join(frontendRoot, 'public', 'static', 'robopark', image));
+}
+await copy(
+  path.join(repoRoot, 'node_modules', 'livekit-client', 'dist', 'livekit-client.umd.js'),
+  path.join(frontendRoot, 'public', 'vendor', 'livekit-client.umd.js')
+);
+
+const composePath = path.join(targetRoot, 'docker-compose.yaml');
+let compose = await readFile(composePath, 'utf8');
+if (!compose.includes('ROBOPARK_CONTROL_URL=')) {
+  compose = compose.replace(
+    '      - SCHEDULER_URL=http://host.docker.internal:8080',
+    `      - SCHEDULER_URL=http://host.docker.internal:8080
+      - ROBOPARK_CONTROL_URL=\${ROBOPARK_CONTROL_URL:-http://host.docker.internal:47913}
+      - ROBOPARK_CONTROL_TOKEN=\${ROBOPARK_CONTROL_TOKEN:-}`
+  );
+  await writeFile(composePath, compose, 'utf8');
+}
+if (!compose.includes('ROBOVOICE_ROBOTS_JSON=')) {
+  compose = compose.replace(
+    '      - ROBOPARK_CONTROL_TOKEN=${ROBOPARK_CONTROL_TOKEN:-}',
+    `      - ROBOPARK_CONTROL_TOKEN=\${ROBOPARK_CONTROL_TOKEN:-}
+      - ROBOVOICE_ROBOTS_JSON=\${ROBOVOICE_ROBOTS_JSON:-}
+      - ROBOVOICE_BMW_HOST=\${ROBOVOICE_BMW_HOST:-192.168.0.178}`
+  );
+  await writeFile(composePath, compose, 'utf8');
+}
+
+const envExamplePath = path.join(targetRoot, '.env.example');
+let envExample = await readFile(envExamplePath, 'utf8');
+if (!envExample.includes('ROBOPARK_CONTROL_URL=')) {
+  envExample += `
+
+# Control upstream. Credentials stay server-side and are never exposed to the browser.
+ROBOPARK_CONTROL_URL=http://host.docker.internal:47913
+ROBOPARK_CONTROL_TOKEN=
+ROBOVOICE_BMW_HOST=192.168.0.178
+# JSON array for all robots. Fields: id, name, deviceId, host, visionPort, audioPort, aliases.
+ROBOVOICE_ROBOTS_JSON=
+`;
+  await writeFile(envExamplePath, envExample, 'utf8');
+}
+
+console.log(`RoboPark Control Center integrated into ${frontendRoot}`);
+console.log('Default UI: /robopark-control.html');
+console.log('Native RoboVoice calls and settings: /voice');