kimaki 0.4.77 → 0.4.78

package/dist/cli.js

@@ -735,6 +735,16 @@ async function registerCommands({ token, appId, guildIds, userCommands = [], age
             .setDescription('List and manage MCP servers for this project')
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('screenshare')
+            .setDescription('Start screen sharing via VNC tunnel (auto-stops after 1 hour)')
+            .setDMPermission(false)
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('screenshare-stop')
+            .setDescription('Stop screen sharing')
+            .setDMPermission(false)
+            .toJSON(),
     ];
     // Add user-defined commands with source-based suffixes (-cmd / -skill)
     // Also populate registeredUserCommands in the store for /queue-command autocomplete
@@ -2937,6 +2947,23 @@ cli
         command: command.length > 0 ? command : undefined,
     });
 });
+cli
+    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 1 hour. Runs until Ctrl+C. Use tmux to run in background.')
+    .action(async () => {
+    const { startScreenshare } = await import('./commands/screenshare.js');
+    try {
+        const session = await startScreenshare({
+            sessionKey: 'cli',
+            startedBy: 'cli',
+        });
+        cliLogger.log(`Screen sharing started: ${session.noVncUrl}`);
+        cliLogger.log('Press Ctrl+C to stop');
+    }
+    catch (err) {
+        cliLogger.error('Failed to start screen share:', err instanceof Error ? err.message : String(err));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli
     .command('sqlitedb', 'Show the location of the SQLite database file')
     .action(() => {

package/dist/commands/diff.js

@@ -3,7 +3,7 @@ import { ChannelType, EmbedBuilder, MessageFlags, } from 'discord.js';
 import path from 'node:path';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import { execAsync } from '../worktrees.js';
+import { uploadGitDiffViaCritique } from '../critique-utils.js';
 const logger = createLogger(LogPrefix.DIFF);
 export async function handleDiffCommand({ command, }) {
     const channel = command.channel;
@@ -39,90 +39,25 @@ export async function handleDiffCommand({ command, }) {
     }
     const { workingDirectory } = resolved;
     await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
-    try {
-        const projectName = path.basename(workingDirectory);
-        const title = `${projectName}: Discord /diff`;
-        const { stdout, stderr } = await execAsync(`bunx critique --web "${title}" --json`, {
-            cwd: workingDirectory,
-            timeout: 30000,
-        });
-        // critique --json outputs JSON on the last line: {"url":"...","id":"..."} or {"error":"..."}
-        const output = stdout || stderr;
-        const lines = output.trim().split('\n');
-        const jsonLine = lines[lines.length - 1];
-        if (!jsonLine) {
-            await command.editReply({
-                content: 'No changes to show',
-            });
-            return;
-        }
-        let result;
-        try {
-            result = JSON.parse(jsonLine);
-        }
-        catch {
-            // Fallback: try to find URL in output
-            const urlMatch = output.match(/https?:\/\/critique\.work\/[^\s]+/);
-            if (urlMatch) {
-                await command.editReply({
-                    content: `[diff](${urlMatch[0]})`,
-                });
-                logger.log(`Diff shared: ${urlMatch[0]}`);
-                return;
-            }
-            await command.editReply({
-                content: 'No changes to show',
-            });
-            return;
-        }
-        if (result.error || !result.url || !result.id) {
-            await command.editReply({
-                content: result.error || 'No changes to show',
-            });
-            return;
-        }
-        const imageUrl = `https://critique.work/og/${result.id}.png`;
-        const embed = new EmbedBuilder()
-            .setTitle(title)
-            .setURL(result.url)
-            .setImage(imageUrl);
-        await command.editReply({
-            embeds: [embed],
-        });
-        logger.log(`Diff shared: ${result.url}`);
+    const projectName = path.basename(workingDirectory);
+    const title = `${projectName}: Discord /diff`;
+    const result = await uploadGitDiffViaCritique({
+        title,
+        cwd: workingDirectory,
+    });
+    if (!result) {
+        await command.editReply({ content: 'No changes to show' });
+        return;
     }
-    catch (error) {
-        logger.error('[DIFF] Error:', error);
-        // exec error includes stdout/stderr - try to parse JSON from it
-        const execError = error;
-        const output = execError.stdout || execError.stderr || '';
-        // Check if critique output JSON even on error
-        const lines = output.trim().split('\n');
-        const jsonLine = lines[lines.length - 1];
-        if (jsonLine) {
-            try {
-                const result = JSON.parse(jsonLine);
-                if (result.error) {
-                    await command.editReply({
-                        content: result.error,
-                    });
-                    return;
-                }
-            }
-            catch {
-                // not JSON, continue to generic error
-            }
-        }
-        // Check for common errors
-        const message = execError.message || 'Unknown error';
-        if (message.includes('command not found') || message.includes('ENOENT')) {
-            await command.editReply({
-                content: 'bunx/critique not available',
-            });
-            return;
-        }
-        await command.editReply({
-            content: `Failed to generate diff: ${message.slice(0, 200)}`,
-        });
+    if (result.error || !result.url) {
+        await command.editReply({ content: result.error || 'No changes to show' });
+        return;
     }
+    const imageUrl = `https://critique.work/og/${result.id}.png`;
+    const embed = new EmbedBuilder()
+        .setTitle(title)
+        .setURL(result.url)
+        .setImage(imageUrl);
+    await command.editReply({ embeds: [embed] });
+    logger.log(`Diff shared: ${result.url}`);
 }

package/dist/commands/screenshare.js

@@ -0,0 +1,295 @@
+// /screenshare command - Start screen sharing via VNC + WebSocket bridge + kimaki tunnel.
+// On macOS: uses built-in Screen Sharing (port 5900).
+// On Linux: spawns x11vnc against the current $DISPLAY.
+// Exposes the VNC stream via an in-process websockify bridge and a traforo tunnel,
+// then sends the user a noVNC URL they can open in a browser.
+//
+// /screenshare-stop command - Stops the active screen share for this guild.
+import { MessageFlags } from 'discord.js';
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import { TunnelClient } from 'traforo/client';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { startWebsockify } from '../websockify.js';
+import { createLogger } from '../logger.js';
+import { execAsync } from '../worktrees.js';
+const logger = createLogger('SCREEN');
+/** One active screenshare per guild (Discord) or per machine (CLI) */
+const activeSessions = new Map();
+const VNC_PORT = 5900;
+const MAX_SESSION_MS = 60 * 60 * 1000; // 1 hour
+const TUNNEL_BASE_DOMAIN = 'kimaki.xyz';
+// Public noVNC client — we point it at our tunnel URL
+export function buildNoVncUrl({ tunnelHost }) {
+    const params = new URLSearchParams({
+        autoconnect: 'true',
+        host: tunnelHost,
+        port: '443',
+        encrypt: '1',
+        resize: 'scale',
+        view_only: 'false',
+    });
+    return `https://novnc.com/noVNC/vnc.html?${params.toString()}`;
+}
+// macOS has two separate services:
+// - "Screen Sharing" = view-only VNC (com.apple.screensharing)
+// - "Remote Management" = full control VNC with mouse/keyboard (ARDAgent)
+// We need Remote Management for interactive control, not just Screen Sharing.
+export async function ensureMacRemoteManagement() {
+    // Check if port 5900 is listening via netstat (no sudo needed).
+    // lsof and launchctl list both require sudo for system daemons.
+    try {
+        const { stdout } = await execAsync('netstat -an | grep "\\.5900 " | grep LISTEN', { timeout: 5000 });
+        if (stdout.trim()) {
+            return;
+        }
+    }
+    catch {
+        // not listening
+    }
+    throw new Error('macOS Remote Management is not enabled.\n' +
+        'Enable it: **System Settings > General > Sharing > Remote Management**\n' +
+        'Make sure "VNC viewers may control screen with password" is enabled.\n' +
+        'Or via terminal:\n' +
+        '```\nsudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart \\\n' +
+        '  -activate -configure -allowAccessFor -allUsers -privs -all \\\n' +
+        '  -clientopts -setvnclegacy -vnclegacy yes \\\n' +
+        '  -restart -agent -console\n```');
+}
+export function spawnX11Vnc() {
+    const display = process.env['DISPLAY'] || ':0';
+    const child = spawn('x11vnc', [
+        '-display', display,
+        '-nopw',
+        '-localhost',
+        '-rfbport', String(VNC_PORT),
+        '-shared',
+        '-forever',
+    ], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    child.stdout?.on('data', (data) => {
+        logger.log(`x11vnc: ${data.toString().trim()}`);
+    });
+    child.stderr?.on('data', (data) => {
+        logger.error(`x11vnc: ${data.toString().trim()}`);
+    });
+    return child;
+}
+function waitForPort({ port, process: proc, timeoutMs, }) {
+    return new Promise((resolve, reject) => {
+        const maxAttempts = Math.ceil(timeoutMs / 100);
+        let attempts = 0;
+        const check = () => {
+            if (proc.exitCode !== null) {
+                reject(new Error(`x11vnc exited with code ${proc.exitCode} before becoming ready`));
+                return;
+            }
+            const sock = net.createConnection(port, 'localhost');
+            sock.on('connect', () => {
+                sock.destroy();
+                resolve();
+            });
+            sock.on('error', () => {
+                sock.destroy();
+                if (++attempts >= maxAttempts) {
+                    reject(new Error(`Port ${port} not reachable after ${timeoutMs}ms`));
+                }
+                else {
+                    setTimeout(check, 100);
+                }
+            });
+        };
+        check();
+    });
+}
+export function cleanupSession(session) {
+    clearTimeout(session.timeoutTimer);
+    try {
+        session.tunnelClient.close();
+    }
+    catch { }
+    try {
+        session.wss.close();
+    }
+    catch { }
+    if (session.vncProcess) {
+        try {
+            session.vncProcess.kill();
+        }
+        catch { }
+    }
+}
+/**
+ * Core screenshare start logic, reused by both Discord command and CLI.
+ * Returns the session or throws on failure.
+ */
+export async function startScreenshare({ sessionKey, startedBy, }) {
+    const existing = activeSessions.get(sessionKey);
+    if (existing) {
+        throw new Error(`Screen sharing is already active: ${existing.noVncUrl}`);
+    }
+    const platform = process.platform;
+    let vncProcess;
+    // Step 1: ensure VNC server is running
+    if (platform === 'darwin') {
+        await ensureMacRemoteManagement();
+    }
+    else if (platform === 'linux') {
+        if (!process.env['DISPLAY']) {
+            throw new Error('No $DISPLAY found. Screen sharing requires a running X11 display.');
+        }
+        try {
+            await execAsync('which x11vnc', { timeout: 3000 });
+        }
+        catch {
+            throw new Error('x11vnc is not installed. Install it with: sudo apt install x11vnc');
+        }
+        vncProcess = spawnX11Vnc();
+        // Wait for x11vnc to actually be ready (port 5900 accepting connections)
+        // instead of a blind 1s sleep. Polls every 100ms, fails if process exits first.
+        await waitForPort({ port: VNC_PORT, process: vncProcess, timeoutMs: 3000 });
+    }
+    else {
+        throw new Error(`Screen sharing is not supported on ${platform}. Only macOS and Linux are supported.`);
+    }
+    // Step 2: start in-process websockify bridge
+    let wsInstance;
+    try {
+        wsInstance = await startWebsockify({
+            wsPort: 0,
+            tcpHost: 'localhost',
+            tcpPort: VNC_PORT,
+        });
+    }
+    catch (err) {
+        if (vncProcess) {
+            vncProcess.kill();
+        }
+        throw err;
+    }
+    // Step 3: create tunnel
+    const tunnelId = crypto.randomBytes(8).toString('hex');
+    const tunnelClient = new TunnelClient({
+        localPort: wsInstance.port,
+        tunnelId,
+        baseDomain: TUNNEL_BASE_DOMAIN,
+    });
+    try {
+        await Promise.race([
+            tunnelClient.connect(),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error('Tunnel connection timed out after 15s'));
+                }, 15000);
+            }),
+        ]);
+    }
+    catch (err) {
+        tunnelClient.close();
+        wsInstance.close();
+        if (vncProcess) {
+            vncProcess.kill();
+        }
+        throw err;
+    }
+    const tunnelHost = `${tunnelId}-tunnel.${TUNNEL_BASE_DOMAIN}`;
+    const tunnelUrl = `https://${tunnelHost}`;
+    const noVncUrl = buildNoVncUrl({ tunnelHost });
+    // Auto-kill after 1 hour
+    const timeoutTimer = setTimeout(() => {
+        logger.log(`Screen share auto-stopped after 1 hour (key: ${sessionKey})`);
+        stopScreenshare({ sessionKey });
+    }, MAX_SESSION_MS);
+    // Don't keep the process alive just for this timer
+    timeoutTimer.unref();
+    const session = {
+        tunnelClient,
+        wss: wsInstance.wss,
+        vncProcess,
+        url: tunnelUrl,
+        noVncUrl,
+        startedBy,
+        startedAt: Date.now(),
+        timeoutTimer,
+    };
+    activeSessions.set(sessionKey, session);
+    logger.log(`Screen share started by ${startedBy}: ${tunnelUrl}`);
+    return session;
+}
+/**
+ * Core screenshare stop logic, reused by both Discord command and CLI.
+ */
+export function stopScreenshare({ sessionKey }) {
+    const session = activeSessions.get(sessionKey);
+    if (!session) {
+        return false;
+    }
+    cleanupSession(session);
+    activeSessions.delete(sessionKey);
+    logger.log(`Screen share stopped (key: ${sessionKey})`);
+    return true;
+}
+export async function handleScreenshareCommand({ command, }) {
+    const guildId = command.guildId;
+    if (!guildId) {
+        await command.reply({
+            content: 'This command can only be used in a server',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    try {
+        const session = await startScreenshare({
+            sessionKey: guildId,
+            startedBy: command.user.tag,
+        });
+        await command.editReply({
+            content: `Screen sharing started\n${session.noVncUrl}`,
+        });
+    }
+    catch (err) {
+        logger.error('Failed to start screen share:', err);
+        await command.editReply({
+            content: `Failed to start screen share: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+}
+export async function handleScreenshareStopCommand({ command, }) {
+    const guildId = command.guildId;
+    if (!guildId) {
+        await command.reply({
+            content: 'This command can only be used in a server',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const stopped = stopScreenshare({ sessionKey: guildId });
+    if (!stopped) {
+        await command.reply({
+            content: 'No active screen share to stop',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.reply({
+        content: 'Screen sharing stopped',
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+}
+/** Cleanup all sessions on bot shutdown */
+export function cleanupAllScreenshares() {
+    for (const [guildId, session] of activeSessions) {
+        cleanupSession(session);
+        activeSessions.delete(guildId);
+    }
+}
+// Kill all screenshares when the process exits (Ctrl+C, SIGTERM, etc.)
+function onProcessExit() {
+    cleanupAllScreenshares();
+}
+process.on('SIGINT', onProcessExit);
+process.on('SIGTERM', onProcessExit);
+process.on('exit', onProcessExit);

package/dist/critique-utils.js

@@ -0,0 +1,95 @@
+// Shared utilities for invoking the critique CLI and parsing its JSON output.
+// Used by /diff command and footer diff link uploads.
+import { execAsync } from './worktrees.js';
+import { createLogger, LogPrefix } from './logger.js';
+const logger = createLogger(LogPrefix.DIFF);
+const CRITIQUE_TIMEOUT_MS = 30_000;
+/**
+ * Shell-quote a string by wrapping in single quotes and escaping embedded
+ * single quotes. Prevents injection when interpolating into shell commands.
+ */
+function shellQuote(s) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}
+/**
+ * Parse critique --json output. Critique prints progress to stderr and JSON
+ * to stdout. The JSON line contains { url, id } on success or { error } on
+ * failure. We scan all lines for the first valid JSON object with a url or
+ * error field, falling back to searching for a critique.work URL in the raw
+ * output.
+ */
+export function parseCritiqueOutput(output) {
+    const lines = output.trim().split('\n');
+    for (const line of lines) {
+        if (!line.startsWith('{')) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.error) {
+                return { error: parsed.error };
+            }
+            if (parsed.url && parsed.id) {
+                return { url: parsed.url, id: parsed.id };
+            }
+        }
+        catch {
+            // not valid JSON, try next line
+        }
+    }
+    // Fallback: try to find a URL in the raw output
+    const urlMatch = output.match(/https?:\/\/critique\.work\/[^\s]+/);
+    if (urlMatch) {
+        const url = urlMatch[0];
+        // Extract ID from URL path: /v/{id}
+        const idMatch = url.match(/\/v\/([a-f0-9]+)/);
+        const id = idMatch?.[1];
+        if (id) {
+            return { url, id };
+        }
+        // URL without parseable id — return as error so callers don't build
+        // broken OG image URLs from an empty id
+        return { error: url };
+    }
+    return undefined;
+}
+/**
+ * Run critique on the current git working tree diff and return the result.
+ * Used by the /diff slash command.
+ */
+export async function uploadGitDiffViaCritique({ title, cwd, }) {
+    try {
+        const { stdout, stderr } = await execAsync(`critique --web ${shellQuote(title)} --json`, { cwd, timeout: CRITIQUE_TIMEOUT_MS });
+        return parseCritiqueOutput(stdout || stderr);
+    }
+    catch (error) {
+        // exec error includes stdout/stderr — try to parse JSON from it
+        const execError = error;
+        const output = execError.stdout || execError.stderr || '';
+        const parsed = parseCritiqueOutput(output);
+        if (parsed) {
+            return parsed;
+        }
+        const message = execError.message || 'Unknown error';
+        if (message.includes('command not found') || message.includes('ENOENT')) {
+            return { error: 'critique not available' };
+        }
+        return { error: `Failed to generate diff: ${message.slice(0, 200)}` };
+    }
+}
+/**
+ * Upload a .patch file to critique.work via critique --stdin.
+ * Returns the critique URL on success, undefined on failure.
+ * Default timeout is 10s since this runs in the background (footer edit).
+ */
+export async function uploadPatchViaCritique({ patchPath, title, cwd, timeoutMs = 10_000, }) {
+    try {
+        const { stdout } = await execAsync(`critique --stdin --web ${shellQuote(title)} --json < ${shellQuote(patchPath)}`, { cwd, timeout: timeoutMs });
+        const result = parseCritiqueOutput(stdout);
+        return result?.url;
+    }
+    catch (error) {
+        logger.error('critique upload failed:', error);
+        return undefined;
+    }
+}