kimaki 0.24.0 → 0.26.0

package/dist/task-runner.js

@@ -3,11 +3,15 @@ import { Routes } from 'discord.js';
 import { createDiscordRest } from './discord-urls.js';
 import { ensureThreadMember } from './discord-utils.js';
 import YAML from 'yaml';
-import { claimScheduledTaskRunning, getDuePlannedScheduledTasks, getScheduledTask, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, deleteScheduledTask, recoverStaleRunningScheduledTasks, } from './database.js';
+import { claimScheduledTaskRunning, createScheduledTaskRun, failScheduledTaskRun, finishScheduledTaskRun, getDuePlannedScheduledTasks, getScheduledTask, getActiveScheduledTaskRuns, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, deleteScheduledTask, recoverStaleRunningScheduledTasks, releaseScheduledTaskClaim, setScheduledTaskRunThread, } from './database.js';
+import { execAsync } from './exec-async.js';
+import { initializeOpencodeForDirectory } from './opencode.js';
 import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
-import { getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
+import { appendTaskCommandOutput, getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
 const taskLogger = createLogger(LogPrefix.TASK);
+const MAX_SCHEDULED_PROMPT_LENGTH = 1_900;
+const PENDING_RUN_TIMEOUT_MS = 120_000;
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -20,7 +24,7 @@ function parseMessageId(value) {
     }
     return value.id;
 }
-async function executeThreadScheduledTask({ rest, task, payload, }) {
+async function executeThreadScheduledTask({ rest, task, payload, prompt, runId, }) {
     const marker = {
         start: true,
         scheduledKind: task.schedule_kind,
@@ -28,6 +32,7 @@ async function executeThreadScheduledTask({ rest, task, payload, }) {
         // after execution, so the ID would be stale by the time the bot processes
         // the Discord event and tries to insert a session_start_sources row.
         ...(task.schedule_kind === 'cron' ? { scheduledTaskId: task.id } : {}),
+        ...(runId ? { scheduledTaskRunId: runId } : {}),
         ...(payload.agent ? { agent: payload.agent } : {}),
         ...(payload.model ? { model: payload.model } : {}),
         ...(payload.username ? { username: payload.username } : {}),
@@ -41,7 +46,7 @@ async function executeThreadScheduledTask({ rest, task, payload, }) {
     const embed = [{ color: 0x2b2d31, footer: { text: YAML.stringify(marker) } }];
     // Newline between prefix and prompt so leading /command detection can
     // find the command on its own line.
-    const prefixedPrompt = `» **kimaki-cli:**\n${payload.prompt}`;
+    const prefixedPrompt = `» **kimaki-cli:**\n${prompt}`;
     // Re-join the user before posting, so the message they get notified about is
     // in a thread they are already a member of. Works on archived threads too;
     // the post below auto-unarchives.
@@ -69,8 +74,9 @@ async function executeThreadScheduledTask({ rest, task, payload, }) {
     });
     if (postResult instanceof Error)
         return postResult;
+    return payload.threadId;
 }
-async function executeChannelScheduledTask({ rest, task, payload, }) {
+async function executeChannelScheduledTask({ rest, task, payload, prompt, runId, }) {
     const marker = payload.notifyOnly
         ? undefined
         : {
@@ -78,6 +84,7 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
             scheduledKind: task.schedule_kind,
             // Only include scheduledTaskId for cron tasks (see thread variant comment)
             ...(task.schedule_kind === 'cron' ? { scheduledTaskId: task.id } : {}),
+            ...(runId ? { scheduledTaskRunId: runId } : {}),
             ...(payload.worktreeName ? { worktree: payload.worktreeName } : {}),
             ...(payload.cwd ? { cwd: payload.cwd } : {}),
             ...(payload.agent ? { agent: payload.agent } : {}),
@@ -96,7 +103,7 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
     const starterResult = await rest
         .post(Routes.channelMessages(payload.channelId), {
         body: {
-            content: payload.prompt,
+            content: prompt,
             embeds,
         },
     })
@@ -113,7 +120,7 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
             cause: starterMessageId,
         });
     }
-    const threadName = (payload.name || getPromptPreview(payload.prompt)).slice(0, 100);
+    const threadName = (payload.name || getPromptPreview(prompt)).slice(0, 100);
     const threadResult = await rest
         .post(Routes.threads(payload.channelId, starterMessageId), {
         body: {
@@ -128,15 +135,14 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
     });
     if (threadResult instanceof Error)
         return threadResult;
-    if (!payload.userId) {
-        return;
-    }
     const threadIdResult = parseMessageId(threadResult);
     if (threadIdResult instanceof Error) {
         return new Error(`Invalid thread response for task ${task.id}`, {
             cause: threadIdResult,
         });
     }
+    if (!payload.userId)
+        return threadIdResult;
     const addMemberResult = await ensureThreadMember({
         rest,
         threadId: threadIdResult,
@@ -145,25 +151,111 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
     if (addMemberResult instanceof Error) {
         return new Error(`Failed to add user to scheduled thread for task ${task.id}`, { cause: addMemberResult });
     }
+    return threadIdResult;
+}
+export async function runTaskCommand({ task, payload, }) {
+    if (!payload.preRunCommand)
+        return { kind: 'run', prompt: payload.prompt };
+    if (!task.project_directory) {
+        return new Error(`Task ${task.id} has a pre-run command but no project directory`);
+    }
+    const command = payload.preRunCommand;
+    const result = await execAsync(command, { cwd: task.project_directory }).catch((error) => error instanceof Error ? error : new Error(String(error)));
+    const stdout = isRecord(result) && typeof result.stdout === 'string'
+        ? result.stdout
+        : '';
+    const stderr = isRecord(result) && typeof result.stderr === 'string'
+        ? result.stderr
+        : '';
+    const exitCode = result instanceof Error && isRecord(result)
+        ? result.code ?? 1
+        : 0;
+    if (stdout)
+        taskLogger.log(`[task-runner] task ${task.id} pre-run stdout:\n${stdout}`);
+    if (stderr)
+        taskLogger.log(`[task-runner] task ${task.id} pre-run stderr:\n${stderr}`);
+    taskLogger.log(`[task-runner] task ${task.id} pre-run exited with ${exitCode}`);
+    if (result instanceof Error)
+        return { kind: 'skip' };
+    const prompt = appendTaskCommandOutput({ prompt: payload.prompt, stdout });
+    if (prompt.length > MAX_SCHEDULED_PROMPT_LENGTH) {
+        return new Error(`Task ${task.id} prompt and pre-run stdout exceed ${MAX_SCHEDULED_PROMPT_LENGTH} characters`);
+    }
+    return { kind: 'run', prompt };
+}
+async function hasRunningSession(task) {
+    const runs = await getActiveScheduledTaskRuns(task.id);
+    if (runs.length === 0)
+        return false;
+    let active = false;
+    for (const run of runs) {
+        if (!run.session_id) {
+            if (Date.now() - run.started_at.getTime() < PENDING_RUN_TIMEOUT_MS) {
+                active = true;
+                continue;
+            }
+            await failScheduledTaskRun({
+                runId: run.id,
+                error: 'Timed out waiting for scheduled session to start',
+            });
+            continue;
+        }
+        if (!run.project_directory) {
+            active = true;
+            continue;
+        }
+        const getClient = await initializeOpencodeForDirectory(run.project_directory);
+        if (getClient instanceof Error)
+            return getClient;
+        const statusResponse = await getClient().session.status({
+            directory: run.project_directory,
+        }).catch((error) => new Error('Failed to check scheduled session status', {
+            cause: error,
+        }));
+        if (statusResponse instanceof Error)
+            return statusResponse;
+        if (statusResponse.error)
+            return new Error('Failed to check scheduled session status');
+        const status = statusResponse.data?.[run.session_id];
+        if (status && status.type !== 'idle') {
+            active = true;
+            continue;
+        }
+        if (!status && Date.now() - run.started_at.getTime() < PENDING_RUN_TIMEOUT_MS) {
+            active = true;
+            continue;
+        }
+        await finishScheduledTaskRun({ runId: run.id, status: 'completed' });
+    }
+    return active;
 }
-async function executeScheduledTask({ rest, task, }) {
+async function executeScheduledTask({ rest, task, runId, }) {
     const payloadResult = parseScheduledTaskPayload(task.payload_json);
     if (payloadResult instanceof Error) {
         return new Error(`Task ${task.id} has invalid payload`, {
             cause: payloadResult,
         });
     }
+    const commandResult = await runTaskCommand({ task, payload: payloadResult });
+    if (commandResult instanceof Error)
+        return commandResult;
+    if (commandResult.kind === 'skip')
+        return { kind: 'condition-not-met' };
     if (payloadResult.kind === 'thread') {
         return executeThreadScheduledTask({
             rest,
             task,
             payload: payloadResult,
+            prompt: commandResult.prompt,
+            runId,
         });
     }
     return executeChannelScheduledTask({
         rest,
         task,
         payload: payloadResult,
+        prompt: commandResult.prompt,
+        runId,
     });
 }
 async function finalizeSuccessfulTask({ task, completedAt, }) {
@@ -234,7 +326,32 @@ async function processDueTask({ rest, task, }) {
     if (!claimed) {
         return { kind: 'skipped' };
     }
-    const executeResult = await executeScheduledTask({ rest, task });
+    const payload = parseScheduledTaskPayload(task.payload_json);
+    if (payload instanceof Error) {
+        await finalizeFailedTask({ task, failedAt: new Date(), error: payload });
+        return { kind: 'failed', error: payload };
+    }
+    const activeSession = payload.allowConcurrency
+        ? false
+        : await hasRunningSession(task);
+    if (activeSession instanceof Error) {
+        await releaseScheduledTaskClaim(task.id);
+        taskLogger.warn(`[task-runner] could not check concurrency for task ${task.id}: ${formatErrorWithStack(activeSession)}`);
+        return { kind: 'failed', error: activeSession };
+    }
+    if (activeSession) {
+        if (task.schedule_kind === 'cron') {
+            await finalizeSuccessfulTask({ task, completedAt: new Date() });
+        }
+        else {
+            await releaseScheduledTaskClaim(task.id);
+        }
+        return { kind: 'concurrency-blocked' };
+    }
+    const runId = task.schedule_kind === 'cron'
+        ? await createScheduledTaskRun({ taskId: task.id, startedAt })
+        : undefined;
+    const executeResult = await executeScheduledTask({ rest, task, runId });
     const finishedAt = new Date();
     if (executeResult instanceof Error) {
         taskLogger.warn(`[task-runner] task ${task.id} failed: ${formatErrorWithStack(executeResult)}`);
@@ -243,8 +360,22 @@ async function processDueTask({ rest, task, }) {
             failedAt: finishedAt,
             error: executeResult,
         });
+        if (runId)
+            await failScheduledTaskRun({ runId, error: executeResult.message });
         return { kind: 'failed', error: executeResult };
     }
+    if (!(typeof executeResult === 'string' || executeResult === null)) {
+        if (runId)
+            await finishScheduledTaskRun({ runId, status: 'skipped' });
+        await finalizeSuccessfulTask({ task, completedAt: finishedAt });
+        return executeResult;
+    }
+    if (executeResult && runId) {
+        await setScheduledTaskRunThread({ runId, threadId: executeResult });
+    }
+    else if (runId) {
+        await finishScheduledTaskRun({ runId, status: 'completed' });
+    }
     await finalizeSuccessfulTask({ task, completedAt: finishedAt });
     return { kind: 'success' };
 }

package/dist/task-schedule.js

@@ -106,6 +106,12 @@ export function getNextCronRun({ cronExpr, timezone, from, }) {
 export function serializeScheduledTaskPayload(payload) {
     return JSON.stringify(payload);
 }
+export function appendTaskCommandOutput({ prompt, stdout, }) {
+    const output = stdout.trim();
+    if (!output)
+        return prompt;
+    return `${prompt}\n\n## Pre-run command output\n\n${output}`;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -135,6 +141,8 @@ export function parseScheduledTaskPayload(payloadJson) {
         return new Error('Task payload must be an object');
     }
     const kind = asString(parsed.kind);
+    const preRunCommand = asString(parsed.preRunCommand);
+    const allowConcurrency = parsed.allowConcurrency === true;
     if (kind === 'thread') {
         const threadId = asString(parsed.threadId);
         const prompt = asString(parsed.prompt);
@@ -159,6 +167,8 @@ export function parseScheduledTaskPayload(payloadJson) {
             permissions,
             injectionGuardPatterns,
             parentSessionId,
+            preRunCommand,
+            allowConcurrency,
         };
     }
     if (kind === 'channel') {
@@ -194,6 +204,8 @@ export function parseScheduledTaskPayload(payloadJson) {
             permissions,
             injectionGuardPatterns,
             parentSessionId,
+            preRunCommand,
+            allowConcurrency,
         };
     }
     return new Error('Task payload has unknown kind');

package/dist/task-schedule.test.js

@@ -1,6 +1,12 @@
 // Tests for scheduled task date/cron parsing and UTC validation rules.
-import { describe, expect, test } from 'vitest';
-import { parseSendAtValue } from './task-schedule.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, afterEach, describe, expect, test } from 'vitest';
+import { completeScheduledTaskRunsForSession, createScheduledTask, createScheduledTaskRun, getActiveScheduledTaskRuns, getScheduledTask, startScheduledTaskRunSession, } from './database.js';
+import { closeDb } from './db.js';
+import { runTaskCommand } from './task-runner.js';
+import { appendTaskCommandOutput, parseScheduledTaskPayload, parseSendAtValue, } from './task-schedule.js';
 describe('parseSendAtValue', () => {
     test('accepts UTC ISO date ending with Z', () => {
         const now = new Date('2026-02-22T13:00:00Z');
@@ -69,3 +75,144 @@ describe('parseSendAtValue', () => {
         expect(result.nextRunAt.toISOString()).toBe('2026-02-23T09:00:00.000Z');
     });
 });
+describe('scheduled task execution options', () => {
+    const tempDirectories = [];
+    afterEach(() => {
+        for (const directory of tempDirectories.splice(0)) {
+            fs.rmSync(directory, { recursive: true, force: true });
+        }
+    });
+    test('defaults old payloads to no command and no concurrency', () => {
+        const payload = parseScheduledTaskPayload(JSON.stringify({
+            kind: 'thread',
+            threadId: 'thread-1',
+            prompt: 'Handle support requests',
+        }));
+        expect(payload).toMatchInlineSnapshot(`
+      {
+        "agent": null,
+        "allowConcurrency": false,
+        "injectionGuardPatterns": null,
+        "kind": "thread",
+        "model": null,
+        "parentSessionId": null,
+        "permissions": null,
+        "preRunCommand": null,
+        "prompt": "Handle support requests",
+        "threadId": "thread-1",
+        "userId": null,
+        "username": null,
+      }
+    `);
+    });
+    test('adds command stdout to the prompt', () => {
+        expect(appendTaskCommandOutput({
+            prompt: 'Handle support requests',
+            stdout: '{"ticketId":"ticket-123"}\n',
+        })).toMatchInlineSnapshot(`
+      "Handle support requests
+
+      ## Pre-run command output
+
+      {"ticketId":"ticket-123"}"
+    `);
+    });
+    test('runs the pre-run command in the project directory', async () => {
+        const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-task-'));
+        tempDirectories.push(directory);
+        fs.writeFileSync(path.join(directory, 'should-run.ts'), "process.stdout.write(JSON.stringify({ cwd: process.cwd(), ticketId: 'ticket-123' }))\n");
+        const taskId = await createScheduledTask({
+            scheduleKind: 'cron',
+            cronExpr: '*/5 * * * *',
+            timezone: 'UTC',
+            nextRunAt: new Date('2026-08-12T18:00:00Z'),
+            payloadJson: JSON.stringify({
+                kind: 'thread',
+                threadId: 'thread-1',
+                prompt: 'Handle support requests',
+                preRunCommand: 'tsx should-run.ts',
+            }),
+            promptPreview: 'Handle support requests',
+            projectDirectory: directory,
+        });
+        const task = await getScheduledTask(taskId);
+        if (!task)
+            throw new Error('Expected scheduled task');
+        const payload = parseScheduledTaskPayload(task.payload_json);
+        if (payload instanceof Error)
+            throw payload;
+        const result = await runTaskCommand({ task, payload });
+        const realDirectory = fs.realpathSync(directory);
+        expect(result instanceof Error || result.kind === 'skip' ? result : {
+            ...result,
+            prompt: result.prompt.replace(realDirectory, '<project-directory>'),
+        }).toMatchInlineSnapshot(`
+      {
+        "kind": "run",
+        "prompt": "Handle support requests
+
+      ## Pre-run command output
+
+      {"cwd":"<project-directory>","ticketId":"ticket-123"}",
+      }
+    `);
+    });
+    test('skips the task when the pre-run command exits nonzero', async () => {
+        const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-task-'));
+        tempDirectories.push(directory);
+        const taskId = await createScheduledTask({
+            scheduleKind: 'cron',
+            cronExpr: '*/5 * * * *',
+            timezone: 'UTC',
+            nextRunAt: new Date('2026-08-12T18:00:00Z'),
+            payloadJson: JSON.stringify({
+                kind: 'thread',
+                threadId: 'thread-skip',
+                prompt: 'Handle support requests',
+                preRunCommand: "node -e \"process.stdout.write('nothing pending'); process.exit(1)\"",
+            }),
+            promptPreview: 'Handle support requests',
+            projectDirectory: directory,
+        });
+        const task = await getScheduledTask(taskId);
+        if (!task)
+            throw new Error('Expected scheduled task');
+        const payload = parseScheduledTaskPayload(task.payload_json);
+        if (payload instanceof Error)
+            throw payload;
+        expect(await runTaskCommand({ task, payload })).toMatchInlineSnapshot(`
+      {
+        "kind": "skip",
+      }
+    `);
+    });
+    test('tracks active runs until their OpenCode session completes', async () => {
+        const taskId = await createScheduledTask({
+            scheduleKind: 'cron',
+            cronExpr: '*/5 * * * *',
+            timezone: 'UTC',
+            nextRunAt: new Date('2026-08-12T18:00:00Z'),
+            payloadJson: JSON.stringify({
+                kind: 'thread',
+                threadId: 'thread-2',
+                prompt: 'Handle support requests',
+            }),
+            promptPreview: 'Handle support requests',
+        });
+        const runId = await createScheduledTaskRun({
+            taskId,
+            startedAt: new Date('2026-08-12T18:00:00Z'),
+        });
+        await startScheduledTaskRunSession({
+            runId,
+            sessionId: 'session-1',
+            projectDirectory: '/project',
+        });
+        expect(await getActiveScheduledTaskRuns(taskId)).toHaveLength(1);
+        await completeScheduledTaskRunsForSession('session-1');
+        expect(await getActiveScheduledTaskRuns(taskId)).toHaveLength(0);
+    });
+});
+afterAll(async () => {
+    await closeDb();
+});

package/dist/voice-handler.js

@@ -11,7 +11,8 @@ import * as prism from 'prism-media';
 import dedent from 'string-dedent';
 import { Events, } from 'discord.js';
 import { createGenAIWorker } from './genai-worker-wrapper.js';
-import { getVoiceChannelDirectory, getGeminiApiKey, getTranscriptionApiKey, findTextChannelByVoiceChannel, } from './database.js';
+import { getVoiceChannelDirectory, getGeminiApiKey, getTranscriptionApiKey, getBotTokenWithMode, findTextChannelByVoiceChannel, } from './database.js';
+import { transcribeViaKimakiGateway } from './cloudflare-transcription.js';
 import { sendThreadMessage, escapeDiscordFormatting, NOTIFY_MESSAGE_FLAGS, hasKimakiBotPermission, } from './discord-utils.js';
 import { requestAudioApiKey } from './commands/gemini-apikey.js';
 import { transcribeAudio } from './voice.js';
@@ -446,7 +447,30 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
         transcriptionApiKey = process.env.GEMINI_API_KEY;
         transcriptionProvider = 'gemini';
     }
+    // No user-configured key: gateway-mode installs get one free transcription
+    // via the kimaki.dev Whisper fallback before we bother the user with the
+    // "add API key" dialog. This fallback has no tool-calling, so it can't
+    // detect queueMessage/agent hints spoken in the voice message the way the
+    // OpenAI/Gemini path can.
+    let gatewayTranscription;
     if (!transcriptionApiKey) {
+        const botRow = await getBotTokenWithMode().catch(() => undefined);
+        if (botRow?.mode === 'gateway' && botRow.clientId && botRow.clientSecret) {
+            const result = await transcribeViaKimakiGateway({
+                audio: audioBuffer,
+                mediaType: audioAttachment.contentType || undefined,
+                clientId: botRow.clientId,
+                clientSecret: botRow.clientSecret,
+            });
+            if (result instanceof Error) {
+                voiceLogger.log(`Kimaki gateway transcription fallback failed:`, result);
+            }
+            else {
+                gatewayTranscription = result;
+            }
+        }
+    }
+    if (!transcriptionApiKey && !gatewayTranscription) {
         if (!appId) {
             await sendThreadMessage(thread, 'Voice transcription requires an API key. Set OPENAI_API_KEY or GEMINI_API_KEY, or use /login in this channel.');
             return null;
@@ -461,16 +485,18 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
         transcriptionApiKey = requested.apiKey;
         transcriptionProvider = requested.provider;
     }
-    const transcription = await transcribeAudio({
-        audio: audioBuffer,
-        prompt: transcriptionPrompt,
-        apiKey: transcriptionApiKey,
-        provider: transcriptionProvider,
-        mediaType: audioAttachment.contentType || undefined,
-        currentSessionContext,
-        lastSessionContext,
-        agents,
-    });
+    const transcription = gatewayTranscription
+        ? { transcription: gatewayTranscription, queueMessage: false, agent: undefined }
+        : await transcribeAudio({
+            audio: audioBuffer,
+            prompt: transcriptionPrompt,
+            apiKey: transcriptionApiKey,
+            provider: transcriptionProvider,
+            mediaType: audioAttachment.contentType || undefined,
+            currentSessionContext,
+            lastSessionContext,
+            agents,
+        });
     if (transcription instanceof Error) {
         const errMsg = errore.matchError(transcription, {
             ApiKeyMissingError: (e) => e.message,