infinicode 2.7.0 → 2.8.0

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

@@ -63,28 +63,19 @@ 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];
-    /** 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). */
+    /** Publish this node's shared config to the fleet (backs POST /fed/apply). */
     onApply?: () => Promise<unknown> | unknown;
-    /** Gate remote/dashboard slash-commands. Returns {ok:false,reason} to reject —
-     *  used to keep an unauthenticated, network-exposed node read-only. */
+    /** Gate remote 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 node + dashboard are served over HTTPS. */
+    /** TLS material — when set, the mesh is 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 {
@@ -98,11 +89,9 @@ export interface FleetStatus {
         peerId: string;
         f: StreamFrame;
     }>;
-    /** Console capabilities for the dashboard: whether control writes are allowed
-     *  on this node and whether a RoboPark scheduler is linked. */
+    /** Console capabilities: whether control writes are allowed on this node. */
     control: {
         readonly: boolean;
-        schedulerLinked: boolean;
     };
     ts: number;
 }

package/dist/kernel/federation/federation.js

@@ -1,5 +1,4 @@
 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';
@@ -89,11 +88,7 @@ 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();
@@ -694,8 +689,7 @@ export class Federation {
             agents: this.localAgents(),
             activity: this.recentFrames(60),
             control: {
-                readonly: Boolean(this.deps.options.schedulerReadOnly),
-                schedulerLinked: Boolean(this.deps.options.schedulerUrl),
+                readonly: Boolean(this.deps.options.commandGate && !this.deps.options.commandGate('/status').ok),
             },
             ts: Date.now(),
         };

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

@@ -23,23 +23,11 @@ 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;
 }
@@ -51,8 +39,6 @@ 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,28 +16,7 @@
 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);
@@ -72,32 +51,6 @@ 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)
@@ -141,29 +94,10 @@ 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.
+        // Mesh root: redirect to /fed/status so browsers and probes get useful data.
         if (req.method === 'GET' && (path === '/' || path === '/ui' || path === '/dashboard')) {
-            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);
+            res.writeHead(302, { location: '/fed/status' });
+            res.end();
             return;
         }
         if (req.method === 'GET' && path === '/fed/status') {
@@ -171,25 +105,6 @@ 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/auto-start.d.ts

@@ -0,0 +1,16 @@
+export interface ServiceArgs {
+    role: 'hub' | 'robot' | 'control' | 'hub-scheduler';
+    name: string;
+    command: string;
+    args: string[];
+    workingDir?: string;
+    env?: Record<string, string>;
+}
+export declare function registerAutoStart(service: ServiceArgs): Promise<{
+    ok: boolean;
+    message: string;
+}>;
+export declare function unregisterAutoStart(role: string, name: string): {
+    ok: boolean;
+    message: string;
+};

package/dist/robopark/auto-start.js

@@ -0,0 +1,142 @@
+/**
+ * RoboPark — auto-start registration for production machines.
+ *
+ * Registers the RoboPark service to start on boot:
+ *   - Windows → Task Scheduler
+ *   - Linux   → systemd
+ *   - macOS   → launchd
+ *
+ * This is used by `robopark setup --auto-start`.
+ */
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawn } from 'node:child_process';
+function shellQuote(s) {
+    if (!/[^a-zA-Z0-9_./:=,-]/.test(s))
+        return s;
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+export async function registerAutoStart(service) {
+    const platform = process.platform;
+    if (platform === 'win32')
+        return registerWindows(service);
+    if (platform === 'linux')
+        return registerSystemd(service);
+    if (platform === 'darwin')
+        return registerLaunchd(service);
+    return { ok: false, message: `auto-start not supported on ${platform}` };
+}
+async function registerWindows(service) {
+    const taskName = `RoboPark-${service.role}-${service.name}`;
+    const logDir = join(homedir(), 'AppData', 'Roaming', 'robopark', 'logs');
+    mkdirSync(logDir, { recursive: true });
+    const outLog = join(logDir, `${taskName}.log`);
+    const errLog = join(logDir, `${taskName}.err.log`);
+    const script = [service.command, ...service.args].map(shellQuote).join(' ');
+    const cmd = ['powershell.exe', '-WindowStyle', 'Hidden', '-ExecutionPolicy', 'Bypass', '-Command', script];
+    const xmlPath = join(homedir(), 'AppData', 'Roaming', 'robopark', `${taskName}.xml`);
+    mkdirSync(dirname(xmlPath), { recursive: true });
+    const xml = `<?xml version="1.0" encoding="UTF-16"?>\n<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">\n  <RegistrationInfo>\n    <Description>RoboPark ${service.role} for ${service.name}</Description>\n  </RegistrationInfo>\n  <Triggers>\n    <BootTrigger>\n      <Enabled>true</Enabled>\n    </BootTrigger>\n    <LogonTrigger>\n      <Enabled>true</Enabled>\n    </LogonTrigger>\n  </Triggers>\n  <Principals>\n    <Principal id="Author">\n      <LogonType>S4U</LogonType>\n      <RunLevel>HighestAvailable</RunLevel>\n    </Principal>\n  </Principals>\n  <Settings>\n    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>\n    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>\n    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>\n    <StartWhenAvailable>true</StartWhenAvailable>\n    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>\n    <IdleSettings>\n      <StopOnIdleEnd>false</StopOnIdleEnd>\n      <RestartOnIdle>false</RestartOnIdle>\n    </IdleSettings>\n    <AllowStartOnDemand>true</AllowStartOnDemand>\n    <Enabled>true</Enabled>\n    <Hidden>false</Hidden>\n    <RunOnlyIfIdle>false</RunOnlyIfIdle>\n    <DisallowStartOnRemoteAppSession>false</DisallowStartOnRemoteAppSession>\n    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>\n    <WakeToRun>false</WakeToRun>\n    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>\n  </Settings>\n  <Actions Context="Author">\n    <Exec>\n      <Command>${cmd[0]}</Command>\n      <Arguments>${cmd.slice(1).map(a => a.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;')).join(' ')}</Arguments>\n      <WorkingDirectory>${service.workingDir ?? homedir()}</WorkingDirectory>\n    </Exec>\n  </Actions>\n</Task>`;
+    // schtasks /XML requires UTF-16 LE *with* BOM when the XML declares UTF-16.
+    const bom = Buffer.from([0xff, 0xfe]);
+    const body = Buffer.from(xml, 'utf16le');
+    writeFileSync(xmlPath, Buffer.concat([bom, body]));
+    return new Promise((resolve) => {
+        const schtasks = spawn('schtasks', ['/Create', '/TN', taskName, '/XML', xmlPath, '/F'], { stdio: 'pipe' });
+        let out = '';
+        let err = '';
+        schtasks.stdout.on('data', d => (out += d.toString()));
+        schtasks.stderr.on('data', d => (err += d.toString()));
+        schtasks.on('close', code => {
+            if (code === 0) {
+                resolve({ ok: true, message: `registered Windows Task Scheduler task "${taskName}"` });
+            }
+            else {
+                resolve({ ok: false, message: `schtasks failed (${code}): ${err || out}` });
+            }
+        });
+        schtasks.on('error', e => resolve({ ok: false, message: `could not run schtasks: ${e.message}` }));
+    });
+}
+async function registerSystemd(service) {
+    const unitName = `robopark-${service.role}-${service.name.toLowerCase().replace(/[^a-z0-9]+/g, '-')}.service`;
+    const unitPath = `/etc/systemd/system/${unitName}`;
+    const envLines = Object.entries(service.env ?? {})
+        .map(([k, v]) => `Environment="${k}=${v.replace(/"/g, '\\"')}"`)
+        .join('\n');
+    const unit = `[Unit]
+Description=RoboPark ${service.role} for ${service.name}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${service.command} ${service.args.map(shellQuote).join(' ')}
+WorkingDirectory=${service.workingDir ?? '/opt/robopark'}
+Restart=always
+RestartSec=5
+${envLines}
+
+[Install]
+WantedBy=multi-user.target
+`;
+    try {
+        writeFileSync(unitPath, unit, 'utf8');
+        return { ok: true, message: `wrote systemd unit ${unitPath}. Run: systemctl enable --now ${unitName}` };
+    }
+    catch (e) {
+        return { ok: false, message: `could not write ${unitPath}: ${e instanceof Error ? e.message : String(e)}` };
+    }
+}
+async function registerLaunchd(service) {
+    const label = `ai.robopark.${service.role}.${service.name}`;
+    const plistPath = join(homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+    mkdirSync(join(homedir(), 'Library', 'LaunchAgents'), { recursive: true });
+    const env = service.env ?? {};
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${service.command}</string>
+    ${service.args.map(a => `<string>${a.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')}</string>`).join('\n    ')}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${service.workingDir ?? homedir()}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join(homedir(), 'Library', 'Logs', `${label}.log`)}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(homedir(), 'Library', 'Logs', `${label}.err.log`)}</string>
+  ${Object.entries(env).map(([k, v]) => `<key>EnvironmentVariables</key>\n  <dict>\n    <key>${k}</key>\n    <string>${v}</string>\n  </dict>`).join('\n  ')}
+</dict>
+</plist>`;
+    try {
+        writeFileSync(plistPath, plist, 'utf8');
+        return { ok: true, message: `wrote launchd plist ${plistPath}. Run: launchctl load ${plistPath}` };
+    }
+    catch (e) {
+        return { ok: false, message: `could not write ${plistPath}: ${e instanceof Error ? e.message : String(e)}` };
+    }
+}
+export function unregisterAutoStart(role, name) {
+    const platform = process.platform;
+    const taskName = `RoboPark-${role}-${name}`;
+    if (platform === 'win32') {
+        try {
+            spawn('schtasks', ['/Delete', '/TN', taskName, '/F'], { stdio: 'ignore' }).unref();
+            return { ok: true, message: `deleted Windows task "${taskName}"` };
+        }
+        catch (e) {
+            return { ok: false, message: `failed: ${e instanceof Error ? e.message : String(e)}` };
+        }
+    }
+    return { ok: false, message: `unregister not implemented for ${platform}` };
+}

package/dist/robopark/discovery.d.ts

@@ -0,0 +1,62 @@
+export interface DiscoveredPeer {
+    name: string;
+    ip: string;
+    tags?: string[];
+    online: boolean;
+    source: 'tailscale' | 'lan';
+}
+export interface DiscoveredContext {
+    /** Best hub candidate (the on-site box). */
+    hub?: DiscoveredPeer;
+    /** InfiniBot gateway if found on the tailnet. */
+    gateway?: {
+        host: string;
+        port: number;
+        token?: string;
+    };
+    /** Robots discovered on LAN or Tailscale. */
+    robots: DiscoveredPeer[];
+    /** Tailscale auth key if one is cached locally. */
+    tailscaleAuthKey?: string;
+    /** Existing infinicode mesh token if already configured. */
+    meshToken?: string;
+    /** Existing infinicode mesh port. */
+    meshPort?: number;
+    /** This machine's hostname. */
+    localName: string;
+}
+interface TailscalePeer {
+    HostName?: string;
+    DNSName?: string;
+    TailscaleIPs?: string[];
+    Online?: boolean;
+    Tags?: string[];
+}
+interface TailscaleStatus {
+    Self?: TailscalePeer;
+    Peer?: Record<string, TailscalePeer>;
+}
+/** Run `tailscale status --json` and parse. */
+export declare function tailscaleStatus(): Promise<TailscaleStatus | null>;
+/** Discover peers from Tailscale. */
+export declare function discoverTailscale(): Promise<DiscoveredPeer[]>;
+/** Scan LAN UDP beacons on the default mesh discovery port. */
+export declare function discoverLan(port?: number, timeoutMs?: number): Promise<DiscoveredPeer[]>;
+/** Read a Tailscale auth key from common locations. */
+export declare function findTailscaleAuthKey(): string | undefined;
+/** Read InfiniBot gateway config from common locations. */
+export declare function findInfinibotGateway(): {
+    host: string;
+    port: number;
+    token?: string;
+} | undefined;
+/** Read existing infinicode mesh token/port from config. */
+export declare function readInfinicodeFederation(): {
+    token?: string;
+    port?: number;
+};
+/** Build the full discovered context for this environment. */
+export declare function discoverContext(): Promise<DiscoveredContext>;
+/** Generate a random token for mesh auth or scheduler enrollment. */
+export declare function generateToken(length?: number): string;
+export {};

package/dist/robopark/discovery.js

@@ -0,0 +1,144 @@
+/**
+ * RoboPark — auto-discovery helpers.
+ *
+ * Scans the environment so operators never type IPs, URLs, or tokens:
+ *   - Tailscale status → find the RoboPark hub and InfiniBot gateway
+ *   - LAN beacons → find robots
+ *   - Known config files → read Tailscale auth key, InfiniBot gateway token
+ *   - Running infinicode nodes → reuse mesh identity + token
+ */
+import { execa } from 'execa';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { join } from 'node:path';
+const HUB_HINTS = /livekit|hub|scheduler|robopark/i;
+const GATEWAY_HINTS = /infinibot|gateway/i;
+const ROBOT_HINTS = /robo|panda|bear|car|dragon|frog|bmw/i;
+/** Best IPv4-ish address from a Tailscale peer. */
+function ipv4(peer) {
+    return (peer.TailscaleIPs ?? []).find(ip => ip.includes('.'));
+}
+/** Run `tailscale status --json` and parse. */
+export async function tailscaleStatus() {
+    try {
+        const { stdout } = await execa('tailscale', ['status', '--json'], { timeout: 5000 });
+        return JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+/** Discover peers from Tailscale. */
+export async function discoverTailscale() {
+    const status = await tailscaleStatus();
+    if (!status?.Peer)
+        return [];
+    return Object.values(status.Peer)
+        .filter(p => p.Online)
+        .map(p => ({
+        name: p.HostName ?? p.DNSName?.split('.')[0] ?? 'unknown',
+        ip: ipv4(p) ?? 'unknown',
+        tags: p.Tags,
+        online: true,
+        source: 'tailscale',
+    }))
+        .filter(p => p.ip !== 'unknown');
+}
+/** Scan LAN UDP beacons on the default mesh discovery port. */
+export async function discoverLan(port = 47915, timeoutMs = 3000) {
+    // LAN discovery currently relies on the infinicode beacon protocol.
+    // For auto-setup we reuse Tailscale when available; LAN fallback is a TODO
+    // once the beacon protocol is stable enough to parse here.
+    return [];
+}
+/** Read a Tailscale auth key from common locations. */
+export function findTailscaleAuthKey() {
+    const paths = [
+        join(homedir(), '.robopark', 'tailscale.key'),
+        join(homedir(), '.config', 'robopark', 'tailscale.key'),
+        process.env.ROBOPARK_TAILSCALE_KEY ? '__env__' : undefined,
+    ].filter(Boolean);
+    for (const p of paths) {
+        if (p === '__env__')
+            return process.env.ROBOPARK_TAILSCALE_KEY;
+        if (existsSync(p)) {
+            const key = readFileSync(p, 'utf8').trim();
+            if (key.startsWith('tskey-'))
+                return key;
+        }
+    }
+    return undefined;
+}
+/** Read InfiniBot gateway config from common locations. */
+export function findInfinibotGateway() {
+    const candidates = [
+        join(homedir(), '.infinibot', 'config.json'),
+        join(homedir(), '.config', 'infinibot', 'config.json'),
+        join(homedir(), 'AppData', 'Roaming', 'infinibot', 'config.json'),
+    ];
+    for (const p of candidates) {
+        if (!existsSync(p))
+            continue;
+        try {
+            const cfg = JSON.parse(readFileSync(p, 'utf8'));
+            const gateway = cfg.gatewayUrl ?? cfg.gateway ?? cfg.gateway_url;
+            const token = cfg.gatewayToken ?? cfg.gateway_token ?? cfg.token;
+            if (typeof gateway === 'string') {
+                const u = new URL(gateway);
+                return { host: u.hostname, port: parseInt(u.port || '18789', 10), token: typeof token === 'string' ? token : undefined };
+            }
+        }
+        catch {
+            // ignore malformed
+        }
+    }
+    return undefined;
+}
+/** Read existing infinicode mesh token/port from config. */
+export function readInfinicodeFederation() {
+    const paths = [
+        join(homedir(), 'AppData', 'Roaming', 'infinicode-nodejs', 'Config', 'config.json'),
+        join(homedir(), '.config', 'infinicode-nodejs', 'config.json'),
+        join(homedir(), '.infinicode-nodejs', 'config.json'),
+    ];
+    for (const p of paths) {
+        if (!existsSync(p))
+            continue;
+        try {
+            const cfg = JSON.parse(readFileSync(p, 'utf8'));
+            return { token: cfg.federation?.token, port: cfg.federation?.port };
+        }
+        catch {
+            // ignore
+        }
+    }
+    return {};
+}
+/** Build the full discovered context for this environment. */
+export async function discoverContext() {
+    const peers = await discoverTailscale();
+    // Exclude this machine from the fleet tables.
+    const selfName = hostname();
+    const others = peers.filter(p => p.name !== selfName && p.online);
+    const hub = others.find(p => HUB_HINTS.test(p.name));
+    const robots = others.filter(p => ROBOT_HINTS.test(p.name) || p.tags?.some(t => /robopark/i.test(t)));
+    const gateway = findInfinibotGateway();
+    const fed = readInfinicodeFederation();
+    return {
+        hub,
+        gateway,
+        robots,
+        tailscaleAuthKey: findTailscaleAuthKey(),
+        meshToken: fed.token,
+        meshPort: fed.port,
+        localName: hostname(),
+    };
+}
+/** Generate a random token for mesh auth or scheduler enrollment. */
+export function generateToken(length = 32) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let out = '';
+    for (let i = 0; i < length; i++)
+        out += chars[Math.floor(Math.random() * chars.length)];
+    return out;
+}

package/dist/robopark/scan.d.ts

@@ -0,0 +1,10 @@
+interface ScanOptions {
+    /** Write generated install scripts to this directory. */
+    output?: string;
+    /** Include InfiniBot gateway in hub command if found. */
+    gateway?: boolean;
+    /** Mesh auth token to use on all devices. */
+    token?: string;
+}
+export declare function roboparkScan(opts?: ScanOptions): Promise<void>;
+export {};