@kernel.chat/kbot 3.86.0 → 3.88.0

package/dist/tools/index.js

@@ -318,6 +318,8 @@ const LAZY_MODULE_IMPORTS = [
     { path: './stream-character.js', registerFn: 'registerStreamCharacterTools' },
     { path: './stream-renderer.js', registerFn: 'registerStreamRendererTools' },
     { path: './kbot-browser.js', registerFn: 'registerKBotBrowserTools' },
+    { path: './kbot-terminal.js', registerFn: 'registerKBotTerminalTools' },
+    { path: './stream-control.js', registerFn: 'registerStreamControlTools' },
 ];
 /** Track whether lazy tools have been registered */
 let lazyToolsRegistered = false;

package/dist/tools/kbot-terminal.d.ts

@@ -0,0 +1,2 @@
+export declare function registerKBotTerminalTools(): void;
+//# sourceMappingURL=kbot-terminal.d.ts.map

package/dist/tools/kbot-terminal.js

@@ -0,0 +1,424 @@
+// kbot Persistent Terminal — kbot's own shell environment
+//
+// A persistent terminal that survives session disconnects.
+// Shell state (cwd, env, history) persists to disk.
+// Command queue enables autonomous unattended execution.
+// Multiple named sessions with independent state.
+//
+// State: ~/.kbot/terminal-state.json
+// Queue: ~/.kbot/terminal-queue.json
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { registerTool } from './index.js';
+// ─── State ────────────────────────────────────────────────────────────────
+const KBOT_DIR = join(homedir(), '.kbot');
+const TERMINAL_STATE = join(KBOT_DIR, 'terminal-state.json');
+const COMMAND_QUEUE = join(KBOT_DIR, 'terminal-queue.json');
+const terminal = {
+    sessions: new Map(),
+    defaultSession: '',
+};
+let queueInterval = null;
+// ─── Session Management ───────────────────────────────────────────────────
+function createShellSession(name) {
+    const id = `term_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const session = {
+        id,
+        name,
+        cwd: homedir(),
+        env: { ...process.env },
+        history: [],
+        running: true,
+        pid: null,
+        createdAt: Date.now(),
+        lastActivity: Date.now(),
+        outputBuffer: [],
+        pendingCommand: null,
+        exitCode: null,
+    };
+    return session;
+}
+function findSession(nameOrId) {
+    if (terminal.sessions.has(nameOrId))
+        return nameOrId;
+    for (const [id, s] of terminal.sessions) {
+        if (s.name === nameOrId)
+            return id;
+    }
+    return terminal.defaultSession;
+}
+// ─── Command Execution ────────────────────────────────────────────────────
+async function executeInSession(session, command) {
+    const start = Date.now();
+    return new Promise((resolve_) => {
+        const proc = spawn('bash', ['-c', command], {
+            cwd: session.cwd,
+            env: session.env,
+            timeout: 300_000, // 5 min timeout
+        });
+        session.pid = proc.pid ?? null;
+        session.pendingCommand = command;
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (d) => {
+            const text = d.toString();
+            stdout += text;
+            // Add to rolling buffer
+            const lines = text.split('\n');
+            session.outputBuffer.push(...lines);
+            if (session.outputBuffer.length > 500) {
+                session.outputBuffer = session.outputBuffer.slice(-500);
+            }
+        });
+        proc.stderr?.on('data', (d) => {
+            const text = d.toString();
+            stderr += text;
+            // Also add stderr to output buffer for visibility
+            const lines = text.split('\n');
+            session.outputBuffer.push(...lines);
+            if (session.outputBuffer.length > 500) {
+                session.outputBuffer = session.outputBuffer.slice(-500);
+            }
+        });
+        proc.on('close', (code) => {
+            const entry = {
+                command,
+                output: (stdout + stderr).slice(0, 50_000), // cap at 50KB
+                exitCode: code ?? 1,
+                timestamp: start,
+                duration: Date.now() - start,
+            };
+            session.history.push(entry);
+            if (session.history.length > 200)
+                session.history = session.history.slice(-200);
+            session.lastActivity = Date.now();
+            session.exitCode = code;
+            session.pendingCommand = null;
+            session.pid = null;
+            // Track cwd changes
+            if (/^\s*cd\s/.test(command) && !command.includes('&&') && !command.includes(';')) {
+                const dir = command.replace(/^\s*cd\s+/, '').trim().replace(/^['"]|['"]$/g, '');
+                const expanded = dir.replace(/^~/, homedir());
+                try {
+                    const resolved = resolve(session.cwd, expanded);
+                    if (existsSync(resolved))
+                        session.cwd = resolved;
+                }
+                catch { /* keep current cwd */ }
+            }
+            // Save to disk
+            saveTerminalState();
+            resolve_(entry);
+        });
+        proc.on('error', (err) => {
+            const entry = {
+                command,
+                output: `Error: ${err.message}`,
+                exitCode: 1,
+                timestamp: start,
+                duration: Date.now() - start,
+            };
+            session.history.push(entry);
+            session.lastActivity = Date.now();
+            session.pendingCommand = null;
+            session.pid = null;
+            saveTerminalState();
+            resolve_(entry);
+        });
+    });
+}
+// ─── State Persistence ────────────────────────────────────────────────────
+function saveTerminalState() {
+    try {
+        if (!existsSync(KBOT_DIR))
+            mkdirSync(KBOT_DIR, { recursive: true });
+        const state = {
+            sessions: Array.from(terminal.sessions.entries()).map(([_id, s]) => ({
+                id: s.id,
+                name: s.name,
+                cwd: s.cwd,
+                createdAt: s.createdAt,
+                lastActivity: s.lastActivity,
+                history: s.history.slice(-50), // save last 50 commands
+                outputBuffer: s.outputBuffer.slice(-100), // save last 100 lines
+            })),
+            defaultSession: terminal.defaultSession,
+            savedAt: Date.now(),
+        };
+        writeFileSync(TERMINAL_STATE, JSON.stringify(state, null, 2));
+    }
+    catch { /* best-effort persistence */ }
+}
+function loadTerminalState() {
+    try {
+        if (existsSync(TERMINAL_STATE)) {
+            const raw = readFileSync(TERMINAL_STATE, 'utf-8');
+            const state = JSON.parse(raw);
+            for (const s of state.sessions || []) {
+                terminal.sessions.set(s.id, {
+                    id: s.id,
+                    name: s.name,
+                    cwd: s.cwd || homedir(),
+                    env: { ...process.env },
+                    history: s.history || [],
+                    running: true,
+                    pid: null,
+                    createdAt: s.createdAt || Date.now(),
+                    lastActivity: s.lastActivity || Date.now(),
+                    outputBuffer: s.outputBuffer || [],
+                    pendingCommand: null,
+                    exitCode: null,
+                });
+            }
+            if (state.defaultSession && terminal.sessions.has(state.defaultSession)) {
+                terminal.defaultSession = state.defaultSession;
+            }
+        }
+    }
+    catch { /* start fresh if state is corrupted */ }
+}
+// ─── Command Queue ────────────────────────────────────────────────────────
+function loadQueue() {
+    try {
+        if (existsSync(COMMAND_QUEUE)) {
+            return JSON.parse(readFileSync(COMMAND_QUEUE, 'utf-8'));
+        }
+    }
+    catch { /* empty queue on corruption */ }
+    return [];
+}
+function saveQueue(queue) {
+    try {
+        if (!existsSync(KBOT_DIR))
+            mkdirSync(KBOT_DIR, { recursive: true });
+        writeFileSync(COMMAND_QUEUE, JSON.stringify(queue, null, 2));
+    }
+    catch { /* best-effort */ }
+}
+function queueCommand(command, sessionId, delay) {
+    const queue = loadQueue();
+    queue.push({
+        command,
+        session: sessionId,
+        scheduledAt: Date.now(),
+        runAt: delay ? Date.now() + delay : undefined,
+    });
+    saveQueue(queue);
+}
+async function processQueue() {
+    const queue = loadQueue();
+    if (queue.length === 0)
+        return;
+    const now = Date.now();
+    const ready = queue.filter(q => !q.runAt || q.runAt <= now);
+    const remaining = queue.filter(q => q.runAt != null && q.runAt > now);
+    for (const cmd of ready) {
+        const session = terminal.sessions.get(cmd.session);
+        if (session) {
+            await executeInSession(session, cmd.command);
+        }
+    }
+    saveQueue(remaining);
+}
+function startQueueProcessor() {
+    if (queueInterval)
+        return;
+    queueInterval = setInterval(() => {
+        processQueue().catch(() => { });
+    }, 10_000);
+    // Don't keep the process alive just for the queue
+    if (queueInterval.unref)
+        queueInterval.unref();
+}
+// ─── Tool Registration ────────────────────────────────────────────────────
+export function registerKBotTerminalTools() {
+    // Initialize: load persisted state
+    loadTerminalState();
+    // Ensure at least one session exists
+    if (terminal.sessions.size === 0) {
+        const defaultSession = createShellSession('main');
+        terminal.sessions.set(defaultSession.id, defaultSession);
+        terminal.defaultSession = defaultSession.id;
+        saveTerminalState();
+    }
+    else if (!terminal.defaultSession || !terminal.sessions.has(terminal.defaultSession)) {
+        terminal.defaultSession = terminal.sessions.keys().next().value;
+    }
+    // Start background queue processor
+    // Queue processor disabled by default — only runs when explicitly commanded
+    // startQueueProcessor()
+    registerTool({
+        name: 'terminal_exec',
+        description: 'Execute a command in kbot\'s persistent terminal. Shell state (cwd, history) persists across calls and sessions. Output is stored for later retrieval.',
+        parameters: {
+            command: { type: 'string', description: 'Shell command to execute', required: true },
+            session: { type: 'string', description: 'Session name or ID (default: current default session)' },
+        },
+        tier: 'free',
+        timeout: 300_000,
+        async execute(args) {
+            const sessionId = findSession(String(args.session || 'main'));
+            const session = terminal.sessions.get(sessionId);
+            if (!session)
+                return 'Session not found. Use terminal_sessions action="list" to see available sessions.';
+            const result = await executeInSession(session, String(args.command));
+            return `[${session.name}:${session.cwd}] $ ${result.command}\n${result.output}\n[exit: ${result.exitCode}, ${result.duration}ms]`;
+        },
+    });
+    registerTool({
+        name: 'terminal_history',
+        description: 'View command history from kbot\'s persistent terminal. Shows recent commands and their output. History persists across process restarts.',
+        parameters: {
+            count: { type: 'string', description: 'Number of recent commands to show (default: 10)' },
+            session: { type: 'string', description: 'Session name or ID' },
+        },
+        tier: 'free',
+        async execute(args) {
+            const sessionId = findSession(String(args.session || 'main'));
+            const session = terminal.sessions.get(sessionId);
+            if (!session)
+                return 'Session not found';
+            const count = parseInt(String(args.count || '10'), 10) || 10;
+            const recent = session.history.slice(-count);
+            if (recent.length === 0)
+                return `[${session.name}] No command history yet.`;
+            return recent.map(h => `[${new Date(h.timestamp).toLocaleTimeString()}] $ ${h.command}\n${h.output.slice(0, 200)}${h.output.length > 200 ? '...' : ''}\n[exit: ${h.exitCode}, ${h.duration}ms]`).join('\n\n');
+        },
+    });
+    registerTool({
+        name: 'terminal_output',
+        description: 'Get the current output buffer from a terminal session. Shows the last N lines of combined stdout/stderr output across all commands.',
+        parameters: {
+            lines: { type: 'string', description: 'Number of lines to show (default: 50)' },
+            session: { type: 'string', description: 'Session name or ID' },
+        },
+        tier: 'free',
+        async execute(args) {
+            const sessionId = findSession(String(args.session || 'main'));
+            const session = terminal.sessions.get(sessionId);
+            if (!session)
+                return 'Session not found';
+            const lines = parseInt(String(args.lines || '50'), 10) || 50;
+            const buf = session.outputBuffer.slice(-lines);
+            if (buf.length === 0)
+                return `[${session.name}] Output buffer empty.`;
+            return buf.join('\n');
+        },
+    });
+    registerTool({
+        name: 'terminal_sessions',
+        description: 'List, create, or close terminal sessions. Each session has its own cwd, history, and output buffer.',
+        parameters: {
+            action: { type: 'string', description: '"list", "new", or "close"', required: true },
+            name: { type: 'string', description: 'Session name (for new/close)' },
+        },
+        tier: 'free',
+        async execute(args) {
+            const action = String(args.action);
+            if (action === 'list') {
+                const sessions = Array.from(terminal.sessions.values());
+                if (sessions.length === 0)
+                    return 'No sessions.';
+                return sessions.map(s => {
+                    const isDefault = s.id === terminal.defaultSession ? ' [default]' : '';
+                    const pending = s.pendingCommand ? `\n    running: ${s.pendingCommand}` : '';
+                    return `${s.name} (${s.id})${isDefault}\n    cwd: ${s.cwd}\n    commands: ${s.history.length}\n    last: ${new Date(s.lastActivity).toLocaleString()}${pending}`;
+                }).join('\n\n');
+            }
+            if (action === 'new') {
+                const name = String(args.name || `session-${terminal.sessions.size + 1}`);
+                // Check for duplicate names
+                for (const s of terminal.sessions.values()) {
+                    if (s.name === name)
+                        return `Session "${name}" already exists. Choose a different name.`;
+                }
+                const session = createShellSession(name);
+                terminal.sessions.set(session.id, session);
+                terminal.defaultSession = session.id;
+                saveTerminalState();
+                return `Created session: ${name} (${session.id}) — now the default session.`;
+            }
+            if (action === 'close') {
+                if (!args.name)
+                    return 'Specify session name to close.';
+                const sessionId = findSession(String(args.name));
+                if (!terminal.sessions.has(sessionId))
+                    return `Session "${args.name}" not found.`;
+                if (sessionId === terminal.defaultSession && terminal.sessions.size === 1) {
+                    return 'Cannot close the last session.';
+                }
+                const closedName = terminal.sessions.get(sessionId)?.name;
+                terminal.sessions.delete(sessionId);
+                if (sessionId === terminal.defaultSession) {
+                    terminal.defaultSession = terminal.sessions.keys().next().value;
+                }
+                saveTerminalState();
+                return `Closed session: ${closedName}`;
+            }
+            return 'Unknown action. Use: list, new, close';
+        },
+    });
+    registerTool({
+        name: 'terminal_queue',
+        description: 'Queue a command for later execution in kbot\'s terminal. Queued commands only run when explicitly triggered with terminal_exec "process_queue". Use for batching commands you want to run together.',
+        parameters: {
+            command: { type: 'string', description: 'Command to queue (omit to list pending queue)', required: false },
+            delay_seconds: { type: 'string', description: 'Delay in seconds before execution (default: 0 = next cycle)' },
+            session: { type: 'string', description: 'Session name or ID' },
+            action: { type: 'string', description: '"add" (default), "list", or "clear"' },
+        },
+        tier: 'free',
+        async execute(args) {
+            const action = String(args.action || 'add');
+            if (action === 'list') {
+                const queue = loadQueue();
+                if (queue.length === 0)
+                    return 'Queue is empty.';
+                return queue.map((q, i) => {
+                    const delay = q.runAt ? `runs at ${new Date(q.runAt).toLocaleTimeString()}` : 'runs next cycle';
+                    return `${i + 1}. [${q.session}] ${q.command}\n   scheduled: ${new Date(q.scheduledAt).toLocaleTimeString()}, ${delay}`;
+                }).join('\n\n');
+            }
+            if (action === 'clear') {
+                saveQueue([]);
+                return 'Queue cleared.';
+            }
+            // action === 'add'
+            if (!args.command)
+                return 'Specify a command to queue, or use action="list" to view pending commands.';
+            const delay = parseInt(String(args.delay_seconds || '0'), 10) * 1000;
+            const sessionId = findSession(String(args.session || 'main'));
+            queueCommand(String(args.command), sessionId, delay || undefined);
+            return `Queued: ${args.command}${delay ? ` (runs in ${args.delay_seconds}s)` : ' (runs next cycle ~10s)'}`;
+        },
+    });
+    registerTool({
+        name: 'terminal_cwd',
+        description: 'Get or change the working directory of a terminal session.',
+        parameters: {
+            path: { type: 'string', description: 'New directory path (omit to show current cwd)' },
+            session: { type: 'string', description: 'Session name or ID' },
+        },
+        tier: 'free',
+        async execute(args) {
+            const sessionId = findSession(String(args.session || 'main'));
+            const session = terminal.sessions.get(sessionId);
+            if (!session)
+                return 'Session not found';
+            if (args.path) {
+                const target = String(args.path).replace(/^~/, homedir());
+                const resolved = resolve(session.cwd, target);
+                if (existsSync(resolved)) {
+                    session.cwd = resolved;
+                    saveTerminalState();
+                    return `[${session.name}] cwd: ${resolved}`;
+                }
+                return `Directory not found: ${resolved}`;
+            }
+            return `[${session.name}] cwd: ${session.cwd}`;
+        },
+    });
+}
+//# sourceMappingURL=kbot-terminal.js.map

package/dist/tools/stream-control.d.ts

@@ -0,0 +1,2 @@
+export declare function registerStreamControlTools(): void;
+//# sourceMappingURL=stream-control.d.ts.map

package/dist/tools/stream-control.js

@@ -0,0 +1,789 @@
+// kbot Stream Control Tools — Manage Twitch, Kick, and Rumble dashboards
+//
+// Tools: stream_title, stream_category, stream_info, stream_viewers,
+//        stream_chat_settings, stream_clip, stream_marker, stream_followers,
+//        stream_chat_send, stream_ban, stream_announce, stream_dashboard,
+//        stream_setup_oauth
+//
+// These tools manage the streaming platform *dashboards* — titles, categories,
+// chat moderation, clips, markers, followers — not the video feed itself
+// (that's in streaming.ts).
+//
+// Env: TWITCH_CLIENT_ID, TWITCH_OAUTH_TOKEN, TWITCH_BROADCASTER_ID
+//      RUMBLE_API_KEY
+//      KICK_CHANNEL_SLUG (for browser-based fallback)
+import { registerTool } from './index.js';
+// ─── Constants ─────────────────────────────────────────────────
+const TWITCH_API = 'https://api.twitch.tv/helix';
+const KICK_API = 'https://kick.com/api/v2';
+const RUMBLE_API = 'https://rumble.com/-livestream-api/get-data';
+// ─── Twitch Helpers ────────────────────────────────────────────
+function twitchHeaders() {
+    const token = process.env.TWITCH_OAUTH_TOKEN;
+    const clientId = process.env.TWITCH_CLIENT_ID;
+    if (!token || !clientId) {
+        throw new Error('Twitch OAuth not configured. Set TWITCH_OAUTH_TOKEN and TWITCH_CLIENT_ID.\n' +
+            'Run stream_setup_oauth for instructions.');
+    }
+    return {
+        'Authorization': `Bearer ${token}`,
+        'Client-Id': clientId,
+        'Content-Type': 'application/json',
+    };
+}
+function getBroadcasterId() {
+    const id = process.env.TWITCH_BROADCASTER_ID;
+    if (!id) {
+        throw new Error('TWITCH_BROADCASTER_ID not set. Find yours at: https://www.streamweasels.com/tools/convert-twitch-username-to-user-id/');
+    }
+    return id;
+}
+async function twitchGet(endpoint) {
+    const res = await fetch(`${TWITCH_API}${endpoint}`, { headers: twitchHeaders() });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Twitch API ${res.status}: ${body}`);
+    }
+    return res.json();
+}
+async function twitchPatch(endpoint, body) {
+    const res = await fetch(`${TWITCH_API}${endpoint}`, {
+        method: 'PATCH',
+        headers: twitchHeaders(),
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Twitch API ${res.status}: ${text}`);
+    }
+    // 204 No Content is a success response for PATCH
+    if (res.status === 204)
+        return { ok: true };
+    const ct = res.headers.get('content-type') || '';
+    if (ct.includes('application/json'))
+        return res.json();
+    return { ok: true };
+}
+async function twitchPost(endpoint, body) {
+    const res = await fetch(`${TWITCH_API}${endpoint}`, {
+        method: 'POST',
+        headers: twitchHeaders(),
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Twitch API ${res.status}: ${text}`);
+    }
+    if (res.status === 204)
+        return { ok: true };
+    return res.json();
+}
+// ─── Rumble Helpers ────────────────────────────────────────────
+async function rumbleGetData() {
+    const key = process.env.RUMBLE_API_KEY;
+    if (!key)
+        throw new Error('RUMBLE_API_KEY not set.');
+    const res = await fetch(`${RUMBLE_API}?key=${encodeURIComponent(key)}`);
+    if (!res.ok)
+        throw new Error(`Rumble API ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+// ─── Kick Helpers ──────────────────────────────────────────────
+async function kickGetChannel() {
+    const slug = process.env.KICK_CHANNEL_SLUG;
+    if (!slug)
+        throw new Error('KICK_CHANNEL_SLUG not set.');
+    const res = await fetch(`${KICK_API}/channels/${encodeURIComponent(slug)}`, {
+        headers: { 'Accept': 'application/json' },
+    });
+    if (!res.ok)
+        throw new Error(`Kick API ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+// ─── Utility ───────────────────────────────────────────────────
+function hasTwitch() {
+    return !!(process.env.TWITCH_OAUTH_TOKEN && process.env.TWITCH_CLIENT_ID);
+}
+function hasRumble() {
+    return !!process.env.RUMBLE_API_KEY;
+}
+function hasKick() {
+    return !!process.env.KICK_CHANNEL_SLUG;
+}
+function formatUptime(startedAt) {
+    const start = new Date(startedAt);
+    const now = new Date();
+    const diff = now.getTime() - start.getTime();
+    const hours = Math.floor(diff / 3_600_000);
+    const minutes = Math.floor((diff % 3_600_000) / 60_000);
+    return `${hours}h ${minutes}m`;
+}
+function noPlatforms() {
+    return ('No streaming platforms configured. Set at least one:\n' +
+        '  TWITCH_CLIENT_ID + TWITCH_OAUTH_TOKEN + TWITCH_BROADCASTER_ID (Twitch)\n' +
+        '  RUMBLE_API_KEY (Rumble)\n' +
+        '  KICK_CHANNEL_SLUG (Kick)\n\n' +
+        'Run stream_setup_oauth for detailed instructions.');
+}
+// ─── Registration ──────────────────────────────────────────────
+export function registerStreamControlTools() {
+    // ── stream_title ──
+    registerTool({
+        name: 'stream_title',
+        description: 'Update the stream title on Twitch. Optionally update the category/game at the same time. Kick dashboard changes require browser (noted in output).',
+        parameters: {
+            title: { type: 'string', description: 'New stream title (max 140 chars for Twitch)', required: true },
+            category: { type: 'string', description: 'Optional: category/game name to set alongside the title' },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const title = String(args.title || '').slice(0, 140);
+            if (!title)
+                return 'Error: title is required.';
+            const results = [];
+            // Twitch
+            if (hasTwitch()) {
+                try {
+                    const broadcasterId = getBroadcasterId();
+                    const body = { title };
+                    // If category provided, search for game_id first
+                    if (args.category) {
+                        const search = await twitchGet(`/search/categories?query=${encodeURIComponent(String(args.category))}&first=1`);
+                        if (search.data?.length > 0) {
+                            body.game_id = search.data[0].id;
+                            results.push(`Twitch: title set to "${title}", category set to "${search.data[0].name}" (id: ${search.data[0].id})`);
+                        }
+                        else {
+                            results.push(`Twitch: title set to "${title}" (category "${args.category}" not found, skipped)`);
+                        }
+                    }
+                    else {
+                        results.push(`Twitch: title set to "${title}"`);
+                    }
+                    await twitchPatch(`/channels?broadcaster_id=${broadcasterId}`, body);
+                }
+                catch (e) {
+                    results.push(`Twitch: ${e.message}`);
+                }
+            }
+            // Kick — no direct API for title changes
+            if (hasKick()) {
+                results.push('Kick: title changes require the dashboard (dashboard.kick.com/Stream). Use computer-use tools or kbot_browse to navigate there.');
+            }
+            // Rumble — read-only API
+            if (hasRumble()) {
+                results.push('Rumble: title changes not available via API. Use the Rumble Studio dashboard.');
+            }
+            if (results.length === 0)
+                return noPlatforms();
+            return results.join('\n');
+        },
+    });
+    // ── stream_category ──
+    registerTool({
+        name: 'stream_category',
+        description: 'Change the stream category/game on Twitch. Searches Twitch categories by name and applies the best match.',
+        parameters: {
+            category: { type: 'string', description: 'Category/game name to search for and set', required: true },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const query = String(args.category || '');
+            if (!query)
+                return 'Error: category is required.';
+            if (!hasTwitch())
+                return 'Twitch not configured. Set TWITCH_CLIENT_ID, TWITCH_OAUTH_TOKEN, and TWITCH_BROADCASTER_ID.';
+            try {
+                const broadcasterId = getBroadcasterId();
+                const search = await twitchGet(`/search/categories?query=${encodeURIComponent(query)}&first=5`);
+                if (!search.data?.length) {
+                    return `No categories found for "${query}". Try a different search term.`;
+                }
+                // Use the first match
+                const cat = search.data[0];
+                await twitchPatch(`/channels?broadcaster_id=${broadcasterId}`, { game_id: cat.id });
+                const alternatives = search.data.slice(1, 5).map((c) => `  - ${c.name} (id: ${c.id})`).join('\n');
+                let result = `Category set to: ${cat.name} (id: ${cat.id})`;
+                if (alternatives)
+                    result += `\n\nOther matches:\n${alternatives}`;
+                return result;
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+    });
+    // ── stream_info ──
+    registerTool({
+        name: 'stream_info',
+        description: 'Get current stream info from Twitch (viewers, uptime, title, category) and Rumble (viewers, status). Shows whether you are live on each platform.',
+        parameters: {
+            platform: { type: 'string', description: 'Specific platform: "twitch", "kick", "rumble". Default: all configured' },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const platform = args.platform ? String(args.platform).toLowerCase() : 'all';
+            const results = [];
+            // Twitch
+            if ((platform === 'all' || platform === 'twitch') && hasTwitch()) {
+                try {
+                    const broadcasterId = getBroadcasterId();
+                    const streams = await twitchGet(`/streams?user_id=${broadcasterId}`);
+                    const channelInfo = await twitchGet(`/channels?broadcaster_id=${broadcasterId}`);
+                    const channel = channelInfo.data?.[0];
+                    if (streams.data?.length > 0) {
+                        const s = streams.data[0];
+                        results.push(`TWITCH [LIVE]\n` +
+                            `  Title:    ${s.title}\n` +
+                            `  Category: ${s.game_name}\n` +
+                            `  Viewers:  ${s.viewer_count.toLocaleString()}\n` +
+                            `  Uptime:   ${formatUptime(s.started_at)}\n` +
+                            `  Language:  ${s.language}`);
+                    }
+                    else {
+                        results.push(`TWITCH [OFFLINE]\n` +
+                            `  Title:    ${channel?.title || 'N/A'}\n` +
+                            `  Category: ${channel?.game_name || 'N/A'}`);
+                    }
+                }
+                catch (e) {
+                    results.push(`TWITCH: Error — ${e.message}`);
+                }
+            }
+            // Rumble
+            if ((platform === 'all' || platform === 'rumble') && hasRumble()) {
+                try {
+                    const data = await rumbleGetData();
+                    if (data.is_live) {
+                        results.push(`RUMBLE [LIVE]\n` +
+                            `  Viewers:    ${(data.viewers || 0).toLocaleString()}\n` +
+                            `  Chat count: ${(data.chat_messages || 0).toLocaleString()}`);
+                    }
+                    else {
+                        results.push('RUMBLE [OFFLINE]');
+                    }
+                }
+                catch (e) {
+                    results.push(`RUMBLE: Error — ${e.message}`);
+                }
+            }
+            // Kick
+            if ((platform === 'all' || platform === 'kick') && hasKick()) {
+                try {
+                    const data = await kickGetChannel();
+                    const livestream = data.livestream;
+                    if (livestream && livestream.is_live) {
+                        results.push(`KICK [LIVE]\n` +
+                            `  Title:    ${livestream.session_title || 'N/A'}\n` +
+                            `  Category: ${livestream.categories?.[0]?.name || 'N/A'}\n` +
+                            `  Viewers:  ${(livestream.viewer_count || 0).toLocaleString()}`);
+                    }
+                    else {
+                        results.push(`KICK [OFFLINE]\n` +
+                            `  Channel: ${data.slug || process.env.KICK_CHANNEL_SLUG}`);
+                    }
+                }
+                catch (e) {
+                    results.push(`KICK: Error — ${e.message}`);
+                }
+            }
+            if (results.length === 0)
+                return noPlatforms();
+            return results.join('\n\n');
+        },
+    });
+    // ── stream_viewers ──
+    registerTool({
+        name: 'stream_viewers',
+        description: 'Get viewer count across all configured streaming platforms (Twitch, Kick, Rumble). Returns per-platform counts and a combined total.',
+        parameters: {},
+        tier: 'free',
+        execute: async () => {
+            const counts = [];
+            // Twitch
+            if (hasTwitch()) {
+                try {
+                    const broadcasterId = getBroadcasterId();
+                    const streams = await twitchGet(`/streams?user_id=${broadcasterId}`);
+                    if (streams.data?.length > 0) {
+                        counts.push({ platform: 'Twitch', viewers: streams.data[0].viewer_count, live: true });
+                    }
+                    else {
+                        counts.push({ platform: 'Twitch', viewers: 0, live: false });
+                    }
+                }
+                catch (e) {
+                    counts.push({ platform: 'Twitch', viewers: 0, live: false });
+                }
+            }
+            // Rumble
+            if (hasRumble()) {
+                try {
+                    const data = await rumbleGetData();
+                    counts.push({ platform: 'Rumble', viewers: data.viewers || 0, live: !!data.is_live });
+                }
+                catch {
+                    counts.push({ platform: 'Rumble', viewers: 0, live: false });
+                }
+            }
+            // Kick
+            if (hasKick()) {
+                try {
+                    const data = await kickGetChannel();
+                    const live = data.livestream?.is_live || false;
+                    counts.push({ platform: 'Kick', viewers: live ? (data.livestream?.viewer_count || 0) : 0, live });
+                }
+                catch {
+                    counts.push({ platform: 'Kick', viewers: 0, live: false });
+                }
+            }
+            if (counts.length === 0)
+                return noPlatforms();
+            const total = counts.reduce((sum, c) => sum + c.viewers, 0);
+            const lines = counts.map(c => `  ${c.platform.padEnd(8)} ${c.live ? 'LIVE' : 'OFF '} ${c.viewers.toLocaleString().padStart(8)} viewers`);
+            lines.push(`  ${'TOTAL'.padEnd(8)}      ${total.toLocaleString().padStart(8)} viewers`);
+            return `Viewer counts:\n${lines.join('\n')}`;
+        },
+    });
+    // ── stream_chat_settings ──
+    registerTool({
+        name: 'stream_chat_settings',
+        description: 'Manage Twitch chat settings: slow mode, subscriber-only mode, emote-only mode, follower-only mode. Pass the settings you want to change.',
+        parameters: {
+            slow_mode: { type: 'string', description: '"on" or "off" — enable/disable slow mode' },
+            slow_mode_wait: { type: 'string', description: 'Seconds between messages in slow mode (3-120). Default: 10' },
+            sub_only: { type: 'string', description: '"on" or "off" — subscriber-only mode' },
+            emote_only: { type: 'string', description: '"on" or "off" — emote-only mode' },
+            follower_only: { type: 'string', description: '"on" or "off" — follower-only mode' },
+            follower_only_minutes: { type: 'string', description: 'Minutes a user must follow before chatting (0-129600). Default: 10' },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            if (!hasTwitch())
+                return 'Twitch not configured. Set TWITCH_CLIENT_ID, TWITCH_OAUTH_TOKEN, and TWITCH_BROADCASTER_ID.';
+            try {
+                const broadcasterId = getBroadcasterId();
+                const body = {};
+                if (args.slow_mode !== undefined) {
+                    body.slow_mode = args.slow_mode === 'on';
+                    if (body.slow_mode && args.slow_mode_wait) {
+                        body.slow_mode_wait_time = Math.max(3, Math.min(120, parseInt(String(args.slow_mode_wait), 10) || 10));
+                    }
+                }
+                if (args.sub_only !== undefined)
+                    body.subscriber_mode = args.sub_only === 'on';
+                if (args.emote_only !== undefined)
+                    body.emote_mode = args.emote_only === 'on';
+                if (args.follower_only !== undefined) {
+                    body.follower_mode = args.follower_only === 'on';
+                    if (body.follower_mode && args.follower_only_minutes) {
+                        body.follower_mode_duration = Math.max(0, Math.min(129600, parseInt(String(args.follower_only_minutes), 10) || 10));
+                    }
+                }
+                if (Object.keys(body).length === 0) {
+                    return 'No settings provided. Available: slow_mode, sub_only, emote_only, follower_only';
+                }
+                // moderator_id = broadcaster_id when the broadcaster is the moderator
+                await twitchPatch(`/chat/settings?broadcaster_id=${broadcasterId}&moderator_id=${broadcasterId}`, body);
+                const applied = Object.entries(body)
+                    .map(([k, v]) => `  ${k}: ${v}`)
+                    .join('\n');
+                return `Chat settings updated:\n${applied}`;
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+    });
+    // ── stream_clip ──
+    registerTool({
+        name: 'stream_clip',
+        description: 'Create a clip of the current Twitch stream. The stream must be live. Returns the clip edit URL.',
+        parameters: {
+            has_delay: { type: 'string', description: '"true" if the stream has a delay (captures from the delay buffer). Default: false' },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            if (!hasTwitch())
+                return 'Twitch not configured. Set TWITCH_CLIENT_ID, TWITCH_OAUTH_TOKEN, and TWITCH_BROADCASTER_ID.';
+            try {
+                const broadcasterId = getBroadcasterId();
+                // Verify stream is live
+                const streams = await twitchGet(`/streams?user_id=${broadcasterId}`);
+                if (!streams.data?.length) {
+                    return 'Cannot create clip — stream is not live.';
+                }
+                const body = { broadcaster_id: broadcasterId };
+                if (args.has_delay === 'true')
+                    body.has_delay = true;
+                const result = await twitchPost('/clips', body);
+                const clip = result.data?.[0];
+                if (clip) {
+                    return `Clip created!\n  Edit URL: ${clip.edit_url}\n  ID: ${clip.id}\n\nNote: It takes ~15 seconds for the clip to be processed.`;
+                }
+                return 'Clip creation returned no data. The stream may not be clippable.';
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+    });
+    // ── stream_marker ──
+    registerTool({
+        name: 'stream_marker',
+        description: 'Add a stream marker (bookmark) on the current Twitch stream. Useful for marking interesting moments to highlight later. Stream must be live.',
+        parameters: {
+            description: { type: 'string', description: 'Description of the marker (max 140 chars). Default: "Marked by kbot"' },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            if (!hasTwitch())
+                return 'Twitch not configured. Set TWITCH_CLIENT_ID, TWITCH_OAUTH_TOKEN, and TWITCH_BROADCASTER_ID.';
+            try {
+                const broadcasterId = getBroadcasterId();
+                const description = String(args.description || 'Marked by kbot').slice(0, 140);
+                const result = await twitchPost('/streams/markers', {
+                    user_id: broadcasterId,
+                    description,
+                });
+                const marker = result.data?.[0];
+                if (marker) {
+                    return `Stream marker added at ${marker.position_seconds}s: "${description}"\n  ID: ${marker.id}\n  Created: ${marker.created_at}`;
+                }
+                return 'Marker created (no position data returned). Stream must be live for markers to work.';
+            }
+            catch (e) {
+                if (e.message.includes('404'))
+                    return 'Cannot add marker — stream is not live.';
+                return `Error: ${e.message}`;
+            }
+        },
+    });
+    // ── stream_followers ──
+    registerTool({
+        name: 'stream_followers',
+        description: 'Get follower count and recent followers from Twitch. Shows total count and the latest followers with follow dates.',
+        parameters: {
+            count: { type: 'string', description: 'Number of recent followers to show (1-100). Default: 10' },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            if (!hasTwitch())
+                return 'Twitch not configured. Set TWITCH_CLIENT_ID, TWITCH_OAUTH_TOKEN, and TWITCH_BROADCASTER_ID.';
+            try {
+                const broadcasterId = getBroadcasterId();
+                const first = Math.max(1, Math.min(100, parseInt(String(args.count || '10'), 10) || 10));
+                const result = await twitchGet(`/channels/followers?broadcaster_id=${broadcasterId}&first=${first}`);
+                const total = result.total || 0;
+                const followers = (result.data || []).map((f) => {
+                    const date = new Date(f.followed_at).toLocaleDateString();
+                    return `  ${f.user_name.padEnd(25)} followed ${date}`;
+                });
+                let output = `Total followers: ${total.toLocaleString()}\n`;
+                if (followers.length > 0) {
+                    output += `\nRecent followers:\n${followers.join('\n')}`;
+                }
+                else {
+                    output += '\nNo recent followers found.';
+                }
+                return output;
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+    });
+    // ── stream_chat_send ──
+    registerTool({
+        name: 'stream_chat_send',
+        description: 'Send a message to Twitch chat as the authenticated user/bot. Requires the chat:edit scope on the OAuth token.',
+        parameters: {
+            message: { type: 'string', description: 'Message to send to chat (max 500 chars)', required: true },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const message = String(args.message || '').slice(0, 500);
+            if (!message)
+                return 'Error: message is required.';
+            if (!hasTwitch())
+                return 'Twitch not configured. Set TWITCH_CLIENT_ID, TWITCH_OAUTH_TOKEN, and TWITCH_BROADCASTER_ID.';
+            try {
+                const broadcasterId = getBroadcasterId();
+                await twitchPost('/chat/messages', {
+                    broadcaster_id: broadcasterId,
+                    sender_id: broadcasterId,
+                    message,
+                });
+                return `Message sent to Twitch chat: "${message}"`;
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+    });
+    // ── stream_ban ──
+    registerTool({
+        name: 'stream_ban',
+        description: 'Ban or timeout a user from Twitch chat. Omit duration for a permanent ban. Set duration in seconds for a timeout.',
+        parameters: {
+            user_id: { type: 'string', description: 'Twitch user ID to ban. Use stream_followers or Twitch API to look up by username.', required: true },
+            duration: { type: 'string', description: 'Timeout duration in seconds (1-1209600). Omit for permanent ban.' },
+            reason: { type: 'string', description: 'Reason for the ban/timeout. Default: "Banned by kbot"' },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const userId = String(args.user_id || '');
+            if (!userId)
+                return 'Error: user_id is required.';
+            if (!hasTwitch())
+                return 'Twitch not configured. Set TWITCH_CLIENT_ID, TWITCH_OAUTH_TOKEN, and TWITCH_BROADCASTER_ID.';
+            try {
+                const broadcasterId = getBroadcasterId();
+                const banData = {
+                    user_id: userId,
+                    reason: String(args.reason || 'Banned by kbot'),
+                };
+                if (args.duration) {
+                    const dur = Math.max(1, Math.min(1_209_600, parseInt(String(args.duration), 10) || 600));
+                    banData.duration = dur;
+                }
+                await twitchPost(`/moderation/bans?broadcaster_id=${broadcasterId}&moderator_id=${broadcasterId}`, {
+                    data: banData,
+                });
+                const action = args.duration ? `timed out for ${args.duration}s` : 'permanently banned';
+                return `User ${userId} ${action}. Reason: ${banData.reason}`;
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+    });
+    // ── stream_announce ──
+    registerTool({
+        name: 'stream_announce',
+        description: 'Send an announcement to Twitch chat. Announcements appear highlighted in chat. Requires moderator:manage:chat_settings scope.',
+        parameters: {
+            message: { type: 'string', description: 'Announcement message', required: true },
+            color: { type: 'string', description: 'Announcement color: "primary" (default), "blue", "green", "orange", "purple"' },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const message = String(args.message || '');
+            if (!message)
+                return 'Error: message is required.';
+            if (!hasTwitch())
+                return 'Twitch not configured. Set TWITCH_CLIENT_ID, TWITCH_OAUTH_TOKEN, and TWITCH_BROADCASTER_ID.';
+            try {
+                const broadcasterId = getBroadcasterId();
+                const validColors = ['primary', 'blue', 'green', 'orange', 'purple'];
+                const color = validColors.includes(String(args.color || '')) ? String(args.color) : 'primary';
+                await twitchPost(`/chat/announcements?broadcaster_id=${broadcasterId}&moderator_id=${broadcasterId}`, { message, color });
+                return `Announcement sent (${color}): "${message}"`;
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+    });
+    // ── stream_dashboard ──
+    registerTool({
+        name: 'stream_dashboard',
+        description: 'Get a unified dashboard view across all configured streaming platforms. Shows live status, viewers, title, category, uptime, and follower count from Twitch, Kick, and Rumble.',
+        parameters: {},
+        tier: 'free',
+        execute: async () => {
+            const sections = [];
+            const configured = [hasTwitch() && 'Twitch', hasRumble() && 'Rumble', hasKick() && 'Kick'].filter(Boolean);
+            if (configured.length === 0)
+                return noPlatforms();
+            sections.push(`STREAM DASHBOARD — ${new Date().toLocaleString()}`);
+            sections.push('═'.repeat(50));
+            // Twitch
+            if (hasTwitch()) {
+                try {
+                    const broadcasterId = getBroadcasterId();
+                    const [streams, channelInfo, followers] = await Promise.all([
+                        twitchGet(`/streams?user_id=${broadcasterId}`),
+                        twitchGet(`/channels?broadcaster_id=${broadcasterId}`),
+                        twitchGet(`/channels/followers?broadcaster_id=${broadcasterId}&first=1`),
+                    ]);
+                    const channel = channelInfo.data?.[0];
+                    const isLive = streams.data?.length > 0;
+                    const stream = isLive ? streams.data[0] : null;
+                    sections.push(`\nTWITCH ${isLive ? '🔴 LIVE' : '⚫ OFFLINE'}` +
+                        `\n  Title:     ${stream?.title || channel?.title || 'N/A'}` +
+                        `\n  Category:  ${stream?.game_name || channel?.game_name || 'N/A'}` +
+                        (isLive ? `\n  Viewers:   ${stream.viewer_count.toLocaleString()}` : '') +
+                        (isLive ? `\n  Uptime:    ${formatUptime(stream.started_at)}` : '') +
+                        `\n  Followers: ${(followers.total || 0).toLocaleString()}`);
+                }
+                catch (e) {
+                    sections.push(`\nTWITCH: Error — ${e.message}`);
+                }
+            }
+            // Kick
+            if (hasKick()) {
+                try {
+                    const data = await kickGetChannel();
+                    const livestream = data.livestream;
+                    const isLive = livestream?.is_live || false;
+                    sections.push(`\nKICK ${isLive ? '🔴 LIVE' : '⚫ OFFLINE'}` +
+                        `\n  Channel:   ${data.slug || process.env.KICK_CHANNEL_SLUG}` +
+                        (isLive ? `\n  Title:     ${livestream.session_title || 'N/A'}` : '') +
+                        (isLive ? `\n  Category:  ${livestream.categories?.[0]?.name || 'N/A'}` : '') +
+                        (isLive ? `\n  Viewers:   ${(livestream.viewer_count || 0).toLocaleString()}` : '') +
+                        `\n  Followers: ${(data.followers_count || 0).toLocaleString()}`);
+                }
+                catch (e) {
+                    sections.push(`\nKICK: Error — ${e.message}`);
+                }
+            }
+            // Rumble
+            if (hasRumble()) {
+                try {
+                    const data = await rumbleGetData();
+                    const isLive = !!data.is_live;
+                    sections.push(`\nRUMBLE ${isLive ? '🔴 LIVE' : '⚫ OFFLINE'}` +
+                        (isLive ? `\n  Viewers:      ${(data.viewers || 0).toLocaleString()}` : '') +
+                        (isLive ? `\n  Chat msgs:    ${(data.chat_messages || 0).toLocaleString()}` : '') +
+                        (data.followers !== undefined ? `\n  Followers:    ${(data.followers || 0).toLocaleString()}` : ''));
+                }
+                catch (e) {
+                    sections.push(`\nRUMBLE: Error — ${e.message}`);
+                }
+            }
+            // Combined stats
+            let totalViewers = 0;
+            if (hasTwitch()) {
+                try {
+                    const broadcasterId = getBroadcasterId();
+                    const s = await twitchGet(`/streams?user_id=${broadcasterId}`);
+                    if (s.data?.length)
+                        totalViewers += s.data[0].viewer_count;
+                }
+                catch { /* skip */ }
+            }
+            if (hasRumble()) {
+                try {
+                    const d = await rumbleGetData();
+                    if (d.is_live)
+                        totalViewers += d.viewers || 0;
+                }
+                catch { /* skip */ }
+            }
+            if (hasKick()) {
+                try {
+                    const d = await kickGetChannel();
+                    if (d.livestream?.is_live)
+                        totalViewers += d.livestream.viewer_count || 0;
+                }
+                catch { /* skip */ }
+            }
+            sections.push(`\n${'═'.repeat(50)}`);
+            sections.push(`Combined viewers: ${totalViewers.toLocaleString()}`);
+            sections.push(`Platforms: ${configured.join(', ')}`);
+            return sections.join('\n');
+        },
+    });
+    // ── stream_setup_oauth ──
+    registerTool({
+        name: 'stream_setup_oauth',
+        description: 'Show instructions for setting up OAuth tokens for Twitch, Kick, and Rumble streaming platform control. Does not execute anything — just shows the setup guide.',
+        parameters: {
+            platform: { type: 'string', description: 'Specific platform to show setup for: "twitch", "kick", "rumble". Default: all' },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const platform = args.platform ? String(args.platform).toLowerCase() : 'all';
+            const sections = [];
+            sections.push('STREAM CONTROL — OAUTH SETUP GUIDE');
+            sections.push('═'.repeat(50));
+            if (platform === 'all' || platform === 'twitch') {
+                const scopes = [
+                    'channel:manage:broadcast',
+                    'chat:edit',
+                    'chat:read',
+                    'moderator:manage:chat_settings',
+                    'clips:edit',
+                    'channel:read:stream_key',
+                    'moderator:manage:banned_users',
+                    'moderator:manage:announcements',
+                    'channel:read:editors',
+                ].join('+');
+                sections.push(`
+TWITCH (Helix API)
+──────────────────
+1. Go to: https://dev.twitch.tv/console/apps
+2. Click "Register Your Application"
+3. Name: "kbot" (or anything)
+4. OAuth Redirect URL: http://localhost
+5. Category: Chat Bot
+6. Click "Create" — note the Client ID
+
+7. Generate an OAuth token:
+   Open this URL in your browser (replace YOUR_CLIENT_ID):
+
+   https://id.twitch.tv/oauth2/authorize?client_id=YOUR_CLIENT_ID&redirect_uri=http://localhost&response_type=token&scope=${scopes}
+
+8. After authorizing, you'll be redirected to:
+   http://localhost/#access_token=YOUR_TOKEN&...
+   Copy the access_token value.
+
+9. Find your broadcaster ID:
+   https://www.streamweasels.com/tools/convert-twitch-username-to-user-id/
+
+10. Set environment variables:
+    export TWITCH_CLIENT_ID="your_client_id"
+    export TWITCH_OAUTH_TOKEN="your_access_token"
+    export TWITCH_BROADCASTER_ID="your_user_id"
+
+Required scopes:
+  channel:manage:broadcast — update title/category
+  chat:edit — send chat messages
+  chat:read — read chat
+  moderator:manage:chat_settings — slow mode, sub-only, etc.
+  clips:edit — create clips
+  moderator:manage:banned_users — ban/timeout users
+  moderator:manage:announcements — send announcements`);
+            }
+            if (platform === 'all' || platform === 'kick') {
+                sections.push(`
+KICK
+────
+Kick has a limited public API. For most dashboard actions, kbot uses
+its built-in browser (kbot_browse) or computer-use tools to navigate
+dashboard.kick.com.
+
+For basic channel info via API:
+  export KICK_CHANNEL_SLUG="your_channel_name"
+
+For full dashboard control, use kbot with --computer-use flag:
+  kbot --computer-use "update my Kick stream title"`);
+            }
+            if (platform === 'all' || platform === 'rumble') {
+                sections.push(`
+RUMBLE
+──────
+Rumble provides a livestream API key for reading stream data.
+
+1. Go to your Rumble account settings
+2. Find the "Livestream API" section
+3. Copy your API key
+
+4. Set environment variable:
+   export RUMBLE_API_KEY="your_api_key"
+
+Note: Rumble's API is mostly read-only (viewer count, chat, status).
+For dashboard changes, use kbot with --computer-use flag or kbot_browse.`);
+            }
+            // Show current status
+            sections.push(`\n${'═'.repeat(50)}`);
+            sections.push('CURRENT STATUS:');
+            sections.push(`  Twitch:  ${hasTwitch() ? 'Configured' : 'NOT configured'}${process.env.TWITCH_BROADCASTER_ID ? '' : ' (missing TWITCH_BROADCASTER_ID)'}`);
+            sections.push(`  Kick:    ${hasKick() ? 'Configured' : 'NOT configured'}`);
+            sections.push(`  Rumble:  ${hasRumble() ? 'Configured' : 'NOT configured'}`);
+            return sections.join('\n');
+        },
+    });
+}
+//# sourceMappingURL=stream-control.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernel.chat/kbot",
-  "version": "3.86.0",
+  "version": "3.88.0",
   "description": "Open-source terminal AI agent. 764+ tools, 35 agents, 20 providers. Dreams, learns, watches your system. Controls your phone. Fully local, fully sovereign. MIT.",
   "type": "module",
   "repository": {