kimaki 0.4.39 → 0.4.40

package/dist/errors.js

@@ -1,110 +1,109 @@
 // TaggedError definitions for type-safe error handling with errore.
 // Errors are grouped by category: infrastructure, domain, and validation.
 // Use errore.matchError() for exhaustive error handling in command handlers.
-import * as errore from 'errore';
+import { createTaggedError } from 'errore';
 // ═══════════════════════════════════════════════════════════════════════════
 // INFRASTRUCTURE ERRORS - Server, filesystem, external services
 // ═══════════════════════════════════════════════════════════════════════════
-export class DirectoryNotAccessibleError extends errore.TaggedError('DirectoryNotAccessibleError')() {
-    constructor(args) {
-        super({ ...args, message: `Directory does not exist or is not accessible: ${args.directory}` });
-    }
-}
-export class ServerStartError extends errore.TaggedError('ServerStartError')() {
-    constructor(args) {
-        super({ ...args, message: `Server failed to start on port ${args.port}: ${args.reason}` });
-    }
-}
-export class ServerNotFoundError extends errore.TaggedError('ServerNotFoundError')() {
-    constructor(args) {
-        super({ ...args, message: `OpenCode server not found for directory: ${args.directory}` });
-    }
-}
-export class ServerNotReadyError extends errore.TaggedError('ServerNotReadyError')() {
-    constructor(args) {
-        super({
-            ...args,
-            message: `OpenCode server for directory "${args.directory}" is in an error state (no client available)`,
-        });
-    }
-}
-export class ApiKeyMissingError extends errore.TaggedError('ApiKeyMissingError')() {
-    constructor(args) {
-        super({ ...args, message: `${args.service} API key is required` });
-    }
+export class DirectoryNotAccessibleError extends createTaggedError({
+    name: 'DirectoryNotAccessibleError',
+    message: 'Directory does not exist or is not accessible: $directory',
+}) {
+}
+export class ServerStartError extends createTaggedError({
+    name: 'ServerStartError',
+    message: 'Server failed to start on port $port: $reason',
+}) {
+}
+export class ServerNotFoundError extends createTaggedError({
+    name: 'ServerNotFoundError',
+    message: 'OpenCode server not found for directory: $directory',
+}) {
+}
+export class ServerNotReadyError extends createTaggedError({
+    name: 'ServerNotReadyError',
+    message: 'OpenCode server for directory "$directory" is in an error state (no client available)',
+}) {
+}
+export class ApiKeyMissingError extends createTaggedError({
+    name: 'ApiKeyMissingError',
+    message: '$service API key is required',
+}) {
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // DOMAIN ERRORS - Sessions, messages, transcription
 // ═══════════════════════════════════════════════════════════════════════════
-export class SessionNotFoundError extends errore.TaggedError('SessionNotFoundError')() {
-    constructor(args) {
-        super({ ...args, message: `Session ${args.sessionId} not found` });
-    }
-}
-export class SessionCreateError extends errore.TaggedError('SessionCreateError')() {
-}
-export class MessagesNotFoundError extends errore.TaggedError('MessagesNotFoundError')() {
-    constructor(args) {
-        super({ ...args, message: `No messages found for session ${args.sessionId}` });
-    }
-}
-export class TranscriptionError extends errore.TaggedError('TranscriptionError')() {
-    constructor(args) {
-        super({ ...args, message: `Transcription failed: ${args.reason}` });
-    }
-}
-export class GrepSearchError extends errore.TaggedError('GrepSearchError')() {
-    constructor(args) {
-        super({ ...args, message: `Grep search failed for pattern: ${args.pattern}` });
-    }
-}
-export class GlobSearchError extends errore.TaggedError('GlobSearchError')() {
-    constructor(args) {
-        super({ ...args, message: `Glob search failed for pattern: ${args.pattern}` });
-    }
+export class SessionNotFoundError extends createTaggedError({
+    name: 'SessionNotFoundError',
+    message: 'Session $sessionId not found',
+}) {
+}
+export class SessionCreateError extends createTaggedError({
+    name: 'SessionCreateError',
+    message: '$message',
+}) {
+}
+export class MessagesNotFoundError extends createTaggedError({
+    name: 'MessagesNotFoundError',
+    message: 'No messages found for session $sessionId',
+}) {
+}
+export class TranscriptionError extends createTaggedError({
+    name: 'TranscriptionError',
+    message: 'Transcription failed: $reason',
+}) {
+}
+export class GrepSearchError extends createTaggedError({
+    name: 'GrepSearchError',
+    message: 'Grep search failed for pattern: $pattern',
+}) {
+}
+export class GlobSearchError extends createTaggedError({
+    name: 'GlobSearchError',
+    message: 'Glob search failed for pattern: $pattern',
+}) {
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // VALIDATION ERRORS - Input validation, format checks
 // ═══════════════════════════════════════════════════════════════════════════
-export class InvalidAudioFormatError extends errore.TaggedError('InvalidAudioFormatError')() {
-    constructor() {
-        super({ message: 'Invalid audio format' });
-    }
-}
-export class EmptyTranscriptionError extends errore.TaggedError('EmptyTranscriptionError')() {
-    constructor() {
-        super({ message: 'Model returned empty transcription' });
-    }
-}
-export class NoResponseContentError extends errore.TaggedError('NoResponseContentError')() {
-    constructor() {
-        super({ message: 'No response content from model' });
-    }
-}
-export class NoToolResponseError extends errore.TaggedError('NoToolResponseError')() {
-    constructor() {
-        super({ message: 'No valid tool responses' });
-    }
+export class InvalidAudioFormatError extends createTaggedError({
+    name: 'InvalidAudioFormatError',
+    message: 'Invalid audio format',
+}) {
+}
+export class EmptyTranscriptionError extends createTaggedError({
+    name: 'EmptyTranscriptionError',
+    message: 'Model returned empty transcription',
+}) {
+}
+export class NoResponseContentError extends createTaggedError({
+    name: 'NoResponseContentError',
+    message: 'No response content from model',
+}) {
+}
+export class NoToolResponseError extends createTaggedError({
+    name: 'NoToolResponseError',
+    message: 'No valid tool responses',
+}) {
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // NETWORK ERRORS - Fetch and HTTP
 // ═══════════════════════════════════════════════════════════════════════════
-export class FetchError extends errore.TaggedError('FetchError')() {
-    constructor(args) {
-        const causeMsg = args.cause instanceof Error ? args.cause.message : String(args.cause);
-        super({ ...args, message: `Fetch failed for ${args.url}: ${causeMsg}` });
-    }
+export class FetchError extends createTaggedError({
+    name: 'FetchError',
+    message: 'Fetch failed for $url',
+}) {
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // API ERRORS - External service responses
 // ═══════════════════════════════════════════════════════════════════════════
-export class DiscordApiError extends errore.TaggedError('DiscordApiError')() {
-    constructor(args) {
-        super({ ...args, message: `Discord API error: ${args.status}${args.body ? ` - ${args.body}` : ''}` });
-    }
-}
-export class OpenCodeApiError extends errore.TaggedError('OpenCodeApiError')() {
-    constructor(args) {
-        super({ ...args, message: `OpenCode API error (${args.status})${args.body ? `: ${args.body}` : ''}` });
-    }
+export class DiscordApiError extends createTaggedError({
+    name: 'DiscordApiError',
+    message: 'Discord API error: $status $body',
+}) {
+}
+export class OpenCodeApiError extends createTaggedError({
+    name: 'OpenCodeApiError',
+    message: 'OpenCode API error ($status): $body',
+}) {
 }

package/dist/genai-worker.js

@@ -103,7 +103,7 @@ async function createAssistantAudioLogStream(guildId, channelId) {
         try: () => mkdir(audioDir, { recursive: true }),
         catch: (e) => e,
     });
-    if (errore.isError(mkdirError)) {
+    if (mkdirError instanceof Error) {
         workerLogger.error(`Failed to create audio log directory:`, mkdirError.message);
         return null;
     }

package/dist/interaction-handler.js

@@ -3,6 +3,7 @@
 // and manages autocomplete, select menu interactions for the bot.
 import { Events } from 'discord.js';
 import { handleSessionCommand, handleSessionAutocomplete } from './commands/session.js';
+import { handleNewWorktreeCommand } from './commands/worktree.js';
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js';
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js';
 import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
@@ -30,7 +31,7 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     : 'other'}`);
             if (interaction.isAutocomplete()) {
                 switch (interaction.commandName) {
-                    case 'session':
+                    case 'new-session':
                         await handleSessionAutocomplete({ interaction, appId });
                         return;
                     case 'resume':
@@ -50,9 +51,12 @@ export function registerInteractionHandler({ discordClient, appId, }) {
             if (interaction.isChatInputCommand()) {
                 interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`);
                 switch (interaction.commandName) {
-                    case 'session':
+                    case 'new-session':
                         await handleSessionCommand({ command: interaction, appId });
                         return;
+                    case 'new-worktree':
+                        await handleNewWorktreeCommand({ command: interaction, appId });
+                        return;
                     case 'resume':
                         await handleResumeCommand({ command: interaction, appId });
                         return;

package/dist/markdown.js

@@ -3,13 +3,17 @@
 // user messages, assistant responses, tool calls, and reasoning blocks.
 // Uses errore for type-safe error handling.
 import * as errore from 'errore';
+import { createTaggedError } from 'errore';
 import * as yaml from 'js-yaml';
 import { formatDateTime } from './utils.js';
 import { extractNonXmlContent } from './xml.js';
 import { createLogger } from './logger.js';
 import { SessionNotFoundError, MessagesNotFoundError } from './errors.js';
 // Generic error for unexpected exceptions in async operations
-class UnexpectedError extends errore.TaggedError('UnexpectedError')() {
+class UnexpectedError extends createTaggedError({
+    name: 'UnexpectedError',
+    message: '$message',
+}) {
 }
 const markdownLogger = createLogger('MARKDOWN');
 export class ShareMarkdown {

package/dist/message-formatting.js

@@ -62,7 +62,7 @@ export async function getTextAttachments(message) {
             try: () => fetch(attachment.url),
             catch: (e) => new FetchError({ url: attachment.url, cause: e }),
         });
-        if (errore.isError(response)) {
+        if (response instanceof Error) {
             return `<attachment filename="${attachment.name}" error="${response.message}" />`;
         }
         if (!response.ok) {
@@ -90,7 +90,7 @@ export async function getFileAttachments(message) {
             try: () => fetch(attachment.url),
             catch: (e) => new FetchError({ url: attachment.url, cause: e }),
         });
-        if (errore.isError(response)) {
+        if (response instanceof Error) {
             logger.error(`Error downloading attachment ${attachment.name}:`, response.message);
             return null;
         }

package/dist/opencode.js

@@ -43,7 +43,7 @@ async function waitForServer(port, maxAttempts = 30) {
                 try: () => fetch(endpoint),
                 catch: (e) => new FetchError({ url: endpoint, cause: e }),
             });
-            if (errore.isError(response)) {
+            if (response instanceof Error) {
                 // Connection refused or other transient errors - continue polling
                 opencodeLogger.debug(`Server polling attempt failed: ${response.message}`);
                 continue;
@@ -80,7 +80,7 @@ export async function initializeOpencodeForDirectory(directory) {
         },
         catch: () => new DirectoryNotAccessibleError({ directory }),
     });
-    if (errore.isError(accessCheck)) {
+    if (accessCheck instanceof Error) {
         return accessCheck;
     }
     const port = await getOpenPort();
@@ -125,7 +125,7 @@ export async function initializeOpencodeForDirectory(directory) {
                 serverRetryCount.set(directory, retryCount + 1);
                 opencodeLogger.log(`Restarting server for directory: ${directory} (attempt ${retryCount + 1}/5)`);
                 initializeOpencodeForDirectory(directory).then((result) => {
-                    if (errore.isError(result)) {
+                    if (result instanceof Error) {
                         opencodeLogger.error(`Failed to restart opencode server:`, result);
                     }
                 });
@@ -139,7 +139,7 @@ export async function initializeOpencodeForDirectory(directory) {
         }
     });
     const waitResult = await waitForServer(port);
-    if (errore.isError(waitResult)) {
+    if (waitResult instanceof Error) {
         // Dump buffered logs on failure
         opencodeLogger.error(`Server failed to start for ${directory}:`);
         for (const line of logBuffer) {

package/dist/session-handler.js

@@ -49,7 +49,7 @@ export async function abortAndRetrySession({ sessionId, thread, projectDirectory
     controller.abort('model-change');
     // Also call the API abort endpoint
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message);
         return false;
     }
@@ -98,7 +98,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     const directory = projectDirectory || process.cwd();
     sessionLogger.log(`Using directory: ${directory}`);
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await sendThreadMessage(thread, `✗ ${getClient.message}`);
         return;
     }

package/dist/tools.js

@@ -15,7 +15,7 @@ import pc from 'picocolors';
 import { initializeOpencodeForDirectory, getOpencodeSystemMessage } from './discord-bot.js';
 export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         throw new Error(getClient.message);
     }
     const client = getClient();
@@ -248,7 +248,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         sessionID: sessionId,
                         lastAssistantOnly: true,
                     });
-                    if (errore.isError(markdownResult)) {
+                    if (markdownResult instanceof Error) {
                         throw new Error(markdownResult.message);
                     }
                     return {
@@ -261,7 +261,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     const markdownResult = await markdownRenderer.generate({
                         sessionID: sessionId,
                     });
-                    if (errore.isError(markdownResult)) {
+                    if (markdownResult instanceof Error) {
                         throw new Error(markdownResult.message);
                     }
                     const messages = await getClient().session.messages({

package/dist/voice-handler.js

@@ -326,7 +326,7 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
         try: () => fetch(audioAttachment.url),
         catch: (e) => new FetchError({ url: audioAttachment.url, cause: e }),
     });
-    if (errore.isError(audioResponse)) {
+    if (audioResponse instanceof Error) {
         voiceLogger.error(`Failed to download audio attachment:`, audioResponse.message);
         await sendThreadMessage(thread, `⚠️ Failed to download audio: ${audioResponse.message}`);
         return null;
@@ -367,7 +367,7 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
         currentSessionContext,
         lastSessionContext,
     });
-    if (errore.isError(transcription)) {
+    if (transcription instanceof Error) {
         const errMsg = errore.matchError(transcription, {
             ApiKeyMissingError: (e) => e.message,
             InvalidAudioFormatError: (e) => e.message,
@@ -398,7 +398,7 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             if (renamed === null) {
                 voiceLogger.log(`Thread name update timed out`);
             }
-            else if (errore.isError(renamed)) {
+            else if (renamed instanceof Error) {
                 voiceLogger.log(`Could not update thread name:`, renamed.message);
             }
             else {

package/dist/voice.js

@@ -103,7 +103,7 @@ function createToolRunner({ directory }) {
             voiceLogger.log(`Grep search: "${pattern}"`);
             const result = await runGrep({ pattern, directory });
             const output = (() => {
-                if (errore.isError(result)) {
+                if (result instanceof Error) {
                     voiceLogger.error('grep search failed:', result);
                     return 'grep search failed';
                 }
@@ -117,7 +117,7 @@ function createToolRunner({ directory }) {
             voiceLogger.log(`Glob search: "${pattern}"`);
             const result = await runGlob({ pattern, directory });
             const output = (() => {
-                if (errore.isError(result)) {
+                if (result instanceof Error) {
                     voiceLogger.error('glob search failed:', result);
                     return 'glob search failed';
                 }
@@ -145,7 +145,7 @@ export async function runTranscriptionLoop({ genAI, model, initialContents, tool
         }),
         catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
     });
-    if (errore.isError(initialResponse)) {
+    if (initialResponse instanceof Error) {
         return initialResponse;
     }
     let response = initialResponse;
@@ -233,7 +233,7 @@ export async function runTranscriptionLoop({ genAI, model, initialContents, tool
             }),
             catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
         });
-        if (errore.isError(nextResponse)) {
+        if (nextResponse instanceof Error) {
             return nextResponse;
         }
         response = nextResponse;

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.39",
+  "version": "0.4.40",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",
@@ -34,18 +34,19 @@
     "@clack/prompts": "^0.11.0",
     "@discordjs/voice": "^0.19.0",
     "@google/genai": "^1.34.0",
-    "@opencode-ai/sdk": "^1.1.12",
+    "@opencode-ai/sdk": "^1.1.31",
     "@purinton/resampler": "^1.0.4",
     "ai": "^5.0.114",
     "better-sqlite3": "^12.3.0",
     "cac": "^6.7.14",
     "discord.js": "^14.16.3",
     "domhandler": "^5.0.3",
-    "errore": "^0.5.2",
+    "errore": "workspace:^",
     "glob": "^13.0.0",
     "htmlparser2": "^10.0.0",
     "js-yaml": "^4.1.0",
     "marked": "^16.3.0",
+    "mime": "^4.1.0",
     "picocolors": "^1.1.1",
     "pretty-ms": "^9.3.0",
     "ripgrep-js": "^3.0.0",

package/src/cli.ts

@@ -43,6 +43,7 @@ import fs from 'node:fs'
 import * as errore from 'errore'
 
 import { createLogger } from './logger.js'
+import { uploadFilesToDiscord } from './discord-utils.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 import http from 'node:http'
 import { setDataDir, getDataDir, getLockPort } from './config.js'
@@ -211,7 +212,7 @@ async function registerCommands({
       })
       .toJSON(),
     new SlashCommandBuilder()
-      .setName('session')
+      .setName('new-session')
       .setDescription('Start a new OpenCode session')
       .addStringOption((option) => {
         option.setName('prompt').setDescription('Prompt content for the session').setRequired(true)
@@ -236,6 +237,18 @@ async function registerCommands({
         return option
       })
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('new-worktree')
+      .setDescription('Create a new git worktree and start a session thread')
+      .addStringOption((option) => {
+        option
+          .setName('name')
+          .setDescription('Name for the worktree (will be formatted: lowercase, spaces to dashes)')
+          .setRequired(true)
+
+        return option
+      })
+      .toJSON(),
     new SlashCommandBuilder()
       .setName('add-project')
       .setDescription('Create Discord channels for a new OpenCode project')
@@ -582,7 +595,7 @@ async function run({ restart, addChannels }: CliOptions) {
   const currentDir = process.cwd()
   s.start('Starting OpenCode server...')
   const opencodePromise = initializeOpencodeForDirectory(currentDir).then((result) => {
-    if (errore.isError(result)) {
+    if (result instanceof Error) {
       throw new Error(result.message)
     }
     return result
@@ -998,34 +1011,11 @@ cli
       const s = spinner()
       s.start(`Uploading ${resolvedFiles.length} file(s)...`)
 
-      for (const file of resolvedFiles) {
-        const buffer = fs.readFileSync(file)
-
-        const formData = new FormData()
-        formData.append(
-          'payload_json',
-          JSON.stringify({
-            attachments: [{ id: 0, filename: path.basename(file) }],
-          }),
-        )
-        formData.append('files[0]', new Blob([buffer]), path.basename(file))
-
-        const response = await fetch(
-          `https://discord.com/api/v10/channels/${threadRow.thread_id}/messages`,
-          {
-            method: 'POST',
-            headers: {
-              Authorization: `Bot ${botRow.token}`,
-            },
-            body: formData,
-          },
-        )
-
-        if (!response.ok) {
-          const error = await response.text()
-          throw new Error(`Discord API error: ${response.status} - ${error}`)
-        }
-      }
+      await uploadFilesToDiscord({
+        threadId: threadRow.thread_id,
+        botToken: botRow.token,
+        files: resolvedFiles,
+      })
 
       s.stop(`Uploaded ${resolvedFiles.length} file(s)!`)
 

package/src/commands/abort.ts

@@ -72,7 +72,7 @@ export async function handleAbortCommand({ command }: CommandContext): Promise<v
   }
 
   const getClient = await initializeOpencodeForDirectory(directory)
-  if (errore.isError(getClient)) {
+  if (getClient instanceof Error) {
     await command.reply({
       content: `Failed to abort: ${getClient.message}`,
       ephemeral: true,

package/src/commands/add-project.ts

@@ -26,7 +26,7 @@ export async function handleAddProjectCommand({ command, appId }: CommandContext
   try {
     const currentDir = process.cwd()
     const getClient = await initializeOpencodeForDirectory(currentDir)
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
       await command.editReply(getClient.message)
       return
     }
@@ -94,7 +94,7 @@ export async function handleAddProjectAutocomplete({
   try {
     const currentDir = process.cwd()
     const getClient = await initializeOpencodeForDirectory(currentDir)
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
       await interaction.respond([])
       return
     }

package/src/commands/agent.ts

@@ -162,7 +162,7 @@ export async function handleAgentCommand({
 
   try {
     const getClient = await initializeOpencodeForDirectory(context.dir)
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
       await interaction.editReply({ content: getClient.message })
       return
     }
@@ -297,7 +297,7 @@ export async function handleQuickAgentCommand({
 
   try {
     const getClient = await initializeOpencodeForDirectory(context.dir)
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
       await command.editReply({ content: getClient.message })
       return
     }

package/src/commands/fork.ts

@@ -73,7 +73,7 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
   const sessionId = row.session_id
 
   const getClient = await initializeOpencodeForDirectory(directory)
-  if (errore.isError(getClient)) {
+  if (getClient instanceof Error) {
     await interaction.editReply({
       content: `Failed to load messages: ${getClient.message}`,
     })
@@ -171,7 +171,7 @@ export async function handleForkSelectMenu(
   await interaction.deferReply({ ephemeral: false })
 
   const getClient = await initializeOpencodeForDirectory(directory)
-  if (errore.isError(getClient)) {
+  if (getClient instanceof Error) {
     await interaction.editReply(`Failed to fork session: ${getClient.message}`)
     return
   }

package/src/commands/model.ts

@@ -129,7 +129,7 @@ export async function handleModelCommand({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
       await interaction.editReply({ content: getClient.message })
       return
     }
@@ -237,7 +237,7 @@ export async function handleProviderSelectMenu(
 
   try {
     const getClient = await initializeOpencodeForDirectory(context.dir)
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
       await interaction.editReply({
         content: getClient.message,
         components: [],

package/src/commands/remove-project.ts

@@ -42,7 +42,7 @@ export async function handleRemoveProjectCommand({ command, appId }: CommandCont
         catch: (e) => e as Error,
       })
       
-      if (errore.isError(channel)) {
+      if (channel instanceof Error) {
         logger.error(`Failed to fetch channel ${channel_id}:`, channel)
         failedChannels.push(`${channel_type}: ${channel_id}`)
         continue
@@ -116,7 +116,7 @@ export async function handleRemoveProjectAutocomplete({
         try: () => guild.channels.fetch(channel_id),
         catch: (e) => e as Error,
       })
-      if (errore.isError(channel)) {
+      if (channel instanceof Error) {
         // Channel not in this guild, skip
         continue
       }