@otto-assistant/bridge 0.4.92

package/dist/task-runner.js

@@ -0,0 +1,295 @@
+// Scheduled task runner for executing due `send --send-at` jobs in the bot process.
+import { Routes } from 'discord.js';
+import { createDiscordRest } from './discord-urls.js';
+import YAML from '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 { getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
+const taskLogger = createLogger(LogPrefix.TASK);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function parseMessageId(value) {
+    if (!isRecord(value)) {
+        return new Error('Discord response is not an object');
+    }
+    if (typeof value.id !== 'string') {
+        return new Error('Discord response is missing message ID');
+    }
+    return value.id;
+}
+async function executeThreadScheduledTask({ rest, task, payload, }) {
+    const marker = {
+        start: true,
+        scheduledKind: task.schedule_kind,
+        scheduledTaskId: task.id,
+        ...(payload.agent ? { agent: payload.agent } : {}),
+        ...(payload.model ? { model: payload.model } : {}),
+        ...(payload.username ? { username: payload.username } : {}),
+        ...(payload.userId ? { userId: payload.userId } : {}),
+        ...(payload.permissions?.length ? { permissions: payload.permissions } : {}),
+        ...(payload.injectionGuardPatterns?.length
+            ? { injectionGuardPatterns: payload.injectionGuardPatterns }
+            : {}),
+    };
+    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 postResult = await rest
+        .post(Routes.channelMessages(payload.threadId), {
+        body: {
+            content: prefixedPrompt,
+            embeds: embed,
+        },
+    })
+        .catch((error) => {
+        return new Error(`Failed to post scheduled thread task ${task.id}`, {
+            cause: error,
+        });
+    });
+    if (postResult instanceof Error) {
+        return postResult;
+    }
+}
+async function executeChannelScheduledTask({ rest, task, payload, }) {
+    const marker = payload.notifyOnly
+        ? undefined
+        : {
+            start: true,
+            scheduledKind: task.schedule_kind,
+            scheduledTaskId: task.id,
+            ...(payload.worktreeName ? { worktree: payload.worktreeName } : {}),
+            ...(payload.cwd ? { cwd: payload.cwd } : {}),
+            ...(payload.agent ? { agent: payload.agent } : {}),
+            ...(payload.model ? { model: payload.model } : {}),
+            ...(payload.username ? { username: payload.username } : {}),
+            ...(payload.userId ? { userId: payload.userId } : {}),
+            ...(payload.permissions?.length ? { permissions: payload.permissions } : {}),
+            ...(payload.injectionGuardPatterns?.length
+                ? { injectionGuardPatterns: payload.injectionGuardPatterns }
+                : {}),
+        };
+    const embeds = marker
+        ? [{ color: 0x2b2d31, footer: { text: YAML.stringify(marker) } }]
+        : undefined;
+    const starterResult = await rest
+        .post(Routes.channelMessages(payload.channelId), {
+        body: {
+            content: payload.prompt,
+            embeds,
+        },
+    })
+        .catch((error) => {
+        return new Error(`Failed to create starter message for task ${task.id}`, {
+            cause: error,
+        });
+    });
+    if (starterResult instanceof Error) {
+        return starterResult;
+    }
+    const starterMessageId = parseMessageId(starterResult);
+    if (starterMessageId instanceof Error) {
+        return new Error(`Invalid starter message response for task ${task.id}`, {
+            cause: starterMessageId,
+        });
+    }
+    const threadName = (payload.name || getPromptPreview(payload.prompt)).slice(0, 100);
+    const threadResult = await rest
+        .post(Routes.threads(payload.channelId, starterMessageId), {
+        body: {
+            name: threadName,
+            auto_archive_duration: 1440,
+        },
+    })
+        .catch((error) => {
+        return new Error(`Failed to create thread for task ${task.id}`, {
+            cause: error,
+        });
+    });
+    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,
+        });
+    }
+    const addMemberResult = await rest
+        .put(Routes.threadMembers(threadIdResult, payload.userId))
+        .catch((error) => {
+        return new Error(`Failed to add user to scheduled thread for task ${task.id}`, { cause: error });
+    });
+    if (addMemberResult instanceof Error) {
+        return addMemberResult;
+    }
+}
+async function executeScheduledTask({ rest, task, }) {
+    const payloadResult = parseScheduledTaskPayload(task.payload_json);
+    if (payloadResult instanceof Error) {
+        return new Error(`Task ${task.id} has invalid payload`, {
+            cause: payloadResult,
+        });
+    }
+    if (payloadResult.kind === 'thread') {
+        return executeThreadScheduledTask({
+            rest,
+            task,
+            payload: payloadResult,
+        });
+    }
+    return executeChannelScheduledTask({
+        rest,
+        task,
+        payload: payloadResult,
+    });
+}
+async function finalizeSuccessfulTask({ task, completedAt, }) {
+    if (task.schedule_kind === 'at') {
+        await markScheduledTaskOneShotCompleted({ taskId: task.id, completedAt });
+        return;
+    }
+    if (!task.cron_expr) {
+        await markScheduledTaskFailed({
+            taskId: task.id,
+            failedAt: completedAt,
+            errorMessage: 'Missing cron expression on cron task',
+        });
+        return;
+    }
+    // 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,
+        from: completedAt,
+    });
+    if (nextRunResult instanceof Error) {
+        await markScheduledTaskFailed({
+            taskId: task.id,
+            failedAt: completedAt,
+            errorMessage: nextRunResult.message,
+        });
+        return;
+    }
+    await markScheduledTaskCronRescheduled({
+        taskId: task.id,
+        completedAt,
+        nextRunAt: nextRunResult,
+    });
+}
+async function finalizeFailedTask({ task, failedAt, error, }) {
+    if (task.schedule_kind === 'cron' && task.cron_expr) {
+        // 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,
+            from: failedAt,
+        });
+        if (!(nextRunResult instanceof Error)) {
+            await markScheduledTaskCronRetry({
+                taskId: task.id,
+                failedAt,
+                errorMessage: error.message,
+                nextRunAt: nextRunResult,
+            });
+            return;
+        }
+    }
+    await markScheduledTaskFailed({
+        taskId: task.id,
+        failedAt,
+        errorMessage: error.message,
+    });
+}
+async function processDueTask({ rest, task, }) {
+    const startedAt = new Date();
+    const claimed = await claimScheduledTaskRunning({
+        taskId: task.id,
+        startedAt,
+    });
+    if (!claimed) {
+        return;
+    }
+    const executeResult = await executeScheduledTask({ rest, task });
+    const finishedAt = new Date();
+    if (executeResult instanceof Error) {
+        taskLogger.warn(`[task-runner] task ${task.id} failed: ${formatErrorWithStack(executeResult)}`);
+        await finalizeFailedTask({
+            task,
+            failedAt: finishedAt,
+            error: executeResult,
+        });
+        return;
+    }
+    await finalizeSuccessfulTask({ task, completedAt: finishedAt });
+}
+async function runTaskRunnerTick({ rest, staleRunningMs, dueBatchSize, }) {
+    const staleBefore = new Date(Date.now() - staleRunningMs);
+    const recoveredCount = await recoverStaleRunningScheduledTasks({
+        staleBefore,
+    });
+    if (recoveredCount > 0) {
+        taskLogger.warn(`[task-runner] Recovered ${recoveredCount} stale running task(s)`);
+    }
+    const dueTasks = await getDuePlannedScheduledTasks({
+        now: new Date(),
+        limit: dueBatchSize,
+    });
+    await dueTasks.reduce(async (previous, task) => {
+        await previous;
+        await processDueTask({ rest, task });
+    }, Promise.resolve());
+}
+export function startTaskRunner({ token, pollIntervalMs = 5_000, staleRunningMs = 120_000, dueBatchSize = 20, }) {
+    const rest = createDiscordRest(token);
+    let stopped = false;
+    let ticking = false;
+    let tickPromise = null;
+    const tick = async () => {
+        if (stopped || ticking) {
+            return;
+        }
+        ticking = true;
+        const currentTickPromise = runTaskRunnerTick({
+            rest,
+            staleRunningMs,
+            dueBatchSize,
+        }).catch((error) => {
+            return new Error('Task runner tick failed', { cause: error });
+        });
+        tickPromise = currentTickPromise.then(() => {
+            return;
+        });
+        const runResult = await currentTickPromise;
+        if (runResult instanceof Error) {
+            taskLogger.error(`[task-runner] ${formatErrorWithStack(runResult)}`);
+            void notifyError(runResult, 'Task runner tick failed');
+        }
+        ticking = false;
+        tickPromise = null;
+    };
+    const timer = setInterval(() => {
+        void tick();
+    }, pollIntervalMs);
+    void tick();
+    taskLogger.log(`[task-runner] started (interval=${pollIntervalMs}ms)`);
+    return async () => {
+        if (stopped) {
+            return;
+        }
+        stopped = true;
+        clearInterval(timer);
+        if (tickPromise) {
+            await tickPromise;
+            tickPromise = null;
+        }
+        taskLogger.log('[task-runner] stopped');
+    };
+}

package/dist/task-schedule.js

@@ -0,0 +1,209 @@
+// Scheduled task parsing utilities for `send --send-at` and task runner execution.
+import { CronExpressionParser } from 'cron-parser';
+import * as errore from 'errore';
+const UTC_SEND_AT_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?Z$/;
+export function getLocalTimeZone() {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (!tz) {
+        return 'UTC';
+    }
+    return tz;
+}
+export function getPromptPreview(prompt) {
+    const normalized = prompt.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= 120) {
+        return normalized;
+    }
+    return `${normalized.slice(0, 117)}...`;
+}
+function parseUtcSendAtDate({ value, now, }) {
+    const looksLikeDate = value.includes('T') || /^\d{4}-\d{2}-\d{2}/.test(value);
+    if (!looksLikeDate) {
+        return null;
+    }
+    if (!UTC_SEND_AT_DATE_REGEX.test(value)) {
+        return new Error(`--send-at date must be UTC ISO format ending with Z (example: 2026-03-01T09:00:00Z). Received: ${value}`);
+    }
+    const runAt = new Date(value);
+    if (Number.isNaN(runAt.getTime())) {
+        return new Error(`Invalid UTC date for --send-at: ${value}`);
+    }
+    if (runAt.getTime() <= now.getTime()) {
+        return new Error(`--send-at date must be in the future (UTC): ${value}`);
+    }
+    return runAt;
+}
+export function parseSendAtValue({ value, now, timezone, }) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return new Error('--send-at cannot be empty');
+    }
+    const utcDateResult = parseUtcSendAtDate({ value: trimmed, now });
+    if (utcDateResult instanceof Error) {
+        return utcDateResult;
+    }
+    if (utcDateResult) {
+        return {
+            scheduleKind: 'at',
+            runAt: utcDateResult,
+            cronExpr: null,
+            timezone: null,
+            nextRunAt: utcDateResult,
+        };
+    }
+    const looksLikeCron = trimmed.startsWith('@') || trimmed.split(/\s+/).length >= 5;
+    if (looksLikeCron) {
+        const nextRunAtResult = getNextCronRun({
+            cronExpr: trimmed,
+            timezone,
+            from: now,
+        });
+        if (!(nextRunAtResult instanceof Error)) {
+            return {
+                scheduleKind: 'cron',
+                runAt: null,
+                cronExpr: trimmed,
+                timezone,
+                nextRunAt: nextRunAtResult,
+            };
+        }
+    }
+    const cronResult = getNextCronRun({ cronExpr: trimmed, timezone, from: now });
+    if (cronResult instanceof Error) {
+        return new Error(`Invalid --send-at value: "${trimmed}". Use UTC ISO date/time ending in Z or a cron expression.`, {
+            cause: cronResult,
+        });
+    }
+    return {
+        scheduleKind: 'cron',
+        runAt: null,
+        cronExpr: trimmed,
+        timezone,
+        nextRunAt: cronResult,
+    };
+}
+export function getNextCronRun({ cronExpr, timezone, from, }) {
+    const parsed = errore.try({
+        try: () => {
+            return CronExpressionParser.parse(cronExpr, {
+                currentDate: from,
+                tz: timezone,
+            });
+        },
+        catch: (error) => {
+            return new Error(`Invalid cron expression: ${cronExpr}`, { cause: error });
+        },
+    });
+    if (parsed instanceof Error) {
+        return parsed;
+    }
+    const next = errore.try({
+        try: () => {
+            return parsed.next().toDate();
+        },
+        catch: (error) => {
+            return new Error(`Could not compute next run for cron: ${cronExpr}`, {
+                cause: error,
+            });
+        },
+    });
+    if (next instanceof Error) {
+        return next;
+    }
+    return next;
+}
+export function serializeScheduledTaskPayload(payload) {
+    return JSON.stringify(payload);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function asString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    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: () => {
+            return JSON.parse(payloadJson);
+        },
+        catch: (error) => {
+            return new Error('Task payload is not valid JSON', { cause: error });
+        },
+    });
+    if (parsed instanceof Error) {
+        return parsed;
+    }
+    if (!isRecord(parsed)) {
+        return new Error('Task payload must be an object');
+    }
+    const kind = asString(parsed.kind);
+    if (kind === 'thread') {
+        const threadId = asString(parsed.threadId);
+        const prompt = asString(parsed.prompt);
+        const agent = asString(parsed.agent);
+        const model = asString(parsed.model);
+        const username = asString(parsed.username);
+        const userId = asString(parsed.userId);
+        const permissions = asStringArray(parsed.permissions);
+        const injectionGuardPatterns = asStringArray(parsed.injectionGuardPatterns);
+        if (!threadId || !prompt) {
+            return new Error('Thread task payload requires threadId and prompt');
+        }
+        return {
+            kind: 'thread',
+            threadId,
+            prompt,
+            agent,
+            model,
+            username,
+            userId,
+            permissions,
+            injectionGuardPatterns,
+        };
+    }
+    if (kind === 'channel') {
+        const channelId = asString(parsed.channelId);
+        const prompt = asString(parsed.prompt);
+        const nameValue = parsed.name;
+        const name = typeof nameValue === 'string' ? nameValue : null;
+        const notifyOnly = parsed.notifyOnly === true;
+        const worktreeName = asString(parsed.worktreeName);
+        const cwd = asString(parsed.cwd);
+        const agent = asString(parsed.agent);
+        const model = asString(parsed.model);
+        const username = asString(parsed.username);
+        const userId = asString(parsed.userId);
+        const permissions = asStringArray(parsed.permissions);
+        const injectionGuardPatterns = asStringArray(parsed.injectionGuardPatterns);
+        if (!channelId || !prompt) {
+            return new Error('Channel task payload requires channelId and prompt');
+        }
+        return {
+            kind: 'channel',
+            channelId,
+            prompt,
+            name,
+            notifyOnly,
+            worktreeName,
+            cwd,
+            agent,
+            model,
+            username,
+            userId,
+            permissions,
+            injectionGuardPatterns,
+        };
+    }
+    return new Error('Task payload has unknown kind');
+}

package/dist/task-schedule.test.js

@@ -0,0 +1,71 @@
+// Tests for scheduled task date/cron parsing and UTC validation rules.
+import { describe, expect, test } from 'vitest';
+import { parseSendAtValue } from './task-schedule.js';
+describe('parseSendAtValue', () => {
+    test('accepts UTC ISO date ending with Z', () => {
+        const now = new Date('2026-02-22T13:00:00Z');
+        const result = parseSendAtValue({
+            value: '2026-03-01T09:00:00Z',
+            now,
+            timezone: 'UTC',
+        });
+        expect(result).not.toBeInstanceOf(Error);
+        if (result instanceof Error) {
+            throw result;
+        }
+        expect(result.scheduleKind).toBe('at');
+        expect(result.runAt?.toISOString()).toBe('2026-03-01T09:00:00.000Z');
+        expect(result.nextRunAt.toISOString()).toBe('2026-03-01T09:00:00.000Z');
+    });
+    test('rejects ISO date with non-UTC offset', () => {
+        const now = new Date('2026-02-22T13:00:00Z');
+        const result = parseSendAtValue({
+            value: '2026-03-01T09:00:00+01:00',
+            now,
+            timezone: 'UTC',
+        });
+        expect(result).toBeInstanceOf(Error);
+        if (result instanceof Error) {
+            expect(result.message).toContain('must be UTC ISO format ending with Z');
+        }
+    });
+    test('rejects local ISO date without timezone suffix', () => {
+        const now = new Date('2026-02-22T13:00:00Z');
+        const result = parseSendAtValue({
+            value: '2026-03-01T09:00:00',
+            now,
+            timezone: 'UTC',
+        });
+        expect(result).toBeInstanceOf(Error);
+        if (result instanceof Error) {
+            expect(result.message).toContain('must be UTC ISO format ending with Z');
+        }
+    });
+    test('rejects UTC dates in the past', () => {
+        const now = new Date('2026-02-22T13:00:00Z');
+        const result = parseSendAtValue({
+            value: '2026-02-22T12:59:59Z',
+            now,
+            timezone: 'UTC',
+        });
+        expect(result).toBeInstanceOf(Error);
+        if (result instanceof Error) {
+            expect(result.message).toContain('must be in the future (UTC)');
+        }
+    });
+    test('accepts cron expressions', () => {
+        const now = new Date('2026-02-22T13:00:00Z');
+        const result = parseSendAtValue({
+            value: '0 9 * * 1',
+            now,
+            timezone: 'UTC',
+        });
+        expect(result).not.toBeInstanceOf(Error);
+        if (result instanceof Error) {
+            throw result;
+        }
+        expect(result.scheduleKind).toBe('cron');
+        expect(result.cronExpr).toBe('0 9 * * 1');
+        expect(result.nextRunAt.toISOString()).toBe('2026-02-23T09:00:00.000Z');
+    });
+});