kimaki 0.26.0 → 0.28.0

package/dist/external-opencode-sync.js

@@ -1,11 +1,11 @@
 import fs from 'node:fs';
 import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
 import { getChannelVerbosity, getPartMessageIds, getThreadIdBySessionId, getThreadSessionSource, listTrackedTextChannels, setPartMessagesBatch, upsertThreadSession, } from './database.js';
-import { sendThreadMessage } from './discord-utils.js';
+import { sendSessionPartBatches } from './discord-utils.js';
 import { createLogger, LogPrefix } from './logger.js';
-import { formatPart, collectSessionChunks, batchChunksForDiscord, } from './message-formatting.js';
+import { formatPart, collectSessionChunks, batchChunksForDiscord, QUEUE_PREFIX, } from './message-formatting.js';
 import { initializeOpencodeForDirectory, } from './opencode.js';
-import { isEssentialToolPart } from './session-handler/thread-session-runtime.js';
+import { getRuntime, isEssentialToolPart } from './session-handler/thread-session-runtime.js';
 import { notifyError } from './sentry.js';
 import { store } from './store.js';
 import { extractNonXmlContent } from './xml.js';
@@ -20,8 +20,7 @@ const SYNC_PER_DIRECTORY_TIMEOUT_MS = 30_000;
 const CLI_START_MS = Date.now() - 5 * 60 * 1000;
 let externalSyncInterval = null;
 function isSyntheticTextPart(part) {
-    const candidate = part;
-    return candidate.synthetic === true;
+    return part.synthetic === true;
 }
 function parseDiscordOriginMetadata(text) {
     const match = text.match(/<discord-user\s+([^>]+)\s*\/>/);
@@ -64,7 +63,7 @@ function getDiscordOriginMetadataFromMessage({ message, }) {
     }
     return null;
 }
-function getRenderableUserTextParts({ message, }) {
+export function getRenderableUserTextParts({ message, }) {
     if (message.info.role !== 'user') {
         return [];
     }
@@ -72,7 +71,7 @@ function getRenderableUserTextParts({ message, }) {
         if (part.type !== 'text') {
             return [];
         }
-        if (isSyntheticTextPart(part)) {
+        if (isSyntheticTextPart(part) || part.ignored === true) {
             return [];
         }
         const cleanedText = extractNonXmlContent(part.text || '').trim();
@@ -82,8 +81,49 @@ function getRenderableUserTextParts({ message, }) {
         return [{ id: part.id, text: cleanedText }];
     });
 }
+function hasCompactionContinueMetadata(part) {
+    return part.metadata?.compaction_continue === true;
+}
+export function isInternalOpenCodeUserMessage({ message, }) {
+    if (message.info.role !== 'user') {
+        return false;
+    }
+    return message.parts.some((part) => {
+        if (part.type === 'compaction') {
+            return true;
+        }
+        if (part.type !== 'text') {
+            return false;
+        }
+        return isSyntheticTextPart(part) && hasCompactionContinueMetadata(part);
+    });
+}
+export function shouldSkipExternalAssistantMessage({ message, }) {
+    if (message.info.role !== 'assistant') {
+        return false;
+    }
+    return message.info.summary === true;
+}
+export function getIgnoredNoticeTextParts({ message, }) {
+    if (message.info.role !== 'user') {
+        return [];
+    }
+    return message.parts.flatMap((part) => {
+        if (part.type !== 'text') {
+            return [];
+        }
+        if (part.ignored !== true || isSyntheticTextPart(part)) {
+            return [];
+        }
+        const text = part.text?.trim();
+        if (!text) {
+            return [];
+        }
+        return [{ id: part.id, text }];
+    });
+}
 function getExternalUserMirrorText({ username, prompt, }) {
-    return `» **${username}:** ${prompt.slice(0, 1000)}${prompt.length > 1000 ? '...' : ''}`;
+    return `${QUEUE_PREFIX}**${username}:** ${prompt.slice(0, 1000)}${prompt.length > 1000 ? '...' : ''}`;
 }
 // Pure derivation: is the latest user turn from Discord?
 // Checks the newest user message with renderable text for a <discord-user />
@@ -91,12 +131,15 @@ function getExternalUserMirrorText({ username, prompt, }) {
 // (kimaki manages it) and external sync should skip it. If absent (CLI/TUI),
 // external sync should mirror it — this naturally handles the "reclaim" case
 // (external → discord → external) without any DB source toggling.
-function isLatestUserTurnFromDiscord({ messages, }) {
+export function isLatestUserTurnFromDiscord({ messages, }) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
         if (message.info.role !== 'user') {
             continue;
         }
+        if (isInternalOpenCodeUserMessage({ message })) {
+            continue;
+        }
         const renderableParts = getRenderableUserTextParts({ message });
         if (renderableParts.length === 0) {
             continue;
@@ -234,6 +277,23 @@ function collectUnsyncedChunks({ messages, syncedPartIds, verbosity, thread, })
     const directMappings = [];
     for (const message of messages) {
         if (message.info.role === 'user') {
+            if (isInternalOpenCodeUserMessage({ message })) {
+                continue;
+            }
+            const ignoredNoticeParts = getIgnoredNoticeTextParts({ message }).filter((part) => {
+                return !syncedPartIds.has(part.id);
+            });
+            if (ignoredNoticeParts.length > 0) {
+                chunks.push({
+                    partIds: ignoredNoticeParts.map((part) => {
+                        return part.id;
+                    }),
+                    content: ignoredNoticeParts.map((part) => {
+                        return part.text;
+                    }).join('\n\n'),
+                    kind: 'text',
+                });
+            }
             const renderableParts = getRenderableUserTextParts({ message });
             const unsyncedParts = renderableParts.filter((p) => {
                 return !syncedPartIds.has(p.id);
@@ -265,12 +325,16 @@ function collectUnsyncedChunks({ messages, syncedPartIds, verbosity, thread, })
                     return p.id;
                 }),
                 content: getExternalUserMirrorText({ username: 'user', prompt: promptText }),
+                kind: 'text',
             });
             continue;
         }
         if (message.info.role !== 'assistant') {
             continue;
         }
+        if (shouldSkipExternalAssistantMessage({ message })) {
+            continue;
+        }
         // Filter assistant parts by verbosity before passing to shared collector
         const filteredParts = message.parts.filter((part) => {
             return shouldMirrorAssistantPart({ part, verbosity });
@@ -314,6 +378,10 @@ async function syncSessionToThread({ client, discordClient, directory, channelId
     if (isLatestUserTurnFromDiscord({ messages })) {
         return;
     }
+    const existingThreadId = await getThreadIdBySessionId(sessionId);
+    if (existingThreadId && getRuntime(existingThreadId)) {
+        return;
+    }
     const thread = await ensureExternalSessionThread({
         discordClient,
         channelId,
@@ -340,13 +408,15 @@ async function syncSessionToThread({ client, discordClient, directory, channelId
         await setPartMessagesBatch(directMappings);
     }
     const batched = batchChunksForDiscord(chunks);
-    for (const batch of batched) {
+    if (signal.aborted)
+        return;
+    const sent = await sendSessionPartBatches({ thread, batches: batched });
+    for (const batch of sent) {
         if (signal.aborted)
             return;
-        const sentMessage = await sendThreadMessage(thread, batch.content);
         await setPartMessagesBatch(batch.partIds.map((partId) => ({
             partId,
-            messageId: sentMessage.id,
+            messageId: batch.message.id,
             threadId: thread.id,
         })));
     }
@@ -377,6 +447,15 @@ async function pulseTypingForBusySessions({ discordClient, statuses, }) {
     }
 }
 const EXTERNAL_SYNC_MAX_SESSIONS = 50;
+export function isExternalSyncRootSession({ title, parentID, }) {
+    if (parentID) {
+        return false;
+    }
+    if (/^new session\s*-/i.test(title || '')) {
+        return false;
+    }
+    return !/subagent\)\s*$/i.test(title || '');
+}
 // Tracks directories with an in-flight sync. When a directory times out,
 // its AbortController is aborted so the inner work stops producing side
 // effects (Discord messages, DB writes). The next poll tick skips the
@@ -449,11 +528,7 @@ async function syncDirectoryInner({ directory, channelId, startMs, discordClient
     if (signal.aborted)
         return;
     const sessions = (sessionsResponse.data || []).filter((session) => {
-        const title = session.title || '';
-        if (/^new session\s*-/i.test(title)) {
-            return false;
-        }
-        return !/subagent\)\s*$/i.test(title);
+        return isExternalSyncRootSession(session);
     });
     const sorted = sortSessionsByRecency(sessions);
     for (const session of sorted) {
@@ -540,4 +615,6 @@ export const externalOpencodeSyncInternals = {
     parseDiscordOriginMetadata,
     getDiscordOriginMetadataFromMessage,
     isLatestUserTurnFromDiscord,
+    isInternalOpenCodeUserMessage,
+    shouldSkipExternalAssistantMessage,
 };

package/dist/external-opencode-sync.test.js

@@ -0,0 +1,206 @@
+/** Tests external OpenCode user-message filtering for Discord mirroring and ownership. */
+import { describe, expect, test } from 'vitest';
+import { getIgnoredNoticeTextParts, getRenderableUserTextParts, isExternalSyncRootSession, isInternalOpenCodeUserMessage, isLatestUserTurnFromDiscord, shouldSkipExternalAssistantMessage, } from './external-opencode-sync.js';
+function textMessage({ text, ignored, synthetic, }) {
+    return {
+        info: { role: 'user' },
+        parts: [
+            {
+                id: 'part-1',
+                sessionID: 'session-1',
+                messageID: 'message-1',
+                type: 'text',
+                text,
+                ignored,
+                synthetic,
+            },
+        ],
+    };
+}
+describe('external OpenCode user-message filtering', () => {
+    test('does not sync task child sessions into Discord', () => {
+        expect(isExternalSyncRootSession({
+            title: 'Design shader visual stack',
+            parentID: 'ses_parent',
+        })).toBe(false);
+        expect(isExternalSyncRootSession({
+            title: 'Main session',
+        })).toBe(true);
+    });
+    test('keeps normal external user text renderable', () => {
+        const message = textMessage({ text: 'Run the tests' });
+        expect(getRenderableUserTextParts({ message })).toEqual([
+            { id: 'part-1', text: 'Run the tests' },
+        ]);
+    });
+    test('skips ignored plugin notices from user mirroring', () => {
+        const message = textMessage({
+            text: 'Subrouter: xai/grok-4.6 was rate limited.',
+            ignored: true,
+        });
+        expect(getRenderableUserTextParts({ message })).toEqual([]);
+    });
+    test('collects ignored plugin notices as bot text', () => {
+        const message = textMessage({
+            text: 'Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.',
+            ignored: true,
+        });
+        expect(getIgnoredNoticeTextParts({ message })).toEqual([
+            {
+                id: 'part-1',
+                text: 'Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.',
+            },
+        ]);
+    });
+    test('does not collect synthetic or normal user text as ignored notices', () => {
+        expect(getIgnoredNoticeTextParts({
+            message: textMessage({ text: 'Run the tests' }),
+        })).toEqual([]);
+        expect(getIgnoredNoticeTextParts({
+            message: textMessage({
+                text: '<discord-user name="Tommy" />',
+                synthetic: true,
+            }),
+        })).toEqual([]);
+    });
+    test('skips synthetic context parts', () => {
+        const message = textMessage({
+            text: '<discord-user name="Tommy" />',
+            synthetic: true,
+        });
+        expect(getRenderableUserTextParts({ message })).toEqual([]);
+    });
+    test('does not treat an ignored notice as an external takeover', () => {
+        const discordMessage = {
+            info: { role: 'user' },
+            parts: [
+                {
+                    id: 'part-2',
+                    sessionID: 'session-1',
+                    messageID: 'message-2',
+                    type: 'text',
+                    text: '<discord-user name="Tommy" />',
+                    synthetic: true,
+                },
+                {
+                    id: 'part-3',
+                    sessionID: 'session-1',
+                    messageID: 'message-2',
+                    type: 'text',
+                    text: 'What failed?',
+                },
+            ],
+        };
+        const notice = textMessage({
+            text: 'Subrouter: xai/grok-4.6 was rate limited.',
+            ignored: true,
+        });
+        expect(isLatestUserTurnFromDiscord({ messages: [discordMessage, notice] })).toBe(true);
+    });
+    test('skips compaction user messages when deciding Discord ownership', () => {
+        const discordMessage = {
+            info: { role: 'user' },
+            parts: [
+                {
+                    id: 'part-2',
+                    sessionID: 'session-1',
+                    messageID: 'message-2',
+                    type: 'text',
+                    text: '<discord-user name="Tommy" />',
+                    synthetic: true,
+                },
+                {
+                    id: 'part-3',
+                    sessionID: 'session-1',
+                    messageID: 'message-2',
+                    type: 'text',
+                    text: 'Fix the tabs',
+                },
+            ],
+        };
+        const compactionUser = {
+            info: { role: 'user' },
+            parts: [
+                {
+                    id: 'part-4',
+                    sessionID: 'session-1',
+                    messageID: 'message-4',
+                    type: 'compaction',
+                    auto: true,
+                },
+            ],
+        };
+        expect(isInternalOpenCodeUserMessage({ message: compactionUser })).toBe(true);
+        expect(isLatestUserTurnFromDiscord({ messages: [discordMessage, compactionUser] })).toBe(true);
+    });
+    test('skips compaction continue users when deciding Discord ownership', () => {
+        const discordMessage = {
+            info: { role: 'user' },
+            parts: [
+                {
+                    id: 'part-2',
+                    sessionID: 'session-1',
+                    messageID: 'message-2',
+                    type: 'text',
+                    text: '<discord-user name="Tommy" />',
+                    synthetic: true,
+                },
+                {
+                    id: 'part-3',
+                    sessionID: 'session-1',
+                    messageID: 'message-2',
+                    type: 'text',
+                    text: 'Fix the tabs',
+                },
+            ],
+        };
+        const continueUser = {
+            info: { role: 'user' },
+            parts: [
+                {
+                    id: 'part-5',
+                    sessionID: 'session-1',
+                    messageID: 'message-5',
+                    type: 'text',
+                    text: 'Continue if you have next steps',
+                    synthetic: true,
+                    metadata: { compaction_continue: true },
+                },
+            ],
+        };
+        expect(isInternalOpenCodeUserMessage({ message: continueUser })).toBe(true);
+        expect(isLatestUserTurnFromDiscord({ messages: [discordMessage, continueUser] })).toBe(true);
+    });
+    test('skips compaction summary assistants from external mirroring', () => {
+        expect(shouldSkipExternalAssistantMessage({
+            message: {
+                info: { role: 'assistant', summary: true },
+                parts: [
+                    {
+                        id: 'part-6',
+                        sessionID: 'session-1',
+                        messageID: 'message-6',
+                        type: 'text',
+                        text: 'internal compaction summary must not reach Discord',
+                    },
+                ],
+            },
+        })).toBe(true);
+    });
+    test('does not skip a user-facing assistant just because the agent is named compaction', () => {
+        expect(shouldSkipExternalAssistantMessage({
+            message: {
+                info: { role: 'assistant', agent: 'compaction' },
+                parts: [
+                    {
+                        id: 'part-7',
+                        sessionID: 'session-1',
+                        messageID: 'message-7',
+                        type: 'text',
+                        text: 'user-facing reply',
+                    },
+                ],
+            },
+        })).toBe(false);
+    });
+});

package/dist/extract-sdk-error-message.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, test } from 'vitest';
+import { extractSdkErrorMessage } from './opencode.js';
+describe('extractSdkErrorMessage', () => {
+    test('includes UnknownError name, message, and ref from session.create', () => {
+        expect(extractSdkErrorMessage({
+            name: 'UnknownError',
+            data: {
+                message: 'Unexpected server error. Check server logs for details.',
+                ref: 'err_58d6c6cf',
+            },
+        })).toMatchInlineSnapshot(`"UnknownError: Unexpected server error. Check server logs for details. (err_58d6c6cf)"`);
+    });
+});

package/dist/file-edit-log.js

@@ -0,0 +1,197 @@
+// Tracks which OpenCode sessions last edited each file.
+// Plugin appends JSONL events; CLI derives the per-file session list on read.
+import fs from 'node:fs';
+import path from 'node:path';
+import * as errore from 'errore';
+import { FilesystemOperationError } from './errors.js';
+import { extractPatchFilePaths } from './patch-text-parser.js';
+import { createPluginLogger, setPluginLogFilePath } from './plugin-logger.js';
+const logger = createPluginLogger('FILEEDIT');
+export const FILE_EDIT_EVENTS_FILENAME = 'file-edit-events.jsonl';
+const DEFAULT_MAX_EVENTS = 10_000;
+const DEFAULT_COMPACT_AFTER_BYTES = 5 * 1024 * 1024;
+function isFileEditTool(tool) {
+    return tool === 'edit' || tool === 'write' || tool === 'apply_patch';
+}
+function getStringField({ args, key }) {
+    const value = args[key];
+    return typeof value === 'string' ? value : '';
+}
+export function extractEditedFiles({ tool, args, directory, }) {
+    const name = tool.toLowerCase();
+    if (name === 'edit' || name === 'write') {
+        const filePath = getStringField({ args, key: 'filePath' });
+        if (!filePath)
+            return [];
+        return [path.resolve(directory, filePath)];
+    }
+    if (name !== 'apply_patch')
+        return [];
+    const patchText = getStringField({ args, key: 'patchText' });
+    if (!patchText)
+        return [];
+    return extractPatchFilePaths(patchText).map((filePath) => {
+        return path.resolve(directory, filePath);
+    });
+}
+export function editorsForFile({ events, filePath, cwd, }) {
+    const resolved = path.resolve(cwd, filePath);
+    const latestBySession = new Map();
+    for (const event of events) {
+        if (path.resolve(event.file) !== resolved)
+            continue;
+        const previous = latestBySession.get(event.sessionId);
+        if (previous === undefined || event.at > previous) {
+            latestBySession.set(event.sessionId, event.at);
+        }
+    }
+    return [...latestBySession.entries()]
+        .map(([sessionId, at]) => {
+        return { sessionId, at };
+    })
+        .sort((left, right) => {
+        return right.at - left.at;
+    });
+}
+function parseFileEditEvent(line) {
+    const parsed = errore.try(() => JSON.parse(line), (cause) => new FilesystemOperationError({ operation: 'parse file edit event', cause }));
+    if (parsed instanceof Error)
+        return null;
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    if (parsed.v !== 1)
+        return null;
+    if (typeof parsed.at !== 'number' || !Number.isFinite(parsed.at))
+        return null;
+    if (typeof parsed.sessionId !== 'string' || parsed.sessionId.length === 0)
+        return null;
+    if (typeof parsed.file !== 'string' || parsed.file.length === 0)
+        return null;
+    if (typeof parsed.tool !== 'string' || !isFileEditTool(parsed.tool))
+        return null;
+    return {
+        v: 1,
+        at: parsed.at,
+        sessionId: parsed.sessionId,
+        file: parsed.file,
+        tool: parsed.tool,
+    };
+}
+function nodeErrorCode(error) {
+    const cause = error.cause;
+    if (!cause || typeof cause !== 'object')
+        return '';
+    const code = Reflect.get(cause, 'code');
+    return typeof code === 'string' ? code : '';
+}
+export function loadFileEditEvents({ dataDir }) {
+    const logPath = path.join(dataDir, FILE_EDIT_EVENTS_FILENAME);
+    const raw = errore.try(() => fs.readFileSync(logPath, 'utf8'), (cause) => new FilesystemOperationError({ operation: 'read file edit log', cause }));
+    if (raw instanceof Error) {
+        if (nodeErrorCode(raw) === 'ENOENT')
+            return [];
+        return raw;
+    }
+    const events = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        const event = parseFileEditEvent(line);
+        if (event)
+            events.push(event);
+    }
+    return events;
+}
+function collapseFileEditEvents(events) {
+    const latest = new Map();
+    for (const event of events) {
+        const key = `${event.sessionId}\0${event.file}`;
+        const previous = latest.get(key);
+        if (!previous || event.at >= previous.at)
+            latest.set(key, event);
+    }
+    return [...latest.values()].sort((left, right) => {
+        return left.at - right.at;
+    });
+}
+function compactFileEditLog({ dataDir, maxEvents, }) {
+    const loaded = loadFileEditEvents({ dataDir });
+    if (loaded instanceof Error)
+        return loaded;
+    const collapsed = collapseFileEditEvents(loaded);
+    const kept = collapsed.length > maxEvents ? collapsed.slice(-maxEvents) : collapsed;
+    const logPath = path.join(dataDir, FILE_EDIT_EVENTS_FILENAME);
+    const tempPath = `${logPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    const body = kept.map((event) => `${JSON.stringify(event)}\n`).join('');
+    const written = errore.try(() => {
+        fs.writeFileSync(tempPath, body);
+        fs.renameSync(tempPath, logPath);
+    }, (cause) => new FilesystemOperationError({ operation: 'compact file edit log', cause }));
+    if (written instanceof Error) {
+        fs.rmSync(tempPath, { force: true });
+        return written;
+    }
+}
+export function appendFileEditEvents({ dataDir, events, maxEvents = DEFAULT_MAX_EVENTS, compactAfterBytes = DEFAULT_COMPACT_AFTER_BYTES, }) {
+    if (events.length === 0)
+        return;
+    const logPath = path.join(dataDir, FILE_EDIT_EVENTS_FILENAME);
+    const prepared = errore.try(() => {
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.appendFileSync(logPath, events.map((event) => `${JSON.stringify(event)}\n`).join(''));
+    }, (cause) => new FilesystemOperationError({ operation: 'append file edit log', cause }));
+    if (prepared instanceof Error)
+        return prepared;
+    const size = errore.try(() => fs.statSync(logPath).size, (cause) => new FilesystemOperationError({ operation: 'stat file edit log', cause }));
+    if (size instanceof Error)
+        return size;
+    if (size < compactAfterBytes)
+        return;
+    return compactFileEditLog({ dataDir, maxEvents });
+}
+function recordToolEdits({ dataDir, directory, sessionId, tool, args, }) {
+    const name = tool.toLowerCase();
+    if (!isFileEditTool(name))
+        return;
+    const files = extractEditedFiles({ tool: name, args, directory });
+    if (files.length === 0)
+        return;
+    const at = Date.now();
+    const events = files.map((file) => {
+        return {
+            v: 1,
+            at,
+            sessionId,
+            file,
+            tool: name,
+        };
+    });
+    const result = appendFileEditEvents({ dataDir, events });
+    if (result instanceof Error) {
+        logger.warn('Failed to record file edit', result.message);
+    }
+}
+export function createFileEditHooks({ dataDir, directory, }) {
+    return {
+        'tool.execute.after': async (input) => {
+            recordToolEdits({
+                dataDir,
+                directory,
+                sessionId: input.sessionID,
+                tool: input.tool,
+                args: input.args,
+            });
+        },
+    };
+}
+export const fileEditTrackerPlugin = async ({ directory }) => {
+    const dataDir = process.env.KIMAKI_DATA_DIR;
+    if (!dataDir)
+        return {};
+    setPluginLogFilePath(dataDir);
+    const created = errore.try(() => fs.mkdirSync(dataDir, { recursive: true }), (cause) => new FilesystemOperationError({ operation: 'create file edit log dir', cause }));
+    if (created instanceof Error) {
+        logger.warn('Failed to create file edit log dir', created.message);
+    }
+    return createFileEditHooks({ dataDir, directory });
+};