infinicode 2.8.22 → 2.8.25

package/dist/kernel/federation/peer-mesh.js

@@ -77,8 +77,22 @@ export class PeerMesh {
                 peer.lastSeenAt = Date.now();
                 if (!peer.connected) {
                     peer.connected = true;
+                    // A peer coming back online may be a fresh process with a changed
+                    // role (e.g. someone fixed a bad `--hub` flag and relaunched as
+                    // `--role satellite`) — the nodeId is stable across restarts (it's
+                    // a persisted identity, not per-process), so without this refetch
+                    // the stale role from the peer's *first ever* connect() would
+                    // stick forever, since nothing else in this class ever updates it.
+                    try {
+                        const manifest = await this.opts.client.fetchManifest(peer.url);
+                        peer.role = manifest.role;
+                        peer.displayName = manifest.displayName;
+                        peer.version = manifest.version;
+                        peer.manifest = manifest;
+                    }
+                    catch { /* keep last-known manifest fields if the refetch fails */ }
                     this.openStream(peer); // revive stream after an outage
-                    this.opts.logger.info(`[federation] peer ${peer.displayName} back online`);
+                    this.opts.logger.info(`[federation] peer ${peer.displayName} back online (role: ${peer.role})`);
                     this.opts.onPeerChange?.();
                 }
             }

package/dist/kernel/providers/ollama-provider.d.ts

@@ -15,6 +15,8 @@ export interface OllamaProviderOptions {
     fallbackURL?: string;
     defaultModel?: string;
     timeoutMs?: number;
+    /** Bearer token for Ollama Cloud (ollama.com) — unset for local Ollama, which has no auth. */
+    apiKey?: string;
 }
 export declare class OllamaProvider implements ProviderInterface {
     info: ProviderInfo;
@@ -23,6 +25,7 @@ export declare class OllamaProvider implements ProviderInterface {
     private activeURL;
     private defaultModel?;
     private timeoutMs;
+    private apiKey?;
     private cachedModels;
     constructor(options: OllamaProviderOptions);
     capabilities(): Promise<ProviderCapabilities>;
@@ -34,6 +37,7 @@ export declare class OllamaProvider implements ProviderInterface {
         latencyMs: number;
         error?: string;
     }>;
+    private headers;
     private fetchModels;
     private toProviderModel;
     private guessContextLength;

package/dist/kernel/providers/ollama-provider.js

@@ -5,6 +5,7 @@ export class OllamaProvider {
     activeURL;
     defaultModel;
     timeoutMs;
+    apiKey;
     cachedModels = [];
     constructor(options) {
         const id = options.id ?? 'ollama';
@@ -13,6 +14,7 @@ export class OllamaProvider {
         this.activeURL = this.baseURL;
         this.defaultModel = options.defaultModel;
         this.timeoutMs = options.timeoutMs ?? 10_000;
+        this.apiKey = options.apiKey;
         this.info = {
             id,
             name: options.name ?? 'Ollama',
@@ -45,7 +47,7 @@ export class OllamaProvider {
         };
         const response = await fetch(endpoint, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: this.headers(),
             body: JSON.stringify(body),
             signal: AbortSignal.timeout(this.timeoutMs * 3),
         });
@@ -77,7 +79,7 @@ export class OllamaProvider {
         };
         const response = await fetch(endpoint, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: this.headers(),
             body: JSON.stringify(body),
             signal: AbortSignal.timeout(this.timeoutMs * 6),
         });
@@ -133,7 +135,19 @@ export class OllamaProvider {
             return { ok: false, latencyMs: Date.now() - start, error: err instanceof Error ? err.message : String(err) };
         }
     }
+    headers() {
+        const h = { 'Content-Type': 'application/json' };
+        if (this.apiKey)
+            h['Authorization'] = `Bearer ${this.apiKey}`;
+        return h;
+    }
     async fetchModels() {
+        // Ollama Cloud has no /api/tags (that lists locally-pulled models, which
+        // isn't a concept cloud-hosted models have) — a configured defaultModel
+        // is used directly by complete()/completeStream() regardless, so treat
+        // this as best-effort rather than failing capabilities()/verify().
+        if (this.apiKey)
+            return this.cachedModels;
         const url = await this.resolveURL();
         const response = await fetch(`${url}/api/tags`, {
             signal: AbortSignal.timeout(this.timeoutMs),

package/dist/kernel/setup.js

@@ -79,6 +79,19 @@ export function buildKernelFromConfig(config, options) {
     };
     const kernel = new Kernel({ loadBuiltinWorkers: true, logger: options?.logger });
     kernel.registerProvider('ollama', new OllamaProvider(ollamaOptions));
+    // Ollama Cloud (ollama.com) — separate from the local instance above:
+    // different base URL, requires a Bearer token, and its /v1/chat/completions
+    // is used directly rather than the local-only /api/tags model listing.
+    const ollamaCloudKey = process.env.OLLAMA_CLOUD_API_KEY;
+    if (ollamaCloudKey) {
+        kernel.registerProvider('ollama-cloud', new OllamaProvider({
+            id: 'ollama-cloud',
+            name: 'Ollama Cloud',
+            baseURL: 'https://ollama.com',
+            defaultModel: process.env.OLLAMA_CLOUD_MODEL ?? 'gemma3:27b',
+            apiKey: ollamaCloudKey,
+        }));
+    }
     // Register cloud providers
     registerCloudProviders(kernel, config.get('cloudProviders') ?? []);
     // Register local OpenAI-compatible providers (LM Studio, vLLM, SGLang,

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

@@ -0,0 +1,8 @@
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/config-schema.js';
+import { type ExplicitContextOpts } from './profile.js';
+export interface AddRobotOptions extends ExplicitContextOpts {
+    name: string;
+    start?: boolean;
+}
+export declare function roboparkAddRobot(config: Conf<InfinicodeConfig>, opts: AddRobotOptions): Promise<void>;

package/dist/robopark/add-robot.js

@@ -0,0 +1,113 @@
+/**
+ * RoboPark — `robopark add-robot`.
+ *
+ * Collapses what used to be two manual steps — hand-curling
+ * `POST /api/devices` to mint an enrollment token, then hand-typing the full
+ * `robopark setup --robot --hub-url ... --token ... --scheduler-url ...
+ * --enrollment-token ...` one-liner on the actual robot machine — into one
+ * command.
+ *
+ * Usage:
+ *   robopark add-robot --name robobmw --site "Tel Aviv"
+ *     → mints an enrollment token against the resolved scheduler and prints
+ *       the ready-to-paste `robopark setup --robot ...` command to run ON
+ *       THE ROBOT.
+ *
+ *   robopark add-robot --name robobmw --start
+ *     → mints the token AND starts the robot node right here, on this
+ *       machine (useful when this machine IS the robot).
+ *
+ * Hub/scheduler/token context is resolved the standard way: explicit flags >
+ * saved hub profile (see profile.ts / `robopark hub-use`) > discoverContext()
+ * auto-discovery.
+ */
+import chalk from 'chalk';
+import { resolveContext } from './profile.js';
+import { roboparkSetup } from './setup.js';
+async function mintEnrollmentToken(schedulerUrl, name) {
+    const url = `${schedulerUrl.replace(/\/$/, '')}/api/devices`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ name }),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`${res.status}: ${text || res.statusText}`);
+    }
+    return (await res.json());
+}
+/**
+ * Build a Windows-task-friendly command string from an argv array.
+ *
+ * Mirrors setup.ts's local `commandString()` helper (kept private there) so
+ * the one-liner this command prints looks exactly like the ones `robopark
+ * setup` itself prints — same quoting convention, so it's paste-safe on both
+ * POSIX and Windows shells.
+ */
+function commandString(argv) {
+    return argv.map(a => /[^a-zA-Z0-9_./:=,-]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a).join(' ');
+}
+export async function roboparkAddRobot(config, opts) {
+    console.log(chalk.bold('\n  robopark add-robot'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    if (!opts.name || !opts.name.trim()) {
+        console.log(chalk.red('  ✗ --name is required, e.g. --name robobmw'));
+        process.exit(1);
+    }
+    const ctx = await resolveContext(opts);
+    if (!ctx.schedulerUrl) {
+        console.log(chalk.red('  ✗ no scheduler URL resolved. Pass --scheduler-url/--hub-url, run `robopark hub-use` first, or run this on/near the hub.'));
+        process.exit(1);
+    }
+    console.log(`  scheduler: ${chalk.cyan(ctx.schedulerUrl)}`);
+    console.log(`  name:      ${chalk.cyan(opts.name)}${ctx.site ? chalk.dim('  @ ' + ctx.site) : ''}`);
+    console.log();
+    let minted;
+    try {
+        minted = await mintEnrollmentToken(ctx.schedulerUrl, opts.name);
+    }
+    catch (e) {
+        console.log(chalk.red(`  ✗ failed to mint enrollment token: ${e.message}`));
+        process.exit(1);
+        return;
+    }
+    // The API returns this once and does not store it in plaintext — always
+    // show it, even when auto-starting, so it's available for reference or a
+    // future re-enrollment against the same scheduler.
+    console.log(chalk.green(`  ✓ minted enrollment token for '${opts.name}' (device ${minted.id})`));
+    console.log(`  enrollment token: ${chalk.yellow(minted.enrollment_token)}`);
+    console.log();
+    if (opts.start) {
+        console.log(chalk.dim('  --start given — starting robot node on this machine…\n'));
+        await roboparkSetup(config, {
+            role: 'robot',
+            name: opts.name,
+            site: ctx.site,
+            hub: ctx.hubUrl,
+            token: ctx.token,
+            schedulerPort: ctx.schedulerUrl ? String(new URL(ctx.schedulerUrl).port || '8080') : undefined,
+            enrollmentToken: minted.enrollment_token,
+            start: true,
+        });
+        return;
+    }
+    // Default: print the ready-to-paste one-liner for running on the actual
+    // (different) robot machine, in the same format `robopark setup` itself
+    // prints/expects.
+    const argv = ['robopark', 'setup', '--robot', '--name', opts.name];
+    if (ctx.site)
+        argv.push('--site', ctx.site);
+    if (ctx.hubUrl)
+        argv.push('--hub-url', ctx.hubUrl);
+    if (ctx.token)
+        argv.push('--token', ctx.token);
+    if (ctx.schedulerUrl) {
+        const schedulerPort = new URL(ctx.schedulerUrl).port || '8080';
+        argv.push('--scheduler-port', schedulerPort);
+    }
+    argv.push('--enrollment-token', minted.enrollment_token, '--start', '--auto-start');
+    console.log(chalk.dim('  run this ON THE ROBOT:'));
+    console.log('  ' + chalk.cyan(commandString(argv)));
+    console.log();
+}

package/dist/robopark/agent-ctl.d.ts

@@ -0,0 +1,20 @@
+export interface AgentUpOptions {
+    path: string;
+    schedulerUrl?: string;
+    hubUrl?: string;
+    token?: string;
+    serverId?: string;
+    serverName?: string;
+    register?: boolean;
+}
+export interface AgentDownOptions {
+    path: string;
+}
+export interface AgentLogsOptions {
+    path: string;
+    follow?: boolean;
+    service?: string;
+}
+export declare function roboparkAgentUp(opts: AgentUpOptions): Promise<void>;
+export declare function roboparkAgentDown(opts: AgentDownOptions): Promise<void>;
+export declare function roboparkAgentLogs(opts: AgentLogsOptions): Promise<void>;

package/dist/robopark/agent-ctl.js

@@ -0,0 +1,237 @@
+/**
+ * RoboPark — `robopark agent up/down/logs`.
+ *
+ * ROBOVOICE (the production voice stack: LiveKit + STT/TTS + agent) today
+ * requires an operator to manually `docker compose up -d` in that checkout,
+ * then manually `curl POST /api/servers` on the RoboPark scheduler to
+ * register the LiveKit instance it brought up. This file collapses both
+ * steps into one command so a hub/GPU machine only needs:
+ *
+ *   robopark setup --role hub
+ *   robopark agent-up --path C:\path\to\ROBOVOICE
+ *
+ * to be fully wired end to end.
+ *
+ * Reuses `roboparkServerAdd` (server-add.ts) for the exact POST /api/servers
+ * shape, and `resolveContext` (profile.ts) for hub/scheduler/token
+ * resolution with saved hub-profile fallback — nothing about the
+ * registration mechanics is reimplemented here.
+ */
+import { spawn, execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { hostname, networkInterfaces } from 'node:os';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { roboparkServerAdd } from './server-add.js';
+import { resolveContext } from './profile.js';
+const LIVEKIT_PORT = 7880;
+const LIVEKIT_DEV_API_KEY = 'devkey';
+const LIVEKIT_DEV_API_SECRET = 'secret';
+/** This machine's first non-internal IPv4 LAN address, if any. */
+function getLanIps() {
+    const out = [];
+    for (const addrs of Object.values(networkInterfaces())) {
+        if (!addrs)
+            continue;
+        for (const a of addrs) {
+            if (a.family === 'IPv4' && !a.internal)
+                out.push(a.address);
+        }
+    }
+    return out;
+}
+/** Run `cmd version` quietly; resolve true if it exits 0. */
+function commandWorks(cmd, args) {
+    return new Promise((resolve) => {
+        execFile(cmd, args, { timeout: 8000 }, (err) => resolve(!err));
+    });
+}
+/**
+ * Detect whether to use Docker Compose v2 (`docker compose`, space-separated
+ * subcommand) or the legacy v1 standalone `docker-compose` binary. v2 is
+ * tried first since it's bundled with modern Docker Desktop/Engine; v1 is
+ * the fallback for older hosts that only have the standalone binary.
+ */
+async function resolveComposeCommand() {
+    if (await commandWorks('docker', ['compose', 'version'])) {
+        return { cmd: 'docker', baseArgs: ['compose'] };
+    }
+    if (await commandWorks('docker-compose', ['version'])) {
+        return { cmd: 'docker-compose', baseArgs: [] };
+    }
+    return null;
+}
+/** Spawn a compose subcommand, streaming stdout/stderr to the console. */
+function runCompose(compose, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(compose.cmd, [...compose.baseArgs, ...args], {
+            cwd,
+            stdio: 'inherit',
+        });
+        proc.on('error', reject);
+        proc.on('close', (code) => resolve(code ?? 1));
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Poll http://localhost:<port> until it responds (any HTTP status counts as "up" — LiveKit's bare HTTP port returns 404 for GET, which is fine). */
+async function waitForLivekitHealthy(port, timeoutMs, intervalMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(`http://localhost:${port}/`, { signal: AbortSignal.timeout(2000) });
+            // LiveKit's plain HTTP listener answers (even 4xx) once the process is up.
+            if (res.status < 500)
+                return true;
+        }
+        catch {
+            // not up yet — fall through to retry
+        }
+        await sleep(intervalMs);
+    }
+    return false;
+}
+/** Validate that `path` looks like a ROBOVOICE checkout (has a docker-compose.yaml). */
+function validateComposePath(path) {
+    const candidates = ['docker-compose.yaml', 'docker-compose.yml'];
+    for (const name of candidates) {
+        const full = join(path, name);
+        if (existsSync(full))
+            return full;
+    }
+    throw new Error(`no docker-compose.yaml/.yml found in '${path}'. Pass --path pointing at a ROBOVOICE checkout ` +
+        `(the directory containing docker-compose.yaml), not this repo.`);
+}
+export async function roboparkAgentUp(opts) {
+    console.log(chalk.bold('\n  robopark agent up'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    if (!existsSync(opts.path)) {
+        console.log(chalk.red(`  ✗ path does not exist: ${opts.path}`));
+        process.exit(1);
+    }
+    try {
+        validateComposePath(opts.path);
+    }
+    catch (e) {
+        console.log(chalk.red(`  ✗ ${e.message}`));
+        process.exit(1);
+    }
+    const compose = await resolveComposeCommand();
+    if (!compose) {
+        console.log(chalk.red('  ✗ neither `docker compose` (v2) nor `docker-compose` (v1) is available on PATH.'));
+        process.exit(1);
+    }
+    console.log(chalk.dim(`  using: ${compose.cmd} ${compose.baseArgs.join(' ')}`.trimEnd()));
+    console.log(`  path:  ${chalk.cyan(opts.path)}`);
+    console.log();
+    console.log(chalk.bold('  1. starting ROBOVOICE docker stack (docker compose up -d)…'));
+    const upCode = await runCompose(compose, ['up', '-d'], opts.path);
+    if (upCode !== 0) {
+        console.log(chalk.red(`\n  ✗ docker compose up -d exited with code ${upCode}`));
+        process.exit(upCode);
+    }
+    console.log(chalk.green('  ✓ docker compose up -d completed'));
+    console.log();
+    console.log(chalk.bold(`  2. waiting for LiveKit to become healthy on :${LIVEKIT_PORT} (up to 60s)…`));
+    const healthy = await waitForLivekitHealthy(LIVEKIT_PORT, 60_000, 3_000);
+    if (!healthy) {
+        console.log(chalk.red(`  ✗ LiveKit did not respond on http://localhost:${LIVEKIT_PORT} within 60s.`));
+        console.log(chalk.dim(`    check container health: ${compose.cmd} ${compose.baseArgs.join(' ')} ps`.trim()));
+        process.exit(1);
+    }
+    console.log(chalk.green(`  ✓ LiveKit is up on :${LIVEKIT_PORT}`));
+    if (opts.register === false) {
+        console.log();
+        console.log(chalk.dim('  --no-register passed; skipping scheduler registration.'));
+        console.log(chalk.green('\n  ✓ robopark agent up complete (docker only)\n'));
+        return;
+    }
+    console.log();
+    console.log(chalk.bold('  3. registering LiveKit server with the RoboPark scheduler…'));
+    const ctx = await resolveContext({ hubUrl: opts.hubUrl, token: opts.token, schedulerUrl: opts.schedulerUrl });
+    if (!ctx.schedulerUrl) {
+        console.log(chalk.red('  ✗ no scheduler URL resolved. Pass --scheduler-url/--hub-url, or run `robopark setup --role hub` first.'));
+        process.exit(1);
+    }
+    // Advertise this machine's own reachable address. This is a best-effort
+    // guess (first non-internal LAN IPv4); if the scheduler runs on a
+    // *different* machine than the one running `agent up` and that machine
+    // can't reach this LAN IP (e.g. NAT, VPN split), correct the registration
+    // manually afterwards with `robopark server-add --id <id> --url ws://<correct-host>:7880`.
+    const lanIps = getLanIps();
+    const advertiseHost = lanIps[0] ?? hostname();
+    if (lanIps.length === 0) {
+        console.log(chalk.yellow(`  ⚠ no LAN IPv4 detected; advertising hostname '${advertiseHost}'. Correct with 'robopark server-add' if the scheduler can't resolve it.`));
+    }
+    const id = opts.serverId ?? `robovoice-${hostname()}`;
+    const name = opts.serverName ?? `ROBOVOICE (${hostname()})`;
+    const url = `ws://${advertiseHost}:${LIVEKIT_PORT}`;
+    await roboparkServerAdd({
+        hubUrl: ctx.hubUrl,
+        schedulerUrl: ctx.schedulerUrl,
+        token: ctx.token,
+        id,
+        name,
+        url,
+        apiKey: LIVEKIT_DEV_API_KEY,
+        apiSecret: LIVEKIT_DEV_API_SECRET,
+    });
+    console.log(chalk.green('\n  ✓ robopark agent up complete — ROBOVOICE is running and registered with the scheduler\n'));
+}
+export async function roboparkAgentDown(opts) {
+    console.log(chalk.bold('\n  robopark agent down'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    if (!existsSync(opts.path)) {
+        console.log(chalk.red(`  ✗ path does not exist: ${opts.path}`));
+        process.exit(1);
+    }
+    try {
+        validateComposePath(opts.path);
+    }
+    catch (e) {
+        console.log(chalk.red(`  ✗ ${e.message}`));
+        process.exit(1);
+    }
+    const compose = await resolveComposeCommand();
+    if (!compose) {
+        console.log(chalk.red('  ✗ neither `docker compose` (v2) nor `docker-compose` (v1) is available on PATH.'));
+        process.exit(1);
+    }
+    console.log(`  path: ${chalk.cyan(opts.path)}`);
+    console.log();
+    const code = await runCompose(compose, ['down'], opts.path);
+    if (code !== 0) {
+        console.log(chalk.red(`\n  ✗ docker compose down exited with code ${code}`));
+        process.exit(code);
+    }
+    console.log(chalk.green('\n  ✓ ROBOVOICE stack stopped\n'));
+}
+export async function roboparkAgentLogs(opts) {
+    if (!existsSync(opts.path)) {
+        console.log(chalk.red(`  ✗ path does not exist: ${opts.path}`));
+        process.exit(1);
+    }
+    try {
+        validateComposePath(opts.path);
+    }
+    catch (e) {
+        console.log(chalk.red(`  ✗ ${e.message}`));
+        process.exit(1);
+    }
+    const compose = await resolveComposeCommand();
+    if (!compose) {
+        console.log(chalk.red('  ✗ neither `docker compose` (v2) nor `docker-compose` (v1) is available on PATH.'));
+        process.exit(1);
+    }
+    const args = ['logs'];
+    if (opts.follow)
+        args.push('-f');
+    if (opts.service)
+        args.push(opts.service);
+    // Live tail: no buffering, no capture — inherit stdio directly.
+    const code = await runCompose(compose, args, opts.path);
+    if (code !== 0 && !opts.follow) {
+        process.exit(code);
+    }
+}

package/dist/robopark/doctor.d.ts

@@ -0,0 +1,6 @@
+export interface DoctorOptions {
+    hubUrl?: string;
+    token?: string;
+    schedulerUrl?: string;
+}
+export declare function roboparkDoctor(opts: DoctorOptions): Promise<void>;