kimaki 0.4.90 → 0.4.91

package/dist/image-optimizer-plugin.js

@@ -0,0 +1,153 @@
+// Optimizes oversized images before they reach the LLM API.
+// Prevents "image dimensions exceed max allowed" errors from Anthropic/Google/OpenAI.
+// Hooks into tool.execute.after (read) and experimental.chat.messages.transform (clipboard paste).
+// Uses sharp to resize images > 2000px and compress images > 4MB.
+// Vendored from https://github.com/kargnas/opencode-large-image-optimizer, simplified to zero-config.
+// Conservative safe floor for Anthropic many-image requests (20+ images = 2000px limit).
+// OpenCode resends history so image counts accumulate across turns — 2000px is safest.
+const MAX_DIMENSION = 2000;
+// 4MB safe margin under Anthropic's 5MB limit
+const MAX_FILE_SIZE = 4 * 1024 * 1024;
+const SUPPORTED_MIMES = new Set([
+    'image/png',
+    'image/jpeg',
+    'image/jpg',
+    'image/gif',
+    'image/webp',
+]);
+let sharpFactory;
+async function getSharp() {
+    if (sharpFactory !== undefined) {
+        return sharpFactory;
+    }
+    try {
+        const mod = await import('sharp');
+        // sharp uses `export =` so it lands on .default in ESM interop
+        const fn = typeof mod === 'function' ? mod : mod.default;
+        if (typeof fn === 'function') {
+            sharpFactory = fn;
+        }
+        else {
+            sharpFactory = null;
+        }
+    }
+    catch {
+        sharpFactory = null;
+    }
+    return sharpFactory;
+}
+function extractBase64Data(dataUrl) {
+    const match = dataUrl.match(/^data:[^;]+;base64,(.+)$/s);
+    if (match?.[1]) {
+        return match[1];
+    }
+    // raw base64 string (no data: prefix)
+    if (/^[A-Za-z0-9+/]+={0,2}$/.test(dataUrl)) {
+        return dataUrl;
+    }
+    return null;
+}
+async function optimizeImage(dataUrl, mime) {
+    const sharp = await getSharp();
+    if (!sharp) {
+        return null;
+    }
+    const rawBase64 = extractBase64Data(dataUrl);
+    if (!rawBase64) {
+        return null;
+    }
+    const inputBuffer = Buffer.from(rawBase64, 'base64');
+    if (inputBuffer.length === 0) {
+        return null;
+    }
+    const metadata = await sharp(inputBuffer).metadata();
+    const width = metadata.width || 0;
+    const height = metadata.height || 0;
+    if (width === 0 || height === 0) {
+        return null;
+    }
+    const needsResize = width > MAX_DIMENSION || height > MAX_DIMENSION;
+    const needsCompress = inputBuffer.length > MAX_FILE_SIZE;
+    if (!needsResize && !needsCompress) {
+        return null;
+    }
+    let pipeline = sharp(inputBuffer);
+    let outputMime = mime;
+    if (needsResize) {
+        pipeline = pipeline.resize(MAX_DIMENSION, MAX_DIMENSION, {
+            fit: 'inside',
+            withoutEnlargement: true,
+        });
+    }
+    let outputBuffer = await pipeline.toBuffer();
+    // if still over 4MB, convert to JPEG with progressive quality reduction
+    if (outputBuffer.length > MAX_FILE_SIZE) {
+        for (const quality of [100, 90, 80, 70]) {
+            outputBuffer = await sharp(outputBuffer)
+                .jpeg({ quality, mozjpeg: true })
+                .toBuffer();
+            outputMime = 'image/jpeg';
+            if (outputBuffer.length <= MAX_FILE_SIZE) {
+                break;
+            }
+        }
+    }
+    return {
+        dataUrl: `data:${outputMime};base64,${outputBuffer.toString('base64')}`,
+        mime: outputMime,
+    };
+}
+// runtime guard — tool.execute.after output type doesn't declare attachments
+function hasAttachments(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'attachments' in value &&
+        Array.isArray(value.attachments));
+}
+const imageOptimizerPlugin = async () => {
+    return {
+        'tool.execute.after': async (input, output) => {
+            const tool = input.tool.toLowerCase();
+            // read tool: optimize image attachments
+            if (tool === 'read' && hasAttachments(output)) {
+                for (const att of output.attachments) {
+                    if (!att.mime ||
+                        !att.url ||
+                        !SUPPORTED_MIMES.has(att.mime.toLowerCase())) {
+                        continue;
+                    }
+                    const result = await optimizeImage(att.url, att.mime).catch(() => null);
+                    if (result) {
+                        att.url = result.dataUrl;
+                        att.mime = result.mime;
+                    }
+                }
+            }
+        },
+        // clipboard paste: optimize file parts in message history
+        'experimental.chat.messages.transform': async (_input, output) => {
+            if (!output.messages || !Array.isArray(output.messages)) {
+                return;
+            }
+            for (const msg of output.messages) {
+                if (!msg.parts || !Array.isArray(msg.parts)) {
+                    continue;
+                }
+                for (const part of msg.parts) {
+                    if (part.type !== 'file') {
+                        continue;
+                    }
+                    if (!SUPPORTED_MIMES.has(part.mime.toLowerCase())) {
+                        continue;
+                    }
+                    const result = await optimizeImage(part.url, part.mime).catch(() => null);
+                    if (result) {
+                        part.url = result.dataUrl;
+                        part.mime = result.mime;
+                    }
+                }
+            }
+        },
+    };
+};
+export { imageOptimizerPlugin };

package/dist/ipc-tools-plugin.js

@@ -9,9 +9,8 @@
 // plugin by OpenCode's plugin loader.
 import dedent from 'string-dedent';
 import { z } from 'zod';
-import { getPrisma, createIpcRequest, getIpcRequestById } from './database.js';
 import { setDataDir } from './config.js';
-import { createLogger, LogPrefix, setLogFilePath } from './logger.js';
+import { createPluginLogger, setPluginLogFilePath } from './plugin-logger.js';
 import { initSentry } from './sentry.js';
 // Inlined from '@opencode-ai/plugin/tool' because the subpath value import
 // fails at runtime in global npm installs (#35). Opencode loads this plugin
@@ -27,10 +26,16 @@ import { initSentry } from './sentry.js';
 function tool(input) {
     return input;
 }
-const logger = createLogger(LogPrefix.OPENCODE);
+const logger = createPluginLogger('OPENCODE');
 const FILE_UPLOAD_TIMEOUT_MS = 6 * 60 * 1000;
 const DEFAULT_FILE_UPLOAD_MAX_FILES = 5;
 const ACTION_BUTTON_TIMEOUT_MS = 30 * 1000;
+async function loadDatabaseModule() {
+    // The plugin-loading e2e test boots OpenCode directly without the bot-side
+    // Hrana env vars. Lazy-loading avoids pulling Prisma + libsql sqlite mode
+    // during plugin startup when no IPC tool is being executed yet.
+    return import('./database.js');
+}
 // @opencode-ai/plugin bundles zod 4.1.x as a hard dep; our code uses 4.3.x
 // (required by goke for ~standard.jsonSchema). The Plugin return type is
 // structurally incompatible due to _zod.version.minor skew even though
@@ -42,7 +47,7 @@ const ipcToolsPlugin = async () => {
     const dataDir = process.env.KIMAKI_DATA_DIR;
     if (dataDir) {
         setDataDir(dataDir);
-        setLogFilePath(dataDir);
+        setPluginLogFilePath(dataDir);
     }
     return {
         tool: {
@@ -64,6 +69,7 @@ const ipcToolsPlugin = async () => {
                         .describe('Maximum number of files the user can upload (1-10, default 5)'),
                 },
                 async execute({ prompt, maxFiles }, context) {
+                    const { getPrisma, createIpcRequest, getIpcRequestById } = await loadDatabaseModule();
                     const prisma = await getPrisma();
                     const row = await prisma.thread_sessions.findFirst({
                         where: { session_id: context.sessionID },
@@ -142,6 +148,7 @@ const ipcToolsPlugin = async () => {
                         .describe('Array of 1-3 action buttons. Prefer one button whenever possible.'),
                 },
                 async execute({ buttons }, context) {
+                    const { getPrisma, createIpcRequest, getIpcRequestById } = await loadDatabaseModule();
                     const prisma = await getPrisma();
                     const row = await prisma.thread_sessions.findFirst({
                         where: { session_id: context.sessionID },

package/dist/kimaki-opencode-plugin.js

@@ -12,5 +12,6 @@ export { ipcToolsPlugin } from './ipc-tools-plugin.js';
 export { contextAwarenessPlugin } from './context-awareness-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
+export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
 export { kittyGraphicsPlugin } from 'kitty-graphics-agent';
 export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard';

package/dist/logger.js

@@ -135,7 +135,6 @@ export function createLogger(prefix) {
         }
         clackLog.message(formatMessage(getTimestamp(), pc.cyan(paddedPrefix), args), {
             ...noSpacing,
-            // symbol: `|`,
         });
     };
     return {

package/dist/markdown.js

@@ -4,7 +4,7 @@
 // Uses errore for type-safe error handling.
 import * as errore from 'errore';
 import { createTaggedError } from 'errore';
-import * as yaml from 'js-yaml';
+import YAML from 'yaml';
 import { formatDateTime } from './utils.js';
 import { extractNonXmlContent } from './xml.js';
 import { createLogger, LogPrefix } from './logger.js';
@@ -175,7 +175,7 @@ export class ShareMarkdown {
                     if (part.state.input && Object.keys(part.state.input).length > 0) {
                         lines.push('**Input:**');
                         lines.push('```yaml');
-                        lines.push(yaml.dump(part.state.input, { lineWidth: -1 }));
+                        lines.push(YAML.stringify(part.state.input, null, { lineWidth: 0 }));
                         lines.push('```');
                         lines.push('');
                     }

package/dist/message-preprocessing.js

@@ -17,12 +17,33 @@ import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
 const logger = createLogger(LogPrefix.SESSION);
 const voiceLogger = createLogger(LogPrefix.VOICE);
+export const VOICE_MESSAGE_TRANSCRIPTION_PREFIX = 'Voice message transcription from Discord user:\n';
+/** Fetch available agents from OpenCode for voice transcription agent selection. */
+async function fetchAvailableAgents(getClient) {
+    if (getClient instanceof Error) {
+        return [];
+    }
+    const result = await errore.tryAsync(() => {
+        return getClient().app.agents({});
+    });
+    if (result instanceof Error) {
+        return [];
+    }
+    return (result.data || [])
+        .filter((a) => {
+        return (a.mode === 'primary' || a.mode === 'all') && !a.hidden;
+    })
+        .map((a) => {
+        return { name: a.name, description: a.description };
+    });
+}
 // Matches punctuation + "queue" at the end of a message (case-insensitive).
 // Supports any common punctuation before "queue" (. ! ? , ; :) and an optional
 // trailing period: ". queue", "! queue", ". queue.", "!queue." etc.
 // When present the suffix is stripped and the message is routed through
 // kimaki's local queue (same as /queue command).
 const QUEUE_SUFFIX_RE = /[.!?,;:]\s*queue\.?\s*$/i;
+const REPLIED_MESSAGE_TEXT_LIMIT = 1_000;
 function extractQueueSuffix(prompt) {
     if (!QUEUE_SUFFIX_RE.test(prompt)) {
         return { prompt, forceQueue: false };
@@ -45,6 +66,28 @@ function shouldSkipEmptyPrompt({ message, prompt, images, hasVoiceAttachment, })
     voiceLogger.warn(`[INGRESS] Skipping empty prompt after preprocessing attachments=${message.attachments.size} hasVoiceAttachment=${hasVoiceAttachment} inferredVoiceAttachment=${inferredVoiceAttachment}`);
     return true;
 }
+async function getRepliedMessageContext({ message, }) {
+    if (!message.reference?.messageId) {
+        return undefined;
+    }
+    const referencedMessage = await errore.tryAsync(() => {
+        return message.fetchReference();
+    });
+    if (referencedMessage instanceof Error) {
+        logger.warn(`[INGRESS] Failed to fetch replied message ${message.reference.messageId} for ${message.id}: ${referencedMessage.message}`);
+        return undefined;
+    }
+    const repliedText = resolveMentions(referencedMessage)
+        .trim()
+        .slice(0, REPLIED_MESSAGE_TEXT_LIMIT);
+    if (!repliedText) {
+        return undefined;
+    }
+    return {
+        authorUsername: referencedMessage.author.username,
+        text: repliedText,
+    };
+}
 /**
  * Pre-process a message in an existing thread (thread already has a session or
  * needs a new one). Handles voice transcription, text/file attachments, and
@@ -71,9 +114,11 @@ export async function preprocessExistingThreadMessage({ message, thread, project
     let messageContent = isCliInjected
         ? (message.content || '')
         : resolveMentions(message);
-    // Fetch session context for voice transcription enrichment
+    const repliedMessage = await getRepliedMessageContext({ message });
+    // Fetch session context and available agents for voice transcription enrichment
     let currentSessionContext;
     let lastSessionContext;
+    let agents = [];
     if (projectDirectory) {
         try {
             const getClient = await initializeOpencodeForDirectory(projectDirectory, { channelId });
@@ -82,19 +127,23 @@ export async function preprocessExistingThreadMessage({ message, thread, project
                 throw new Error(getClient.message);
             }
             const client = getClient();
-            const result = await getCompactSessionContext({
-                client,
-                sessionId,
-                includeSystemPrompt: false,
-                maxMessages: 15,
-            });
-            if (errore.isOk(result)) {
-                currentSessionContext = result;
+            const [sessionContextResult, lastSessionResult, fetchedAgents] = await Promise.all([
+                getCompactSessionContext({
+                    client,
+                    sessionId,
+                    includeSystemPrompt: false,
+                    maxMessages: 15,
+                }),
+                getLastSessionId({
+                    client,
+                    excludeSessionId: sessionId,
+                }),
+                fetchAvailableAgents(getClient),
+            ]);
+            if (errore.isOk(sessionContextResult)) {
+                currentSessionContext = sessionContextResult;
             }
-            const lastSessionResult = await getLastSessionId({
-                client,
-                excludeSessionId: sessionId,
-            });
+            agents = fetchedAgents;
             const lastSessionId = errore.unwrapOr(lastSessionResult, null);
             if (lastSessionId) {
                 const result = await getCompactSessionContext({
@@ -120,9 +169,10 @@ export async function preprocessExistingThreadMessage({ message, thread, project
         appId,
         currentSessionContext,
         lastSessionContext,
+        agents,
     });
     if (voiceResult) {
-        messageContent = `Voice message transcription from Discord user:\n${voiceResult.transcription}`;
+        messageContent = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`;
     }
     // Voice transcription failed and no text — drop silently
     if (hasVoiceAttachment && !voiceResult && !messageContent.trim()) {
@@ -148,7 +198,9 @@ export async function preprocessExistingThreadMessage({ message, thread, project
     return {
         prompt,
         images: fileAttachments.length > 0 ? fileAttachments : undefined,
+        repliedMessage,
         mode: qs.forceQueue || voiceResult?.queueMessage ? 'local-queue' : 'opencode',
+        agent: voiceResult?.agent,
     };
 }
 /**
@@ -158,15 +210,29 @@ export async function preprocessExistingThreadMessage({ message, thread, project
  */
 export async function preprocessNewSessionMessage({ message, thread, projectDirectory, hasVoiceAttachment, appId, }) {
     logger.log(`No session for thread ${thread.id}, starting new session`);
+    // Fetch available agents only for voice messages to avoid unnecessary SDK
+    // roundtrips on plain text messages.
+    let agents = [];
+    if (hasVoiceAttachment && projectDirectory) {
+        try {
+            const getClient = await initializeOpencodeForDirectory(projectDirectory);
+            agents = await fetchAvailableAgents(getClient);
+        }
+        catch (e) {
+            voiceLogger.error(`Could not fetch agents for voice transcription:`, e);
+        }
+    }
     let prompt = resolveMentions(message);
+    const repliedMessage = await getRepliedMessageContext({ message });
     const voiceResult = await processVoiceAttachment({
         message,
         thread,
         projectDirectory,
         appId,
+        agents,
     });
     if (voiceResult) {
-        prompt = `Voice message transcription from Discord user:\n${voiceResult.transcription}`;
+        prompt = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`;
     }
     // Voice transcription failed and no text — drop silently
     if (hasVoiceAttachment && !voiceResult && !prompt.trim()) {
@@ -199,7 +265,9 @@ export async function preprocessNewSessionMessage({ message, thread, projectDire
     }
     return {
         prompt: qs.prompt,
+        repliedMessage,
         mode: qs.forceQueue || voiceResult?.queueMessage ? 'local-queue' : 'opencode',
+        agent: voiceResult?.agent,
     };
 }
 /**
@@ -207,16 +275,30 @@ export async function preprocessNewSessionMessage({ message, thread, projectDire
  * Handles voice transcription and file/text attachments.
  */
 export async function preprocessNewThreadMessage({ message, thread, projectDirectory, hasVoiceAttachment, appId, }) {
+    // Fetch available agents only for voice messages to avoid unnecessary SDK
+    // roundtrips on plain text messages.
+    let agents = [];
+    if (hasVoiceAttachment && projectDirectory) {
+        try {
+            const getClient = await initializeOpencodeForDirectory(projectDirectory);
+            agents = await fetchAvailableAgents(getClient);
+        }
+        catch (e) {
+            voiceLogger.error(`Could not fetch agents for voice transcription:`, e);
+        }
+    }
     let messageContent = resolveMentions(message);
+    const repliedMessage = await getRepliedMessageContext({ message });
     const voiceResult = await processVoiceAttachment({
         message,
         thread,
         projectDirectory,
         isNewThread: true,
         appId,
+        agents,
     });
     if (voiceResult) {
-        messageContent = `Voice message transcription from Discord user:\n${voiceResult.transcription}`;
+        messageContent = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`;
     }
     // Voice transcription failed and no text — drop silently
     if (hasVoiceAttachment && !voiceResult && !messageContent.trim()) {
@@ -241,6 +323,8 @@ export async function preprocessNewThreadMessage({ message, thread, projectDirec
     return {
         prompt,
         images: fileAttachments.length > 0 ? fileAttachments : undefined,
+        repliedMessage,
         mode: qs.forceQueue || voiceResult?.queueMessage ? 'local-queue' : 'opencode',
+        agent: voiceResult?.agent,
     };
 }

package/dist/onboarding-tutorial.js

@@ -142,7 +142,7 @@ ${backticks}bash
 PORT=$((RANDOM % 6000 + 3000))
 tmux kill-session -t game-dev 2>/dev/null
 tmux new-session -d -s game-dev -c "$PWD"
-tmux send-keys -t game-dev "PORT=$PORT kimaki tunnel --kill -p $PORT -- bun run server.ts" Enter
+tmux send-keys -t game-dev "PORT=$PORT kimaki tunnel -p $PORT -- bun run server.ts" Enter
 ${backticks}
 
 Wait a moment, then get the tunnel URL:

package/dist/opencode-command-detection.js

@@ -0,0 +1,70 @@
+// Detect a /commandname token on its own line in a user prompt and resolve it
+// to a registered opencode command. Mirrors the Discord slash command flow
+// (commands/user-command.ts) so users can type `/build foo` or `/build-cmd foo`
+// in chat, via `/new-session`, through `kimaki send --prompt`, or scheduled
+// tasks and have it routed to opencode's session.command API instead of going
+// to the model as plain text.
+//
+// Detection is line-based: we scan each line and return the first one whose
+// first non-whitespace token is `/<registered-command>`. This keeps the
+// detector oblivious to prefix lines (`» **kimaki-cli:**`, `Context from
+// thread:`, etc). Producers that add such prefixes must put them on their
+// own line so the user's content starts on a fresh line.
+import { store } from './store.js';
+const DISCORD_SUFFIXES = ['-mcp-prompt', '-skill', '-cmd'];
+function stripDiscordSuffix(token) {
+    for (const suffix of DISCORD_SUFFIXES) {
+        if (token.endsWith(suffix)) {
+            return token.slice(0, -suffix.length);
+        }
+    }
+    return token;
+}
+function findRegisteredCommand({ token, registered, }) {
+    // Try exact matches first (original name, then Discord-sanitized name).
+    const exact = registered.find((c) => {
+        return c.name === token || c.discordCommandName === token;
+    });
+    if (exact)
+        return exact;
+    // Fall back to matching after stripping -cmd / -skill / -mcp-prompt from
+    // the user's token. This lets `/build-cmd` resolve to an opencode command
+    // whose base name is `build`.
+    const base = stripDiscordSuffix(token);
+    if (base === token)
+        return undefined;
+    return registered.find((c) => {
+        return c.name === base || c.discordCommandName === base;
+    });
+}
+export function extractLeadingOpencodeCommand(prompt, registered = store.getState().registeredUserCommands) {
+    if (!prompt)
+        return null;
+    if (registered.length === 0)
+        return null;
+    // Scan each line; the first line whose trimmed start is `/<token>` and
+    // resolves against registeredUserCommands wins. Args are everything after
+    // the command token on that line. Lines before and after are ignored —
+    // they're prefix (`» **name:**`) or context noise.
+    for (const line of prompt.split('\n')) {
+        const trimmed = line.trimStart();
+        if (!trimmed.startsWith('/'))
+            continue;
+        const match = trimmed.match(/^\/([^\s]+)(?:\s+(.*))?$/);
+        if (!match)
+            continue;
+        const [, token, rest] = match;
+        if (!token)
+            continue;
+        const resolved = findRegisteredCommand({ token, registered });
+        if (!resolved)
+            continue;
+        return {
+            command: {
+                name: resolved.name,
+                arguments: (rest ?? '').trim(),
+            },
+        };
+    }
+    return null;
+}