@brianli/kimaki 0.4.72-brianli.1

package/dist/bot-token.js

@@ -0,0 +1,121 @@
+import crypto from 'node:crypto';
+let dbBotToken = null;
+function toBase64(value) {
+    const normalized = value.replace(/-/g, '+').replace(/_/g, '/');
+    const padding = '='.repeat((4 - (normalized.length % 4)) % 4);
+    return `${normalized}${padding}`;
+}
+function resolveAuthModeConfig() {
+    const guildId = process.env.KIMAKI_GUILD_ID?.trim();
+    const privateKey = process.env.KIMAKI_PRIVATE_KEY?.trim();
+    const appId = process.env.KIMAKI_APP_ID?.trim();
+    if (!guildId || !privateKey || !appId) {
+        return null;
+    }
+    return {
+        guildId,
+        privateKey,
+        appId,
+    };
+}
+function parsePrivateKey(privateKeyValue) {
+    if (privateKeyValue.includes('BEGIN PRIVATE KEY')) {
+        return crypto.createPrivateKey(privateKeyValue);
+    }
+    const candidates = [];
+    try {
+        candidates.push({
+            key: Buffer.from(toBase64(privateKeyValue), 'base64'),
+            format: 'der',
+            type: 'pkcs8',
+        });
+    }
+    catch {
+        // Ignore and continue to hex fallback.
+    }
+    try {
+        candidates.push({
+            key: Buffer.from(privateKeyValue, 'hex'),
+            format: 'der',
+            type: 'pkcs8',
+        });
+    }
+    catch {
+        // Ignore and continue.
+    }
+    for (const candidate of candidates) {
+        try {
+            return crypto.createPrivateKey(candidate);
+        }
+        catch {
+            // Try next candidate.
+        }
+    }
+    throw new Error('Invalid KIMAKI_PRIVATE_KEY for auth mode');
+}
+function createAuthModeToken(config) {
+    const timestamp = Date.now();
+    const key = parsePrivateKey(config.privateKey);
+    const message = `${config.guildId}\n${timestamp}`;
+    const signature = crypto
+        .sign(null, Buffer.from(message, 'utf8'), key)
+        .toString('base64url');
+    const guildPart = Buffer.from(config.guildId, 'utf8').toString('base64');
+    return `${guildPart}.${timestamp}.${signature}`;
+}
+// Derive the Discord Application ID from a bot token.
+// Discord bot tokens have the format: base64(userId).timestamp.hmac
+// The first segment is the bot's user ID (= Application ID) base64-encoded.
+export function appIdFromToken(token) {
+    const segment = token.split('.')[0];
+    if (!segment) {
+        return undefined;
+    }
+    try {
+        const decoded = Buffer.from(segment, 'base64').toString('utf8');
+        if (/^\d{17,20}$/.test(decoded)) {
+            return decoded;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function hydrateBotTokenCache(botToken) {
+    dbBotToken = botToken;
+}
+export function isAuthModeEnabled() {
+    return resolveAuthModeConfig() !== null;
+}
+export function getBotToken(options = {}) {
+    const { appIdOverride, preferEnv = true, allowDatabase = true } = options;
+    const authMode = resolveAuthModeConfig();
+    if (authMode) {
+        return {
+            token: createAuthModeToken(authMode),
+            appId: appIdOverride || authMode.appId,
+            source: 'auth',
+        };
+    }
+    const envToken = process.env.KIMAKI_BOT_TOKEN;
+    if (preferEnv && envToken) {
+        return {
+            token: envToken,
+            appId: appIdOverride || appIdFromToken(envToken),
+            source: 'env',
+        };
+    }
+    if (!allowDatabase) {
+        return undefined;
+    }
+    const botRow = dbBotToken;
+    if (!botRow) {
+        return undefined;
+    }
+    return {
+        token: botRow.token,
+        appId: appIdOverride || botRow.app_id,
+        source: 'db',
+    };
+}

package/dist/bot-token.test.js

@@ -0,0 +1,134 @@
+import crypto from 'node:crypto';
+import { afterAll, beforeEach, describe, expect, test } from 'vitest';
+import { appIdFromToken, getBotToken, hydrateBotTokenCache, isAuthModeEnabled, } from './bot-token.js';
+const ORIGINAL_BOT_TOKEN = process.env.KIMAKI_BOT_TOKEN;
+const ORIGINAL_GUILD_ID = process.env.KIMAKI_GUILD_ID;
+const ORIGINAL_PRIVATE_KEY = process.env.KIMAKI_PRIVATE_KEY;
+const ORIGINAL_APP_ID = process.env.KIMAKI_APP_ID;
+beforeEach(() => {
+    delete process.env.KIMAKI_BOT_TOKEN;
+    delete process.env.KIMAKI_GUILD_ID;
+    delete process.env.KIMAKI_PRIVATE_KEY;
+    delete process.env.KIMAKI_APP_ID;
+    hydrateBotTokenCache(null);
+});
+afterAll(() => {
+    process.env.KIMAKI_BOT_TOKEN = ORIGINAL_BOT_TOKEN;
+    process.env.KIMAKI_GUILD_ID = ORIGINAL_GUILD_ID;
+    process.env.KIMAKI_PRIVATE_KEY = ORIGINAL_PRIVATE_KEY;
+    process.env.KIMAKI_APP_ID = ORIGINAL_APP_ID;
+});
+describe('appIdFromToken', () => {
+    test('derives app id from valid token format', () => {
+        const token = 'MTQ3Njc0NTc2MzAwOTU5MzM2NQ.anything.anything';
+        expect(appIdFromToken(token)).toBe('1476745763009593365');
+    });
+    test('returns undefined for malformed tokens', () => {
+        expect(appIdFromToken('not-a-token')).toBeUndefined();
+        expect(appIdFromToken('')).toBeUndefined();
+    });
+});
+describe('getBotToken', () => {
+    test('prefers env token over db by default', () => {
+        process.env.KIMAKI_BOT_TOKEN =
+            'MTQ3Njc0NTc2MzAwOTU5MzM2NQ.env.payload';
+        hydrateBotTokenCache({ app_id: 'db-app', token: 'db-token' });
+        const resolved = getBotToken();
+        expect(resolved).toEqual({
+            token: 'MTQ3Njc0NTc2MzAwOTU5MzM2NQ.env.payload',
+            appId: '1476745763009593365',
+            source: 'env',
+        });
+    });
+    test('uses db token when env is absent', () => {
+        delete process.env.KIMAKI_BOT_TOKEN;
+        hydrateBotTokenCache({
+            app_id: '1476745763009593365',
+            token: 'db-token',
+        });
+        const resolved = getBotToken();
+        expect(resolved).toEqual({
+            token: 'db-token',
+            appId: '1476745763009593365',
+            source: 'db',
+        });
+    });
+    test('supports db-only lookup when preferEnv is false', () => {
+        process.env.KIMAKI_BOT_TOKEN = 'env-token';
+        hydrateBotTokenCache({
+            app_id: '1476745763009593365',
+            token: 'db-token',
+        });
+        const resolved = getBotToken({ preferEnv: false });
+        expect(resolved).toEqual({
+            token: 'db-token',
+            appId: '1476745763009593365',
+            source: 'db',
+        });
+    });
+    test('can skip db lookup entirely', () => {
+        delete process.env.KIMAKI_BOT_TOKEN;
+        hydrateBotTokenCache({ app_id: 'x', token: 'y' });
+        const resolved = getBotToken({ allowDatabase: false });
+        expect(resolved).toBeUndefined();
+    });
+    test('applies appId override consistently', () => {
+        process.env.KIMAKI_BOT_TOKEN = 'env-token';
+        const fromEnv = getBotToken({
+            appIdOverride: 'override-app-id',
+            allowDatabase: false,
+        });
+        expect(fromEnv?.appId).toBe('override-app-id');
+        delete process.env.KIMAKI_BOT_TOKEN;
+        hydrateBotTokenCache({
+            app_id: 'db-app',
+            token: 'db-token',
+        });
+        const fromDb = getBotToken({
+            appIdOverride: 'override-app-id',
+        });
+        expect(fromDb?.appId).toBe('override-app-id');
+    });
+    test('auth mode takes precedence over env and db token', () => {
+        const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+        process.env.KIMAKI_GUILD_ID = '1477130736841658398';
+        process.env.KIMAKI_APP_ID = '1476745763009593365';
+        process.env.KIMAKI_PRIVATE_KEY = privateKey
+            .export({ format: 'pem', type: 'pkcs8' })
+            .toString();
+        process.env.KIMAKI_BOT_TOKEN = 'env-token';
+        hydrateBotTokenCache({
+            app_id: 'db-app',
+            token: 'db-token',
+        });
+        const resolved = getBotToken();
+        expect(isAuthModeEnabled()).toBe(true);
+        expect(resolved?.source).toBe('auth');
+        expect(resolved?.appId).toBe('1476745763009593365');
+        expect(resolved?.token.split('.')).toHaveLength(3);
+        const tokenParts = resolved.token.split('.');
+        expect(tokenParts).toHaveLength(3);
+        const guildPart = tokenParts[0];
+        const timestamp = tokenParts[1];
+        const signaturePart = tokenParts[2];
+        const decodedGuildId = Buffer.from(guildPart, 'base64').toString('utf8');
+        expect(decodedGuildId).toBe('1477130736841658398');
+        expect(Number.isNaN(Number.parseInt(timestamp, 10))).toBe(false);
+        const signature = Buffer.from(signaturePart, 'base64url');
+        const verified = crypto.verify(null, Buffer.from(`${decodedGuildId}\n${timestamp}`, 'utf8'), publicKey, signature);
+        expect(verified).toBe(true);
+    });
+    test('auth mode requires all env vars', () => {
+        process.env.KIMAKI_GUILD_ID = '1477130736841658398';
+        delete process.env.KIMAKI_PRIVATE_KEY;
+        process.env.KIMAKI_APP_ID = '1476745763009593365';
+        process.env.KIMAKI_BOT_TOKEN = 'env-token';
+        const resolved = getBotToken();
+        expect(isAuthModeEnabled()).toBe(false);
+        expect(resolved).toEqual({
+            token: 'env-token',
+            appId: undefined,
+            source: 'env',
+        });
+    });
+});

package/dist/channel-management.js

@@ -0,0 +1,101 @@
+// Discord channel and category management.
+// Creates and manages Kimaki project channels (text + voice pairs),
+// extracts channel metadata from topic tags, and ensures category structure.
+import { ChannelType, } from 'discord.js';
+import path from 'node:path';
+import { getChannelDirectory, setChannelDirectory } from './database.js';
+export async function ensureKimakiCategory(guild, botName) {
+    // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
+    const isKimakiBot = botName?.toLowerCase() === 'kimaki';
+    const categoryName = botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki';
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        return channel.name.toLowerCase() === categoryName.toLowerCase();
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: categoryName,
+        type: ChannelType.GuildCategory,
+    });
+}
+export async function ensureKimakiAudioCategory(guild, botName) {
+    // Skip appending bot name if it's already "kimaki" to avoid "Kimaki Audio kimaki"
+    const isKimakiBot = botName?.toLowerCase() === 'kimaki';
+    const categoryName = botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        return channel.name.toLowerCase() === categoryName.toLowerCase();
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: categoryName,
+        type: ChannelType.GuildCategory,
+    });
+}
+export async function createProjectChannels({ guild, projectDirectory, appId, botName, enableVoiceChannels = false, }) {
+    const baseName = path.basename(projectDirectory);
+    const channelName = `${baseName}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .slice(0, 100);
+    const kimakiCategory = await ensureKimakiCategory(guild, botName);
+    const textChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: kimakiCategory,
+        // Channel configuration is stored in SQLite, not in the topic
+    });
+    await setChannelDirectory({
+        channelId: textChannel.id,
+        directory: projectDirectory,
+        channelType: 'text',
+        appId,
+    });
+    let voiceChannelId = null;
+    if (enableVoiceChannels) {
+        const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName);
+        const voiceChannel = await guild.channels.create({
+            name: channelName,
+            type: ChannelType.GuildVoice,
+            parent: kimakiAudioCategory,
+        });
+        await setChannelDirectory({
+            channelId: voiceChannel.id,
+            directory: projectDirectory,
+            channelType: 'voice',
+            appId,
+        });
+        voiceChannelId = voiceChannel.id;
+    }
+    return {
+        textChannelId: textChannel.id,
+        voiceChannelId,
+        channelName,
+    };
+}
+export async function getChannelsWithDescriptions(guild) {
+    const channels = [];
+    const textChannels = guild.channels.cache.filter((channel) => channel.isTextBased());
+    for (const channel of textChannels.values()) {
+        const textChannel = channel;
+        const description = textChannel.topic || null;
+        // Get channel config from database instead of parsing XML from topic
+        const channelConfig = await getChannelDirectory(textChannel.id);
+        channels.push({
+            id: textChannel.id,
+            name: textChannel.name,
+            description,
+            kimakiDirectory: channelConfig?.directory,
+            kimakiApp: channelConfig?.appId || undefined,
+        });
+    }
+    return channels;
+}

package/dist/cli-parsing.test.js

@@ -0,0 +1,89 @@
+// Regression tests for CLI argument parsing around Discord ID string preservation.
+import { describe, expect, test } from 'vitest';
+import { goke } from 'goke';
+function createCliForIdParsing() {
+    const cli = goke('kimaki');
+    cli
+        .command('send', 'Send a message')
+        .option('-c, --channel <channelId>', 'Discord channel ID')
+        .option('--thread <threadId>', 'Thread ID')
+        .option('--session <sessionId>', 'Session ID')
+        .option('--send-at <schedule>', 'Schedule');
+    cli.command('session archive <threadId>', 'Archive a thread');
+    cli
+        .command('session search <query>', 'Search sessions')
+        .option('--channel <channelId>', 'Discord channel ID')
+        .option('--project <path>', 'Project path');
+    cli
+        .command('add-project', 'Add a project')
+        .option('-g, --guild <guildId>', 'Discord guild/server ID');
+    cli.command('task delete <id>', 'Delete task');
+    return cli;
+}
+describe('goke CLI ID parsing', () => {
+    test('keeps large Discord IDs as strings', () => {
+        const cli = createCliForIdParsing();
+        const channelId = '1234567890123456789';
+        const threadId = '9876543210987654321';
+        const sessionId = '1111222233334444555';
+        const channelResult = cli.parse(['node', 'kimaki', 'send', '--channel', channelId], {
+            run: false,
+        });
+        expect(channelResult.options.channel).toBe(channelId);
+        expect(typeof channelResult.options.channel).toBe('string');
+        const threadResult = cli.parse(['node', 'kimaki', 'send', '--thread', threadId], { run: false });
+        expect(threadResult.options.thread).toBe(threadId);
+        expect(typeof threadResult.options.thread).toBe('string');
+        const sessionResult = cli.parse(['node', 'kimaki', 'send', '--session', sessionId], {
+            run: false,
+        });
+        expect(sessionResult.options.session).toBe(sessionId);
+        expect(typeof sessionResult.options.session).toBe('string');
+    });
+    test('preserves leading zeros in Discord IDs', () => {
+        const cli = createCliForIdParsing();
+        const guildId = '001230045600789';
+        const result = cli.parse(['node', 'kimaki', 'add-project', '--guild', guildId], { run: false });
+        expect(result.options.guild).toBe(guildId);
+        expect(typeof result.options.guild).toBe('string');
+    });
+    test('keeps session archive thread ID as string', () => {
+        const cli = createCliForIdParsing();
+        const threadId = '0098765432109876543';
+        const result = cli.parse(['node', 'kimaki', 'session', 'archive', threadId], {
+            run: false,
+        });
+        expect(result.args[0]).toBe(threadId);
+        expect(typeof result.args[0]).toBe('string');
+    });
+    test('keeps session search regex and channel ID as strings', () => {
+        const cli = createCliForIdParsing();
+        const channelId = '0012345678901234567';
+        const query = '/error\\s+42/i';
+        const result = cli.parse(['node', 'kimaki', 'session', 'search', query, '--channel', channelId], {
+            run: false,
+        });
+        expect(result.args[0]).toBe(query);
+        expect(typeof result.args[0]).toBe('string');
+        expect(result.options.channel).toBe(channelId);
+        expect(typeof result.options.channel).toBe('string');
+    });
+    test('keeps --send-at cron string intact', () => {
+        const cli = createCliForIdParsing();
+        const cron = '0 9 * * 1';
+        const result = cli.parse(['node', 'kimaki', 'send', '--send-at', cron], {
+            run: false,
+        });
+        expect(result.options.sendAt).toBe(cron);
+        expect(typeof result.options.sendAt).toBe('string');
+    });
+    test('keeps task delete ID as string before validation', () => {
+        const cli = createCliForIdParsing();
+        const taskId = '0012345';
+        const result = cli.parse(['node', 'kimaki', 'task', 'delete', taskId], {
+            run: false,
+        });
+        expect(result.args[0]).toBe(taskId);
+        expect(typeof result.args[0]).toBe('string');
+    });
+});