robopark 2.8.35 → 3.0.0

package/conversation/requirements.txt

@@ -0,0 +1,3 @@
+elevenlabs[pyaudio]>=2.39.0,<3
+audioop-lts>=0.2.2; python_version >= "3.13"
+gpiozero>=2.0

package/conversation/supervisor_store.py

@@ -0,0 +1,189 @@
+"""Durable state for the robot-local voice supervisor.
+
+This module deliberately has no scheduler dependency. The voice process writes
+locally first and the management plane may consume events later by cursor.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+import time
+import uuid
+from contextlib import contextmanager
+from pathlib import Path
+
+
+COMMAND_STATES = {
+    "queued", "delivered", "acknowledged", "running", "succeeded",
+    "failed", "expired", "superseded",
+}
+
+
+class SupervisorStore:
+    def __init__(self, config_path: str, robot_id: str, max_events: int = 50_000) -> None:
+        source = Path(config_path)
+        self.path = source.with_suffix(source.suffix + ".supervisor.sqlite3")
+        self.robot_id = robot_id
+        self.max_events = max(1_000, int(max_events))
+        self.lock = threading.RLock()
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._initialize()
+
+    def _connect(self) -> sqlite3.Connection:
+        connection = sqlite3.connect(self.path, timeout=10)
+        connection.row_factory = sqlite3.Row
+        connection.execute("PRAGMA journal_mode=WAL")
+        connection.execute("PRAGMA synchronous=NORMAL")
+        return connection
+
+    @contextmanager
+    def _db(self):
+        connection = self._connect()
+        try:
+            with connection:
+                yield connection
+        finally:
+            connection.close()
+
+    def _initialize(self) -> None:
+        with self.lock, self._db() as db:
+            db.executescript(
+                """
+                CREATE TABLE IF NOT EXISTS events (
+                    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+                    event_id TEXT NOT NULL UNIQUE,
+                    robot_id TEXT NOT NULL,
+                    session_id TEXT,
+                    type TEXT NOT NULL,
+                    timestamp REAL NOT NULL,
+                    payload TEXT NOT NULL,
+                    acknowledged INTEGER NOT NULL DEFAULT 0
+                );
+                CREATE INDEX IF NOT EXISTS idx_voice_events_ack_sequence
+                    ON events(acknowledged, sequence);
+                CREATE TABLE IF NOT EXISTS state (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL
+                );
+                CREATE TABLE IF NOT EXISTS completed_commands (
+                    command_id TEXT PRIMARY KEY,
+                    status TEXT NOT NULL,
+                    result TEXT NOT NULL,
+                    completed_at REAL NOT NULL
+                );
+                """
+            )
+
+    def get_state(self, key: str, default=None):
+        with self.lock, self._db() as db:
+            row = db.execute("SELECT value FROM state WHERE key = ?", (key,)).fetchone()
+        return json.loads(row["value"]) if row else default
+
+    def set_state(self, key: str, value) -> None:
+        encoded = json.dumps(value, separators=(",", ":"), ensure_ascii=True)
+        with self.lock, self._db() as db:
+            db.execute(
+                "INSERT INTO state(key, value) VALUES(?, ?) "
+                "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
+                (key, encoded),
+            )
+
+    def append_event(self, event_type: str, payload: dict, session_id: str | None = None) -> dict:
+        event_id = str(uuid.uuid4())
+        timestamp = time.time()
+        with self.lock, self._db() as db:
+            cursor = db.execute(
+                "INSERT INTO events(event_id, robot_id, session_id, type, timestamp, payload) "
+                "VALUES(?, ?, ?, ?, ?, ?)",
+                (
+                    event_id,
+                    self.robot_id,
+                    session_id,
+                    event_type,
+                    timestamp,
+                    json.dumps(payload, separators=(",", ":"), ensure_ascii=True),
+                ),
+            )
+            sequence = int(cursor.lastrowid)
+            overflow = db.execute(
+                "SELECT sequence FROM events ORDER BY sequence DESC LIMIT 1 OFFSET ?",
+                (self.max_events,),
+            ).fetchone()
+            if overflow:
+                db.execute("DELETE FROM events WHERE sequence <= ? AND acknowledged = 1", (overflow["sequence"],))
+        return {
+            "event_id": event_id,
+            "sequence": sequence,
+            "robot_id": self.robot_id,
+            "session_id": session_id,
+            "type": event_type,
+            "timestamp": timestamp,
+            "payload": payload,
+        }
+
+    def events_after(self, cursor: int, limit: int = 250) -> list[dict]:
+        safe_limit = min(1_000, max(1, int(limit)))
+        with self.lock, self._db() as db:
+            rows = db.execute(
+                "SELECT * FROM events WHERE sequence > ? ORDER BY sequence LIMIT ?",
+                (max(0, int(cursor)), safe_limit),
+            ).fetchall()
+        return [
+            {
+                "event_id": row["event_id"],
+                "sequence": row["sequence"],
+                "robot_id": row["robot_id"],
+                "session_id": row["session_id"],
+                "type": row["type"],
+                "timestamp": row["timestamp"],
+                "payload": json.loads(row["payload"]),
+            }
+            for row in rows
+        ]
+
+    def acknowledge(self, sequence: int) -> int:
+        highest = max(0, int(sequence))
+        with self.lock, self._db() as db:
+            db.execute("UPDATE events SET acknowledged = 1 WHERE sequence <= ?", (highest,))
+            db.execute("DELETE FROM events WHERE acknowledged = 1 AND sequence <= ?", (highest,))
+        return highest
+
+    def stats(self) -> dict:
+        with self.lock, self._db() as db:
+            row = db.execute(
+                "SELECT COUNT(*) total, COALESCE(MIN(sequence), 0) first_sequence, "
+                "COALESCE(MAX(sequence), 0) last_sequence, "
+                "SUM(CASE WHEN acknowledged = 0 THEN 1 ELSE 0 END) pending FROM events"
+            ).fetchone()
+        return {
+            "total": int(row["total"] or 0),
+            "pending": int(row["pending"] or 0),
+            "first_sequence": int(row["first_sequence"] or 0),
+            "last_sequence": int(row["last_sequence"] or 0),
+        }
+
+    def command_result(self, command_id: str) -> dict | None:
+        with self.lock, self._db() as db:
+            row = db.execute(
+                "SELECT status, result, completed_at FROM completed_commands WHERE command_id = ?",
+                (command_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return {
+            "status": row["status"],
+            "result": json.loads(row["result"]),
+            "completed_at": row["completed_at"],
+        }
+
+    def complete_command(self, command_id: str, status: str, result: dict) -> None:
+        if status not in COMMAND_STATES:
+            raise ValueError(f"invalid command state: {status}")
+        with self.lock, self._db() as db:
+            db.execute(
+                "INSERT OR REPLACE INTO completed_commands(command_id, status, result, completed_at) "
+                "VALUES(?, ?, ?, ?)",
+                (command_id, status, json.dumps(result, ensure_ascii=True), time.time()),
+            )

package/dist/kernel/config-schema.js

@@ -0,0 +1,37 @@
+export const DEFAULT_CONFIG = {
+    masterUrl: 'http://localhost:11434',
+    defaultModel: 'qwen2.5-coder:14b',
+    theme: 'infini',
+    // Auto-routes across all providers by capability + benchmark. Use 'offline'
+    // to lock to local, or 'quality'/'fastest'/'free-first' to bias the router.
+    policy: 'balanced',
+    workerModels: {},
+    cloudProviders: [],
+    localProviders: [],
+};
+export const WORKER_TYPES_ORDER = [
+    'coding',
+    'frontend',
+    'research',
+    'architecture',
+    'review',
+    'documentation',
+    'translation',
+    'terminal',
+    'verification',
+    'vision',
+    'browser',
+];
+export const WORKER_DESCRIPTIONS = {
+    coding: 'Writes code — functions, implementations, fixes',
+    frontend: 'Builds production-grade UI (HTML/CSS/vanilla JS) — design systems, components, animation',
+    research: 'Searches, crawls, summarizes with citations',
+    architecture: 'Designs structure, modules, data flow, tradeoffs',
+    review: 'Critiques code, design, or plans',
+    documentation: 'Produces docs in Markdown',
+    translation: 'Translates content across languages',
+    terminal: 'Produces shell commands',
+    verification: 'Verifies tasks meet acceptance criteria',
+    vision: 'Analyzes images, OCR, visual content',
+    browser: 'Drives a browser via Playwright',
+};

package/dist/kernel/types.js

@@ -0,0 +1,7 @@
+/**
+ * OpenKernel — Core Type Definitions
+ *
+ * Provider-agnostic AI execution kernel types.
+ * Mission → Objectives → Tasks → Workers → Providers.
+ */
+export {};

package/dist/robopark/access.js

@@ -0,0 +1,99 @@
+import { createHash, timingSafeEqual } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+const ACCESS_HASH = 'af6bf6bcf8f63360a09a15c211f0824b608d3ce462e8a53fc45dfc63b42e4751';
+const STATE_DIR = process.env.ROBOPARK_HOME
+    ? resolve(process.env.ROBOPARK_HOME)
+    : join(homedir(), '.robopark');
+const ACCESS_PATH = join(STATE_DIR, 'package-access.json');
+function digest(value) {
+    return createHash('sha256').update(value, 'utf8').digest();
+}
+export function passwordMatches(value) {
+    const expected = Buffer.from(ACCESS_HASH, 'hex');
+    const actual = digest(value);
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function jsonHas(path, keys) {
+    if (!existsSync(path))
+        return false;
+    try {
+        const value = JSON.parse(readFileSync(path, 'utf8'));
+        return keys.every(key => typeof value[key] === 'string' && String(value[key]).trim().length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+function validDeviceToken() {
+    const path = join(STATE_DIR, 'device_token');
+    if (!existsSync(path))
+        return false;
+    try {
+        return readFileSync(path, 'utf8').trim().length >= 20;
+    }
+    catch {
+        return false;
+    }
+}
+function validSchedulerDatabase() {
+    const path = join(STATE_DIR, 'scheduler', 'scheduler.db');
+    if (!existsSync(path) || statSync(path).size < 100)
+        return false;
+    try {
+        const header = readFileSync(path).subarray(0, 16).toString('utf8');
+        return header === 'SQLite format 3\u0000';
+    }
+    catch {
+        return false;
+    }
+}
+/** Existing enrolled robots and gateways upgrade without an activation outage. */
+export function hasExistingRoboParkIdentity() {
+    return validDeviceToken()
+        || validSchedulerDatabase()
+        || jsonHas(join(STATE_DIR, 'connection.json'), ['schedulerUrl', 'deviceId', 'deviceToken'])
+        || jsonHas(join(STATE_DIR, 'preview_agent.json'), ['scheduler_url'])
+        || jsonHas(join(STATE_DIR, 'hub-profile.json'), ['hubUrl']);
+}
+function activated() {
+    if (!existsSync(ACCESS_PATH))
+        return false;
+    try {
+        const record = JSON.parse(readFileSync(ACCESS_PATH, 'utf8'));
+        return record.accessHash === ACCESS_HASH;
+    }
+    catch {
+        return false;
+    }
+}
+function writeActivation(source) {
+    mkdirSync(STATE_DIR, { recursive: true });
+    const temp = `${ACCESS_PATH}.${process.pid}.tmp`;
+    writeFileSync(temp, `${JSON.stringify({
+        version: 1,
+        accessHash: ACCESS_HASH,
+        source,
+        activatedAt: new Date().toISOString(),
+    }, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(temp, ACCESS_PATH);
+}
+export function activateFromPairing() {
+    if (!activated())
+        writeActivation('pairing');
+}
+export function requirePackageAccess(password) {
+    if (activated())
+        return;
+    if (hasExistingRoboParkIdentity()) {
+        writeActivation('existing-install');
+        return;
+    }
+    const candidate = password?.trim() || process.env.ROBOPARK_PACKAGE_PASSWORD?.trim();
+    if (candidate && passwordMatches(candidate)) {
+        writeActivation('password');
+        return;
+    }
+    throw new Error('RoboPark activation required. Set ROBOPARK_PACKAGE_PASSWORD or pass `robopark --password <password> ...` once.');
+}

package/dist/robopark/add-robot.js

@@ -0,0 +1,188 @@
+/**
+ * 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';
+function robotReachableSchedulerUrl(schedulerUrl, hubUrl) {
+    if (!hubUrl)
+        return schedulerUrl;
+    try {
+        // Port 8080 is intentionally private to the hub. Enrollment, character
+        // lookup, heartbeats, and robot sessions must all use the authenticated
+        // mesh proxy, whether the hidden scheduler is loopback or a 192.168.x.x
+        // address that is only meaningful on the hub's own LAN.
+        new URL(schedulerUrl);
+        new URL(hubUrl);
+        return `${hubUrl.replace(/\/+$/, '')}/robopark`;
+    }
+    catch {
+        // Keep the original value so the existing request reports a useful error.
+    }
+    return schedulerUrl;
+}
+function schedulerApiUrl(schedulerUrl, path, token) {
+    const url = new URL(`${schedulerUrl.replace(/\/+$/, '')}${path}`);
+    if (token && url.pathname.startsWith('/robopark/')) {
+        url.searchParams.set('token', token);
+    }
+    return url.toString();
+}
+async function mintEnrollmentToken(schedulerUrl, name, characterId, token) {
+    const url = schedulerApiUrl(schedulerUrl, '/api/devices', token);
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ name, character_id: characterId }),
+        });
+    }
+    catch (error) {
+        const cause = error.cause;
+        throw new Error(`cannot reach scheduler through ${schedulerUrl}: ${cause?.message ?? error.message}`);
+    }
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`${res.status}: ${text || res.statusText}`);
+    }
+    return (await res.json());
+}
+async function pickCharacterPreset(schedulerUrl, name, token) {
+    const lower = name.toLowerCase();
+    try {
+        const res = await fetch(schedulerApiUrl(schedulerUrl, '/api/character-presets', token));
+        if (!res.ok)
+            return undefined;
+        const presets = (await res.json());
+        // Exact id match first, then fuzzy name match.
+        const exact = presets.find(p => p.id.toLowerCase() === lower || p.name.toLowerCase() === lower);
+        if (exact)
+            return exact.id;
+        const partial = presets.find(p => lower.includes(p.id.toLowerCase()) || p.name.toLowerCase().includes(lower));
+        return partial?.id;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 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);
+    }
+    if (opts.lan && opts.tailscale) {
+        console.log(chalk.red('  ✗ choose exactly one network mode: --lan or --tailscale'));
+        process.exit(1);
+    }
+    const network = opts.tailscale ? 'tailscale' : 'lan';
+    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);
+    }
+    const schedulerUrl = robotReachableSchedulerUrl(ctx.schedulerUrl, ctx.hubUrl);
+    if (schedulerUrl.endsWith('/robopark') && !ctx.token) {
+        console.log(chalk.red('  ✗ hub mesh token is required to use the scheduler proxy. Pass --token or run `robopark hub-use` first.'));
+        process.exit(1);
+    }
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
+    console.log(`  name:      ${chalk.cyan(opts.name)}${ctx.site ? chalk.dim('  @ ' + ctx.site) : ''}`);
+    console.log(`  network:   ${chalk.cyan(network)}`);
+    console.log();
+    const characterId = opts.character?.trim() || await pickCharacterPreset(schedulerUrl, opts.name, ctx.token);
+    if (characterId) {
+        console.log(`  character: ${chalk.cyan(characterId)}${opts.character ? chalk.dim(' (forced via --character)') : chalk.dim(' (auto-matched)')}`);
+    }
+    else {
+        console.log(chalk.yellow(`  ⚠ no character preset matched '${opts.name}' — pass --character <id> to bind this robot to a specific park-map pad`));
+    }
+    let minted;
+    try {
+        minted = await mintEnrollmentToken(schedulerUrl, opts.name, characterId, ctx.token);
+    }
+    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,
+            autoStart: opts.autoStart !== false,
+            yes: opts.yes !== false,
+            lan: opts.lan,
+            tailscale: opts.tailscale,
+        });
+        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(network === 'tailscale' ? '--tailscale' : '--lan');
+    argv.push('--enrollment-token', minted.enrollment_token, '--start', '--auto-start', '--yes');
+    console.log(chalk.dim(`  run this ON THE ROBOT${characterId ? ` (binds to pad: ${characterId})` : ''}:`));
+    console.log('  ' + chalk.cyan(commandString(argv)));
+    if (!ctx.hubUrl) {
+        console.log(chalk.yellow('  ⚠ no hub URL resolved — the command above omits --hub-url; run `robopark hub-use` first or pass --hub-url explicitly if the robot needs it.'));
+    }
+    console.log();
+}