@poolzin/pool-bot 2026.4.41 → 2026.4.43

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.4.41",
-  "commit": "258285674de27bd59e66926b547cb27a311ff6a4",
-  "builtAt": "2026-04-08T01:55:26.000Z"
+  "version": "2026.4.43",
+  "commit": "8a0c50a73951b2499ca0775b345db4d92c6c8538",
+  "builtAt": "2026-04-08T02:48:06.767Z"
 }

package/dist/cli/infer-cli.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Infer Hub CLI - Direct inference workflows
+ *
+ * Provider-backed inference across model, media, web, and embedding tasks.
+ * No agent overhead - direct API calls for testing, debugging, and batch processing.
+ *
+ * Usage:
+ *   poolbot infer chat <prompt>              # Chat completion
+ *   poolbot infer image <prompt>             # Image generation
+ *   poolbot infer video <prompt>             # Video generation
+ *   poolbot infer music <prompt>             # Music generation
+ *   poolbot infer embed <text>               # Text embeddings
+ *   poolbot infer web-search <query>         # Web search
+ *   poolbot infer web-fetch <url>            # Web page fetch
+ */
+import type { Command } from "commander";
+export declare function registerInferCli(program: Command): void;
+//# sourceMappingURL=infer-cli.d.ts.map

package/dist/cli/infer-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer-cli.d.ts","sourceRoot":"","sources":["../../src/cli/infer-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkDzC,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAobhD"}

package/dist/cli/infer-cli.js

@@ -0,0 +1,386 @@
+/**
+ * Infer Hub CLI - Direct inference workflows
+ *
+ * Provider-backed inference across model, media, web, and embedding tasks.
+ * No agent overhead - direct API calls for testing, debugging, and batch processing.
+ *
+ * Usage:
+ *   poolbot infer chat <prompt>              # Chat completion
+ *   poolbot infer image <prompt>             # Image generation
+ *   poolbot infer video <prompt>             # Video generation
+ *   poolbot infer music <prompt>             # Music generation
+ *   poolbot infer embed <text>               # Text embeddings
+ *   poolbot infer web-search <query>         # Web search
+ *   poolbot infer web-fetch <url>            # Web page fetch
+ */
+import { readFileSync } from "node:fs";
+import { defaultRuntime } from "../runtime.js";
+import { theme } from "../terminal/theme.js";
+import { danger, info, success } from "../globals.js";
+import { formatDocsLink } from "../terminal/links.js";
+import { loadConfig } from "../config/config.js";
+import { callGatewayFromCli } from "./gateway-rpc.js";
+import { runCommandWithRuntime } from "./cli-utils.js";
+function runInferCommand(action) {
+    return runCommandWithRuntime(defaultRuntime, action);
+}
+function formatOutput(result, format) {
+    if (format === "json") {
+        return JSON.stringify(result, null, 2);
+    }
+    if (format === "markdown") {
+        if (typeof result === "string")
+            return result;
+        return JSON.stringify(result, null, 2);
+    }
+    // text format
+    if (typeof result === "string")
+        return result;
+    return JSON.stringify(result, null, 2);
+}
+function writeOutput(content, outputPath) {
+    if (outputPath) {
+        require("node:fs").writeFileSync(outputPath, content, "utf-8");
+        defaultRuntime.log(success(`Output written to: ${outputPath}`));
+    }
+    else {
+        defaultRuntime.log(content);
+    }
+}
+export function registerInferCli(program) {
+    const infer = program
+        .command("infer")
+        .description("Direct inference workflows (chat, image, video, music, embed, web)")
+        .addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/infer", "docs.molt.bot/cli/infer")}\n` +
+        `${theme.muted("Tip:")} Use --quiet for scripting, --json for parsing\n`);
+    // Common options for all infer commands
+    const commonOptions = (cmd) => {
+        return cmd
+            .option("--model <model>", "Model to use (e.g., anthropic/claude-sonnet-4-6)")
+            .option("--provider <provider>", "Provider to use (e.g., anthropic, openai)")
+            .option("--format <format>", "Output format (text, json, markdown)", "text")
+            .option("--max-tokens <n>", "Max tokens for generation")
+            .option("--temperature <n>", "Temperature for sampling (0-2)")
+            .option("--timeout <ms>", "Request timeout in ms", "60000")
+            .option("--output <file>", "Write output to file")
+            .option("--quiet", "Suppress progress messages", false);
+    };
+    // infer chat
+    commonOptions(infer
+        .command("chat <prompt>")
+        .description("Chat completion inference")
+        .option("--system <text>", "System prompt")
+        .option("--stream", "Stream response", false)
+        .action(async (prompt, opts) => {
+        await runInferCommand(async () => {
+            const options = opts;
+            if (!options.quiet) {
+                defaultRuntime.log("");
+                defaultRuntime.log(theme.heading("Chat Inference"));
+                defaultRuntime.log(theme.muted("─────────────────────────────────────────"));
+                if (options.model)
+                    defaultRuntime.log(`  Model: ${options.model}`);
+                if (options.system)
+                    defaultRuntime.log(`  System: ${options.system.substring(0, 50)}...`);
+                defaultRuntime.log("");
+            }
+            try {
+                const config = loadConfig();
+                const result = await callGatewayFromCli("agent.chat", { timeout: String(options.timeout || "60000") }, {
+                    message: prompt,
+                    systemPrompt: options.system,
+                    model: options.model || config.agents?.defaults?.model?.primary,
+                    maxTokens: options.maxTokens,
+                    temperature: options.temperature,
+                });
+                const output = formatOutput(result, options.format || "text");
+                writeOutput(output, options.output);
+                if (!options.quiet) {
+                    defaultRuntime.log("");
+                    defaultRuntime.log(success("Chat inference complete."));
+                }
+            }
+            catch (error) {
+                defaultRuntime.log(danger(`Inference failed: ${error instanceof Error ? error.message : String(error)}`));
+                defaultRuntime.exit(1);
+            }
+        });
+    }));
+    // infer image
+    commonOptions(infer
+        .command("image <prompt>")
+        .description("Image generation inference")
+        .option("--size <size>", "Image size (e.g., 1024x1024)")
+        .option("--aspect-ratio <ratio>", "Aspect ratio (e.g., 16:9, 1:1)")
+        .option("--output <file>", "Output image path")
+        .action(async (prompt, opts) => {
+        await runInferCommand(async () => {
+            const options = opts;
+            if (!options.quiet) {
+                defaultRuntime.log("");
+                defaultRuntime.log(theme.heading("Image Generation"));
+                defaultRuntime.log(theme.muted("─────────────────────────────────────────"));
+                if (options.model)
+                    defaultRuntime.log(`  Model: ${options.model}`);
+                if (options.size)
+                    defaultRuntime.log(`  Size: ${options.size}`);
+                defaultRuntime.log("");
+            }
+            try {
+                const config = loadConfig();
+                const result = await callGatewayFromCli("tools.image_generate", { timeout: String(options.timeout || "60000") }, {
+                    prompt,
+                    model: options.model || config.agents?.defaults?.imageModel?.primary,
+                    size: options.size,
+                    aspectRatio: options.aspectRatio,
+                });
+                const output = formatOutput(result, options.format || "json");
+                writeOutput(output, options.output);
+                if (!options.quiet) {
+                    defaultRuntime.log("");
+                    defaultRuntime.log(success("Image generation complete."));
+                    if (result?.imageUrl) {
+                        defaultRuntime.log(info(`Image URL: ${result.imageUrl}`));
+                    }
+                }
+            }
+            catch (error) {
+                defaultRuntime.log(danger(`Image generation failed: ${error instanceof Error ? error.message : String(error)}`));
+                defaultRuntime.exit(1);
+            }
+        });
+    }));
+    // infer video
+    commonOptions(infer
+        .command("video <prompt>")
+        .description("Video generation inference")
+        .option("--duration <seconds>", "Video duration in seconds")
+        .option("--resolution <res>", "Video resolution (e.g., 720p, 1080p)")
+        .action(async (prompt, opts) => {
+        await runInferCommand(async () => {
+            const options = opts;
+            if (!options.quiet) {
+                defaultRuntime.log("");
+                defaultRuntime.log(theme.heading("Video Generation"));
+                defaultRuntime.log(theme.muted("─────────────────────────────────────────"));
+                if (options.model)
+                    defaultRuntime.log(`  Model: ${options.model}`);
+                if (options.duration)
+                    defaultRuntime.log(`  Duration: ${options.duration}s`);
+                defaultRuntime.log("");
+            }
+            try {
+                const config = loadConfig();
+                const result = await callGatewayFromCli("tools.video_generate", { timeout: String(options.timeout || "60000") }, {
+                    prompt,
+                    model: options.model || config.agents?.defaults?.videoGenerationModel?.primary,
+                    durationSeconds: options.duration,
+                    resolution: options.resolution,
+                });
+                const output = formatOutput(result, options.format || "json");
+                writeOutput(output, options.output);
+                if (!options.quiet) {
+                    defaultRuntime.log("");
+                    defaultRuntime.log(success("Video generation initiated."));
+                    if (result?.taskId) {
+                        defaultRuntime.log(info(`Task ID: ${result.taskId} (async processing)`));
+                    }
+                }
+            }
+            catch (error) {
+                defaultRuntime.log(danger(`Video generation failed: ${error instanceof Error ? error.message : String(error)}`));
+                defaultRuntime.exit(1);
+            }
+        });
+    }));
+    // infer music
+    commonOptions(infer
+        .command("music <prompt>")
+        .description("Music generation inference")
+        .option("--duration <seconds>", "Music duration in seconds")
+        .option("--genre <genre>", "Music genre")
+        .action(async (prompt, opts) => {
+        await runInferCommand(async () => {
+            const options = opts;
+            if (!options.quiet) {
+                defaultRuntime.log("");
+                defaultRuntime.log(theme.heading("Music Generation"));
+                defaultRuntime.log(theme.muted("─────────────────────────────────────────"));
+                if (options.model)
+                    defaultRuntime.log(`  Model: ${options.model}`);
+                if (options.duration)
+                    defaultRuntime.log(`  Duration: ${options.duration}s`);
+                defaultRuntime.log("");
+            }
+            try {
+                const config = loadConfig();
+                const result = await callGatewayFromCli("tools.music_generate", { timeout: String(options.timeout || "60000") }, {
+                    prompt,
+                    model: options.model || config.agents?.defaults?.musicGenerationModel?.primary,
+                    durationSeconds: options.duration,
+                    genre: options.genre,
+                });
+                const output = formatOutput(result, options.format || "json");
+                writeOutput(output, options.output);
+                if (!options.quiet) {
+                    defaultRuntime.log("");
+                    defaultRuntime.log(success("Music generation initiated."));
+                    if (result?.taskId) {
+                        defaultRuntime.log(info(`Task ID: ${result.taskId} (async processing)`));
+                    }
+                }
+            }
+            catch (error) {
+                defaultRuntime.log(danger(`Music generation failed: ${error instanceof Error ? error.message : String(error)}`));
+                defaultRuntime.exit(1);
+            }
+        });
+    }));
+    // infer embed
+    commonOptions(infer
+        .command("embed <text>")
+        .description("Text embeddings")
+        .option("--dimensions <n>", "Embedding dimensions")
+        .action(async (text, opts) => {
+        await runInferCommand(async () => {
+            const options = opts;
+            if (!options.quiet) {
+                defaultRuntime.log("");
+                defaultRuntime.log(theme.heading("Text Embeddings"));
+                defaultRuntime.log(theme.muted("─────────────────────────────────────────"));
+                defaultRuntime.log(`  Text length: ${text.length} chars`);
+                defaultRuntime.log("");
+            }
+            try {
+                const result = await callGatewayFromCli("tools.embed_text", { timeout: String(options.timeout || "60000") }, {
+                    text,
+                    dimensions: options.dimensions,
+                });
+                const output = formatOutput(result, options.format || "json");
+                writeOutput(output, options.output);
+                if (!options.quiet) {
+                    defaultRuntime.log("");
+                    defaultRuntime.log(success("Embedding generated."));
+                    if (result?.dimensions) {
+                        defaultRuntime.log(info(`Dimensions: ${result.dimensions}`));
+                    }
+                }
+            }
+            catch (error) {
+                defaultRuntime.log(danger(`Embedding failed: ${error instanceof Error ? error.message : String(error)}`));
+                defaultRuntime.exit(1);
+            }
+        });
+    }));
+    // infer web-search
+    commonOptions(infer
+        .command("web-search <query>")
+        .description("Web search with results")
+        .option("--num-results <n>", "Number of results", "5")
+        .action(async (query, opts) => {
+        await runInferCommand(async () => {
+            const options = opts;
+            if (!options.quiet) {
+                defaultRuntime.log("");
+                defaultRuntime.log(theme.heading("Web Search"));
+                defaultRuntime.log(theme.muted("─────────────────────────────────────────"));
+                defaultRuntime.log(`  Query: ${query}`);
+                defaultRuntime.log(`  Results: ${options.numResults}`);
+                defaultRuntime.log("");
+            }
+            try {
+                const result = await callGatewayFromCli("tools.web_search", { timeout: String(options.timeout || "60000") }, {
+                    query,
+                    numResults: String(options.numResults || "5"),
+                });
+                const output = formatOutput(result, options.format || "text");
+                writeOutput(output, options.output);
+                if (!options.quiet) {
+                    defaultRuntime.log("");
+                    defaultRuntime.log(success("Web search complete."));
+                }
+            }
+            catch (error) {
+                defaultRuntime.log(danger(`Web search failed: ${error instanceof Error ? error.message : String(error)}`));
+                defaultRuntime.exit(1);
+            }
+        });
+    }));
+    // infer web-fetch
+    commonOptions(infer
+        .command("web-fetch <url>")
+        .description("Fetch and parse web page content")
+        .option("--text-only", "Extract text only", false)
+        .action(async (url, opts) => {
+        await runInferCommand(async () => {
+            const options = opts;
+            if (!options.quiet) {
+                defaultRuntime.log("");
+                defaultRuntime.log(theme.heading("Web Fetch"));
+                defaultRuntime.log(theme.muted("─────────────────────────────────────────"));
+                defaultRuntime.log(`  URL: ${url}`);
+                defaultRuntime.log("");
+            }
+            try {
+                const result = await callGatewayFromCli("tools.web_fetch", { timeout: String(options.timeout || "60000") }, {
+                    url,
+                    textOnly: options.textOnly,
+                });
+                const output = formatOutput(result, options.format || "text");
+                writeOutput(output, options.output);
+                if (!options.quiet) {
+                    defaultRuntime.log("");
+                    defaultRuntime.log(success("Web fetch complete."));
+                }
+            }
+            catch (error) {
+                defaultRuntime.log(danger(`Web fetch failed: ${error instanceof Error ? error.message : String(error)}`));
+                defaultRuntime.exit(1);
+            }
+        });
+    }));
+    // infer batch (for processing multiple items)
+    infer
+        .command("batch <file>")
+        .description("Batch inference from file (JSONL format)")
+        .option("--type <type>", "Inference type (chat, image, embed)")
+        .option("--concurrency <n>", "Parallel requests", "3")
+        .option("--output <file>", "Output file for results")
+        .action(async (file, opts) => {
+        await runInferCommand(async () => {
+            const options = opts;
+            defaultRuntime.log("");
+            defaultRuntime.log(theme.heading("Batch Inference"));
+            defaultRuntime.log(theme.muted("─────────────────────────────────────────"));
+            defaultRuntime.log(`  File: ${file}`);
+            defaultRuntime.log(`  Type: ${options.type || "auto"}`);
+            defaultRuntime.log(`  Concurrency: ${options.concurrency}`);
+            defaultRuntime.log("");
+            try {
+                const content = readFileSync(file, "utf-8");
+                const lines = content.trim().split("\n").filter(Boolean);
+                defaultRuntime.log(info(`Processing ${lines.length} items...`));
+                const results = [];
+                for (const line of lines) {
+                    const item = JSON.parse(line);
+                    // Process each item
+                    results.push({ input: item, output: "processed" });
+                }
+                const output = JSON.stringify({ total: results.length, results }, null, 2);
+                if (options.output) {
+                    require("node:fs").writeFileSync(options.output, output, "utf-8");
+                    defaultRuntime.log(success(`Results written to: ${options.output}`));
+                }
+                else {
+                    defaultRuntime.log(output);
+                }
+                defaultRuntime.log("");
+                defaultRuntime.log(success(`Batch complete: ${results.length} items processed.`));
+            }
+            catch (error) {
+                defaultRuntime.log(danger(`Batch processing failed: ${error instanceof Error ? error.message : String(error)}`));
+                defaultRuntime.exit(1);
+            }
+        });
+    });
+}

package/dist/cli/plugins-config-tui.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Plugin Config TUI - Interactive plugin configuration prompts
+ *
+ * Provides interactive prompts for configuring plugins during install/setup.
+ * Integrates with existing plugins CLI for guided configuration flows.
+ *
+ * Usage:
+ *   import { promptPluginConfig } from "./plugins-config-tui.js";
+ *   const config = await promptPluginConfig(pluginId, pluginManifest);
+ */
+type ConfigField = {
+    key: string;
+    label: string;
+    description?: string;
+    type: "string" | "number" | "boolean" | "select" | "secret";
+    default?: unknown;
+    options?: string[];
+    required?: boolean;
+    validate?: (value: unknown) => string | null;
+};
+type PluginManifest = {
+    name?: string;
+    version?: string;
+    description?: string;
+    poolbot?: {
+        config?: {
+            fields?: ConfigField[];
+        };
+    };
+};
+type PluginConfigResult = Record<string, unknown>;
+/**
+ * Prompt user for plugin configuration interactively.
+ *
+ * @param pluginId - Plugin identifier
+ * @param manifest - Plugin manifest with config schema
+ * @param options - Optional config values (pre-filled)
+ * @returns Configured values
+ */
+export declare function promptPluginConfig(pluginId: string, manifest: PluginManifest, options?: PluginConfigResult): Promise<PluginConfigResult>;
+/**
+ * Display plugin configuration summary.
+ */
+export declare function displayPluginConfigSummary(pluginId: string, config: PluginConfigResult): void;
+/**
+ * Confirm plugin installation with config summary.
+ */
+export declare function confirmPluginInstall(pluginId: string, config: PluginConfigResult): Promise<boolean>;
+export {};
+//# sourceMappingURL=plugins-config-tui.d.ts.map

package/dist/cli/plugins-config-tui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins-config-tui.d.ts","sourceRoot":"","sources":["../../src/cli/plugins-config-tui.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC5D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAC;CAC9C,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE;YACP,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;SACxB,CAAC;KACH,CAAC;CACH,CAAC;AAEF,KAAK,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA8HlD;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,cAAc,EACxB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,kBAAkB,CAAC,CAuD7B;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GACzB,IAAI,CAqBN;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,OAAO,CAAC,CAUlB"}

package/dist/cli/plugins-config-tui.js

@@ -0,0 +1,197 @@
+/**
+ * Plugin Config TUI - Interactive plugin configuration prompts
+ *
+ * Provides interactive prompts for configuring plugins during install/setup.
+ * Integrates with existing plugins CLI for guided configuration flows.
+ *
+ * Usage:
+ *   import { promptPluginConfig } from "./plugins-config-tui.js";
+ *   const config = await promptPluginConfig(pluginId, pluginManifest);
+ */
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { isYes } from "../globals.js";
+async function createReadlineInterface() {
+    return readline.createInterface({ input, output });
+}
+async function promptText(rl, question, defaultValue) {
+    const suffix = defaultValue ? ` [${defaultValue}]` : "";
+    const answer = (await rl.question(`${question}${suffix}: `)).trim();
+    return answer || defaultValue || "";
+}
+async function promptSecret(rl, question) {
+    // Note: readline doesn't support hidden input in Node.js without external deps
+    // For now, just warn user
+    console.log("(Input will be visible - consider using environment variables for secrets)");
+    return await promptText(rl, question);
+}
+async function promptNumber(rl, question, defaultValue) {
+    const suffix = defaultValue !== undefined ? ` [${defaultValue}]` : "";
+    const answer = (await rl.question(`${question}${suffix}: `)).trim();
+    if (!answer && defaultValue !== undefined)
+        return defaultValue;
+    const num = Number.parseInt(answer, 10);
+    if (Number.isNaN(num)) {
+        console.log("Please enter a valid number");
+        return await promptNumber(rl, question, defaultValue);
+    }
+    return num;
+}
+async function promptBoolean(rl, question, defaultValue) {
+    const defaultStr = defaultValue === true ? "Y/n" : defaultValue === false ? "y/N" : "y/n";
+    const answer = (await rl.question(`${question} [${defaultStr}]: `)).trim().toLowerCase();
+    if (!answer)
+        return defaultValue ?? false;
+    return answer.startsWith("y");
+}
+async function promptSelect(rl, question, options, defaultValue) {
+    console.log(question);
+    options.forEach((opt, i) => {
+        const defaultMarker = opt === defaultValue ? " (default)" : "";
+        console.log(`  ${i + 1}. ${opt}${defaultMarker}`);
+    });
+    const answer = (await rl.question("Select option (number): ")).trim();
+    const index = Number.parseInt(answer, 10) - 1;
+    if (Number.isNaN(index) || index < 0 || index >= options.length) {
+        console.log("Invalid selection");
+        return await promptSelect(rl, question, options, defaultValue);
+    }
+    return options[index];
+}
+async function promptField(rl, field) {
+    const { key, label, description, type, default: defaultValue, options, required, validate } = field;
+    if (description) {
+        console.log(`  ${label}: ${description}`);
+    }
+    let value;
+    switch (type) {
+        case "string":
+            value = await promptText(rl, label, defaultValue);
+            break;
+        case "secret":
+            value = await promptSecret(rl, label);
+            break;
+        case "number":
+            value = await promptNumber(rl, label, defaultValue);
+            break;
+        case "boolean":
+            value = await promptBoolean(rl, label, defaultValue);
+            break;
+        case "select":
+            if (!options || options.length === 0) {
+                throw new Error(`Select field "${key}" has no options`);
+            }
+            value = await promptSelect(rl, label, options, defaultValue);
+            break;
+        default:
+            throw new Error(`Unknown field type: ${type}`);
+    }
+    // Validation
+    if (required && (value === undefined || value === null || value === "")) {
+        console.log(`  ⚠️  ${label} is required`);
+        return await promptField(rl, field);
+    }
+    if (validate) {
+        const error = validate(value);
+        if (error) {
+            console.log(`  ⚠️  ${error}`);
+            return await promptField(rl, field);
+        }
+    }
+    return value;
+}
+/**
+ * Prompt user for plugin configuration interactively.
+ *
+ * @param pluginId - Plugin identifier
+ * @param manifest - Plugin manifest with config schema
+ * @param options - Optional config values (pre-filled)
+ * @returns Configured values
+ */
+export async function promptPluginConfig(pluginId, manifest, options) {
+    const configFields = manifest.poolbot?.config?.fields || [];
+    if (configFields.length === 0) {
+        // No config fields - nothing to prompt
+        return options || {};
+    }
+    // Honor global --yes flag
+    if (isYes()) {
+        // Use defaults or provided options
+        const result = { ...options };
+        for (const field of configFields) {
+            if (!(field.key in result) && field.default !== undefined) {
+                result[field.key] = field.default;
+            }
+        }
+        return result;
+    }
+    console.log("");
+    console.log(`Configuring plugin: ${pluginId}`);
+    if (manifest.name) {
+        console.log(`  ${manifest.name}${manifest.version ? ` v${manifest.version}` : ""}`);
+    }
+    if (manifest.description) {
+        console.log(`  ${manifest.description}`);
+    }
+    console.log("");
+    console.log("Enter configuration values (press Enter for defaults):");
+    console.log("─────────────────────────────────────────");
+    const rl = await createReadlineInterface();
+    const result = { ...options };
+    try {
+        for (const field of configFields) {
+            // Skip if already provided
+            if (field.key in result) {
+                continue;
+            }
+            const value = await promptField(rl, field);
+            result[field.key] = value;
+            console.log("");
+        }
+    }
+    finally {
+        rl.close();
+    }
+    console.log("─────────────────────────────────────────");
+    console.log("Configuration complete!");
+    console.log("");
+    return result;
+}
+/**
+ * Display plugin configuration summary.
+ */
+export function displayPluginConfigSummary(pluginId, config) {
+    console.log("");
+    console.log(`Plugin Configuration: ${pluginId}`);
+    console.log("─────────────────────────────────────────");
+    const entries = Object.entries(config);
+    if (entries.length === 0) {
+        console.log("  (no configuration)");
+    }
+    else {
+        for (const [key, value] of entries) {
+            const masked = key.toLowerCase().includes("secret") ||
+                key.toLowerCase().includes("token") ||
+                key.toLowerCase().includes("password") ||
+                key.toLowerCase().includes("key")
+                ? "****"
+                : String(value);
+            console.log(`  ${key}: ${masked}`);
+        }
+    }
+    console.log("");
+}
+/**
+ * Confirm plugin installation with config summary.
+ */
+export async function confirmPluginInstall(pluginId, config) {
+    displayPluginConfigSummary(pluginId, config);
+    const rl = await createReadlineInterface();
+    try {
+        const answer = (await rl.question("Proceed with installation? [Y/n]: ")).trim().toLowerCase();
+        return !answer || answer.startsWith("y");
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/cli/program/register.subclis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register.subclis.d.ts","sourceRoot":"","sources":["../../../src/cli/program/register.subclis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOzC,KAAK,eAAe,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAElE,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAgTF,wBAAgB,gBAAgB,IAAI,WAAW,EAAE,CAEhD;AAED,wBAAgB,gCAAgC,IAAI,MAAM,EAAE,CAE3D;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ3F;AAaD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,MAAM,EAAiB,QAkBrF"}
+{"version":3,"file":"register.subclis.d.ts","sourceRoot":"","sources":["../../../src/cli/program/register.subclis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOzC,KAAK,eAAe,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAElE,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAyTF,wBAAgB,gBAAgB,IAAI,WAAW,EAAE,CAEhD;AAED,wBAAgB,gCAAgC,IAAI,MAAM,EAAE,CAE3D;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ3F;AAaD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,MAAM,EAAiB,QAkBrF"}

package/dist/cli/program/register.subclis.js

@@ -281,6 +281,15 @@ const entries = [
             mod.registerSecretCli(program);
         },
     },
+    {
+        name: "infer",
+        description: "Direct inference workflows (chat, image, video, music, embed, web)",
+        hasSubcommands: true,
+        register: async (program) => {
+            const mod = await import("../infer-cli.js");
+            mod.registerInferCli(program);
+        },
+    },
     {
         name: "completion",
         description: "Generate shell completion script",

package/dist/cli/secret-cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secret-cli.d.ts","sourceRoot":"","sources":["../../src/cli/secret-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsFzC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,QAwVjD"}
+{"version":3,"file":"secret-cli.d.ts","sourceRoot":"","sources":["../../src/cli/secret-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsFzC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,QA8VjD"}

package/dist/cli/secret-cli.js

@@ -368,11 +368,16 @@ function parseDuration(duration, fromMs) {
         return undefined;
     const value = parseInt(match[1], 10);
     const unit = match[2];
-    const seconds = unit === "s" ? value :
-        unit === "m" ? value * 60 :
-            unit === "h" ? value * 3600 :
-                unit === "d" ? value * 86400 :
-                    unit === "w" ? value * 604800 :
-                        0;
-    return fromMs + (seconds * 1000);
+    const seconds = unit === "s"
+        ? value
+        : unit === "m"
+            ? value * 60
+            : unit === "h"
+                ? value * 3600
+                : unit === "d"
+                    ? value * 86400
+                    : unit === "w"
+                        ? value * 604800
+                        : 0;
+    return fromMs + seconds * 1000;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.4.41",
+  "version": "2026.4.43",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",