kimaki 0.28.0 → 0.30.0

package/dist/db.test.js

@@ -7,7 +7,7 @@ import { afterAll, describe, expect, test } from 'vitest';
 import { closeDb, getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
-import { appendSessionEventsSinceLastTimestamp, createPendingWorkspace, getDueSessionSleeps, getSessionEventSnapshot, getSessionModel, getSessionSleep, setSessionModel, upsertSessionSleep, } from './database.js';
+import { appendSessionEventsSinceLastTimestamp, cleanupDeletedThread, completeIpcRequest, createIpcRequest, createScheduledTask, createPendingWorkspace, deleteChannelDirectoryById, deleteThreadQueueItem, getChannelDirectory, getDueSessionSleeps, getIpcRequestById, getScheduledTask, getSessionEventSnapshot, getSessionModel, getSessionSleep, getThreadSession, insertThreadQueueItem, listAllThreadQueueItems, listThreadQueueItems, setChannelDirectory, setChannelVerbosity, setSessionModel, setThreadSession, updateThreadQueueItemPayload, upsertSessionSleep, } from './database.js';
 import { createClient } from '@libsql/client';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { chooseLockPort } from './test-utils.js';
@@ -27,6 +27,204 @@ describe('getDb', () => {
         ].map((match) => match[1]);
         expect(new Set(tablesFromSql)).toEqual(new Set(tablesFromTs));
         expect(tablesFromSql).toContain('session_sleeps');
+        expect(tablesFromSql).toContain('thread_queue_items');
+    });
+    test('persists local queue items in FIFO order', async () => {
+        const db = await getDb();
+        const threadId = `test-queue-thread-${crypto.randomUUID()}`;
+        const firstId = `queue-${crypto.randomUUID()}`;
+        const secondId = `queue-${crypto.randomUUID()}`;
+        await insertThreadQueueItem({
+            queueId: firstId,
+            threadId,
+            payloadJson: JSON.stringify({ prompt: 'first', userId: '1', username: 'tommy' }),
+        });
+        await insertThreadQueueItem({
+            queueId: secondId,
+            threadId,
+            payloadJson: JSON.stringify({ prompt: 'second', userId: '1', username: 'tommy' }),
+        });
+        const rows = await listThreadQueueItems(threadId);
+        expect(rows.map((row) => JSON.parse(row.payload_json).prompt)).toEqual([
+            'first',
+            'second',
+        ]);
+        await updateThreadQueueItemPayload({
+            queueId: firstId,
+            payloadJson: JSON.stringify({ prompt: 'first-edited', userId: '1', username: 'tommy' }),
+        });
+        await deleteThreadQueueItem(secondId);
+        const after = await listAllThreadQueueItems();
+        const remaining = after.filter((row) => row.thread_id === threadId);
+        expect(remaining).toHaveLength(1);
+        expect(JSON.parse(remaining[0].payload_json).prompt).toBe('first-edited');
+        await db.delete(schema.thread_queue_items).where(orm.eq(schema.thread_queue_items.thread_id, threadId));
+    });
+    test('cancels channel tasks before deleting a channel mapping', async () => {
+        const channelId = `channel-${crypto.randomUUID()}`;
+        await setChannelDirectory({
+            channelId,
+            directory: `/tmp/${channelId}`,
+            channelType: 'text',
+        });
+        await setChannelVerbosity(channelId, 'text_only');
+        const taskId = await createScheduledTask({
+            scheduleKind: 'at',
+            nextRunAt: new Date('2099-01-01T00:00:00.000Z'),
+            payloadJson: JSON.stringify({ kind: 'channel', channelId, prompt: 'later' }),
+            promptPreview: 'later',
+            channelId,
+        });
+        expect(await deleteChannelDirectoryById(channelId)).toBe(true);
+        const db = await getDb();
+        expect({
+            mapping: await getChannelDirectory(channelId),
+            task: await getScheduledTask(taskId),
+            verbosity: await db.query.channel_verbosity.findFirst({
+                where: { channel_id: channelId },
+            }),
+        }).toMatchObject({
+            mapping: undefined,
+            task: {
+                status: 'cancelled',
+                last_error: 'Discord channel was deleted',
+            },
+            verbosity: undefined,
+        });
+    });
+    test('cleans pending work when a Discord thread is deleted', async () => {
+        const threadId = `thread-${crypto.randomUUID()}`;
+        const sessionId = `session-${crypto.randomUUID()}`;
+        const queueId = `queue-${crypto.randomUUID()}`;
+        await setThreadSession(threadId, sessionId);
+        await insertThreadQueueItem({
+            queueId,
+            threadId,
+            payloadJson: JSON.stringify({ prompt: 'queued' }),
+        });
+        await upsertSessionSleep({
+            sessionId,
+            wakeAt: new Date('2099-01-01T00:00:00.000Z'),
+            reason: 'later',
+        });
+        const ipcRequest = await createIpcRequest({
+            type: 'file_upload',
+            sessionId,
+            threadId,
+            payload: '{}',
+        });
+        const taskId = await createScheduledTask({
+            scheduleKind: 'at',
+            nextRunAt: new Date('2099-01-01T00:00:00.000Z'),
+            payloadJson: JSON.stringify({ kind: 'thread', threadId, prompt: 'later' }),
+            promptPreview: 'later',
+            threadId,
+            sessionId,
+        });
+        await cleanupDeletedThread(threadId);
+        await completeIpcRequest({ id: ipcRequest.id, response: 'late response' });
+        expect({
+            ipc: await getIpcRequestById({ id: ipcRequest.id }),
+            queue: await listThreadQueueItems(threadId),
+            session: await getThreadSession(threadId),
+            sleep: await getSessionSleep({ sessionId }),
+            task: await getScheduledTask(taskId),
+        }).toMatchObject({
+            ipc: { status: 'cancelled' },
+            queue: [],
+            session: sessionId,
+            sleep: { status: 'cancelled' },
+            task: {
+                status: 'cancelled',
+                last_error: 'Discord thread was deleted',
+            },
+        });
+    });
+    test('deleting an old resumed thread preserves the current session sleep', async () => {
+        const db = await getDb();
+        const sessionId = `resumed-session-${crypto.randomUUID()}`;
+        const oldThreadId = `old-thread-${crypto.randomUUID()}`;
+        const currentThreadId = `current-thread-${crypto.randomUUID()}`;
+        await setThreadSession(oldThreadId, sessionId);
+        await setThreadSession(currentThreadId, sessionId);
+        await db.update(schema.thread_sessions)
+            .set({ updated_at: new Date('2020-01-01T00:00:00.000Z') })
+            .where(orm.eq(schema.thread_sessions.thread_id, oldThreadId));
+        await db.update(schema.thread_sessions)
+            .set({ updated_at: new Date('2021-01-01T00:00:00.000Z') })
+            .where(orm.eq(schema.thread_sessions.thread_id, currentThreadId));
+        await upsertSessionSleep({
+            sessionId,
+            wakeAt: new Date('2099-01-01T00:00:00.000Z'),
+            reason: 'still current',
+        });
+        await cleanupDeletedThread(oldThreadId);
+        expect(await getSessionSleep({ sessionId })).toMatchObject({
+            status: 'planned',
+        });
+    });
+    test('rebuilds thread_queue_items that still use queue_id as the primary key', async () => {
+        await closeDb();
+        const previousDbUrl = process.env['KIMAKI_DB_URL'];
+        const dbPath = path.join(process.cwd(), `tmp/test-db-legacy-queue-${crypto.randomUUID().slice(0, 8)}.db`);
+        try {
+            const client = createClient({ url: `file:${dbPath}` });
+            await client.execute(`
+        CREATE TABLE thread_queue_items (
+          queue_id text PRIMARY KEY,
+          thread_id text NOT NULL,
+          payload_json text NOT NULL,
+          created_at datetime DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            await client.execute(`
+        CREATE INDEX thread_queue_items_thread_id_created_at_queue_id_idx
+        ON thread_queue_items (thread_id, created_at, queue_id)
+      `);
+            await client.execute(`
+        INSERT INTO thread_queue_items (queue_id, thread_id, payload_json, created_at)
+        VALUES
+          ('queue-second', 'thr-legacy-queue', '{"prompt":"second"}', '2026-09-17 10:00:02'),
+          ('queue-first', 'thr-legacy-queue', '{"prompt":"first"}', '2026-09-17 10:00:01')
+      `);
+            client.close();
+            process.env['KIMAKI_DB_URL'] = `file:${dbPath}`;
+            await getDb();
+            const rows = await listThreadQueueItems('thr-legacy-queue');
+            expect(rows.map((row) => JSON.parse(row.payload_json).prompt)).toEqual([
+                'first',
+                'second',
+            ]);
+            expect(rows.map((row) => row.id)).toEqual([1, 2]);
+            await insertThreadQueueItem({
+                queueId: 'queue-third',
+                threadId: 'thr-legacy-queue',
+                payloadJson: JSON.stringify({ prompt: 'third' }),
+            });
+            const after = await listThreadQueueItems('thr-legacy-queue');
+            expect(after.map((row) => JSON.parse(row.payload_json).prompt)).toEqual([
+                'first',
+                'second',
+                'third',
+            ]);
+        }
+        finally {
+            await closeDb();
+            if (previousDbUrl === undefined) {
+                delete process.env['KIMAKI_DB_URL'];
+            }
+            else {
+                process.env['KIMAKI_DB_URL'] = previousDbUrl;
+            }
+            for (const file of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+                try {
+                    fs.unlinkSync(file);
+                }
+                catch {
+                    // Test cleanup best effort.
+                }
+            }
+        }
     });
     test('removes part_messages rows whose thread_sessions parent is gone', async () => {
         await closeDb();

package/dist/default-channel-provisioning.test.js

@@ -97,11 +97,12 @@ for (const setup of ['legacy mapping', 'explicit onboarding']) {
         const guild = client.guilds.cache.get(trustedGuildId);
         if (setup === 'legacy mapping') {
             await setChannelDirectory({ channelId: projectChannelId, directory, channelType: 'text' });
+            expect((await findChannelsByDirectory({}))[0]?.guild_id).toBeNull();
         }
         else {
             await createProjectChannels({ guild, projectDirectory: path.join(directory, 'project'), analyticsSource: 'onboarding' });
+            expect((await findChannelsByDirectory({}))[0]?.guild_id).toBe(trustedGuildId);
         }
-        expect((await findChannelsByDirectory({}))[0]?.guild_id).toBeNull();
         // Fetching actual guild channels must work even when startup cache is empty.
         guild.channels.cache.clear();
         const created = await ensureDefaultChannelsWithWelcome({