kimaki 0.4.77 → 0.4.78

package/dist/diff-patch-plugin.js

@@ -0,0 +1,314 @@
+// Tracks tool-driven file changes and writes per-message/session .patch files
+// to $KIMAKI_DATA_DIR/diffs/ (default ~/.kimaki/diffs/).
+//
+// The bot process reads these patch files in emitFooter() to upload them via
+// critique and append [ses diff] / [msg diff] links to the footer message.
+//
+// Lifecycle:
+//   tool.execute.before → snapshot file contents before edit
+//   tool.execute.after  → snapshot again, record the delta
+//   message.updated (completed) → write {sessionId}-{messageId}.patch
+//   session.idle         → write {sessionId}.patch (cumulative, overwrites)
+//   session.deleted      → cleanup in-memory state
+//
+// Pruning: caps the diffs folder at MAX_PATCH_FILES, deleting oldest by mtime.
+import { createTwoFilesPatch } from 'diff';
+import fs from 'node:fs';
+import path from 'node:path';
+import { extractPatchFilePaths } from './patch-text-parser.js';
+const TOOLS = new Set(['edit', 'write', 'apply_patch', 'multiedit']);
+// Skip files larger than 512KB to avoid memory spikes
+const MAX_FILE_BYTES = 512 * 1024;
+// Max patch files before pruning oldest
+const MAX_PATCH_FILES = 200;
+// Pending tool calls older than 10 min are garbage collected
+const PENDING_TTL_MS = 10 * 60 * 1000;
+function extractPaths(tool, args) {
+    if (tool === 'edit' || tool === 'write' || tool === 'multiedit') {
+        return typeof args.filePath === 'string' ? [args.filePath] : [];
+    }
+    if (tool === 'apply_patch') {
+        const text = (args.patchText ?? args.patch ?? '');
+        return extractPatchFilePaths(text);
+    }
+    return [];
+}
+function buildPatch(files) {
+    const parts = [];
+    for (const [file, { first, last }] of files) {
+        if (first === last) {
+            continue;
+        }
+        parts.push(createTwoFilesPatch(file, file, first, last));
+    }
+    return parts.join('\n');
+}
+async function readSafe(file) {
+    const stat = await fs.promises.stat(file).catch(() => {
+        return undefined;
+    });
+    if (!stat) {
+        return '';
+    }
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+        return undefined;
+    }
+    return fs.promises.readFile(file, 'utf8').catch(() => {
+        return '';
+    });
+}
+async function prunePatchDir(dir) {
+    const entries = await fs.promises.readdir(dir).catch(() => {
+        return [];
+    });
+    if (entries.length <= MAX_PATCH_FILES) {
+        return;
+    }
+    const files = (await Promise.all(entries.map(async (name) => {
+        const full = path.join(dir, name);
+        const stat = await fs.promises.stat(full).catch(() => {
+            return undefined;
+        });
+        return stat?.isFile() ? { full, mtime: stat.mtimeMs } : undefined;
+    }))).filter((f) => {
+        return f !== undefined;
+    });
+    files.sort((a, b) => {
+        return b.mtime - a.mtime;
+    });
+    await Promise.all(files.slice(MAX_PATCH_FILES).map((f) => {
+        return fs.promises.unlink(f.full).catch(() => { });
+    }));
+}
+// Atomic write: write to a temp file then rename to avoid torn reads
+// from the bot process reading a partially-written patch.
+// If content is empty, deletes any existing file so stale patches from
+// previous turns aren't re-uploaded by the bot.
+async function writePatch({ dir, name, content, }) {
+    const target = path.join(dir, name);
+    if (!content) {
+        await fs.promises.unlink(target).catch(() => { });
+        return;
+    }
+    await fs.promises.mkdir(dir, { recursive: true });
+    const tmp = `${target}.tmp.${process.pid}`;
+    await fs.promises.writeFile(tmp, content);
+    await fs.promises.rename(tmp, target);
+    await prunePatchDir(dir);
+}
+const diffPatchPlugin = async (input) => {
+    const dataDir = process.env.KIMAKI_DATA_DIR || path.join(process.env.HOME || '~', '.kimaki');
+    const dir = path.join(dataDir, 'diffs');
+    // session → file → { first snapshot, last snapshot }
+    const sessions = new Map();
+    // session → messageId → file → { first, last }
+    const messages = new Map();
+    // callID → pending tool info (for matching before/after)
+    const pending = new Map();
+    // session → current active assistant messageId
+    const activeMessage = new Map();
+    // dedup guard: "sessionID:messageID:completedTimestamp"
+    const completed = new Set();
+    // child session → root (top-level) parent session.
+    // When a task tool spawns a subtask, tools inside that subtask fire with
+    // the child sessionID. We resolve up to the root parent so file snapshots
+    // always roll up into the top-level session's cumulative patch.
+    const childToRoot = new Map();
+    /** Resolve up the parent chain to find the root (top-level) session. */
+    function resolveRoot(sessionID) {
+        return childToRoot.get(sessionID) ?? sessionID;
+    }
+    function ensureSession(sessionID) {
+        if (!sessions.has(sessionID)) {
+            sessions.set(sessionID, new Map());
+        }
+        if (!messages.has(sessionID)) {
+            messages.set(sessionID, new Map());
+        }
+    }
+    function ensureMessage(sessionID, messageID) {
+        const msgs = messages.get(sessionID);
+        if (!msgs.has(messageID)) {
+            msgs.set(messageID, new Map());
+        }
+    }
+    function setFirst(map, file, content) {
+        if (!map.has(file)) {
+            map.set(file, { first: content, last: content });
+        }
+    }
+    function prunePending() {
+        const now = Date.now();
+        for (const [id, item] of pending) {
+            if (now - item.createdAt > PENDING_TTL_MS) {
+                pending.delete(id);
+            }
+        }
+    }
+    function cleanupSession(sessionID) {
+        sessions.delete(sessionID);
+        messages.delete(sessionID);
+        activeMessage.delete(sessionID);
+        for (const [id, p] of pending) {
+            if (p.sessionID === sessionID) {
+                pending.delete(id);
+            }
+        }
+        for (const key of completed) {
+            if (key.startsWith(sessionID + ':')) {
+                completed.delete(key);
+            }
+        }
+        // Clean up child→root mappings pointing to or from this session
+        for (const [child, root] of childToRoot) {
+            if (child === sessionID || root === sessionID) {
+                childToRoot.delete(child);
+            }
+        }
+    }
+    return {
+        'tool.execute.before': async ({ tool, sessionID, callID }, { args }) => {
+            if (!TOOLS.has(tool)) {
+                return;
+            }
+            const raw = extractPaths(tool, args);
+            if (!raw.length) {
+                return;
+            }
+            prunePending();
+            // Resolve root session so child edits roll up into the parent's patch.
+            const rootID = resolveRoot(sessionID);
+            ensureSession(rootID);
+            const rootFiles = sessions.get(rootID);
+            const msgID = activeMessage.get(rootID);
+            const captured = [];
+            for (const r of raw) {
+                const p = path.isAbsolute(r)
+                    ? r
+                    : path.resolve(input.directory, r);
+                const content = await readSafe(p);
+                if (content === undefined) {
+                    continue;
+                }
+                setFirst(rootFiles, p, content);
+                if (msgID) {
+                    ensureMessage(rootID, msgID);
+                    setFirst(messages.get(rootID).get(msgID), p, content);
+                }
+                captured.push(p);
+            }
+            if (captured.length) {
+                pending.set(callID, {
+                    // Store rootID so tool.execute.after updates the correct maps
+                    sessionID: rootID,
+                    messageID: msgID,
+                    paths: captured,
+                    createdAt: Date.now(),
+                });
+            }
+        },
+        'tool.execute.after': async ({ callID }) => {
+            prunePending();
+            const call = pending.get(callID);
+            if (!call) {
+                return;
+            }
+            pending.delete(callID);
+            const sessionFiles = sessions.get(call.sessionID);
+            // Use messageID captured at before-time, not current activeMessage
+            const msgFiles = call.messageID
+                ? messages.get(call.sessionID)?.get(call.messageID)
+                : undefined;
+            for (const p of call.paths) {
+                const content = await readSafe(p);
+                if (content === undefined) {
+                    continue;
+                }
+                const s = sessionFiles.get(p);
+                if (s) {
+                    s.last = content;
+                }
+                if (msgFiles) {
+                    const m = msgFiles.get(p);
+                    if (m) {
+                        m.last = content;
+                    }
+                }
+            }
+        },
+        event: async ({ event }) => {
+            // Track child→root session mapping from session.updated events.
+            // OpenCode emits session.updated with parentID set when a task tool
+            // creates a child session. This fires BEFORE the child starts executing
+            // tools, so the mapping is ready when child tool.execute.before fires.
+            if (event.type === 'session.updated') {
+                const info = event.properties.info;
+                if (info.id && info.parentID) {
+                    const rootID = resolveRoot(info.parentID);
+                    childToRoot.set(info.id, rootID);
+                }
+            }
+            if (event.type === 'message.updated' &&
+                event.properties.info.role === 'assistant') {
+                const msg = event.properties.info;
+                activeMessage.set(msg.sessionID, msg.id);
+                if (msg.time.completed) {
+                    const key = `${msg.sessionID}:${msg.id}:${msg.time.completed}`;
+                    if (completed.has(key)) {
+                        return;
+                    }
+                    completed.add(key);
+                    const msgFiles = messages.get(msg.sessionID)?.get(msg.id);
+                    if (msgFiles?.size) {
+                        const patch = buildPatch(msgFiles);
+                        await writePatch({
+                            dir,
+                            name: `${msg.sessionID}-${msg.id}.patch`,
+                            content: patch,
+                        });
+                    }
+                    messages.get(msg.sessionID)?.delete(msg.id);
+                }
+                return;
+            }
+            if (event.type === 'session.idle') {
+                const sessionID = event.properties.sessionID;
+                // Child sessions: edits already rolled up into root, skip patch write.
+                if (childToRoot.has(sessionID)) {
+                    return;
+                }
+                const sessionFiles = sessions.get(sessionID);
+                if (sessionFiles?.size) {
+                    const patch = buildPatch(sessionFiles);
+                    await writePatch({
+                        dir,
+                        name: `${sessionID}.patch`,
+                        content: patch,
+                    });
+                    // Reset first snapshots to current state so next turn is incremental
+                    for (const state of sessionFiles.values()) {
+                        state.first = state.last;
+                    }
+                }
+                messages.get(sessionID)?.clear();
+                activeMessage.delete(sessionID);
+                for (const [id, p] of pending) {
+                    if (p.sessionID === sessionID) {
+                        pending.delete(id);
+                    }
+                }
+                // Clear completed dedup keys for this session to bound memory growth
+                for (const key of completed) {
+                    if (key.startsWith(sessionID + ':')) {
+                        completed.delete(key);
+                    }
+                }
+                return;
+            }
+            if (event.type === 'session.deleted') {
+                cleanupSession(event.properties.info.id);
+            }
+        },
+    };
+};
+export default diffPatchPlugin;

package/dist/discord-bot.js

@@ -599,7 +599,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 });
             }
             else {
-                discordLogger.log(`Channel type ${channel.type} is not supported`);
+                // discordLogger.log(`Channel type ${channel.type} is not supported`)
             }
         }
         catch (error) {

package/dist/interaction-handler.js

@@ -37,6 +37,7 @@ import { handleContextUsageCommand } from './commands/context-usage.js';
 import { handleSessionIdCommand } from './commands/session-id.js';
 import { handleUpgradeAndRestartCommand } from './commands/upgrade.js';
 import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js';
+import { handleScreenshareCommand, handleScreenshareStopCommand, } from './commands/screenshare.js';
 import { handleModelVariantSelectMenu } from './commands/model.js';
 import { handleModelVariantCommand, handleVariantQuickSelectMenu, handleVariantScopeSelectMenu, } from './commands/model-variant.js';
 import { hasKimakiBotPermission } from './discord-utils.js';
@@ -211,6 +212,15 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'mcp':
                         await handleMcpCommand({ command: interaction, appId });
                         return;
+                    case 'screenshare':
+                        await handleScreenshareCommand({ command: interaction, appId });
+                        return;
+                    case 'screenshare-stop':
+                        await handleScreenshareStopCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
                 }
                 // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
                 if (interaction.commandName.endsWith('-agent') &&

package/dist/message-formatting.js

@@ -5,6 +5,7 @@ import * as errore from 'errore';
 import { createLogger, LogPrefix } from './logger.js';
 import { FetchError } from './errors.js';
 import { processImage } from './image-utils.js';
+import { parsePatchFileCounts } from './patch-text-parser.js';
 const logger = createLogger(LogPrefix.FORMATTING);
 /**
  * Resolves Discord mentions in message content to human-readable names.
@@ -36,67 +37,7 @@ export function resolveMentions(message) {
 function escapeInlineMarkdown(text) {
     return text.replace(/([*_~|`\\])/g, '\\$1');
 }
-/**
- * Parses a patchText string (apply_patch format) and counts additions/deletions per file.
- * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
- * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
- */
-function parsePatchCounts(patchText) {
-    const counts = new Map();
-    const lines = patchText.split('\n');
-    let currentFile = '';
-    let currentType = '';
-    let inHunk = false;
-    for (const line of lines) {
-        const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/);
-        const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/);
-        const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/);
-        if (addMatch || updateMatch || deleteMatch) {
-            const match = addMatch || updateMatch || deleteMatch;
-            currentFile = (match?.[1] ?? '').trim();
-            currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete';
-            counts.set(currentFile, { additions: 0, deletions: 0 });
-            inHunk = false;
-            continue;
-        }
-        if (line.startsWith('@@')) {
-            inHunk = true;
-            continue;
-        }
-        if (line.startsWith('*** ')) {
-            inHunk = false;
-            continue;
-        }
-        if (!currentFile) {
-            continue;
-        }
-        const entry = counts.get(currentFile);
-        if (!entry) {
-            continue;
-        }
-        if (currentType === 'add') {
-            // all content lines in Add File are additions
-            if (line.length > 0 && !line.startsWith('*** ')) {
-                entry.additions++;
-            }
-        }
-        else if (currentType === 'delete') {
-            // all content lines in Delete File are deletions
-            if (line.length > 0 && !line.startsWith('*** ')) {
-                entry.deletions++;
-            }
-        }
-        else if (inHunk) {
-            if (line.startsWith('+')) {
-                entry.additions++;
-            }
-            else if (line.startsWith('-')) {
-                entry.deletions++;
-            }
-        }
-    }
-    return counts;
-}
+// parsePatchCounts → imported from patch-text-parser.ts as parsePatchFileCounts
 /**
  * Normalize whitespace: convert newlines to spaces and collapse consecutive spaces.
  */
@@ -220,7 +161,7 @@ export function getToolSummaryText(part) {
         if (!patchText) {
             return '';
         }
-        const patchCounts = parsePatchCounts(patchText);
+        const patchCounts = parsePatchFileCounts(patchText);
         return [...patchCounts.entries()]
             .map(([filePath, { additions, deletions }]) => {
             const fileName = filePath.split('/').pop() || '';

package/dist/onboarding-tutorial-plugin.js

@@ -42,7 +42,7 @@ const onboardingTutorialPlugin = async () => {
                         return;
                     }
                     output.parts.push({
-                        id: crypto.randomUUID(),
+                        id: `prt_${crypto.randomUUID()}`,
                         sessionID,
                         messageID: firstText.messageID,
                         type: 'text',

package/dist/opencode-plugin.js

@@ -267,7 +267,7 @@ const kimakiPlugin = async ({ directory }) => {
                         if (memoryContent) {
                             const condensed = condenseMemoryMd(memoryContent);
                             output.parts.push({
-                                id: crypto.randomUUID(),
+                                id: `prt_${crypto.randomUUID()}`,
                                 sessionID,
                                 messageID,
                                 type: 'text',
@@ -304,7 +304,7 @@ const kimakiPlugin = async ({ directory }) => {
                                 hour12: false,
                             });
                             output.parts.push({
-                                id: crypto.randomUUID(),
+                                id: `prt_${crypto.randomUUID()}`,
                                 sessionID,
                                 messageID,
                                 type: 'text',
@@ -315,7 +315,7 @@ const kimakiPlugin = async ({ directory }) => {
                             // When the user comes back after a long break, remind the model
                             // to save any important context from the previous conversation.
                             output.parts.push({
-                                id: crypto.randomUUID(),
+                                id: `prt_${crypto.randomUUID()}`,
                                 sessionID,
                                 messageID,
                                 type: 'text',
@@ -340,7 +340,7 @@ const kimakiPlugin = async ({ directory }) => {
                             })();
                             sessionGitStates.set(sessionID, gitState);
                             output.parts.push({
-                                id: crypto.randomUUID(),
+                                id: `prt_${crypto.randomUUID()}`,
                                 sessionID,
                                 messageID,
                                 type: 'text',

package/dist/patch-text-parser.js

@@ -0,0 +1,97 @@
+// Shared apply_patch text parsing utilities.
+// Used by diff-patch-plugin.ts (file path extraction for snapshots) and
+// message-formatting.ts (per-file addition/deletion counts for Discord display).
+//
+// The apply_patch tool uses three path header formats:
+//   *** Add File: path    — new file
+//   *** Update File: path — existing file edit
+//   *** Delete File: path — file removal
+//   *** Move to: path     — rename destination
+//   --- a/path / +++ b/path — unified diff headers (fallback)
+/**
+ * Extract all file paths referenced in a patchText string.
+ * Handles custom apply_patch headers, move targets, and unified diff headers.
+ * Returns deduplicated paths.
+ */
+export function extractPatchFilePaths(patchText) {
+    const custom = [
+        ...patchText.matchAll(/^\*\*\* (?:Add|Update|Delete) File:\s+(.+)$/gm),
+    ].map((m) => {
+        return (m[1] ?? '').trim();
+    });
+    const moved = [
+        ...patchText.matchAll(/^\*\*\* Move to:\s+(.+)$/gm),
+    ].map((m) => {
+        return (m[1] ?? '').trim();
+    });
+    const unified = [
+        ...patchText.matchAll(/^(?:---|\+\+\+) [ab]\/(.+)$/gm),
+    ].map((m) => {
+        return (m[1] ?? '').trim();
+    });
+    const all = [...custom, ...moved, ...unified].filter(Boolean);
+    return all.filter((v, i, a) => {
+        return a.indexOf(v) === i;
+    });
+}
+/**
+ * Parse a patchText string and count additions/deletions per file.
+ * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
+ * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
+ */
+export function parsePatchFileCounts(patchText) {
+    const counts = new Map();
+    const lines = patchText.split('\n');
+    let currentFile = '';
+    let currentType = '';
+    let inHunk = false;
+    for (const line of lines) {
+        const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/);
+        const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/);
+        const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/);
+        if (addMatch || updateMatch || deleteMatch) {
+            const match = addMatch || updateMatch || deleteMatch;
+            currentFile = (match?.[1] ?? '').trim();
+            currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete';
+            counts.set(currentFile, { additions: 0, deletions: 0 });
+            inHunk = false;
+            continue;
+        }
+        if (line.startsWith('@@')) {
+            inHunk = true;
+            continue;
+        }
+        if (line.startsWith('*** ')) {
+            inHunk = false;
+            continue;
+        }
+        if (!currentFile) {
+            continue;
+        }
+        const entry = counts.get(currentFile);
+        if (!entry) {
+            continue;
+        }
+        if (currentType === 'add') {
+            // all content lines in Add File are additions
+            if (line.length > 0 && !line.startsWith('*** ')) {
+                entry.additions++;
+            }
+        }
+        else if (currentType === 'delete') {
+            // all content lines in Delete File are deletions
+            if (line.length > 0 && !line.startsWith('*** ')) {
+                entry.deletions++;
+            }
+        }
+        else if (inHunk) {
+            if (line.startsWith('+')) {
+                entry.additions++;
+            }
+            else if (line.startsWith('-')) {
+                entry.deletions++;
+            }
+        }
+    }
+    return counts;
+}

package/dist/session-handler/thread-session-runtime.js

@@ -2686,7 +2686,7 @@ export class ThreadSessionRuntime {
         let contextInfo = '';
         const folderName = path.basename(this.sdkDirectory);
         const client = getOpencodeClient(this.projectDirectory);
-        // Run git branch, token fetch, and provider list in parallel
+        // Run git branch and token fetch in parallel (fast, no external CLI)
         const [branchResult, contextResult] = await Promise.all([
             errore.tryAsync(() => {
                 return execAsync('git symbolic-ref --short HEAD', {

package/dist/websockify.js

@@ -0,0 +1,69 @@
+// In-process WebSocket-to-TCP bridge (websockify replacement).
+// Accepts WebSocket connections and pipes raw bytes to/from a TCP target.
+// Used by /screenshare to bridge noVNC (WebSocket) to a VNC server (TCP).
+// Supports the 'binary' subprotocol required by noVNC.
+import { WebSocketServer, WebSocket } from 'ws';
+import net from 'node:net';
+import { createLogger } from './logger.js';
+const logger = createLogger('SCREEN');
+export function startWebsockify({ wsPort, tcpHost, tcpPort, }) {
+    return new Promise((resolve, reject) => {
+        const wss = new WebSocketServer({
+            port: wsPort,
+            // noVNC negotiates the 'binary' subprotocol
+            handleProtocols: (protocols) => {
+                if (protocols.has('binary')) {
+                    return 'binary';
+                }
+                return false;
+            },
+        });
+        wss.on('listening', () => {
+            const addr = wss.address();
+            const port = typeof addr === 'object' && addr ? addr.port : wsPort;
+            logger.log(`Websockify listening on port ${port} → ${tcpHost}:${tcpPort}`);
+            resolve({
+                wss,
+                port,
+                close: () => {
+                    for (const client of wss.clients) {
+                        client.close();
+                    }
+                    wss.close();
+                },
+            });
+        });
+        wss.on('error', (err) => {
+            reject(new Error('Websockify failed to start', { cause: err }));
+        });
+        wss.on('connection', (ws) => {
+            const tcp = net.createConnection(tcpPort, tcpHost, () => {
+                logger.log(`TCP connection established to ${tcpHost}:${tcpPort}`);
+            });
+            tcp.on('data', (data) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(data);
+                }
+            });
+            ws.on('message', (data) => {
+                if (!tcp.destroyed) {
+                    tcp.write(data);
+                }
+            });
+            ws.on('close', () => {
+                tcp.destroy();
+            });
+            ws.on('error', (err) => {
+                logger.error('WebSocket error:', err);
+                tcp.destroy();
+            });
+            tcp.on('close', () => {
+                ws.close();
+            });
+            tcp.on('error', (err) => {
+                logger.error('TCP connection error:', err);
+                ws.close();
+            });
+        });
+    });
+}