@brianli/kimaki 0.4.72-brianli.1

package/dist/commands/context-usage.js

@@ -0,0 +1,140 @@
+// /context-usage command - Show token usage and context window percentage for the current session.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.SESSION);
+function getTokenTotal({ input, output, reasoning, cache, }) {
+    return input + output + reasoning + cache.read + cache.write;
+}
+export async function handleContextUsageCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory, workingDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to get context usage: ${getClient.message}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    try {
+        const messagesResponse = await getClient().session.messages({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        const messages = messagesResponse.data || [];
+        const assistantMessages = messages.filter((m) => m.info.role === 'assistant');
+        if (assistantMessages.length === 0) {
+            await command.editReply({
+                content: 'No assistant messages in this session yet',
+            });
+            return;
+        }
+        const lastAssistant = [...assistantMessages].reverse().find((m) => {
+            if (m.info.role !== 'assistant') {
+                return false;
+            }
+            if (!('tokens' in m.info) || !m.info.tokens) {
+                return false;
+            }
+            return getTokenTotal(m.info.tokens) > 0;
+        });
+        if (!lastAssistant || lastAssistant.info.role !== 'assistant') {
+            await command.editReply({
+                content: 'Token usage not available for this session yet',
+            });
+            return;
+        }
+        const { tokens, modelID, providerID } = lastAssistant.info;
+        const totalTokens = getTokenTotal(tokens);
+        // Sum cost across all assistant messages for accurate session total
+        // (AssistantMessage.cost is per-message, not cumulative)
+        const totalCost = assistantMessages.reduce((sum, m) => {
+            if (m.info.role === 'assistant' && 'cost' in m.info) {
+                return sum + (m.info.cost || 0);
+            }
+            return sum;
+        }, 0);
+        // Fetch model context limit from provider API
+        let contextLimit;
+        const providersResult = await errore.tryAsync(() => {
+            return getClient().provider.list({ directory: workingDirectory });
+        });
+        if (providersResult instanceof Error) {
+            logger.error('[CONTEXT-USAGE] Failed to fetch provider info:', providersResult);
+        }
+        else {
+            const provider = providersResult.data?.all?.find((p) => p.id === providerID);
+            const model = provider?.models?.[modelID];
+            if (model?.limit?.context) {
+                contextLimit = model.limit.context;
+            }
+        }
+        const formattedTokens = totalTokens.toLocaleString('en-US');
+        const formattedCost = totalCost > 0 ? `$${totalCost.toFixed(4)}` : '$0.00';
+        const lines = [];
+        if (contextLimit) {
+            const percentage = Math.round((totalTokens / contextLimit) * 100);
+            const formattedLimit = contextLimit.toLocaleString('en-US');
+            lines.push(`**Context usage:** ${percentage}%, ${formattedTokens} / ${formattedLimit} tokens`);
+        }
+        else {
+            lines.push(`**Context usage:** ${formattedTokens} tokens (context limit unavailable)`);
+        }
+        if (modelID) {
+            lines.push(`**Model:** ${modelID}`);
+        }
+        if (totalCost > 0) {
+            lines.push(`**Session cost:** ${formattedCost}`);
+        }
+        await command.editReply({ content: lines.join('\n') });
+        logger.log(`Context usage shown for session ${sessionId}: ${totalTokens} tokens`);
+    }
+    catch (error) {
+        logger.error('[CONTEXT-USAGE] Error:', error);
+        await command.editReply({
+            content: `Failed to get context usage: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}

package/dist/commands/create-new-project.js

@@ -0,0 +1,118 @@
+// /create-new-project command - Create a new project folder, initialize git, and start a session.
+// Also exports createNewProject() for reuse during onboarding (welcome channel creation).
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { getProjectsDir } from '../config.js';
+import { createProjectChannels } from '../channel-management.js';
+import { handleOpencodeSession } from '../session-handler.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.CREATE_PROJECT);
+/**
+ * Core project creation logic: creates directory, inits git, creates Discord channels.
+ * Reused by the slash command handler and by onboarding (welcome channel).
+ * Returns null if the project directory already exists.
+ */
+export async function createNewProject({ guild, projectName, appId, botName, }) {
+    const sanitizedName = projectName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100);
+    if (!sanitizedName) {
+        return null;
+    }
+    const projectsDir = getProjectsDir();
+    const projectDirectory = path.join(projectsDir, sanitizedName);
+    if (!fs.existsSync(projectsDir)) {
+        fs.mkdirSync(projectsDir, { recursive: true });
+        logger.log(`Created projects directory: ${projectsDir}`);
+    }
+    if (fs.existsSync(projectDirectory)) {
+        return null;
+    }
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    logger.log(`Created project directory: ${projectDirectory}`);
+    execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
+    logger.log(`Initialized git in: ${projectDirectory}`);
+    const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+        guild,
+        projectDirectory,
+        appId,
+        botName,
+    });
+    return {
+        textChannelId,
+        voiceChannelId,
+        channelName,
+        projectDirectory,
+        sanitizedName,
+    };
+}
+export async function handleCreateNewProjectCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const projectName = command.options.getString('name', true);
+    const guild = command.guild;
+    const channel = command.channel;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in a text channel');
+        return;
+    }
+    try {
+        const result = await createNewProject({
+            guild,
+            projectName,
+            appId,
+            botName: command.client.user?.username,
+        });
+        if (!result) {
+            const sanitizedName = projectName
+                .toLowerCase()
+                .replace(/[^a-z0-9-]/g, '-')
+                .replace(/-+/g, '-')
+                .replace(/^-|-$/g, '')
+                .slice(0, 100);
+            if (!sanitizedName) {
+                await command.editReply('Invalid project name');
+                return;
+            }
+            const projectDirectory = path.join(getProjectsDir(), sanitizedName);
+            await command.editReply(`Project directory already exists: ${projectDirectory}`);
+            return;
+        }
+        const { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName, } = result;
+        const textChannel = (await guild.channels.fetch(textChannelId));
+        const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : '';
+        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>${voiceInfo}\n_Starting session..._`);
+        const starterMessage = await textChannel.send({
+            content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const thread = await starterMessage.startThread({
+            name: `Init: ${sanitizedName}`,
+            autoArchiveDuration: 1440,
+            reason: 'New project session',
+        });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
+        await handleOpencodeSession({
+            prompt: 'The project was just initialized. Say hi and ask what the user wants to build.',
+            thread,
+            projectDirectory,
+            channelId: textChannel.id,
+            appId,
+        });
+        logger.log(`Created new project ${channelName} at ${projectDirectory}`);
+    }
+    catch (error) {
+        logger.error('[CREATE-NEW-PROJECT] Error:', error);
+        await command.editReply(`Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/diff.js

@@ -0,0 +1,128 @@
+// /diff command - Show git diff as a shareable URL.
+import { ChannelType, EmbedBuilder, MessageFlags, } from 'discord.js';
+import path from 'node:path';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { execAsync } from '../worktree-utils.js';
+const logger = createLogger(LogPrefix.DIFF);
+export async function handleDiffCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const isTextChannel = channel.type === ChannelType.GuildText;
+    if (!isThread && !isTextChannel) {
+        await command.reply({
+            content: 'This command can only be used in a text channel or thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { workingDirectory } = resolved;
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    try {
+        const projectName = path.basename(workingDirectory);
+        const title = `${projectName}: Discord /diff`;
+        const { stdout, stderr } = await execAsync(`bunx critique --web "${title}" --json`, {
+            cwd: workingDirectory,
+            timeout: 30000,
+        });
+        // critique --json outputs JSON on the last line: {"url":"...","id":"..."} or {"error":"..."}
+        const output = stdout || stderr;
+        const lines = output.trim().split('\n');
+        const jsonLine = lines[lines.length - 1];
+        if (!jsonLine) {
+            await command.editReply({
+                content: 'No changes to show',
+            });
+            return;
+        }
+        let result;
+        try {
+            result = JSON.parse(jsonLine);
+        }
+        catch {
+            // Fallback: try to find URL in output
+            const urlMatch = output.match(/https?:\/\/critique\.work\/[^\s]+/);
+            if (urlMatch) {
+                await command.editReply({
+                    content: `[diff](${urlMatch[0]})`,
+                });
+                logger.log(`Diff shared: ${urlMatch[0]}`);
+                return;
+            }
+            await command.editReply({
+                content: 'No changes to show',
+            });
+            return;
+        }
+        if (result.error || !result.url || !result.id) {
+            await command.editReply({
+                content: result.error || 'No changes to show',
+            });
+            return;
+        }
+        const imageUrl = `https://critique.work/og/${result.id}.png`;
+        const embed = new EmbedBuilder()
+            .setTitle(title)
+            .setURL(result.url)
+            .setImage(imageUrl);
+        await command.editReply({
+            embeds: [embed],
+        });
+        logger.log(`Diff shared: ${result.url}`);
+    }
+    catch (error) {
+        logger.error('[DIFF] Error:', error);
+        // exec error includes stdout/stderr - try to parse JSON from it
+        const execError = error;
+        const output = execError.stdout || execError.stderr || '';
+        // Check if critique output JSON even on error
+        const lines = output.trim().split('\n');
+        const jsonLine = lines[lines.length - 1];
+        if (jsonLine) {
+            try {
+                const result = JSON.parse(jsonLine);
+                if (result.error) {
+                    await command.editReply({
+                        content: result.error,
+                    });
+                    return;
+                }
+            }
+            catch {
+                // not JSON, continue to generic error
+            }
+        }
+        // Check for common errors
+        const message = execError.message || 'Unknown error';
+        if (message.includes('command not found') || message.includes('ENOENT')) {
+            await command.editReply({
+                content: 'bunx/critique not available',
+            });
+            return;
+        }
+        await command.editReply({
+            content: `Failed to generate diff: ${message.slice(0, 200)}`,
+        });
+    }
+}

package/dist/commands/file-upload.js

@@ -0,0 +1,275 @@
+// File upload tool handler - Shows Discord modal with FileUploadBuilder.
+// When the AI uses the kimaki_file_upload tool, the plugin inserts a row into
+// the ipc_requests DB table. The bot polls this table, picks up the request,
+// and shows a button in the thread. User clicks it to open a modal with a
+// native file picker. Uploaded files are downloaded to the project directory.
+// The bot writes file paths back to ipc_requests.response, and the plugin
+// polls until the response appears.
+import { ButtonBuilder, ButtonStyle, ActionRowBuilder, ModalBuilder, FileUploadBuilder, LabelBuilder, ComponentType, MessageFlags, } from 'discord.js';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createLogger, LogPrefix } from '../logger.js';
+import { notifyError } from '../sentry.js';
+import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
+const logger = createLogger(LogPrefix.FILE_UPLOAD);
+// 5 minute TTL for pending contexts - if user doesn't click within this time,
+// clean up the context and resolve with empty array to unblock the plugin tool
+const PENDING_TTL_MS = 5 * 60 * 1000;
+export const pendingFileUploadContexts = new Map();
+/**
+ * Sanitize an attachment filename to prevent path traversal.
+ * Strips directory separators, .., and null bytes from the name.
+ * Prepends a short random prefix to avoid collisions between uploads.
+ */
+function sanitizeFilename(name) {
+    // Extract just the base name (strips any directory components)
+    let sanitized = path.basename(name);
+    // Remove null bytes and other dangerous characters
+    sanitized = sanitized.replace(/[\x00]/g, '');
+    // If somehow still empty or just dots, give it a safe name
+    if (!sanitized || sanitized === '.' || sanitized === '..') {
+        sanitized = 'upload';
+    }
+    // Prefix with short random id to avoid collisions
+    const prefix = crypto.randomBytes(4).toString('hex');
+    return `${prefix}-${sanitized}`;
+}
+/**
+ * Safely resolve a pending context exactly once. Prevents double-resolve from
+ * cancel/submit races by checking the `resolved` flag.
+ */
+function resolveContext(context, filePaths) {
+    if (context.resolved) {
+        return false;
+    }
+    context.resolved = true;
+    clearTimeout(context.timer);
+    pendingFileUploadContexts.delete(context.contextHash);
+    context.resolve(filePaths);
+    return true;
+}
+/**
+ * Show a button in the thread that opens a file upload modal when clicked.
+ * Returns a promise that resolves with the downloaded file paths.
+ */
+export function showFileUploadButton({ thread, sessionId, directory, prompt, maxFiles, }) {
+    return new Promise((resolve, reject) => {
+        const contextHash = crypto.randomBytes(8).toString('hex');
+        // TTL timer: auto-cleanup if user never clicks the button
+        const timer = setTimeout(() => {
+            const ctx = pendingFileUploadContexts.get(contextHash);
+            if (ctx && !ctx.resolved) {
+                logger.log(`File upload timed out for session ${sessionId}, hash=${contextHash}`);
+                resolveContext(ctx, []);
+                // Remove button from message
+                if (ctx.messageId) {
+                    ctx.thread.messages
+                        .fetch(ctx.messageId)
+                        .then((msg) => {
+                        return msg.edit({
+                            content: `**File Upload Requested**\n${prompt.slice(0, 1900)}\n_Timed out_`,
+                            components: [],
+                        });
+                    })
+                        .catch(() => { });
+                }
+            }
+        }, PENDING_TTL_MS);
+        const context = {
+            sessionId,
+            directory,
+            thread,
+            prompt,
+            maxFiles,
+            contextHash,
+            resolve,
+            reject,
+            resolved: false,
+            timer,
+        };
+        pendingFileUploadContexts.set(contextHash, context);
+        const uploadButton = new ButtonBuilder()
+            .setCustomId(`file_upload_btn:${contextHash}`)
+            .setLabel('Upload Files')
+            .setStyle(ButtonStyle.Primary);
+        const actionRow = new ActionRowBuilder().addComponents(uploadButton);
+        thread
+            .send({
+            content: `**File Upload Requested**\n${prompt.slice(0, 1900)}`,
+            components: [actionRow],
+            flags: NOTIFY_MESSAGE_FLAGS,
+        })
+            .then((msg) => {
+            context.messageId = msg.id;
+            logger.log(`Showed file upload button for session ${sessionId}, hash=${contextHash}`);
+        })
+            .catch((err) => {
+            clearTimeout(timer);
+            pendingFileUploadContexts.delete(contextHash);
+            reject(new Error('Failed to send file upload button', { cause: err }));
+        });
+    });
+}
+/**
+ * Handle the file upload button click - opens a modal with FileUploadBuilder.
+ */
+export async function handleFileUploadButton(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('file_upload_btn:')) {
+        return;
+    }
+    const contextHash = customId.replace('file_upload_btn:', '');
+    const context = pendingFileUploadContexts.get(contextHash);
+    if (!context || context.resolved) {
+        await interaction.reply({
+            content: 'This file upload request has expired.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const fileUpload = new FileUploadBuilder()
+        .setCustomId('uploaded_files')
+        .setMinValues(1)
+        .setMaxValues(context.maxFiles);
+    const label = new LabelBuilder()
+        .setLabel('Files')
+        .setDescription(context.prompt.slice(0, 100))
+        .setFileUploadComponent(fileUpload);
+    const modal = new ModalBuilder()
+        .setCustomId(`file_upload_modal:${contextHash}`)
+        .setTitle('Upload Files')
+        .addLabelComponents(label);
+    await interaction.showModal(modal);
+}
+/**
+ * Handle the modal submission - download files and resolve the pending promise.
+ */
+export async function handleFileUploadModalSubmit(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('file_upload_modal:')) {
+        return;
+    }
+    const contextHash = customId.replace('file_upload_modal:', '');
+    const context = pendingFileUploadContexts.get(contextHash);
+    if (!context || context.resolved) {
+        await interaction.reply({
+            content: 'This file upload request has expired.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    try {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+        // File upload data is nested in the LabelModalData -> FileUploadModalData
+        const fileField = interaction.fields.getField('uploaded_files', ComponentType.FileUpload);
+        const attachments = fileField.attachments;
+        if (!attachments || attachments.size === 0) {
+            await interaction.editReply({ content: 'No files were uploaded.' });
+            updateButtonMessage(context, '_No files uploaded_');
+            resolveContext(context, []);
+            return;
+        }
+        const uploadsDir = path.join(context.directory, 'uploads');
+        fs.mkdirSync(uploadsDir, { recursive: true });
+        const downloadedPaths = [];
+        const errors = [];
+        for (const [, attachment] of attachments) {
+            // Check if context was cancelled (e.g. user sent new message) while
+            // we were downloading previous files - stop downloading more
+            if (context.resolved) {
+                break;
+            }
+            try {
+                const response = await fetch(attachment.url);
+                if (!response.ok) {
+                    errors.push(`Failed to download ${attachment.name}: HTTP ${response.status}`);
+                    continue;
+                }
+                const buffer = Buffer.from(await response.arrayBuffer());
+                const safeName = sanitizeFilename(attachment.name);
+                const filePath = path.join(uploadsDir, safeName);
+                fs.writeFileSync(filePath, buffer);
+                downloadedPaths.push(filePath);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                errors.push(`Failed to download ${attachment.name}: ${msg}`);
+            }
+        }
+        // If context was resolved by cancel/timeout during download, don't try to
+        // resolve again - just update the ephemeral reply
+        if (context.resolved) {
+            await interaction.editReply({ content: 'Upload was cancelled.' });
+            return;
+        }
+        const fileNames = downloadedPaths.map((p) => {
+            return path.basename(p);
+        });
+        updateButtonMessage(context, downloadedPaths.length > 0
+            ? `Uploaded: ${fileNames.join(', ')}`
+            : '_Upload failed_');
+        const summary = (() => {
+            if (downloadedPaths.length > 0 && errors.length === 0) {
+                return `Uploaded ${downloadedPaths.length} file(s) successfully.`;
+            }
+            if (downloadedPaths.length > 0 && errors.length > 0) {
+                return `Uploaded ${downloadedPaths.length} file(s). Errors: ${errors.join('; ')}`;
+            }
+            return `Upload failed: ${errors.join('; ')}`;
+        })();
+        await interaction.editReply({ content: summary });
+        resolveContext(context, downloadedPaths);
+        logger.log(`File upload completed for session ${context.sessionId}: ${downloadedPaths.length} files`);
+    }
+    catch (err) {
+        // Ensure context is always resolved even on unexpected errors
+        // so the plugin tool doesn't hang indefinitely
+        logger.error('Error in file upload modal submit:', err);
+        void notifyError(err, 'File upload modal submit error');
+        resolveContext(context, []);
+    }
+}
+/**
+ * Best-effort update of the original button message (remove button, append status).
+ */
+function updateButtonMessage(context, status) {
+    if (!context.messageId) {
+        return;
+    }
+    context.thread.messages
+        .fetch(context.messageId)
+        .then((msg) => {
+        return msg.edit({
+            content: `**File Upload Requested**\n${context.prompt.slice(0, 1900)}\n${status}`,
+            components: [],
+        });
+    })
+        .catch(() => { });
+}
+/**
+ * Cancel ALL pending file uploads for a thread (e.g. when user sends a new message).
+ */
+export async function cancelPendingFileUpload(threadId) {
+    const toCancel = [];
+    for (const [, ctx] of pendingFileUploadContexts) {
+        if (ctx.thread.id === threadId) {
+            toCancel.push(ctx);
+        }
+    }
+    if (toCancel.length === 0) {
+        return false;
+    }
+    let cancelled = 0;
+    for (const context of toCancel) {
+        const didResolve = resolveContext(context, []);
+        if (didResolve) {
+            updateButtonMessage(context, '_Cancelled - user sent a new message_');
+            cancelled++;
+        }
+    }
+    if (cancelled > 0) {
+        logger.log(`Cancelled ${cancelled} file upload(s) for thread ${threadId}`);
+    }
+    return cancelled > 0;
+}