infinicode 2.8.38 → 2.8.39

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

@@ -53,6 +53,8 @@ export declare class MeshServer {
     start(): Promise<void>;
     /** Proxy a dashboard request to the RoboPark scheduler (product data). */
     private proxyToScheduler;
+    /** Proxy the scheduler's full Control Center and its same-origin assets. */
+    private proxySchedulerPath;
     /** Protected local runtime controls for the RoboPark operator dashboard. */
     private runtimeDocker;
     /** Push a frame to every connected stream subscriber. */

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

@@ -123,6 +123,39 @@ export class MeshServer {
             res.end(JSON.stringify({ ok: false, error: `scheduler unreachable: ${err instanceof Error ? err.message : String(err)}` }));
         });
     }
+    /** Proxy the scheduler's full Control Center and its same-origin assets. */
+    proxySchedulerPath(req, res, path) {
+        const base = this.opts.schedulerUrl.replace(/\/+$/, '');
+        const target = `${base}${path}${req.url?.includes('?') ? req.url.slice(req.url.indexOf('?')) : ''}`;
+        this.readBody(req)
+            .then(async (body) => {
+            const headers = {};
+            if (req.headers['content-type'])
+                headers['content-type'] = req.headers['content-type'];
+            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(15_000),
+            });
+            const responseHeaders = {
+                'content-type': upstream.headers.get('content-type') ?? 'application/octet-stream',
+                'cache-control': upstream.headers.get('cache-control') ?? 'no-store',
+            };
+            const presented = this.presentedToken(req);
+            if (this.opts.token && presented) {
+                responseHeaders['set-cookie'] = `robopark_auth=${encodeURIComponent(presented)}; Path=/; SameSite=Lax`;
+            }
+            res.writeHead(upstream.status, responseHeaders);
+            res.end(await upstream.arrayBuffer());
+        })
+            .catch(err => {
+            res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' });
+            res.end(`scheduler unreachable: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
     /** Protected local runtime controls for the RoboPark operator dashboard. */
     async runtimeDocker(req, res, path) {
         const send = (status, body) => {
@@ -195,6 +228,10 @@ export class MeshServer {
             if (t)
                 return t;
         }
+        const cookie = req.headers.cookie ?? '';
+        const match = cookie.match(/(?:^|;\s*)robopark_auth=([^;]+)/);
+        if (match)
+            return decodeURIComponent(match[1]);
         return undefined;
     }
     authOk(req) {
@@ -215,17 +252,41 @@ export class MeshServer {
             return;
         }
         const remote = req.socket.remoteAddress ?? 'unknown';
-        // Control dashboard (single self-contained page). Same-origin fetches carry
-        // the ?token= through, so no CORS is opened.
+        // The scheduler owns the complete RoboPark Control Center. The mesh page is
+        // retained at /mesh as a diagnostics view, not as the primary operator UI.
         if (req.method === 'GET' && (path === '/' || path === '/ui' || path === '/dashboard')) {
+            if (this.opts.schedulerUrl) {
+                this.proxySchedulerPath(req, res, '/');
+                return;
+            }
             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',
+                ...(this.opts.token && this.presentedToken(req)
+                    ? { 'set-cookie': `robopark_auth=${encodeURIComponent(this.presentedToken(req))}; Path=/; SameSite=Lax` }
+                    : {}),
+            });
+            res.end(this.opts.dashboardHtml);
+            return;
+        }
+        if (req.method === 'GET' && path === '/mesh') {
+            if (!this.opts.dashboardHtml) {
+                res.writeHead(404).end('mesh 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;
         }
+        // Full scheduler dashboard requests are same-origin after the root proxy.
+        if (this.opts.schedulerUrl && (path.startsWith('/api/') || path.startsWith('/static/') || path.startsWith('/vendor/'))) {
+            this.proxySchedulerPath(req, res, path);
+            return;
+        }
         // Static assets bundled with the dashboard (robot concept avatars, etc.).
         if (req.method === 'GET' && path.startsWith('/static/')) {
             const asset = loadStaticAsset(path.slice(8));

package/dist/robopark/serve.d.ts

@@ -5,6 +5,7 @@ export interface ServeOptions {
     gateway?: string;
     gatewayToken?: string;
     gatewayPassword?: string;
+    /** Open the Control Center after the scheduler is reachable. */
     open?: boolean;
     foreground?: boolean;
 }

package/dist/robopark/serve.js

@@ -181,14 +181,19 @@ export async function roboparkServe(opts) {
             catch { /* ignore */ }
         });
         proc.on('exit', () => process.exit(0));
+        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.'));
-        // give the scheduler a moment to bind before printing URL
-        setTimeout(() => process.exit(0), 1200);
+        setTimeout(() => process.exit(0), 100);
     }
 }
 function printUrl(port) {
@@ -205,3 +210,43 @@ export async function schedulerHealthy(url, timeoutMs = 3000) {
         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-cli.js

@@ -94,6 +94,7 @@ program
     .option('--gateway <url>', 'InfiniBot gateway ws:// URL')
     .option('--gateway-token <token>', 'InfiniBot gateway token')
     .option('--gateway-password <pw>', 'InfiniBot gateway password')
+    .option('--no-open', 'do not open the RoboPark Control Center in a browser')
     .option('--foreground', 'stay in foreground; do not detach')
     .action(async (opts) => {
     await roboparkServe(opts);

package/package.json

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