infinicode 2.3.6 → 2.5.0

package/bin/robopark.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/robopark-cli.js');

package/dist/cli.js

@@ -14,10 +14,12 @@ import { providersList, providersAdd, providersRemove, providersTest } from './c
 import { consoleRepl, consoleRun } from './commands/console.js';
 import { serve } from './commands/serve.js';
 import { mcpCommand } from './commands/mcp.js';
+import { maintain } from './commands/maintain.js';
 import { meshInstall, meshUninstall } from './commands/mesh-install.js';
 import { installTui } from './commands/install-tui.js';
+import { attachRoboparkSubcommands } from './commands/robopark.js';
 import { DEFAULT_CONFIG } from './kernel/config-schema.js';
-const VERSION = '2.3.6';
+const VERSION = '2.5.0';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,
@@ -293,12 +295,35 @@ program
     .option('--lan-port <port>', 'UDP discovery port for --lan (default 47915)')
     .option('--tag <tag>', 'only discover peers carrying this tag (Tailscale ACL tag or LAN beacon tag)')
     .option('--console', 'interactive slash-command console on the node (/nodes, /build, /activity …); on by default in a TTY')
+    .option('--dashboard', 'serve the RoboPark control web UI at http://<host>:<port>/ (fleet map, live activity, actions)')
+    .option('--scheduler-url <url>', 'link a RoboPark scheduler so the dashboard shows sessions + telemetry (e.g. http://localhost:8080)')
+    .option('--scheduler-token <token>', 'bearer token to present to the scheduler on proxied requests')
+    .option('--tls-cert <path>', 'PEM cert file — serve the dashboard/mesh over HTTPS')
+    .option('--tls-key <path>', 'PEM private key file for --tls-cert')
     .option('--gateway <url>', 'link to an InfiniBot gateway (ws://host:18789) — appear on its neural-mesh map')
     .option('--gateway-token <token>', 'auth token for the InfiniBot gateway')
     .option('--gateway-password <password>', 'auth password for the InfiniBot gateway')
     .action(async (opts) => {
     await serve(config, opts);
 });
+// ── RoboPark: fleet control overlay (also shipped as the `robopark` bin) ────
+const roboparkCmd = program
+    .command('robopark')
+    .alias('rp')
+    .description('RoboPark fleet control — setup, fleet status, run, apply, dashboard (rides the mesh)');
+attachRoboparkSubcommands(roboparkCmd, config);
+// ── OpenKernel: one-shot scheduled maintenance ─────────────────────────────
+program
+    .command('maintain <task-prompt>')
+    .description('Run one maintenance task and exit — meant for OS cron/Task Scheduler, not a daemon')
+    .option('--name <name>', 'node name for the report (defaults to this node\'s role, or "infinicode-node")')
+    .option('--task-name <name>', 'short label for the report (defaults to a slice of the task prompt)')
+    .option('--gateway <url>', 'InfiniBot gateway to push the report to (ws://host:18789)')
+    .option('--gateway-token <token>', 'auth token for the InfiniBot gateway')
+    .option('--gateway-password <password>', 'auth password for the InfiniBot gateway')
+    .action(async (taskPrompt, opts) => {
+    await maintain(config, taskPrompt, opts);
+});
 // ── infinicode: mesh — one-command MCP registration (no hand-edited JSON) ──
 const meshCmd = program
     .command('mesh')

package/dist/commands/maintain.d.ts

@@ -0,0 +1,29 @@
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/setup.js';
+import type { MaintenanceReport, Kernel, RoleContext } from '../kernel/index.js';
+export interface MaintainOptions {
+    name?: string;
+    gateway?: string;
+    gatewayToken?: string;
+    gatewayPassword?: string;
+    taskName?: string;
+}
+interface CachedTask {
+    taskPrompt: string;
+    taskName?: string;
+}
+export declare function loadLastMaintenanceTask(storageDir?: string): CachedTask | null;
+/**
+ * Pure execution: run one maintenance task on an ALREADY-BUILT kernel and
+ * return the report — no push, no process.exit. Shared by the standalone
+ * `infinicode maintain` CLI command (builds its own short-lived kernel) and
+ * `infinicode serve`'s inbound-command poller (reuses the node's live
+ * kernel, since that process is already running one).
+ */
+export declare function runMaintenanceTask(kernel: Kernel, taskPrompt: string, opts: {
+    nodeId: string;
+    role: RoleContext | null;
+    taskName?: string;
+}): Promise<MaintenanceReport>;
+export declare function maintain(config: Conf<InfinicodeConfig>, taskPrompt: string, opts: MaintainOptions): Promise<void>;
+export {};

package/dist/commands/maintain.js

@@ -0,0 +1,186 @@
+/**
+ * infinicode maintain — run one scheduled maintenance task and report the
+ * result, then exit. Meant to be invoked by OS-level cron / Task Scheduler on
+ * a monthly (or any) cadence — NOT a daemon. This deliberately does not reuse
+ * the autonomy GoalLoop: GoalLoop is in-memory/setInterval-based and resets on
+ * every process restart, which is wrong for a calendar cadence that must
+ * survive reboots and land on real dates. The OS scheduler already does that
+ * correctly; this command just needs to run once, cleanly, and report home.
+ *
+ *   infinicode maintain "apply OS security patches, restart if required" \
+ *     --name db-primary --gateway ws://100.x.y.z:18789 --gateway-token secret
+ */
+import chalk from 'chalk';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { buildKernelFromConfig } from '../kernel/setup.js';
+import { loadRole, rolePreamble, loadOrCreateIdentity, MoltfedConnector, SilentLogger } from '../kernel/index.js';
+function lastTaskFile(storageDir = join(process.cwd(), '.openkernel')) {
+    return join(storageDir, 'last-maintenance-task.json');
+}
+/** Cache the task text this device just ran LOCALLY — this is the only
+ *  thing an on-demand "run now" trigger is allowed to replay (see
+ *  loadLastMaintenanceTask). Never populated from anything network-supplied. */
+function saveLastMaintenanceTask(task, storageDir) {
+    const dir = storageDir ?? join(process.cwd(), '.openkernel');
+    try {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(lastTaskFile(dir), JSON.stringify(task, null, 2));
+    }
+    catch {
+        // non-fatal — a re-trigger will just report "nothing cached yet"
+    }
+}
+export function loadLastMaintenanceTask(storageDir) {
+    const file = lastTaskFile(storageDir);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Pure execution: run one maintenance task on an ALREADY-BUILT kernel and
+ * return the report — no push, no process.exit. Shared by the standalone
+ * `infinicode maintain` CLI command (builds its own short-lived kernel) and
+ * `infinicode serve`'s inbound-command poller (reuses the node's live
+ * kernel, since that process is already running one).
+ */
+export async function runMaintenanceTask(kernel, taskPrompt, opts) {
+    const { nodeId, role } = opts;
+    const preamble = rolePreamble(role);
+    const prompt = preamble ? `${preamble}\n\n${taskPrompt}` : taskPrompt;
+    const taskName = opts.taskName ?? taskPrompt.slice(0, 60);
+    const startedAt = Date.now();
+    let ok = true;
+    let summary = '';
+    const errors = [];
+    try {
+        const mission = await kernel.execute({
+            description: taskName,
+            goal: taskPrompt,
+            tasks: [{
+                    description: taskName,
+                    capabilities: ['reasoning'],
+                    input: { prompt, context: { proactive: true, maintenance: true, role: role?.role } },
+                }],
+        });
+        ok = mission.status === 'COMPLETED';
+        if (mission.error)
+            errors.push(mission.error);
+        for (const task of mission.tasks) {
+            if (task.error)
+                errors.push(task.error);
+        }
+        summary = mission.tasks
+            .map(t => t.output?.content)
+            .filter((c) => Boolean(c))
+            .join('\n\n')
+            .slice(0, 4000) || (ok ? 'completed with no textual output' : 'mission did not complete');
+    }
+    catch (err) {
+        ok = false;
+        const message = err instanceof Error ? err.message : String(err);
+        errors.push(message);
+        summary = `threw before completion: ${message}`;
+    }
+    const finishedAt = Date.now();
+    return {
+        nodeId,
+        role: role?.role ?? nodeId,
+        site: role?.site,
+        taskName,
+        startedAt,
+        finishedAt,
+        durationMs: finishedAt - startedAt,
+        ok,
+        summary,
+        errors: errors.length ? errors : undefined,
+    };
+}
+/** Open a MoltfedConnector just long enough to push one report, then close it.
+ *  Does not start the periodic hw/status timers — this is a one-shot push, not
+ *  a live mesh presence. */
+async function pushReportOnce(gatewayUrl, report, opts) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            connector.stop();
+            resolve(ok);
+        };
+        const connector = new MoltfedConnector({
+            gatewayUrl,
+            token: opts.token,
+            password: opts.password,
+            role: opts.role,
+            client: { id: report.nodeId, version: '1', platform: 'node', mode: 'maintenance' },
+            logger: new SilentLogger(),
+            // Not used for a one-shot push, but required by the connector's shape.
+            getNodeStatuses: () => [],
+            getHardware: () => undefined,
+            subscribeFrames: () => () => { },
+        });
+        // Poll for handshake completion, then fire the report once (connect() is
+        // async/event-driven internally with no public "connected" callback).
+        const poll = setInterval(() => {
+            if (connector.isConnected) {
+                clearInterval(poll);
+                connector.request('infinicode.push.report', report);
+                // Give the WS a beat to actually flush before closing.
+                setTimeout(() => finish(true), 250);
+            }
+        }, 100);
+        connector.start();
+        setTimeout(() => { clearInterval(poll); finish(false); }, 8000);
+    });
+}
+export async function maintain(config, taskPrompt, opts) {
+    const role = loadRole();
+    // Reuses the SAME identity `infinicode serve` on this device already
+    // persisted (.openkernel/node-identity.json) — so this report's nodeId
+    // matches the nodeId that device's nodes.status push uses, instead of the
+    // two diverging into separate fleet records for the same physical device.
+    const identity = loadOrCreateIdentity({ displayName: opts.name ?? role?.role });
+    const nodeId = identity.nodeId;
+    const taskName = opts.taskName ?? taskPrompt.slice(0, 60);
+    // Cache this as "the task this device runs" — the ONLY thing an on-demand
+    // "run maintenance now" trigger from the Fleet UI is allowed to replay
+    // later (see loadLastMaintenanceTask). Locally sourced only; a network
+    // trigger never carries or supplies task content.
+    saveLastMaintenanceTask({ taskPrompt, taskName });
+    console.log(chalk.bold(`\n  infinicode maintain — ${chalk.cyan(taskName)}`));
+    console.log(chalk.dim(`  node: ${identity.displayName} (${nodeId})${role ? ` · role: ${role.role}` : ''}`));
+    const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
+    let report;
+    try {
+        report = await runMaintenanceTask(kernel, taskPrompt, { nodeId, role, taskName });
+    }
+    finally {
+        kernel.destroy();
+    }
+    const ok = report.ok;
+    console.log(ok ? chalk.green(`  ✓ completed in ${report.durationMs}ms`) : chalk.red(`  ✗ failed in ${report.durationMs}ms`));
+    if (report.errors?.length)
+        console.log(chalk.red(`    ${report.errors.join('\n    ')}`));
+    if (opts.gateway) {
+        const pushed = await pushReportOnce(opts.gateway, report, {
+            token: opts.gatewayToken,
+            password: opts.gatewayPassword,
+            role: role?.role ?? 'operator',
+        });
+        console.log(pushed
+            ? chalk.green(`  ✓ report pushed to ${opts.gateway}`)
+            : chalk.yellow(`  ⚠ could not confirm report delivery to ${opts.gateway} (handshake timed out)`));
+    }
+    else {
+        console.log(chalk.dim('  (no --gateway given — report was not pushed anywhere)'));
+    }
+    process.exit(ok ? 0 : 1);
+}

package/dist/commands/mcp.js

@@ -70,7 +70,7 @@ export async function mcpCommand(config, opts) {
         identity,
         describe,
         logger: stderrLogger,
-        options: { version, port, token, autoUpdate: fed.autoUpdate, applyConfig, autoPullConfig: role === 'satellite' },
+        options: { version, port, token, autoUpdate: fed.autoUpdate, applyConfig, autoPullConfig: role === 'satellite', coder: config.get('coder') },
     });
     // Let the kernel's slash-command surface reach the mesh (/nodes, /node, …).
     kernel.attachFederation(federation);

package/dist/commands/robopark.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from 'commander';
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/config-schema.js';
+/** Attach the robopark verbs to a Commander command (the `robopark` program in
+ *  the standalone bin, or the `infinicode robopark` group). */
+export declare function attachRoboparkSubcommands(cmd: Command, config: Conf<InfinicodeConfig>): void;