kimaki 0.4.22 → 0.4.23

package/dist/channel-management.js

@@ -0,0 +1,92 @@
+import { ChannelType, } from 'discord.js';
+import path from 'node:path';
+import { getDatabase } from './database.js';
+import { extractTagsArrays } from './xml.js';
+export async function ensureKimakiCategory(guild) {
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        return channel.name.toLowerCase() === 'kimaki';
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: 'Kimaki',
+        type: ChannelType.GuildCategory,
+    });
+}
+export async function ensureKimakiAudioCategory(guild) {
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        return channel.name.toLowerCase() === 'kimaki audio';
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: 'Kimaki Audio',
+        type: ChannelType.GuildCategory,
+    });
+}
+export async function createProjectChannels({ guild, projectDirectory, appId, }) {
+    const baseName = path.basename(projectDirectory);
+    const channelName = `${baseName}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .slice(0, 100);
+    const kimakiCategory = await ensureKimakiCategory(guild);
+    const kimakiAudioCategory = await ensureKimakiAudioCategory(guild);
+    const textChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: kimakiCategory,
+        topic: `<kimaki><directory>${projectDirectory}</directory><app>${appId}</app></kimaki>`,
+    });
+    const voiceChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildVoice,
+        parent: kimakiAudioCategory,
+    });
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)')
+        .run(textChannel.id, projectDirectory, 'text');
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)')
+        .run(voiceChannel.id, projectDirectory, 'voice');
+    return {
+        textChannelId: textChannel.id,
+        voiceChannelId: voiceChannel.id,
+        channelName,
+    };
+}
+export async function getChannelsWithDescriptions(guild) {
+    const channels = [];
+    guild.channels.cache
+        .filter((channel) => channel.isTextBased())
+        .forEach((channel) => {
+        const textChannel = channel;
+        const description = textChannel.topic || null;
+        let kimakiDirectory;
+        let kimakiApp;
+        if (description) {
+            const extracted = extractTagsArrays({
+                xml: description,
+                tags: ['kimaki.directory', 'kimaki.app'],
+            });
+            kimakiDirectory = extracted['kimaki.directory']?.[0]?.trim();
+            kimakiApp = extracted['kimaki.app']?.[0]?.trim();
+        }
+        channels.push({
+            id: textChannel.id,
+            name: textChannel.name,
+            description,
+            kimakiDirectory,
+            kimakiApp,
+        });
+    });
+    return channels;
+}

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { cac } from 'cac';
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl } from './utils.js';
-import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discordBot.js';
+import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discord-bot.js';
 import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuilder, } from 'discord.js';
 import path from 'node:path';
 import fs from 'node:fs';
@@ -117,6 +117,14 @@ async function registerCommands(token, appId) {
             .setName('share')
             .setDescription('Share the current session as a public URL')
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('fork')
+            .setDescription('Fork the session from a past user message')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('model')
+            .setDescription('Set the preferred model for this channel or session')
+            .toJSON(),
     ];
     const rest = new REST().setToken(token);
     try {

package/dist/database.js

@@ -0,0 +1,130 @@
+import Database from 'better-sqlite3';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createLogger } from './logger.js';
+const dbLogger = createLogger('DB');
+let db = null;
+export function getDatabase() {
+    if (!db) {
+        const kimakiDir = path.join(os.homedir(), '.kimaki');
+        try {
+            fs.mkdirSync(kimakiDir, { recursive: true });
+        }
+        catch (error) {
+            dbLogger.error('Failed to create ~/.kimaki directory:', error);
+        }
+        const dbPath = path.join(kimakiDir, 'discord-sessions.db');
+        dbLogger.log(`Opening database at: ${dbPath}`);
+        db = new Database(dbPath);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_sessions (
+        thread_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS part_messages (
+        part_id TEXT PRIMARY KEY,
+        message_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS bot_tokens (
+        app_id TEXT PRIMARY KEY,
+        token TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS channel_directories (
+        channel_id TEXT PRIMARY KEY,
+        directory TEXT NOT NULL,
+        channel_type TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS bot_api_keys (
+        app_id TEXT PRIMARY KEY,
+        gemini_api_key TEXT,
+        xai_api_key TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        runModelMigrations(db);
+    }
+    return db;
+}
+/**
+ * Run migrations for model preferences tables.
+ * Called on startup and can be called on-demand.
+ */
+export function runModelMigrations(database) {
+    const targetDb = database || getDatabase();
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_models (
+      channel_id TEXT PRIMARY KEY,
+      model_id TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS session_models (
+      session_id TEXT PRIMARY KEY,
+      model_id TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    dbLogger.log('Model preferences migrations complete');
+}
+/**
+ * Get the model preference for a channel.
+ * @returns Model ID in format "provider_id/model_id" or undefined
+ */
+export function getChannelModel(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT model_id FROM channel_models WHERE channel_id = ?')
+        .get(channelId);
+    return row?.model_id;
+}
+/**
+ * Set the model preference for a channel.
+ * @param modelId Model ID in format "provider_id/model_id"
+ */
+export function setChannelModel(channelId, modelId) {
+    const db = getDatabase();
+    db.prepare(`INSERT INTO channel_models (channel_id, model_id, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET model_id = ?, updated_at = CURRENT_TIMESTAMP`).run(channelId, modelId, modelId);
+}
+/**
+ * Get the model preference for a session.
+ * @returns Model ID in format "provider_id/model_id" or undefined
+ */
+export function getSessionModel(sessionId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT model_id FROM session_models WHERE session_id = ?')
+        .get(sessionId);
+    return row?.model_id;
+}
+/**
+ * Set the model preference for a session.
+ * @param modelId Model ID in format "provider_id/model_id"
+ */
+export function setSessionModel(sessionId, modelId) {
+    const db = getDatabase();
+    db.prepare(`INSERT OR REPLACE INTO session_models (session_id, model_id) VALUES (?, ?)`).run(sessionId, modelId);
+}
+export function closeDatabase() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}

package/dist/discord-bot.js

@@ -0,0 +1,381 @@
+import { getDatabase, closeDatabase } from './database.js';
+import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
+import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
+import { getOpencodeSystemMessage } from './system-message.js';
+import { getFileAttachments, getTextAttachments } from './message-formatting.js';
+import { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions, } from './channel-management.js';
+import { voiceConnections, cleanupVoiceConnection, processVoiceAttachment, registerVoiceStateHandler, } from './voice-handler.js';
+import { handleOpencodeSession, parseSlashCommand, } from './session-handler.js';
+import { registerInteractionHandler } from './interaction-handler.js';
+export { getDatabase, closeDatabase } from './database.js';
+export { initializeOpencodeForDirectory } from './opencode.js';
+export { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discord-utils.js';
+export { getOpencodeSystemMessage } from './system-message.js';
+export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions } from './channel-management.js';
+import { ChannelType, Client, Events, GatewayIntentBits, Partials, PermissionsBitField, ThreadAutoArchiveDuration, } from 'discord.js';
+import fs from 'node:fs';
+import { extractTagsArrays } from './xml.js';
+import { createLogger } from './logger.js';
+import { setGlobalDispatcher, Agent } from 'undici';
+setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }));
+const discordLogger = createLogger('DISCORD');
+const voiceLogger = createLogger('VOICE');
+export async function createDiscordClient() {
+    return new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildVoiceStates,
+        ],
+        partials: [
+            Partials.Channel,
+            Partials.Message,
+            Partials.User,
+            Partials.ThreadMember,
+        ],
+    });
+}
+export async function startDiscordBot({ token, appId, discordClient, }) {
+    if (!discordClient) {
+        discordClient = await createDiscordClient();
+    }
+    let currentAppId = appId;
+    const setupHandlers = async (c) => {
+        discordLogger.log(`Discord bot logged in as ${c.user.tag}`);
+        discordLogger.log(`Connected to ${c.guilds.cache.size} guild(s)`);
+        discordLogger.log(`Bot user ID: ${c.user.id}`);
+        if (!currentAppId) {
+            await c.application?.fetch();
+            currentAppId = c.application?.id;
+            if (!currentAppId) {
+                discordLogger.error('Could not get application ID');
+                throw new Error('Failed to get bot application ID');
+            }
+            discordLogger.log(`Bot Application ID (fetched): ${currentAppId}`);
+        }
+        else {
+            discordLogger.log(`Bot Application ID (provided): ${currentAppId}`);
+        }
+        for (const guild of c.guilds.cache.values()) {
+            discordLogger.log(`${guild.name} (${guild.id})`);
+            const channels = await getChannelsWithDescriptions(guild);
+            const kimakiChannels = channels.filter((ch) => ch.kimakiDirectory &&
+                (!ch.kimakiApp || ch.kimakiApp === currentAppId));
+            if (kimakiChannels.length > 0) {
+                discordLogger.log(`  Found ${kimakiChannels.length} channel(s) for this bot:`);
+                for (const channel of kimakiChannels) {
+                    discordLogger.log(`  - #${channel.name}: ${channel.kimakiDirectory}`);
+                }
+            }
+            else {
+                discordLogger.log(`  No channels for this bot`);
+            }
+        }
+        voiceLogger.log(`[READY] Bot is ready and will only respond to channels with app ID: ${currentAppId}`);
+        registerInteractionHandler({ discordClient: c, appId: currentAppId });
+        registerVoiceStateHandler({ discordClient: c, appId: currentAppId });
+    };
+    // If client is already ready (was logged in before being passed to us),
+    // run setup immediately. Otherwise wait for the ClientReady event.
+    if (discordClient.isReady()) {
+        await setupHandlers(discordClient);
+    }
+    else {
+        discordClient.once(Events.ClientReady, setupHandlers);
+    }
+    discordClient.on(Events.MessageCreate, async (message) => {
+        try {
+            if (message.author?.bot) {
+                return;
+            }
+            if (message.partial) {
+                discordLogger.log(`Fetching partial message ${message.id}`);
+                try {
+                    await message.fetch();
+                }
+                catch (error) {
+                    discordLogger.log(`Failed to fetch partial message ${message.id}:`, error);
+                    return;
+                }
+            }
+            if (message.guild && message.member) {
+                const isOwner = message.member.id === message.guild.ownerId;
+                const isAdmin = message.member.permissions.has(PermissionsBitField.Flags.Administrator);
+                const canManageServer = message.member.permissions.has(PermissionsBitField.Flags.ManageGuild);
+                const hasKimakiRole = message.member.roles.cache.some((role) => role.name.toLowerCase() === 'kimaki');
+                if (!isOwner && !isAdmin && !canManageServer && !hasKimakiRole) {
+                    await message.react('🔒');
+                    return;
+                }
+            }
+            const channel = message.channel;
+            const isThread = [
+                ChannelType.PublicThread,
+                ChannelType.PrivateThread,
+                ChannelType.AnnouncementThread,
+            ].includes(channel.type);
+            if (isThread) {
+                const thread = channel;
+                discordLogger.log(`Message in thread ${thread.name} (${thread.id})`);
+                const row = getDatabase()
+                    .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+                    .get(thread.id);
+                if (!row) {
+                    discordLogger.log(`No session found for thread ${thread.id}`);
+                    return;
+                }
+                voiceLogger.log(`[SESSION] Found session ${row.session_id} for thread ${thread.id}`);
+                const parent = thread.parent;
+                let projectDirectory;
+                let channelAppId;
+                if (parent?.topic) {
+                    const extracted = extractTagsArrays({
+                        xml: parent.topic,
+                        tags: ['kimaki.directory', 'kimaki.app'],
+                    });
+                    projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+                    channelAppId = extracted['kimaki.app']?.[0]?.trim();
+                }
+                if (channelAppId && channelAppId !== currentAppId) {
+                    voiceLogger.log(`[IGNORED] Thread belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`);
+                    return;
+                }
+                if (projectDirectory && !fs.existsSync(projectDirectory)) {
+                    discordLogger.error(`Directory does not exist: ${projectDirectory}`);
+                    await message.reply({
+                        content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory)}`,
+                        flags: SILENT_MESSAGE_FLAGS,
+                    });
+                    return;
+                }
+                let messageContent = message.content || '';
+                let sessionMessagesText;
+                if (projectDirectory && row.session_id) {
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                        const messagesResponse = await getClient().session.messages({
+                            path: { id: row.session_id },
+                        });
+                        const messages = messagesResponse.data || [];
+                        const recentMessages = messages.slice(-10);
+                        sessionMessagesText = recentMessages
+                            .map((m) => {
+                            const role = m.info.role === 'user' ? 'User' : 'Assistant';
+                            const text = (() => {
+                                if (m.info.role === 'user') {
+                                    const textParts = (m.parts || []).filter((p) => p.type === 'text');
+                                    return textParts
+                                        .map((p) => ('text' in p ? p.text : ''))
+                                        .filter(Boolean)
+                                        .join('\n');
+                                }
+                                const assistantInfo = m.info;
+                                return assistantInfo.text?.slice(0, 500);
+                            })();
+                            return `[${role}]: ${text || '(no text)'}`;
+                        })
+                            .join('\n\n');
+                    }
+                    catch (e) {
+                        voiceLogger.log(`Could not get session messages:`, e);
+                    }
+                }
+                const transcription = await processVoiceAttachment({
+                    message,
+                    thread,
+                    projectDirectory,
+                    appId: currentAppId,
+                    sessionMessages: sessionMessagesText,
+                });
+                if (transcription) {
+                    messageContent = transcription;
+                }
+                const fileAttachments = getFileAttachments(message);
+                const textAttachmentsContent = await getTextAttachments(message);
+                const promptWithAttachments = textAttachmentsContent
+                    ? `${messageContent}\n\n${textAttachmentsContent}`
+                    : messageContent;
+                const parsedCommand = parseSlashCommand(messageContent);
+                await handleOpencodeSession({
+                    prompt: promptWithAttachments,
+                    thread,
+                    projectDirectory,
+                    originalMessage: message,
+                    images: fileAttachments,
+                    parsedCommand,
+                    channelId: parent?.id,
+                });
+                return;
+            }
+            if (channel.type === ChannelType.GuildText) {
+                const textChannel = channel;
+                voiceLogger.log(`[GUILD_TEXT] Message in text channel #${textChannel.name} (${textChannel.id})`);
+                if (!textChannel.topic) {
+                    voiceLogger.log(`[IGNORED] Channel #${textChannel.name} has no description`);
+                    return;
+                }
+                const extracted = extractTagsArrays({
+                    xml: textChannel.topic,
+                    tags: ['kimaki.directory', 'kimaki.app'],
+                });
+                const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+                const channelAppId = extracted['kimaki.app']?.[0]?.trim();
+                if (!projectDirectory) {
+                    voiceLogger.log(`[IGNORED] Channel #${textChannel.name} has no kimaki.directory tag`);
+                    return;
+                }
+                if (channelAppId && channelAppId !== currentAppId) {
+                    voiceLogger.log(`[IGNORED] Channel belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`);
+                    return;
+                }
+                discordLogger.log(`DIRECTORY: Found kimaki.directory: ${projectDirectory}`);
+                if (channelAppId) {
+                    discordLogger.log(`APP: Channel app ID: ${channelAppId}`);
+                }
+                if (!fs.existsSync(projectDirectory)) {
+                    discordLogger.error(`Directory does not exist: ${projectDirectory}`);
+                    await message.reply({
+                        content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory)}`,
+                        flags: SILENT_MESSAGE_FLAGS,
+                    });
+                    return;
+                }
+                const hasVoice = message.attachments.some((a) => a.contentType?.startsWith('audio/'));
+                const threadName = hasVoice
+                    ? 'Voice Message'
+                    : message.content?.replace(/\s+/g, ' ').trim() || 'Claude Thread';
+                const thread = await message.startThread({
+                    name: threadName.slice(0, 80),
+                    autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+                    reason: 'Start Claude session',
+                });
+                discordLogger.log(`Created thread "${thread.name}" (${thread.id})`);
+                let messageContent = message.content || '';
+                const transcription = await processVoiceAttachment({
+                    message,
+                    thread,
+                    projectDirectory,
+                    isNewThread: true,
+                    appId: currentAppId,
+                });
+                if (transcription) {
+                    messageContent = transcription;
+                }
+                const fileAttachments = getFileAttachments(message);
+                const textAttachmentsContent = await getTextAttachments(message);
+                const promptWithAttachments = textAttachmentsContent
+                    ? `${messageContent}\n\n${textAttachmentsContent}`
+                    : messageContent;
+                const parsedCommand = parseSlashCommand(messageContent);
+                await handleOpencodeSession({
+                    prompt: promptWithAttachments,
+                    thread,
+                    projectDirectory,
+                    originalMessage: message,
+                    images: fileAttachments,
+                    parsedCommand,
+                    channelId: textChannel.id,
+                });
+            }
+            else {
+                discordLogger.log(`Channel type ${channel.type} is not supported`);
+            }
+        }
+        catch (error) {
+            voiceLogger.error('Discord handler error:', error);
+            try {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                await message.reply({ content: `Error: ${errMsg}`, flags: SILENT_MESSAGE_FLAGS });
+            }
+            catch {
+                voiceLogger.error('Discord handler error (fallback):', error);
+            }
+        }
+    });
+    await discordClient.login(token);
+    const handleShutdown = async (signal, { skipExit = false } = {}) => {
+        discordLogger.log(`Received ${signal}, cleaning up...`);
+        if (global.shuttingDown) {
+            discordLogger.log('Already shutting down, ignoring duplicate signal');
+            return;
+        }
+        ;
+        global.shuttingDown = true;
+        try {
+            const cleanupPromises = [];
+            for (const [guildId] of voiceConnections) {
+                voiceLogger.log(`[SHUTDOWN] Cleaning up voice connection for guild ${guildId}`);
+                cleanupPromises.push(cleanupVoiceConnection(guildId));
+            }
+            if (cleanupPromises.length > 0) {
+                voiceLogger.log(`[SHUTDOWN] Waiting for ${cleanupPromises.length} voice connection(s) to clean up...`);
+                await Promise.allSettled(cleanupPromises);
+                discordLogger.log(`All voice connections cleaned up`);
+            }
+            for (const [dir, server] of getOpencodeServers()) {
+                if (!server.process.killed) {
+                    voiceLogger.log(`[SHUTDOWN] Stopping OpenCode server on port ${server.port} for ${dir}`);
+                    server.process.kill('SIGTERM');
+                }
+            }
+            getOpencodeServers().clear();
+            discordLogger.log('Closing database...');
+            closeDatabase();
+            discordLogger.log('Destroying Discord client...');
+            discordClient.destroy();
+            discordLogger.log('Cleanup complete.');
+            if (!skipExit) {
+                process.exit(0);
+            }
+        }
+        catch (error) {
+            voiceLogger.error('[SHUTDOWN] Error during cleanup:', error);
+            if (!skipExit) {
+                process.exit(1);
+            }
+        }
+    };
+    process.on('SIGTERM', async () => {
+        try {
+            await handleShutdown('SIGTERM');
+        }
+        catch (error) {
+            voiceLogger.error('[SIGTERM] Error during shutdown:', error);
+            process.exit(1);
+        }
+    });
+    process.on('SIGINT', async () => {
+        try {
+            await handleShutdown('SIGINT');
+        }
+        catch (error) {
+            voiceLogger.error('[SIGINT] Error during shutdown:', error);
+            process.exit(1);
+        }
+    });
+    process.on('SIGUSR2', async () => {
+        discordLogger.log('Received SIGUSR2, restarting after cleanup...');
+        try {
+            await handleShutdown('SIGUSR2', { skipExit: true });
+        }
+        catch (error) {
+            voiceLogger.error('[SIGUSR2] Error during shutdown:', error);
+        }
+        const { spawn } = await import('node:child_process');
+        spawn(process.argv[0], [...process.execArgv, ...process.argv.slice(1)], {
+            stdio: 'inherit',
+            detached: true,
+            cwd: process.cwd(),
+            env: process.env,
+        }).unref();
+        process.exit(0);
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+        if (global.shuttingDown) {
+            discordLogger.log('Ignoring unhandled rejection during shutdown:', reason);
+            return;
+        }
+        discordLogger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    });
+}