kimaki 0.4.78 → 0.4.80

package/dist/system-message.js

@@ -294,7 +294,8 @@ Use \`--send-at\` to schedule a one-time or recurring task:
 kimaki send --channel ${channelId} --prompt "Reminder: review open PRs" --send-at "2026-03-01T09:00:00Z"
 kimaki send --channel ${channelId} --prompt "Run weekly test suite and summarize failures" --send-at "0 9 * * 1"
 
-When using a date for \`--send-at\`, it must be UTC in ISO format ending with \`Z\`.
+ALL scheduling is in UTC. Dates must be UTC ISO format ending with \`Z\`. Cron expressions also fire in UTC (e.g. \`0 9 * * 1\` means 9:00 UTC every Monday).
+When the user specifies a time without a timezone, ask them to confirm their timezone or the UTC equivalent. Never guess the user's timezone.
 
 \`--send-at\` supports the same useful options for new threads:
 - \`--notify-only\` to create a reminder thread without auto-starting a session
@@ -318,6 +319,7 @@ Notification strategy for scheduled tasks:
 Manage scheduled tasks with:
 
 kimaki task list
+kimaki task edit <id> --prompt "new prompt" [--send-at "new schedule"]
 kimaki task delete <id>
 
 \`kimaki session list\` also shows if a session was started by a scheduled \`delay\` or \`cron\` task, including task ID when available.

package/dist/task-runner.js

@@ -5,7 +5,7 @@ import yaml from 'js-yaml';
 import { claimScheduledTaskRunning, getDuePlannedScheduledTasks, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, markScheduledTaskOneShotCompleted, recoverStaleRunningScheduledTasks, } from './database.js';
 import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
-import { getLocalTimeZone, getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
+import { getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
 const taskLogger = createLogger(LogPrefix.TASK);
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
@@ -28,6 +28,7 @@ async function executeThreadScheduledTask({ rest, task, payload, }) {
         ...(payload.model ? { model: payload.model } : {}),
         ...(payload.username ? { username: payload.username } : {}),
         ...(payload.userId ? { userId: payload.userId } : {}),
+        ...(payload.permissions?.length ? { permissions: payload.permissions } : {}),
     };
     const embed = [{ color: 0x2b2d31, footer: { text: yaml.dump(marker) } }];
     const prefixedPrompt = `» **kimaki-cli:** ${payload.prompt}`;
@@ -59,6 +60,7 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
             ...(payload.model ? { model: payload.model } : {}),
             ...(payload.username ? { username: payload.username } : {}),
             ...(payload.userId ? { userId: payload.userId } : {}),
+            ...(payload.permissions?.length ? { permissions: payload.permissions } : {}),
         };
     const embeds = marker
         ? [{ color: 0x2b2d31, footer: { text: yaml.dump(marker) } }]
@@ -151,7 +153,8 @@ async function finalizeSuccessfulTask({ task, completedAt, }) {
         });
         return;
     }
-    const timezone = task.timezone || getLocalTimeZone();
+    // Use stored timezone, falling back to UTC (not machine local) for consistency
+    const timezone = task.timezone || 'UTC';
     const nextRunResult = getNextCronRun({
         cronExpr: task.cron_expr,
         timezone,
@@ -173,7 +176,8 @@ async function finalizeSuccessfulTask({ task, completedAt, }) {
 }
 async function finalizeFailedTask({ task, failedAt, error, }) {
     if (task.schedule_kind === 'cron' && task.cron_expr) {
-        const timezone = task.timezone || getLocalTimeZone();
+        // Use stored timezone, falling back to UTC (not machine local) for consistency
+        const timezone = task.timezone || 'UTC';
         const nextRunResult = getNextCronRun({
             cronExpr: task.cron_expr,
             timezone,

package/dist/task-schedule.js

@@ -124,6 +124,14 @@ function asString(value) {
     }
     return value;
 }
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    return value.filter((v) => {
+        return typeof v === 'string';
+    });
+}
 export function parseScheduledTaskPayload(payloadJson) {
     const parsed = errore.try({
         try: () => {
@@ -147,6 +155,7 @@ export function parseScheduledTaskPayload(payloadJson) {
         const model = asString(parsed.model);
         const username = asString(parsed.username);
         const userId = asString(parsed.userId);
+        const permissions = asStringArray(parsed.permissions);
         if (!threadId || !prompt) {
             return new Error('Thread task payload requires threadId and prompt');
         }
@@ -158,6 +167,7 @@ export function parseScheduledTaskPayload(payloadJson) {
             model,
             username,
             userId,
+            permissions,
         };
     }
     if (kind === 'channel') {
@@ -171,6 +181,7 @@ export function parseScheduledTaskPayload(payloadJson) {
         const model = asString(parsed.model);
         const username = asString(parsed.username);
         const userId = asString(parsed.userId);
+        const permissions = asStringArray(parsed.permissions);
         if (!channelId || !prompt) {
             return new Error('Channel task payload requires channelId and prompt');
         }
@@ -185,6 +196,7 @@ export function parseScheduledTaskPayload(payloadJson) {
             model,
             username,
             userId,
+            permissions,
         };
     }
     return new Error('Task payload has unknown kind');

package/dist/thread-message-queue.e2e.test.js

@@ -435,11 +435,20 @@ e2eTest('thread message queue ordering', () => {
             },
         });
         const th = discord.thread(thread.id);
-        // Wait for the first bot reply so session is established
+        // Wait for the first bot reply AND its footer so the first response
+        // cycle is fully complete before sending follow-ups. Without this,
+        // the footer for "one" can still be in-flight when the snapshot runs.
         const firstReply = await th.waitForBotReply({
             timeout: 4_000,
         });
         expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'one',
+            afterAuthorId: TEST_USER_ID,
+        });
         // Snapshot bot message count before sending follow-ups
         const before = await th.getMessages();
         const beforeBotCount = before.filter((m) => {
@@ -478,10 +487,13 @@ e2eTest('thread message queue ordering', () => {
         Reply with exactly: one
         --- from: assistant (TestBot)
         ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (queue-tester)
         Reply with exactly: two
         Reply with exactly: three
         --- from: assistant (TestBot)
+        ⬥ ok
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         const userThreeIndex = after.findIndex((message) => {

package/dist/undo-redo.e2e.test.js

@@ -0,0 +1,166 @@
+// E2e test for /undo command.
+// Validates that:
+// 1. After /undo, session.revert state is set (files reverted, revert boundary marked)
+// 2. Messages are NOT deleted yet (they stay until next prompt cleans them up)
+// 3. On the next user message, reverted messages are cleaned up by OpenCode's
+//    SessionRevert.cleanup() and the model only sees pre-revert messages
+//
+// This matches the OpenCode TUI behavior (use-session-commands.tsx):
+// - Pass the user message ID (not assistant ID)
+// - Don't delete messages — just mark session as reverted
+// - Cleanup happens automatically on next promptAsync()
+//
+// Uses opencode-deterministic-provider (no real LLM calls).
+// Poll timeouts: 4s max, 100ms interval.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForFooterMessage } from './test-utils.js';
+import { getThreadSession } from './database.js';
+import { initializeOpencodeForDirectory } from './opencode.js';
+const TEXT_CHANNEL_ID = '200000000000001200';
+const e2eTest = describe;
+e2eTest('/undo sets revert state and cleans up on next prompt', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-undo-e2e',
+        dirName: 'qa-undo-e2e',
+        username: 'undo-tester',
+    });
+    test('undo sets revert state, next message cleans up reverted messages', async () => {
+        // 1. Send a message and wait for complete session (footer)
+        await ctx.discord
+            .channel(TEXT_CHANNEL_ID)
+            .user(TEST_USER_ID)
+            .sendMessage({
+            content: 'Reply with exactly: undo-test-message',
+        });
+        const thread = await ctx.discord
+            .channel(TEXT_CHANNEL_ID)
+            .waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: undo-test-message';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await th.waitForBotReply({ timeout: 4_000 });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+        });
+        // 2. Get session ID and verify it has messages
+        const sessionId = await getThreadSession(thread.id);
+        expect(sessionId).toBeTruthy();
+        const getClient = await initializeOpencodeForDirectory(ctx.directories.projectDirectory);
+        if (getClient instanceof Error) {
+            throw getClient;
+        }
+        const beforeMessages = await getClient().session.messages({
+            sessionID: sessionId,
+            directory: ctx.directories.projectDirectory,
+        });
+        const beforeCount = (beforeMessages.data || []).length;
+        expect(beforeCount).toBeGreaterThan(0);
+        const beforeUserMessages = (beforeMessages.data || []).filter((m) => {
+            return m.info.role === 'user';
+        });
+        const beforeAssistantMessages = (beforeMessages.data || []).filter((m) => {
+            return m.info.role === 'assistant';
+        });
+        expect(beforeUserMessages.length).toBeGreaterThan(0);
+        expect(beforeAssistantMessages.length).toBeGreaterThan(0);
+        // Verify no revert state yet
+        const beforeSession = await getClient().session.get({
+            sessionID: sessionId,
+        });
+        expect(beforeSession.data?.revert).toBeFalsy();
+        // 3. Run /undo command
+        const { id: undoInteractionId } = await th
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'undo' });
+        const undoAck = await th.waitForInteractionAck({
+            interactionId: undoInteractionId,
+            timeout: 4_000,
+        });
+        expect(undoAck).toBeDefined();
+        // Wait for the undo reply to appear (deferred reply gets edited)
+        if (undoAck.messageId) {
+            const start = Date.now();
+            while (Date.now() - start < 4_000) {
+                const messages = await th.getMessages();
+                const undoMessage = messages.find((m) => {
+                    return m.id === undoAck.messageId;
+                });
+                if (undoMessage && undoMessage.content.length > 0) {
+                    break;
+                }
+                await new Promise((r) => {
+                    setTimeout(r, 100);
+                });
+            }
+        }
+        // 4. Verify session now has revert state set
+        const afterSession = await getClient().session.get({
+            sessionID: sessionId,
+        });
+        expect(afterSession.data?.revert).toBeTruthy();
+        expect(afterSession.data?.revert?.messageID).toBeTruthy();
+        // Messages should still exist (not deleted — cleanup happens on next prompt)
+        const afterMessages = await getClient().session.messages({
+            sessionID: sessionId,
+            directory: ctx.directories.projectDirectory,
+        });
+        expect((afterMessages.data || []).length).toBe(beforeCount);
+        // 5. Send a new message — this triggers SessionRevert.cleanup()
+        // which removes reverted messages before processing the new prompt
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: after-undo-message',
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'after-undo-message',
+        });
+        // 6. Verify reverted messages were cleaned up
+        const finalMessages = await getClient().session.messages({
+            sessionID: sessionId,
+            directory: ctx.directories.projectDirectory,
+        });
+        const finalAssistantMessages = (finalMessages.data || []).filter((m) => {
+            return m.info.role === 'assistant';
+        });
+        // The original assistant message should have been cleaned up,
+        // only the new one (from after-undo-message) should remain
+        const originalAssistantStillExists = finalAssistantMessages.some((m) => {
+            return m.parts.some((p) => {
+                return p.type === 'text' && 'text' in p && p.text === 'ok';
+            });
+        });
+        // The first "ok" response was reverted and should be cleaned up.
+        // The new response for "after-undo-message" should produce a fresh "ok".
+        // We verify the total count dropped: the original user+assistant pair
+        // was removed, and replaced by just the new user+assistant pair.
+        expect(finalAssistantMessages.length).toBeLessThanOrEqual(beforeAssistantMessages.length);
+        // Revert state should be cleared after cleanup
+        const finalSession = await getClient().session.get({
+            sessionID: sessionId,
+        });
+        expect(finalSession.data?.revert).toBeFalsy();
+        // 7. Snapshot the Discord thread
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (undo-tester)
+        Reply with exactly: undo-test-message
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        Undone - reverted last assistant message
+        --- from: user (undo-tester)
+        Reply with exactly: after-undo-message
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+    }, 20_000);
+});

package/dist/utils.js

@@ -47,7 +47,7 @@ export function generateBotInstallUrl({ clientId, permissions = [
 }
 export const KIMAKI_GATEWAY_APP_ID = process.env.KIMAKI_GATEWAY_APP_ID || '1477605701202481173';
 export const KIMAKI_WEBSITE_URL = process.env.KIMAKI_WEBSITE_URL || 'https://kimaki.xyz';
-export function generateDiscordInstallUrlForBot({ appId, mode, clientId, clientSecret, gatewayCallbackUrl, }) {
+export function generateDiscordInstallUrlForBot({ appId, mode, clientId, clientSecret, gatewayCallbackUrl, reachableUrl, }) {
     if (mode !== 'gateway') {
         return generateBotInstallUrl({ clientId: appId });
     }
@@ -66,6 +66,9 @@ export function generateDiscordInstallUrlForBot({ appId, mode, clientId, clientS
     if (gatewayCallbackUrl) {
         url.searchParams.set('kimakiCallbackUrl', gatewayCallbackUrl);
     }
+    if (reachableUrl) {
+        url.searchParams.set('reachableUrl', reachableUrl);
+    }
     return url.toString();
 }
 export function deduplicateByKey(arr, keyFn) {

package/dist/voice-attachment.js

@@ -0,0 +1,34 @@
+// Voice attachment detection helpers.
+// Normalizes Discord attachment heuristics for voice-message detection so
+// message routing, transcription, and empty-prompt guards all agree even when
+// Discord omits contentType on uploaded audio attachments.
+import path from 'node:path';
+const VOICE_ATTACHMENT_EXTENSIONS = new Set([
+    '.m4a',
+    '.mp3',
+    '.mp4',
+    '.oga',
+    '.ogg',
+    '.opus',
+    '.wav',
+]);
+export function getVoiceAttachmentMatchReason(attachment) {
+    const contentType = attachment.contentType?.trim().toLowerCase() || '';
+    if (contentType.startsWith('audio/')) {
+        return `contentType:${contentType}`;
+    }
+    if (typeof attachment.duration === 'number' && attachment.duration > 0) {
+        return `duration:${attachment.duration}`;
+    }
+    if (attachment.waveform?.trim()) {
+        return 'waveform';
+    }
+    const extension = path.extname(attachment.name || '').toLowerCase();
+    if (VOICE_ATTACHMENT_EXTENSIONS.has(extension)) {
+        return `extension:${extension}`;
+    }
+    return null;
+}
+export function isVoiceAttachment(attachment) {
+    return getVoiceAttachmentMatchReason(attachment) !== null;
+}

package/dist/voice-handler.js

@@ -3,21 +3,21 @@
 // and routes audio to the GenAI worker for real-time voice assistant interactions.
 import * as errore from 'errore';
 import { VoiceConnectionStatus, EndBehaviorType, joinVoiceChannel, entersState, } from '@discordjs/voice';
-import { exec } from 'node:child_process';
 import fs, { createWriteStream } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
-import { promisify } from 'node:util';
 import { Transform } from 'node:stream';
 import * as prism from 'prism-media';
 import dedent from 'string-dedent';
 import { Events, ActionRowBuilder, ButtonBuilder, ButtonStyle, } from 'discord.js';
 import { createGenAIWorker } from './genai-worker-wrapper.js';
 import { getVoiceChannelDirectory, getGeminiApiKey, getTranscriptionApiKey, findTextChannelByVoiceChannel, } from './database.js';
-import { sendThreadMessage, escapeDiscordFormatting, SILENT_MESSAGE_FLAGS, hasKimakiBotPermission, } from './discord-utils.js';
+import { sendThreadMessage, escapeDiscordFormatting, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, hasKimakiBotPermission, } from './discord-utils.js';
 import { transcribeAudio } from './voice.js';
 import { FetchError } from './errors.js';
 import { store } from './store.js';
+import { getVoiceAttachmentMatchReason, isVoiceAttachment, } from './voice-attachment.js';
+import { execAsync } from './worktrees.js';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
 const voiceLogger = createLogger(LogPrefix.VOICE);
@@ -195,7 +195,7 @@ export async function setupVoiceHandling({ connection, guildId, channelId, appId
                     if (textChannel?.isTextBased() && 'send' in textChannel) {
                         await textChannel.send({
                             content: `⚠️ Voice session error: ${String(error).slice(0, 1900)}`,
-                            flags: SILENT_MESSAGE_FLAGS,
+                            flags: NOTIFY_MESSAGE_FLAGS,
                         });
                     }
                 }
@@ -329,10 +329,11 @@ export async function cleanupVoiceConnection(guildId) {
 // Per-thread serialization is handled by ThreadSessionRuntime.enqueueIncoming()
 // via the runtime action queue; no local serialization is needed here.
 export async function processVoiceAttachment({ message, thread, projectDirectory, isNewThread = false, appId, currentSessionContext, lastSessionContext, }) {
-    const audioAttachment = Array.from(message.attachments.values()).find((attachment) => attachment.contentType?.startsWith('audio/'));
+    const audioAttachment = Array.from(message.attachments.values()).find((attachment) => isVoiceAttachment(attachment));
     if (!audioAttachment)
         return null;
-    voiceLogger.log(`Detected audio attachment: ${audioAttachment.name} (${audioAttachment.contentType})`);
+    const attachmentMatchReason = getVoiceAttachmentMatchReason(audioAttachment);
+    voiceLogger.log(`Detected audio attachment: ${audioAttachment.name} (${audioAttachment.contentType || 'no contentType'}, ${attachmentMatchReason || 'unknown reason'})`);
     await sendThreadMessage(thread, '🎤 Transcribing voice message...');
     // Deterministic mode: skip audio download and AI model call entirely,
     // return a canned result after an optional delay. Used by e2e tests to
@@ -370,7 +371,7 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
     });
     if (audioResponse instanceof Error) {
         voiceLogger.error(`Failed to download audio attachment:`, audioResponse.message);
-        await sendThreadMessage(thread, `⚠️ Failed to download audio: ${audioResponse.message}`);
+        await sendThreadMessage(thread, `⚠️ Failed to download audio: ${audioResponse.message}`, { flags: NOTIFY_MESSAGE_FLAGS });
         return null;
     }
     const audioBuffer = Buffer.from(await audioResponse.arrayBuffer());
@@ -379,7 +380,6 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
     if (projectDirectory) {
         try {
             voiceLogger.log(`Getting project file tree from ${projectDirectory}`);
-            const execAsync = promisify(exec);
             const { stdout } = await execAsync('git ls-files | tree --fromfile -a', {
                 cwd: projectDirectory,
             });
@@ -450,7 +450,9 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             Error: (e) => e.message,
         });
         voiceLogger.error(`Transcription failed:`, transcription);
-        await sendThreadMessage(thread, `⚠️ Transcription failed: ${errMsg}`);
+        await sendThreadMessage(thread, `⚠️ Transcription failed: ${errMsg}`, {
+            flags: NOTIFY_MESSAGE_FLAGS,
+        });
         return null;
     }
     const { transcription: text, queueMessage } = transcription;

package/dist/voice-message.e2e.test.js

@@ -414,6 +414,84 @@ e2eTest('voice message handling', () => {
         const assistantTexts = getAssistantTexts(messages);
         expect(assistantTexts.length).toBeGreaterThan(0);
     }, 8_000);
+    test('voice attachment without content type still transcribes and avoids empty prompt dispatch', async () => {
+        setDeterministicTranscription({
+            transcription: 'Investigate the missing content type path',
+            queueMessage: false,
+        });
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: '',
+            attachments: [
+                {
+                    id: 'voice-no-content-type',
+                    filename: 'voice-message.ogg',
+                    size: 1024,
+                    url: 'https://fake-cdn.discord.test/voice-no-content-type.ogg',
+                    proxy_url: 'https://fake-cdn.discord.test/voice-no-content-type.ogg',
+                },
+            ],
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name?.includes('Investigate the missing content type path') ?? false;
+            },
+        });
+        const th = discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'Transcribing voice message',
+            timeout: 4_000,
+        });
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'Investigate the missing content type path',
+            timeout: 4_000,
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+        });
+        const finalState = await waitForThreadState({
+            threadId: thread.id,
+            predicate: (state) => {
+                return Boolean(state.sessionId) && state.queueItems.length === 0;
+            },
+            timeout: 4_000,
+            description: 'voice attachment without content type settled',
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (voice-tester)
+        [attachment: voice-message.ogg]
+        --- from: assistant (TestBot)
+        🎤 Transcribing voice message...
+        📝 **Transcribed message:** Investigate the missing content type path
+        ⬥ session-reply
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+        const messages = await waitForSessionMessages({
+            projectDirectory: directories.projectDirectory,
+            sessionID: finalState.sessionId,
+            timeout: 4_000,
+            description: 'voice attachment without content type dispatched once',
+            predicate: (all) => {
+                const userTexts = getUserTexts(all);
+                return userTexts.some((text) => {
+                    return text.includes('Investigate the missing content type path');
+                });
+            },
+        });
+        const userTexts = getUserTexts(messages);
+        expect(userTexts).not.toContain('');
+        expect(userTexts.some((text) => {
+            return text.includes('Investigate the missing content type path');
+        })).toBe(true);
+    }, 8_000);
     // ── Test 2: Voice message in thread with idle session ──
     test('voice message in thread with idle session starts new request', async () => {
         // 1. Create a session with a text message first

package/dist/voice.test.js

@@ -4,6 +4,7 @@ import { describe, test, expect } from 'vitest';
 import fs from 'node:fs';
 import path from 'node:path';
 import { transcribeAudio, convertOggToWav, extractTranscription, normalizeAudioMediaType, getOpenAIAudioConversionStrategy, } from './voice.js';
+import { getVoiceAttachmentMatchReason, isVoiceAttachment, } from './voice-attachment.js';
 describe('audio media type routing', () => {
     test('normalizes m4a aliases to audio/mp4', () => {
         expect(normalizeAudioMediaType('audio/x-m4a')).toMatchInlineSnapshot('"audio/mp4"');
@@ -20,6 +21,36 @@ describe('audio media type routing', () => {
         expect(getOpenAIAudioConversionStrategy('audio/mpeg')).toMatchInlineSnapshot('"none"');
     });
 });
+describe('voice attachment detection', () => {
+    test('detects voice attachments by content type, extension, and waveform metadata', () => {
+        expect([
+            getVoiceAttachmentMatchReason({
+                name: 'voice-message.ogg',
+                contentType: 'audio/ogg',
+            }),
+            getVoiceAttachmentMatchReason({
+                name: 'voice-message.ogg',
+                contentType: null,
+            }),
+            getVoiceAttachmentMatchReason({
+                name: 'upload.bin',
+                contentType: null,
+                waveform: 'abc123',
+            }),
+            isVoiceAttachment({
+                name: 'notes.txt',
+                contentType: null,
+            }),
+        ]).toMatchInlineSnapshot(`
+      [
+        "contentType:audio/ogg",
+        "extension:.ogg",
+        "waveform",
+        false,
+      ]
+    `);
+    });
+});
 describe('extractTranscription', () => {
     test('extracts transcription from tool call', () => {
         const result = extractTranscription([

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.78",
+  "version": "0.4.80",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -19,13 +19,15 @@
     "@types/json-schema": "^7.0.15",
     "@types/ms": "^2.1.0",
     "@types/node": "^24.3.0",
+    "@types/proper-lockfile": "^4.1.4",
     "eventsource-parser": "^3.0.6",
+    "lintcn": "^0.3.0",
     "prisma": "7.4.2",
     "tsx": "^4.20.5",
     "discord-digital-twin": "^0.1.0",
+    "db": "^0.0.0",
     "opencode-cached-provider": "^0.0.1",
-    "opencode-deterministic-provider": "^0.0.1",
-    "db": "^0.0.0"
+    "opencode-deterministic-provider": "^0.0.1"
   },
   "dependencies": {
     "@ai-sdk/google": "^3.0.30",
@@ -35,8 +37,9 @@
     "@discordjs/voice": "^0.19.0",
     "@google/genai": "^1.34.0",
     "@libsql/client": "^0.15.15",
-    "@opencode-ai/plugin": "^1.2.15",
-    "@opencode-ai/sdk": "^1.2.15",
+    "@openauthjs/openauth": "^0.4.3",
+    "@opencode-ai/plugin": "^1.2.27",
+    "@opencode-ai/sdk": "^1.2.27",
     "@parcel/watcher": "^2.5.6",
     "@prisma/adapter-libsql": "7.4.2",
     "@prisma/client": "7.4.2",
@@ -54,14 +57,15 @@
     "mime": "^4.1.0",
     "picocolors": "^1.1.1",
     "pretty-ms": "^9.3.0",
+    "proper-lockfile": "^4.1.2",
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "ws": "^8.19.0",
     "xdg-basedir": "^5.1.0",
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
-    "errore": "^0.14.0",
-    "traforo": "^0.0.9"
+    "errore": "^0.14.1",
+    "traforo": "^0.1.0"
   },
   "optionalDependencies": {
     "@discordjs/opus": "^0.10.0",
@@ -81,6 +85,7 @@
     "validate-typing-indicator": "doppler run -- tsx scripts/validate-typing-indicator.ts",
     "test:send": "tsx send-test-message.ts",
     "register-commands": "tsx scripts/register-commands.ts",
+    "lint": "lintcn lint",
     "format": "oxfmt src",
     "sync-skills": "tsx scripts/sync-skills.ts"
   }