infinicode 2.3.5 → 2.4.0

package/.opencode/plugins/home-logo-animation.tsx

@@ -109,7 +109,7 @@ function AnimatedLogo(props: { renderer?: any }) {
   );
 }
 
-export const tui = async (api: any) => {
+const tui = async (api: any) => {
   api.slots.register({
     slots: {
       home_logo() {
@@ -118,3 +118,7 @@ export const tui = async (api: any) => {
     },
   });
 };
+
+// The TUI plugin loader reads `mod.default` (strict mode) and requires an object
+// with a tui() function — a bare `export const tui` is silently skipped.
+export default { id: "infinicode-home-logo", tui };

package/.opencode/plugins/mesh-commands.tsx

@@ -16,7 +16,6 @@
  * /follow, /dispatch, /goal, /mission, /role) open a prompt first.
  */
 import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
-import { createBindingLookup } from "@opentui/keymap/extras"
 
 type CommandResult = { ok?: boolean; text?: string; data?: unknown }
 
@@ -112,8 +111,10 @@ const SPECS: Spec[] = [
 
 const tui: TuiPlugin = async (api, options) => {
   if (options?.enabled === false) return
-  const keys = createBindingLookup({})
 
+  // No keybindings — these are palette-only slash commands. Empty bindings avoids
+  // any dependency on the keymap-extras runtime module (which may not resolve for
+  // an externally-loaded plugin) so registration can never fail to load.
   api.keymap.registerLayer({
     commands: SPECS.map((s) => ({
       name: s.name,
@@ -127,7 +128,7 @@ const tui: TuiPlugin = async (api, options) => {
         else runNow(api, s.title, cmd)
       },
     })),
-    bindings: keys.gather("mesh.global", SPECS.map((s) => s.name)),
+    bindings: [],
   })
 }
 

package/.opencode/plugins/routing-mode-display.tsx

@@ -85,7 +85,7 @@ function buildRoutingBadge(cfg: InfinicodeConfig | null, tuiModel?: string): Rou
 
 // ── Plugin ──────────────────────────────────────────────────────────────────
 
-export const tui = async (api: any) => {
+const tui = async (api: any) => {
   const [cfg] = createSignal(loadConfig());
 
   const getTuiModel = (): string | undefined => {
@@ -132,4 +132,8 @@ export const tui = async (api: any) => {
       },
     },
   });
-};
+};
+
+// The TUI plugin loader reads `mod.default` (strict mode) and requires an object
+// with a tui() function — a bare `export const tui` is silently skipped.
+export default { id: "infinicode-routing-mode", tui };

package/.opencode/tui.json

@@ -3,6 +3,7 @@
   "theme": "infinibot-gold",
   "plugin": [
     "./plugins/home-logo-animation.tsx",
-    "./plugins/routing-mode-display.tsx"
+    "./plugins/routing-mode-display.tsx",
+    "./plugins/mesh-commands.tsx"
   ]
 }

package/bin/robopark.js

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

package/dist/cli.js

@@ -14,9 +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.5';
+const VERSION = '2.4.0';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,
@@ -292,12 +295,54 @@ 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('--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')
+    .description('Join this device to the agent mesh by auto-registering the MCP server into your coding host');
+meshCmd
+    .command('install', { isDefault: true })
+    .description('Register the infinicode MCP server into Claude Code (and/or OpenCode) — no manual file edits')
+    .option('--host <host>', 'target host: claude | opencode | all', 'claude')
+    .option('--token <token>', 'shared bearer token every device must present (recommended off-LAN)')
+    .option('--name <name>', 'friendly node name for this device')
+    .option('--tailscale', 'discover peers over Tailscale instead of / as well as the LAN')
+    .option('--no-lan', 'disable zero-config LAN auto-discovery')
+    .option('--print', 'dry run — show what would be written without changing anything')
+    .action(async (opts) => {
+    await meshInstall(opts);
+});
+meshCmd
+    .command('uninstall')
+    .description('Remove the infinicode MCP server from your coding host')
+    .option('--host <host>', 'target host: claude | opencode | all', 'claude')
+    .action(async (opts) => {
+    await meshUninstall(opts);
+});
 // ── infinicode: install the TUI binary into this install ───────────────────
 program
     .command('install-tui')

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/mesh-install.d.ts

@@ -0,0 +1,10 @@
+export interface MeshInstallOptions {
+    host?: string;
+    token?: string;
+    name?: string;
+    tailscale?: boolean;
+    lan?: boolean;
+    print?: boolean;
+}
+export declare function meshInstall(opts: MeshInstallOptions): Promise<void>;
+export declare function meshUninstall(opts: MeshInstallOptions): Promise<void>;

package/dist/commands/mesh-install.js

@@ -0,0 +1,160 @@
+/**
+ * infinicode mesh install — register the infinicode MCP server into a coding
+ * host's config automatically, so the user never hand-edits a JSON file.
+ *
+ *   infinicode mesh install                 → add to Claude Code (~/.claude.json)
+ *   infinicode mesh install --host all      → Claude Code + OpenCode
+ *   infinicode mesh install --token secret   → gated mesh
+ *   infinicode mesh uninstall                → remove it again
+ *
+ * After it runs, the user just restarts their coding host and the mesh tools
+ * (list_nodes / spawn_agent / send_message …) are available. On another laptop
+ * with the same one command, the two nodes auto-discover over the LAN.
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findExecutable } from '../kernel/agents/backends/detect.js';
+/** How a host should spawn the infinicode MCP node. Resolves a global binary
+ *  if present, else falls back to `node <this package's cli.js>`. */
+function resolveLaunch() {
+    const onPath = findExecutable('infinicode');
+    if (onPath)
+        return { command: 'infinicode', baseArgs: [] };
+    const cliJs = join(dirname(fileURLToPath(import.meta.url)), '..', 'cli.js');
+    return { command: process.execPath, baseArgs: [cliJs] };
+}
+/** The `infinicode mcp …` argv the host should run. */
+function meshArgs(opts) {
+    const args = ['mcp'];
+    if (opts.lan !== false)
+        args.push('--lan');
+    if (opts.tailscale)
+        args.push('--tailscale');
+    if (opts.token)
+        args.push('--token', opts.token);
+    if (opts.name)
+        args.push('--name', opts.name);
+    return args;
+}
+function readJson(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Back up a config once before the first infinicode edit, then write pretty JSON. */
+function writeJson(path, data) {
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    if (existsSync(path)) {
+        const bak = `${path}.infinicode.bak`;
+        if (!existsSync(bak))
+            copyFileSync(path, bak);
+    }
+    writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+}
+const CLAUDE_CONFIG = () => join(homedir(), '.claude.json');
+const OPENCODE_CONFIG = () => join(homedir(), '.config', 'opencode', 'opencode.json');
+/** Claude Code: mcpServers.infinicode = { command, args }. */
+function installClaude(opts) {
+    const path = CLAUDE_CONFIG();
+    const cfg = readJson(path);
+    const servers = cfg.mcpServers ?? {};
+    const existed = 'infinicode' in servers;
+    const { command, baseArgs } = resolveLaunch();
+    const entry = { command, args: [...baseArgs, ...meshArgs(opts)] };
+    if (!opts.print) {
+        cfg.mcpServers = { ...servers, infinicode: entry };
+        writeJson(path, cfg);
+    }
+    return { path, entry, existed };
+}
+/** OpenCode: mcp.infinicode = { type:'local', command:[...], enabled:true }. */
+function installOpencode(opts) {
+    const path = OPENCODE_CONFIG();
+    const cfg = readJson(path);
+    const mcp = cfg.mcp ?? {};
+    const existed = 'infinicode' in mcp;
+    const { command, baseArgs } = resolveLaunch();
+    const entry = { type: 'local', command: [command, ...baseArgs, ...meshArgs(opts)], enabled: true };
+    if (!opts.print) {
+        cfg.mcp = { ...mcp, infinicode: entry };
+        writeJson(path, cfg);
+    }
+    return { path, entry, existed };
+}
+function removeFrom(path, key) {
+    if (!existsSync(path))
+        return false;
+    const cfg = readJson(path);
+    const bag = cfg[key];
+    if (!bag || !('infinicode' in bag))
+        return false;
+    delete bag.infinicode;
+    cfg[key] = bag;
+    writeJson(path, cfg);
+    return true;
+}
+function selectedHosts(host) {
+    const h = (host ?? 'claude').toLowerCase();
+    if (h === 'all')
+        return ['claude', 'opencode'];
+    if (h === 'opencode')
+        return ['opencode'];
+    if (h === 'claude' || h === 'claude-code')
+        return ['claude'];
+    return ['claude'];
+}
+export async function meshInstall(opts) {
+    const hosts = selectedHosts(opts.host);
+    console.log(chalk.bold('\n🕸  infinicode mesh — MCP registration\n'));
+    for (const host of hosts) {
+        const res = host === 'claude' ? installClaude(opts) : installOpencode(opts);
+        const label = host === 'claude' ? 'Claude Code' : 'OpenCode';
+        const verb = opts.print ? 'would write' : res.existed ? 'updated' : 'added';
+        console.log(`  ${chalk.green('✓')} ${chalk.cyan(label)} — ${verb} ${chalk.dim(res.path)}`);
+        console.log(chalk.dim(`      ${JSON.stringify(res.entry)}`));
+    }
+    // Warn if the target CLI backend isn't installed on THIS machine — a worker
+    // node can only run agents for CLIs it actually has.
+    const present = ['claude', 'codex', 'opencode'].filter(b => findExecutable(b));
+    console.log();
+    if (present.length) {
+        console.log(`  ${chalk.green('•')} coding CLIs detected here (can execute agents): ${chalk.bold(present.join(', '))}`);
+    }
+    else {
+        console.log(`  ${chalk.yellow('•')} no coding CLI (claude/codex/opencode) found on PATH — this device can drive the mesh but can't execute agents until one is installed.`);
+    }
+    if (opts.print) {
+        console.log(chalk.dim('\n  (dry run — nothing was written)\n'));
+        return;
+    }
+    console.log(chalk.bold('\n  Next:'));
+    console.log(`    1. Run the SAME command on the other laptop.`);
+    console.log(`    2. Restart your coding host (Claude Code) on both.`);
+    console.log(`    3. Ask it: ${chalk.italic('"list_nodes"')} then ${chalk.italic('"spawn_agent on <laptop> with agent claude to …"')}`);
+    if (!opts.token) {
+        console.log(chalk.dim(`\n  Tip: on an untrusted network, re-run with --token <secret> on every device.`));
+    }
+    console.log();
+}
+export async function meshUninstall(opts) {
+    const hosts = selectedHosts(opts.host);
+    console.log(chalk.bold('\n🕸  infinicode mesh — removing MCP registration\n'));
+    for (const host of hosts) {
+        const path = host === 'claude' ? CLAUDE_CONFIG() : OPENCODE_CONFIG();
+        const key = host === 'claude' ? 'mcpServers' : 'mcp';
+        const removed = removeFrom(path, key);
+        const label = host === 'claude' ? 'Claude Code' : 'OpenCode';
+        console.log(`  ${removed ? chalk.green('✓ removed from') : chalk.dim('· not present in')} ${chalk.cyan(label)} ${chalk.dim(path)}`);
+    }
+    console.log(chalk.dim('\n  Restart your coding host to apply.\n'));
+}

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;