infinicode 2.8.23 → 2.8.25

package/dist/robopark/doctor.js

@@ -0,0 +1,175 @@
+/**
+ * RoboPark — `robopark doctor`.
+ *
+ * A fast, all-in-one health check that replaces the manual curl-by-curl
+ * triage session: hub federation status, scheduler reachability, LiveKit
+ * server registration, device heartbeat freshness, and production mode.
+ *
+ * Usage:
+ *   robopark doctor
+ *   robopark doctor --hub-url http://100.64.1.2:47913 --scheduler-url http://100.64.1.2:8080
+ */
+import chalk from 'chalk';
+import { discoverContext } from './discovery.js';
+async function fetchJson(url, init) {
+    const res = await fetch(url, { ...init, signal: AbortSignal.timeout(5000) });
+    if (!res.ok)
+        throw new Error(`${res.status} ${res.statusText}`);
+    return res.json();
+}
+const STALE_HEARTBEAT_MS = 60_000;
+function parseTimestamp(value) {
+    if (typeof value !== 'string' || !value)
+        return undefined;
+    // Scheduler stores naive UTC timestamps (no trailing 'Z'); normalize so
+    // Date.parse treats them as UTC instead of local time.
+    const iso = /[zZ]|[+-]\d\d:\d\d$/.test(value) ? value : `${value}Z`;
+    const ms = Date.parse(iso);
+    return Number.isNaN(ms) ? undefined : ms;
+}
+export async function roboparkDoctor(opts) {
+    const ctx = await discoverContext();
+    const hubUrl = (opts.hubUrl ?? (ctx.hub ? `http://${ctx.hub.ip}:47913` : 'http://localhost:47913')).replace(/\/$/, '');
+    const schedulerUrl = (opts.schedulerUrl ?? (ctx.hub ? `http://${ctx.hub.ip}:8080` : 'http://localhost:8080')).replace(/\/$/, '');
+    const authHeaders = opts.token ? { Authorization: `Bearer ${opts.token}` } : {};
+    console.log(chalk.bold('\n  robopark doctor'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  hub:       ${chalk.cyan(hubUrl)}`);
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
+    console.log();
+    const checks = [];
+    // 1. Hub /fed/status reachable + connected nodes.
+    try {
+        const status = (await fetchJson(`${hubUrl}/fed/status`, { headers: authHeaders }));
+        const nodes = status.nodes ?? [];
+        const connected = nodes.filter(n => n.connected);
+        checks.push({
+            name: 'hub reachable',
+            status: 'pass',
+            message: `self=${status.self?.displayName ?? '?'} (${status.self?.role ?? '?'})`,
+        });
+        if (nodes.length === 0) {
+            checks.push({ name: 'mesh peers', status: 'warn', message: 'no peers known to this hub', detail: 'Nothing has joined the mesh yet, or this node has not discovered peers.' });
+        }
+        else if (connected.length === 0) {
+            checks.push({ name: 'mesh peers', status: 'fail', message: `${nodes.length} known peer(s), 0 connected`, detail: 'Check Tailscale connectivity and that peer processes are running.' });
+        }
+        else {
+            const list = connected.map(n => `${n.displayName ?? n.nodeId}(${n.role ?? '?'})`).join(', ');
+            checks.push({ name: 'mesh peers', status: 'pass', message: `${connected.length}/${nodes.length} connected — ${list}` });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'hub reachable', status: 'fail', message: `could not reach ${hubUrl}/fed/status: ${e.message}`, detail: 'Is the hub node running? Is it on the same tailnet? Try --hub-url.' });
+    }
+    // 2. Scheduler /api/robots + /api/devices reachable.
+    let robots = [];
+    let devices = [];
+    try {
+        robots = (await fetchJson(`${schedulerUrl}/api/robots`));
+        checks.push({ name: 'scheduler /api/robots', status: 'pass', message: `${robots.length} robot(s)` });
+    }
+    catch (e) {
+        checks.push({ name: 'scheduler /api/robots', status: 'fail', message: `error: ${e.message}`, detail: 'Is robopark serve running? Check --scheduler-url.' });
+    }
+    try {
+        devices = (await fetchJson(`${schedulerUrl}/api/devices`));
+        checks.push({ name: 'scheduler /api/devices', status: 'pass', message: `${devices.length} device(s)` });
+    }
+    catch (e) {
+        checks.push({ name: 'scheduler /api/devices', status: 'fail', message: `error: ${e.message}` });
+    }
+    // 3. LiveKit servers registered + online.
+    try {
+        const servers = (await fetchJson(`${schedulerUrl}/api/servers`));
+        if (servers.length === 0) {
+            checks.push({ name: 'livekit servers', status: 'fail', message: 'no servers in scheduler', detail: 'Add one via the dashboard or robopark setup-livekit.' });
+        }
+        else {
+            for (const s of servers) {
+                const label = s.name ?? s.id;
+                if (!s.url) {
+                    checks.push({ name: `server ${label}`, status: 'fail', message: 'no url configured' });
+                }
+                else if (s.status === 'online') {
+                    checks.push({ name: `server ${label}`, status: 'pass', message: `online @ ${s.url}` });
+                }
+                else if (s.status === 'offline') {
+                    checks.push({ name: `server ${label}`, status: 'fail', message: `offline @ ${s.url}`, detail: 'Check that the LiveKit container/process is running and reachable.' });
+                }
+                else {
+                    checks.push({ name: `server ${label}`, status: 'warn', message: `status=${s.status ?? 'unknown'} @ ${s.url}` });
+                }
+            }
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'livekit servers', status: 'fail', message: `error: ${e.message}` });
+    }
+    // 4. Stale device heartbeats.
+    const now = Date.now();
+    const staleDevices = devices.filter(d => {
+        const hb = parseTimestamp(d.last_heartbeat);
+        return hb !== undefined && now - hb > STALE_HEARTBEAT_MS;
+    });
+    const noHeartbeatDevices = devices.filter(d => parseTimestamp(d.last_heartbeat) === undefined);
+    if (devices.length === 0) {
+        // covered by the /api/devices check above
+    }
+    else if (staleDevices.length === 0 && noHeartbeatDevices.length === 0) {
+        checks.push({ name: 'device heartbeats', status: 'pass', message: `all ${devices.length} device(s) heartbeating within ${STALE_HEARTBEAT_MS / 1000}s` });
+    }
+    else {
+        const parts = [];
+        if (staleDevices.length)
+            parts.push(`${staleDevices.length} stale: ${staleDevices.map(d => d.name ?? d.id).join(', ')}`);
+        if (noHeartbeatDevices.length)
+            parts.push(`${noHeartbeatDevices.length} never heartbeat: ${noHeartbeatDevices.map(d => d.name ?? d.id).join(', ')}`);
+        checks.push({ name: 'device heartbeats', status: 'warn', message: parts.join('; '), detail: 'Is robopark preview-agent (or the device process) running on those machines?' });
+    }
+    // 5. Production mode.
+    try {
+        const settings = (await fetchJson(`${schedulerUrl}/api/settings`));
+        if (settings.production_mode) {
+            checks.push({ name: 'production mode', status: 'pass', message: 'ON' });
+        }
+        else {
+            checks.push({ name: 'production mode', status: 'warn', message: 'OFF', detail: 'New device enrollment and preview sessions are blocked until production mode is ON (toggle in the dashboard or PUT /api/settings).' });
+        }
+        if (settings.default_enrollment_token_set === false) {
+            checks.push({ name: 'enrollment token', status: 'warn', message: 'no default enrollment token set', detail: 'Rotate one via POST /api/settings/enrollment-token/rotate before enrolling new devices.' });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'production mode', status: 'fail', message: `error: ${e.message}` });
+    }
+    // Print report.
+    let pass = 0;
+    let warn = 0;
+    let fail = 0;
+    for (const c of checks) {
+        const icon = c.status === 'pass' ? chalk.green('✓') : c.status === 'warn' ? chalk.yellow('⚠') : chalk.red('✗');
+        const color = c.status === 'pass' ? chalk.green : c.status === 'warn' ? chalk.yellow : chalk.red;
+        console.log(`  ${icon} ${color(c.name)} — ${c.message}`);
+        if (c.detail)
+            console.log(chalk.dim(`    → ${c.detail}`));
+        if (c.status === 'pass')
+            pass++;
+        else if (c.status === 'warn')
+            warn++;
+        else
+            fail++;
+    }
+    console.log();
+    const total = checks.length;
+    if (fail === 0 && warn === 0) {
+        console.log(chalk.bold.green(`  ${pass}/${total} checks passed — fleet is healthy.`));
+    }
+    else if (fail === 0) {
+        console.log(chalk.bold.yellow(`  ${pass}/${total} passed, ${warn} warning(s) — review the items above.`));
+    }
+    else {
+        console.log(chalk.bold.red(`  ${pass}/${total} passed, ${warn} warning(s), ${fail} failed — fix the items above.`));
+        process.exitCode = 1;
+    }
+}

package/dist/robopark/llm-set.d.ts

@@ -0,0 +1,8 @@
+export interface LlmSetOptions {
+    envPath: string;
+    provider: string;
+    model?: string;
+    host?: string;
+    apiKey?: string;
+}
+export declare function roboparkLlmSet(opts: LlmSetOptions): Promise<void>;

package/dist/robopark/llm-set.js

@@ -0,0 +1,87 @@
+/**
+ * RoboPark — `robopark llm set`.
+ *
+ * Upserts LLM provider config into a ROBOVOICE .env file. ROBOVOICE lives in
+ * a separate repo, so the target .env path is always explicit (--env-path) —
+ * this command never guesses or writes infinicode's own config.
+ *
+ * Known keys (from ROBOVOICE's .env.example and src/caal/settings.py /
+ * src/caal/webhooks.py, which read OLLAMA_HOST and OLLAMA_MODEL):
+ *   LLM_PROVIDER   — "ollama" | "groq" (and whatever else ROBOVOICE adds)
+ *   OLLAMA_HOST    — Ollama server URL (only meaningful for ollama providers)
+ *   OLLAMA_MODEL   — Ollama model name (only meaningful for ollama providers)
+ *   OLLAMA_API_KEY — NOT currently read by ROBOVOICE. src/caal/llm/providers/
+ *                    ollama_provider.py constructs `ollama.Client(host=base_url)`
+ *                    with no api_key/auth support, and no OLLAMA_API_KEY lookup
+ *                    exists anywhere in src/caal. We still write the key (for
+ *                    forward-compat with Ollama Cloud, which needs an API key)
+ *                    but it is a no-op until ROBOVOICE's ollama_provider.py is
+ *                    updated to read it — see the gap noted in the CLI output.
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+/** true for any provider name that talks to an Ollama-compatible server. */
+function isOllamaProvider(provider) {
+    return provider === 'ollama' || provider === 'ollama-cloud';
+}
+/** Mask a secret so only the first/last 4 chars are visible, e.g. `abcd…wxyz`. */
+function maskSecret(value) {
+    if (value.length <= 8)
+        return '*'.repeat(value.length);
+    return `${value.slice(0, 4)}…${value.slice(-4)}`;
+}
+/** Replace an existing `KEY=...` line, or append a new one if absent. */
+function upsertEnvVar(lines, key, value) {
+    const pattern = new RegExp(`^${key}=`);
+    const idx = lines.findIndex(line => pattern.test(line));
+    const entry = `${key}=${value}`;
+    if (idx >= 0) {
+        lines[idx] = entry;
+        return lines;
+    }
+    return [...lines, entry];
+}
+export async function roboparkLlmSet(opts) {
+    if (!opts.envPath) {
+        console.log(chalk.red('  ✗ --env-path is required (points at the target ROBOVOICE .env file)'));
+        process.exit(1);
+    }
+    if (!existsSync(opts.envPath)) {
+        console.log(chalk.red(`  ✗ .env file not found: ${opts.envPath}`));
+        process.exit(1);
+    }
+    if (!opts.provider) {
+        console.log(chalk.red('  ✗ --provider is required (e.g. ollama, ollama-cloud, groq)'));
+        process.exit(1);
+    }
+    const raw = readFileSync(opts.envPath, 'utf8');
+    const hadTrailingNewline = raw.endsWith('\n');
+    let lines = raw.split('\n');
+    // Drop a single trailing empty entry produced by the final newline so we
+    // don't accumulate blank lines across repeated `llm set` runs.
+    if (hadTrailingNewline && lines[lines.length - 1] === '')
+        lines = lines.slice(0, -1);
+    lines = upsertEnvVar(lines, 'LLM_PROVIDER', opts.provider);
+    const ollama = isOllamaProvider(opts.provider);
+    if (ollama && opts.host)
+        lines = upsertEnvVar(lines, 'OLLAMA_HOST', opts.host);
+    if (ollama && opts.model)
+        lines = upsertEnvVar(lines, 'OLLAMA_MODEL', opts.model);
+    if (ollama && opts.apiKey)
+        lines = upsertEnvVar(lines, 'OLLAMA_API_KEY', opts.apiKey);
+    writeFileSync(opts.envPath, lines.join('\n') + (hadTrailingNewline ? '\n' : ''), 'utf8');
+    console.log(chalk.bold('\n  robopark llm set'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  file:     ${chalk.cyan(opts.envPath)}`);
+    console.log(`  provider: ${chalk.yellow(opts.provider)}`);
+    if (ollama && opts.host)
+        console.log(`  host:     ${chalk.cyan(opts.host)}`);
+    if (ollama && opts.model)
+        console.log(`  model:    ${chalk.cyan(opts.model)}`);
+    if (ollama && opts.apiKey) {
+        console.log(`  api key:  ${chalk.cyan(maskSecret(opts.apiKey))} ${chalk.dim('(masked)')}`);
+        console.log(chalk.yellow('  ⚠ note: ROBOVOICE\'s ollama_provider.py does not read OLLAMA_API_KEY yet —'));
+        console.log(chalk.yellow('    this value is written for forward-compat but is currently unused.'));
+    }
+    console.log(chalk.green('\n  ✓ .env updated\n'));
+}

package/dist/robopark/profile.d.ts

@@ -0,0 +1,40 @@
+import { type DiscoveredContext } from './discovery.js';
+export interface HubProfile {
+    hubUrl?: string;
+    token?: string;
+    schedulerUrl?: string;
+    site?: string;
+}
+/** Persist a hub profile to ~/.robopark/hub-profile.json. */
+export declare function saveHubProfile(profile: HubProfile): void;
+/** Load the saved hub profile, or null if none has been saved. */
+export declare function loadHubProfile(): HubProfile | null;
+/** Delete the saved hub profile, if any. */
+export declare function clearHubProfile(): void;
+/** Flags a caller may pass explicitly on the command line. */
+export interface ExplicitContextOpts {
+    hubUrl?: string;
+    token?: string;
+    schedulerUrl?: string;
+    site?: string;
+}
+/** Resolved context: explicit opts > saved hub profile > auto-discovery. */
+export interface ResolvedContext {
+    hubUrl?: string;
+    token?: string;
+    schedulerUrl?: string;
+    site?: string;
+    /** The full auto-discovery result, for callers (like setup.ts) that need
+     *  more than the four flattened fields above (e.g. ctx.gateway, ctx.robots). */
+    discovered: DiscoveredContext;
+}
+/**
+ * Resolve hub/scheduler/token/site context with the standard precedence:
+ * explicit CLI flags win, then the saved hub profile, then discoverContext()
+ * auto-discovery as the final fallback.
+ *
+ * Kept as a separate wrapper (rather than changing discoverContext()'s
+ * signature/behavior) so every existing discoverContext() caller keeps
+ * working unchanged when no profile has been saved.
+ */
+export declare function resolveContext(opts?: ExplicitContextOpts): Promise<ResolvedContext>;

package/dist/robopark/profile.js

@@ -0,0 +1,69 @@
+/**
+ * RoboPark — persisted hub profile.
+ *
+ * Operators kept hand-typing the same --hub-url/--token/--scheduler-url/--site
+ * flags on every command. `robopark hub-use` (see robopark-cli.ts) saves those
+ * once to ~/.robopark/hub-profile.json; `resolveContext()` here is the single
+ * place that layers them back in as defaults so every command benefits without
+ * having to re-implement the precedence logic itself.
+ *
+ * Precedence (highest wins): explicit CLI flags > saved hub profile > existing
+ * discoverContext() auto-discovery (Tailscale/LAN/local config files).
+ */
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { discoverContext } from './discovery.js';
+const PROFILE_DIR = join(homedir(), '.robopark');
+const PROFILE_PATH = join(PROFILE_DIR, 'hub-profile.json');
+/** Persist a hub profile to ~/.robopark/hub-profile.json. */
+export function saveHubProfile(profile) {
+    mkdirSync(PROFILE_DIR, { recursive: true });
+    writeFileSync(PROFILE_PATH, JSON.stringify(profile, null, 2), 'utf8');
+}
+/** Load the saved hub profile, or null if none has been saved. */
+export function loadHubProfile() {
+    if (!existsSync(PROFILE_PATH))
+        return null;
+    try {
+        return JSON.parse(readFileSync(PROFILE_PATH, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Delete the saved hub profile, if any. */
+export function clearHubProfile() {
+    if (existsSync(PROFILE_PATH)) {
+        try {
+            rmSync(PROFILE_PATH);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+const DEFAULT_MESH_PORT = 47913;
+const DEFAULT_SCHEDULER_PORT = 8080;
+/**
+ * Resolve hub/scheduler/token/site context with the standard precedence:
+ * explicit CLI flags win, then the saved hub profile, then discoverContext()
+ * auto-discovery as the final fallback.
+ *
+ * Kept as a separate wrapper (rather than changing discoverContext()'s
+ * signature/behavior) so every existing discoverContext() caller keeps
+ * working unchanged when no profile has been saved.
+ */
+export async function resolveContext(opts = {}) {
+    const discovered = await discoverContext();
+    const profile = loadHubProfile();
+    const hubUrl = opts.hubUrl
+        ?? profile?.hubUrl
+        ?? (discovered.hub ? `http://${discovered.hub.ip}:${discovered.meshPort ?? DEFAULT_MESH_PORT}` : undefined);
+    const token = opts.token ?? profile?.token ?? discovered.meshToken;
+    const schedulerUrl = opts.schedulerUrl
+        ?? profile?.schedulerUrl
+        ?? (hubUrl ? hubUrl.replace(/:\d+$/, `:${DEFAULT_SCHEDULER_PORT}`) : undefined);
+    const site = opts.site ?? profile?.site;
+    return { hubUrl, token, schedulerUrl, site, discovered };
+}

package/dist/robopark/server-add.d.ts

@@ -0,0 +1,13 @@
+export interface ServerAddOptions {
+    hubUrl?: string;
+    schedulerUrl?: string;
+    token?: string;
+    id: string;
+    name?: string;
+    url: string;
+    webhookUrl?: string;
+    apiKey?: string;
+    apiSecret?: string;
+    maxSessions?: string;
+}
+export declare function roboparkServerAdd(opts: ServerAddOptions): Promise<void>;

package/dist/robopark/server-add.js

@@ -0,0 +1,114 @@
+/**
+ * RoboPark — `robopark server add`.
+ *
+ * Registers a LiveKit server with the RoboPark scheduler via
+ * `POST /api/servers`, wrapping the curl call operators previously had to
+ * hand-type.
+ *
+ * Usage:
+ *   robopark server add --id livekit-hub-docker --url ws://100.x.y.z:7880
+ *   robopark server add --id livekit-hub-docker --url ws://100.x.y.z:7880 \
+ *     --api-key devkey --api-secret secret --scheduler-url http://100.x.y.z:8080
+ *
+ * If --scheduler-url is omitted, it is derived from --hub-url (or discovery)
+ * the same way `robopark setup-livekit` does: hub host on port 8080.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { discoverContext } from './discovery.js';
+const DEFAULT_SCHEDULER_PORT = 8080;
+const DEV_API_KEY = 'devkey';
+const DEV_API_SECRET = 'secret';
+function loadMeshToken() {
+    const paths = [
+        join(homedir(), '.robopark', 'mesh.token'),
+        join(homedir(), '.config', 'infinicode-nodejs', 'config.json'),
+        join(homedir(), '.infinicode-nodejs', 'config.json'),
+        join(homedir(), 'AppData', 'Roaming', 'infinicode-nodejs', 'Config', 'config.json'),
+    ];
+    for (const p of paths) {
+        if (!existsSync(p))
+            continue;
+        try {
+            if (p.endsWith('mesh.token'))
+                return readFileSync(p, 'utf8').trim();
+            const cfg = JSON.parse(readFileSync(p, 'utf8'));
+            if (cfg.federation?.token)
+                return cfg.federation.token;
+        }
+        catch { /* ignore */ }
+    }
+    return process.env.ROBOPARK_MESH_TOKEN;
+}
+async function postServer(schedulerUrl, body) {
+    const url = `${schedulerUrl.replace(/\/$/, '')}/api/servers`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`${res.status}: ${text || res.statusText}`);
+    }
+}
+export async function roboparkServerAdd(opts) {
+    const ctx = await discoverContext();
+    const hubUrl = opts.hubUrl ?? (ctx.hub ? `http://${ctx.hub.ip}:${ctx.meshPort ?? 47913}` : undefined);
+    // Kept for parity with setup-livekit's discovery flow, even though the
+    // scheduler's /api/servers endpoint itself is unauthenticated today.
+    void (opts.token ?? ctx.meshToken ?? loadMeshToken());
+    const schedulerUrl = opts.schedulerUrl ?? (hubUrl ? hubUrl.replace(/:\d+$/, `:${DEFAULT_SCHEDULER_PORT}`) : undefined);
+    console.log(chalk.bold('\n  robopark server add'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    if (!schedulerUrl) {
+        console.log(chalk.red('  ✗ no scheduler URL. Pass --scheduler-url or --hub-url, or run robopark setup first.'));
+        process.exit(1);
+    }
+    if (!opts.id) {
+        console.log(chalk.red('  ✗ --id is required (unique server id, e.g. livekit-hub-docker).'));
+        process.exit(1);
+    }
+    if (!opts.url) {
+        console.log(chalk.red('  ✗ --url is required (LiveKit ws:// URL, e.g. ws://100.x.y.z:7880).'));
+        process.exit(1);
+    }
+    let apiKey = opts.apiKey;
+    let apiSecret = opts.apiSecret;
+    if (!apiKey || !apiSecret) {
+        console.log(chalk.yellow(`  ⚠ --api-key/--api-secret not provided; defaulting to LiveKit --dev credentials ('${DEV_API_KEY}'/'${DEV_API_SECRET}')`));
+        apiKey = apiKey ?? DEV_API_KEY;
+        apiSecret = apiSecret ?? DEV_API_SECRET;
+    }
+    const body = {
+        id: opts.id,
+        name: opts.name ?? opts.id,
+        url: opts.url,
+        webhook_url: opts.webhookUrl ?? opts.url.replace(/^wss?/, 'http'),
+        api_key: apiKey,
+        api_secret: apiSecret,
+        gpu_name: 'none',
+        gpu_vram_mb: 0,
+        max_sessions: opts.maxSessions ? parseInt(opts.maxSessions, 10) : 8,
+        status: 'online',
+    };
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
+    console.log(`  id:        ${chalk.cyan(body.id)}`);
+    console.log(`  url:       ${chalk.cyan(body.url)}`);
+    console.log();
+    try {
+        await postServer(schedulerUrl, body);
+        console.log(chalk.green(`  ✓ registered LiveKit server '${body.id}' with scheduler`));
+        console.log(chalk.dim(`    name:         ${body.name}`));
+        console.log(chalk.dim(`    url:          ${body.url}`));
+        console.log(chalk.dim(`    webhook_url:  ${body.webhook_url}`));
+        console.log(chalk.dim(`    api_key:      ${body.api_key}`));
+        console.log(chalk.dim(`    max_sessions: ${body.max_sessions}`));
+    }
+    catch (e) {
+        console.log(chalk.red(`  ✗ failed to register server: ${e.message}`));
+        process.exit(1);
+    }
+}