infinicode 2.8.4 → 2.8.6

package/dist/cli.js

@@ -311,7 +311,10 @@ program
     .option('--lan-port <port>', 'UDP discovery port for --lan (default 47915)')
     .option('--tag <tag>', 'only discover peers carrying this tag (Tailscale ACL tag or LAN beacon tag)')
     .option('--console', 'interactive slash-command console on the node (/nodes, /build, /activity …); on by default in a TTY')
-    .option('--tls-cert <path>', 'PEM cert file — serve the mesh over HTTPS')
+    .option('--dashboard', 'serve the RoboPark control web UI at http://<host>:<port>/ (fleet map, live activity, actions)')
+    .option('--scheduler-url <url>', 'link a RoboPark scheduler so the dashboard shows sessions + telemetry (e.g. http://localhost:8080)')
+    .option('--scheduler-token <token>', 'bearer token to present to the scheduler on proxied requests')
+    .option('--tls-cert <path>', 'PEM cert file — serve the dashboard/mesh over HTTPS')
     .option('--tls-key <path>', 'PEM private key file for --tls-cert')
     .option('--gateway <url>', 'link to an InfiniBot gateway (ws://host:18789) — appear on its neural-mesh map')
     .option('--gateway-token <token>', 'auth token for the InfiniBot gateway')

package/dist/commands/robopark.js

@@ -111,10 +111,10 @@ function renderFleet(snap) {
     return lines.join('\n');
 }
 const ROLE_PRESETS = {
-    scheduler: { mesh: 'hub', blurb: 'on-site hub (LiveKit Server 1) — bridges tailnet ↔ LAN, runs robopark serve', lan: true, tailscale: true },
-    robot: { mesh: 'satellite', blurb: 'a robot Pi — accept-only, LAN-discovered, never dials out', lan: true, tailscale: false },
-    laptop: { mesh: 'peer', blurb: 'your control station — drives the fleet over the mesh', lan: false, tailscale: true },
-    relay: { mesh: 'relay', blurb: 'a relay hop between two networks', lan: true, tailscale: true },
+    scheduler: { mesh: 'hub', blurb: 'on-site hub (LiveKit Server 1) — bridges tailnet ↔ LAN, serves the dashboard', dashboard: true, lan: true, tailscale: true },
+    robot: { mesh: 'satellite', blurb: 'a robot Pi — accept-only, LAN-discovered, never dials out', dashboard: false, lan: true, tailscale: false },
+    laptop: { mesh: 'peer', blurb: 'your control station — drives the fleet over the mesh', dashboard: false, lan: false, tailscale: true },
+    relay: { mesh: 'relay', blurb: 'a relay hop between two networks', dashboard: false, lan: true, tailscale: true },
 };
 // Power users can pass raw mesh roles too; fold them onto the matching preset.
 const MESH_ALIASES = { hub: 'scheduler', satellite: 'robot', peer: 'laptop' };
@@ -192,6 +192,11 @@ async function roboparkSetup(config, opts) {
     const { label, preset } = resolved;
     const meshRole = preset.mesh;
     // Preset defaults, overridable by explicit flags.
+    const dashboard = opts.dashboard ?? preset.dashboard;
+    // The RoboPark scheduler API runs on the same box as the on-site hub, so the
+    // scheduler role links it by default → the dashboard's Sessions & Telemetry
+    // tab is live out of the box. Other roles don't proxy a scheduler.
+    const schedulerUrl = opts.schedulerUrl ?? (label === 'scheduler' ? 'http://127.0.0.1:8080' : undefined);
     const lan = opts.lan ?? preset.lan;
     const tailscale = opts.tailscale ?? (preset.tailscale && !opts.hub); // seed URL replaces discovery
     const port = opts.port ? parseInt(opts.port, 10) : DEFAULT_PORT;
@@ -237,29 +242,33 @@ async function roboparkSetup(config, opts) {
         tailscale,
         lan,
         tag: opts.tag,
+        dashboard,
+        schedulerUrl,
+        schedulerToken: opts.schedulerToken,
         gateway: opts.gateway,
         gatewayToken: opts.gatewayToken,
     };
-    const infinicodeCmd = [
+    if (opts.start) {
+        console.log(chalk.dim('  starting node…\n'));
+        await serve(config, serveOpts);
+        return;
+    }
+    const startCmd = [
         'infinicode serve',
         `--role ${meshRole}`,
+        dashboard ? '--dashboard' : '',
+        schedulerUrl ? `--scheduler-url ${schedulerUrl}` : '',
         lan ? '--lan' : '',
         tailscale ? '--tailscale' : '',
         opts.tag ? `--tag ${opts.tag}` : '',
         opts.hub ? `--seed ${opts.hub}` : '',
         fed.token ? `--token ${fed.token}` : '',
         opts.gateway ? `--gateway ${opts.gateway}` : '',
-    ].filter(Boolean).join(' ');
-    if (opts.start) {
-        console.log(chalk.dim('  starting node…\n'));
-        await serve(config, serveOpts);
-        return;
-    }
+    ]
+        .filter(Boolean)
+        .join(' ');
     console.log(chalk.dim('  saved. start it now with:  ') + chalk.cyan('robopark setup --' + label + ' --start'));
-    console.log(chalk.dim('  or run the node directly:   ') + chalk.cyan(infinicodeCmd));
-    if (label === 'scheduler') {
-        console.log(chalk.dim('  and for the RoboPark UI:    ') + chalk.cyan('robopark serve --port 8080'));
-    }
+    console.log(chalk.dim('  or run the node directly:   ') + chalk.cyan(startCmd));
     console.log();
 }
 async function roboparkFleet(config, opts) {
@@ -356,13 +365,17 @@ function openBrowser(url) {
     }
 }
 async function roboparkDashboard(config, opts) {
-    // The RoboPark dashboard is now served by `robopark serve`, not the mesh node.
-    // Default to the scheduler URL if none is given, falling back to the local node.
-    const base = (opts.url ?? 'http://127.0.0.1:8080').replace(/\/+$/, '');
+    const base = nodeUrl(config, opts.url);
     const token = authToken(config, opts.token);
     const link = `${base}/${token ? `?token=${encodeURIComponent(token)}` : ''}`;
+    // Confirm the node is actually serving the dashboard before pointing there.
     try {
-        const res = await fetch(`${base}/api/settings`, { headers: headers(token), signal: AbortSignal.timeout(5000) });
+        const res = await fetch(link, { headers: headers(token), signal: AbortSignal.timeout(5000) });
+        if (res.status === 404) {
+            console.log(chalk.yellow(`  ⚠ node at ${base} is up but the dashboard is off.`));
+            console.log(chalk.dim('    restart it with  infinicode serve --dashboard'));
+            return;
+        }
         if (!res.ok)
             throw new Error(`HTTP ${res.status}`);
     }
@@ -398,6 +411,9 @@ export function attachRoboparkSubcommands(cmd, config, opts) {
             .option('--architecture <text>', "one-line brief of this device's job in the wider system")
             .option('--lan', 'force zero-config LAN auto-discovery (on by default for scheduler/robot)')
             .option('--tailscale', 'force Tailscale peer discovery (on by default for scheduler/laptop)')
+            .option('--dashboard', 'force the web control UI (on by default for scheduler)')
+            .option('--scheduler-url <url>', 'RoboPark scheduler API to link for the dashboard Sessions tab (default http://127.0.0.1:8080 for the scheduler role)')
+            .option('--scheduler-token <token>', 'bearer token presented to the scheduler on proxied requests')
             .option('--start', 'launch the node now instead of just writing config')
             .option('--yes', 'skip the guided wizard even with no role (non-interactive)')
             .action(async (opts) => {

package/dist/commands/serve.d.ts

@@ -17,6 +17,9 @@ export interface ServeOptions {
     gateway?: string;
     gatewayToken?: string;
     gatewayPassword?: string;
+    dashboard?: boolean;
+    schedulerUrl?: string;
+    schedulerToken?: string;
     tlsCert?: string;
     tlsKey?: string;
     supervised?: boolean;

package/dist/commands/serve.js

@@ -11,7 +11,7 @@
  */
 import chalk from 'chalk';
 import { readFileSync } from 'node:fs';
-import crypto from 'node:crypto';
+import { randomBytes } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { buildKernelFromConfig, registerCloudProviders } from '../kernel/setup.js';
@@ -60,20 +60,18 @@ export async function serve(config, opts) {
     // performSelfUpdate via the environment.
     if (opts.supervised ?? fed.supervised)
         process.env.INFINICODE_SUPERVISED = '1';
-    // Mesh nodes should always present a token on a routable interface. If none
-    // is provided, generate one so remote peers can authenticate.
-    if (!token && !isLoopback(bindHost)) {
-        token = crypto.randomBytes(9).toString('base64url');
-        console.log(chalk.yellow(`  ⚠ mesh exposed on ${bindHost} without --token — generated a session token.`));
+    // Secure-by-default: a control dashboard exposed on a routable interface with
+    // no token is a wide-open remote. If the operator asked for the dashboard but
+    // set no token, mint a session token so the surface isn't unauthenticated.
+    if (opts.dashboard && !token && !isLoopback(bindHost)) {
+        token = randomBytes(9).toString('base64url');
+        console.log(chalk.yellow(`  ⚠ dashboard exposed on ${bindHost} without --token — generated a session token.`));
         console.log(chalk.yellow(`    peers must now connect with  --token ${token}`));
     }
     // Keep a network-exposed, tokenless node read-only: it will answer status/map
     // queries but refuse control commands until a token is set. Loopback-only or
     // token-protected nodes are trusted and run everything.
     const trusted = Boolean(token) || isLoopback(bindHost);
-    // commandGate is the mesh-side gate only. The RoboPark product UI is now
-    // served exclusively by `robopark serve`, so control writes there are no
-    // longer in scope for `infinicode serve`.
     const commandGate = (input) => {
         if (trusted)
             return { ok: true };
@@ -160,9 +158,13 @@ export async function serve(config, opts) {
             autoUpdate: opts.autoUpdate ?? fed.autoUpdate,
             applyConfig,
             autoPullConfig: role === 'satellite',
+            dashboard: opts.dashboard,
             onApply,
             commandGate,
             tls,
+            schedulerUrl: opts.schedulerUrl ?? fed.schedulerUrl,
+            schedulerToken: opts.schedulerToken,
+            schedulerReadOnly: !trusted,
         },
     });
     // Let the kernel's slash-command surface reach the mesh (/nodes, /node, …).
@@ -182,10 +184,18 @@ export async function serve(config, opts) {
         console.log(`  auth:   ${chalk.green('token required')}`);
     console.log();
     await federation.start();
-    // Mesh-only node. The RoboPark dashboard + scheduler UI are served by
-    // `robopark serve` on the hub box, not by `infinicode serve`.
-    console.log(chalk.dim('  (use `robopark serve` on the hub for the fleet dashboard + scheduler UI)'));
-    console.log();
+    // Control dashboard link — prefer a reachable host over the 0.0.0.0 wildcard.
+    if (opts.dashboard) {
+        const uiHost = isLoopback(bindHost) || bindHost === '0.0.0.0' ? 'localhost' : bindHost;
+        const scheme = tls ? 'https' : 'http';
+        const url = `${scheme}://${uiHost}:${port}/${token ? `?token=${token}` : ''}`;
+        console.log(chalk.bold(`  dashboard: ${chalk.cyan(url)}`));
+        if (opts.schedulerUrl)
+            console.log(chalk.dim(`    scheduler linked: ${opts.schedulerUrl} (sessions + telemetry tabs live)`));
+        if (!token)
+            console.log(chalk.dim('    (no token — anyone who can reach this port can control the fleet; add --token to lock it)'));
+        console.log();
+    }
     // Connect to seeds. Satellites auto-source shared config from any hub/relay
     // they connect to (handled inside federation.connect()).
     for (const url of seeds) {

package/dist/kernel/federation/federation.d.ts

@@ -63,19 +63,28 @@ export interface FederationOptions {
     /** Coder profiles + rotation config (from node config `coder`). Merged over
      *  built-in defaults, so the mesh rotates across backends out of the box. */
     coder?: Parameters<typeof loadCoderConfig>[0];
-    /** Publish this node's shared config to the fleet (backs POST /fed/apply). */
+    /** Serve the web control dashboard at GET / and /ui (off unless enabled). */
+    dashboard?: boolean;
+    /** Publish this node's shared config to the fleet (backs POST /fed/apply +
+     *  the dashboard's "Apply config to fleet" button). */
     onApply?: () => Promise<unknown> | unknown;
-    /** Gate remote slash-commands. Returns {ok:false,reason} to reject — used to
-     *  keep an unauthenticated, network-exposed node read-only. */
+    /** Gate remote/dashboard slash-commands. Returns {ok:false,reason} to reject —
+     *  used to keep an unauthenticated, network-exposed node read-only. */
     commandGate?: (input: string) => {
         ok: boolean;
         reason?: string;
     };
-    /** TLS material — when set, the mesh is served over HTTPS. */
+    /** TLS material — when set, the node + dashboard are served over HTTPS. */
     tls?: {
         cert: Buffer;
         key: Buffer;
     };
+    /** RoboPark scheduler base URL — proxied under /robopark/* for the dashboard. */
+    schedulerUrl?: string;
+    /** Bearer token presented to the scheduler on proxied requests. */
+    schedulerToken?: string;
+    /** Refuse write actions through the scheduler proxy (read-only console). */
+    schedulerReadOnly?: boolean;
 }
 /** Consolidated fleet view served at GET /fed/status. */
 export interface FleetStatus {
@@ -89,9 +98,11 @@ export interface FleetStatus {
         peerId: string;
         f: StreamFrame;
     }>;
-    /** Console capabilities: whether control writes are allowed on this node. */
+    /** Console capabilities for the dashboard: whether control writes are allowed
+     *  on this node and whether a RoboPark scheduler is linked. */
     control: {
         readonly: boolean;
+        schedulerLinked: boolean;
     };
     ts: number;
 }

package/dist/kernel/federation/federation.js

@@ -1,4 +1,5 @@
 import { MeshServer, MeshClient } from './transport-http.js';
+import { DASHBOARD_HTML } from './dashboard-html.js';
 import { PeerMesh } from './peer-mesh.js';
 import { EventBridge } from './event-bridge.js';
 import { ConfigSync } from './config-sync.js';
@@ -88,7 +89,11 @@ export class Federation {
             runCommand: (input) => this.deps.kernel.command(input),
             commandGate: options.commandGate,
             onApply: options.onApply,
+            dashboardHtml: options.dashboard ? DASHBOARD_HTML : undefined,
             tls: options.tls,
+            schedulerUrl: options.schedulerUrl,
+            schedulerToken: options.schedulerToken,
+            schedulerReadOnly: options.schedulerReadOnly,
             onRpc: (env, remote) => this.onRpc(env, remote),
         });
         await this.server.start();
@@ -689,7 +694,8 @@ export class Federation {
             agents: this.localAgents(),
             activity: this.recentFrames(60),
             control: {
-                readonly: Boolean(this.deps.options.commandGate && !this.deps.options.commandGate('/status').ok),
+                readonly: Boolean(this.deps.options.schedulerReadOnly),
+                schedulerLinked: Boolean(this.deps.options.schedulerUrl),
             },
             ts: Date.now(),
         };

package/dist/kernel/federation/transport-http.d.ts

@@ -23,11 +23,23 @@ export interface MeshServerOptions {
     };
     /** Optional: publish this node's shared config to the fleet (POST /fed/apply). */
     onApply?: () => Promise<unknown> | unknown;
+    /** Optional: static HTML for the control dashboard, served at GET / and /ui. */
+    dashboardHtml?: string;
     /** Optional TLS — when set, the node serves HTTPS/WSS instead of plain HTTP. */
     tls?: {
         cert: Buffer;
         key: Buffer;
     };
+    /** Optional: base URL of the RoboPark scheduler. When set, the node proxies
+     *  GET/POST /robopark/* to it so the dashboard can show sessions + telemetry
+     *  (product data) alongside the mesh. */
+    schedulerUrl?: string;
+    /** Optional bearer token to present to the scheduler on proxied requests. */
+    schedulerToken?: string;
+    /** When true, only GET/HEAD are proxied to the scheduler — write actions
+     *  (end-session, production_mode toggle, trigger) are refused. Set for a
+     *  network-exposed, tokenless node so the operator console stays read-only. */
+    schedulerReadOnly?: boolean;
     onRpc: RpcHandler;
     logger: Logger;
 }
@@ -39,6 +51,8 @@ export declare class MeshServer {
     constructor(opts: MeshServerOptions);
     get streamCount(): number;
     start(): Promise<void>;
+    /** Proxy a dashboard request to the RoboPark scheduler (product data). */
+    private proxyToScheduler;
     /** Push a frame to every connected stream subscriber. */
     broadcast(frame: StreamFrame): void;
     /** Token presented on a request — Bearer header (peers/CLI) OR ?token= query

package/dist/kernel/federation/transport-http.js

@@ -16,7 +16,28 @@
 import { createServer } from 'node:http';
 import { createServer as createHttpsServer } from 'node:https';
 import { timingSafeEqual } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { frameToSSE, parseSSE } from './protocol.js';
+/** Read the livekit-client UMD bundle from the installed dependency, once.
+ *  Returns null (cached) if the package isn't present — the dashboard then
+ *  falls back to an idle camera panel instead of erroring. */
+let _lkUmd;
+function loadLiveKitUmd() {
+    if (_lkUmd !== undefined)
+        return _lkUmd;
+    try {
+        const require = createRequire(import.meta.url);
+        // The package's exports map blocks deep subpaths, but its main/require entry
+        // IS the UMD bundle — so a bare resolve returns dist/livekit-client.umd.js.
+        const file = require.resolve('livekit-client');
+        _lkUmd = readFileSync(file, 'utf8');
+    }
+    catch {
+        _lkUmd = null;
+    }
+    return _lkUmd;
+}
 /** Constant-time string compare — avoids leaking the token via response timing. */
 function safeEqual(a, b) {
     const ab = Buffer.from(a);
@@ -51,6 +72,32 @@ export class MeshServer {
         const scheme = this.opts.tls ? 'https' : 'http';
         this.opts.logger.info(`[federation] mesh listening on ${scheme}://${this.opts.host ?? '0.0.0.0'}:${this.opts.port}`);
     }
+    /** Proxy a dashboard request to the RoboPark scheduler (product data). */
+    proxyToScheduler(req, res, path) {
+        const base = this.opts.schedulerUrl.replace(/\/+$/, '');
+        // strip the /robopark prefix; forward the rest (incl. query) to the scheduler
+        const rest = path.replace(/^\/robopark/, '') || '/';
+        const target = `${base}${rest}`;
+        this.readBody(req)
+            .then(async (body) => {
+            const headers = { 'content-type': req.headers['content-type'] ?? 'application/json' };
+            if (this.opts.schedulerToken)
+                headers['authorization'] = `Bearer ${this.opts.schedulerToken}`;
+            const upstream = await fetch(target, {
+                method: req.method,
+                headers,
+                body: req.method === 'GET' || req.method === 'HEAD' ? undefined : body,
+                signal: AbortSignal.timeout(10_000),
+            });
+            const text = await upstream.text();
+            res.writeHead(upstream.status, { 'content-type': upstream.headers.get('content-type') ?? 'application/json' });
+            res.end(text);
+        })
+            .catch(err => {
+            res.writeHead(502, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: `scheduler unreachable: ${err instanceof Error ? err.message : String(err)}` }));
+        });
+    }
     /** Push a frame to every connected stream subscriber. */
     broadcast(frame) {
         if (this.sse.size === 0)
@@ -94,10 +141,29 @@ export class MeshServer {
             return;
         }
         const remote = req.socket.remoteAddress ?? 'unknown';
-        // Mesh root: redirect to /fed/status so browsers and probes get useful data.
+        // Control dashboard (single self-contained page). Same-origin fetches carry
+        // the ?token= through, so no CORS is opened.
         if (req.method === 'GET' && (path === '/' || path === '/ui' || path === '/dashboard')) {
-            res.writeHead(302, { location: '/fed/status' });
-            res.end();
+            if (!this.opts.dashboardHtml) {
+                res.writeHead(404).end('dashboard not enabled (start with --dashboard)');
+                return;
+            }
+            res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+            res.end(this.opts.dashboardHtml);
+            return;
+        }
+        // LiveKit browser SDK, served from the installed dependency so the Park
+        // tab can subscribe to a robot's live camera track. Loaded by the dashboard
+        // with the ?token= appended (so it passes the auth gate above). Optional:
+        // if livekit-client isn't installed, the dashboard just shows an idle cam.
+        if (req.method === 'GET' && path === '/vendor/livekit-client.umd.js') {
+            const js = loadLiveKitUmd();
+            if (!js) {
+                res.writeHead(404).end('livekit-client not installed');
+                return;
+            }
+            res.writeHead(200, { 'content-type': 'application/javascript; charset=utf-8', 'cache-control': 'public, max-age=86400' });
+            res.end(js);
             return;
         }
         if (req.method === 'GET' && path === '/fed/status') {
@@ -105,6 +171,25 @@ export class MeshServer {
             res.end(JSON.stringify(this.opts.getStatus?.() ?? {}));
             return;
         }
+        // RoboPark product data (sessions, telemetry, robots) — proxied to the
+        // scheduler so the dashboard is one pane of glass. Already token-gated above.
+        if (path.startsWith('/robopark/')) {
+            if (!this.opts.schedulerUrl) {
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, disabled: true, error: 'no scheduler linked — start with --scheduler-url' }));
+                return;
+            }
+            // Keep a network-exposed, tokenless node read-only: mesh writes are gated
+            // by commandGate; the scheduler proxy is the product-side equivalent.
+            const method = (req.method ?? 'GET').toUpperCase();
+            if (this.opts.schedulerReadOnly && method !== 'GET' && method !== 'HEAD') {
+                res.writeHead(403, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, readonly: true, error: 'this node is network-exposed without a token — control actions are disabled. Restart with --token <secret> to enable them.' }));
+                return;
+            }
+            this.proxyToScheduler(req, res, path);
+            return;
+        }
         if (req.method === 'POST' && path.startsWith('/fed/apply')) {
             if (!this.opts.onApply) {
                 res.writeHead(404).end('no apply handler');

package/dist/robopark/setup.js

@@ -88,12 +88,15 @@ async function setupHub(config, opts, internal) {
         lan: true,
     };
     config.set('federation', fed);
+    const schedulerPort = opts.schedulerPort ? parseInt(opts.schedulerPort, 10) : DEFAULT_SCHEDULER_PORT;
     const infinicodeArgs = [
         'serve', '--hub',
         '--name', internal.name,
         '--port', String(internal.port),
         '--token', internal.token,
         '--lan',
+        '--dashboard',
+        `--scheduler-url`, `http://127.0.0.1:${schedulerPort}`,
         '--auto-update',
         '--supervised',
     ];
@@ -101,7 +104,6 @@ async function setupHub(config, opts, internal) {
         infinicodeArgs.push('--gateway', internal.gatewayHost);
     if (internal.gatewayToken)
         infinicodeArgs.push('--gateway-token', internal.gatewayToken);
-    const schedulerPort = opts.schedulerPort ? parseInt(opts.schedulerPort, 10) : DEFAULT_SCHEDULER_PORT;
     console.log(chalk.dim('  hub commands:'));
     console.log('  ' + chalk.cyan(`infinicode ${infinicodeArgs.join(' ')}`));
     console.log('  ' + chalk.cyan(`robopark serve --port ${schedulerPort}`));

package/dist/robopark-cli.js

@@ -17,7 +17,7 @@ const config = new Conf({
 });
 const program = new Command('robopark')
     .description('RoboPark fleet control CLI — set up, watch, and drive talking robots')
-    .version('2.8.4');
+    .version('2.8.6');
 program
     .command('scan')
     .description('Auto-discover the fleet and print ready-to-run setup commands')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.4",
+  "version": "2.8.6",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/scheduler/main.py

@@ -276,19 +276,9 @@ async def init_db():
                 pass  # column already present
         await db.commit()
 
-        # Insert default robots if not exist
-        default_robots = [
-            ("robopanda", "RoboPanda", "panda-character"),
-            ("robobear", "RoboBear", "bear-character"),
-            ("robocar", "RoboCar", "car-character"),
-            ("robodragon", "RoboDragon", "dragon-character"),
-            ("robofrog", "RoboFrog", "frog-character"),
-        ]
-        for robot_id, name, char_id in default_robots:
-            await db.execute(
-                "INSERT OR IGNORE INTO robots (id, name, character_id) VALUES (?, ?, ?)",
-                (robot_id, name, char_id)
-            )
+        # No demo robots are seeded. Actual robots enroll via the device
+        # enrollment API or are added through the scheduler UI. This keeps the
+        # fleet view honest — only real connected hardware appears.
         await db.commit()
 
         # Seed default enrollment token + production_mode flag (only on first run)