kimaki 0.14.0 → 0.16.0

package/dist/commands/new-worktree.js

@@ -3,6 +3,7 @@
 // Creates thread immediately, then worktree in background so user can type
 import { ChannelType, REST, } from 'discord.js';
 import fs from 'node:fs';
+import { OpenCodeSdkError } from '../errors.js';
 import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadSession, setThreadSession, } from '../database.js';
 import { SILENT_MESSAGE_FLAGS, reactToThread, resolveProjectDirectoryFromAutocomplete, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
@@ -149,72 +150,67 @@ async function getProjectDirectoryFromChannel(channel) {
  * Never throws — all internal errors are caught and returned as Error values.
  */
 export async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, baseBranch, rest, }) {
-    return errore.tryAsync({
-        try: async () => {
-            logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`);
-            await createPendingWorktree({
-                threadId: thread.id,
-                worktreeName,
-                projectDirectory,
-            });
-            // Serialize status message edits so onProgress can't overwrite the
-            // final success/error edit even if Discord's API is slow.
-            let editChain = Promise.resolve();
-            const editStatus = (content) => {
-                editChain = editChain
-                    .then(async () => {
-                    await starterMessage?.edit(content);
-                })
-                    .catch(() => { });
-            };
-            const worktreeResult = await createWorktreeWithSubmodules({
-                directory: projectDirectory,
-                name: worktreeName,
-                baseBranch,
-                onProgress: (phase) => {
-                    editStatus(`🌳 **Worktree: ${worktreeName}**\n${phase}`);
-                },
-            });
-            if (worktreeResult instanceof Error) {
-                const errorMsg = worktreeResult.message;
-                logger.error('[WORKTREE] Creation failed:', worktreeResult);
-                await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
-                editStatus(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
-                await editChain;
-                return worktreeResult;
-            }
-            // Success - update database and edit starter message
-            await setWorktreeReady({
-                threadId: thread.id,
-                worktreeDirectory: worktreeResult.directory,
-            });
-            // React with tree emoji to mark as worktree thread
-            await reactToThread({
-                rest,
-                threadId: thread.id,
-                channelId: thread.parentId || undefined,
-                emoji: '🌳',
-            });
-            editStatus(`🌳 **Worktree: ${worktreeName}**\n` +
-                `📁 \`${worktreeResult.directory}\`\n` +
-                `🌿 Branch: \`${worktreeResult.branch}\``);
+    return (async () => {
+        logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`);
+        // Serialize status message edits so onProgress can't overwrite the
+        // final success/error edit even if Discord's API is slow.
+        let editChain = Promise.resolve();
+        const editStatus = (content) => {
+            editChain = editChain
+                .then(async () => {
+                await starterMessage?.edit(content);
+            })
+                .catch(() => { });
+        };
+        // DB pending entry must complete before git creation so error paths
+        // (setWorktreeError) can find the row reliably
+        await createPendingWorktree({
+            threadId: thread.id,
+            worktreeName,
+            projectDirectory,
+        });
+        const worktreeResult = await createWorktreeWithSubmodules({
+            directory: projectDirectory,
+            name: worktreeName,
+            baseBranch,
+            onProgress: (phase) => {
+                editStatus(`🌳 **Worktree: ${worktreeName}**\n${phase}`);
+            },
+        });
+        if (worktreeResult instanceof Error) {
+            const errorMsg = worktreeResult.message;
+            logger.error('[WORKTREE] Creation failed:', worktreeResult);
+            await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
+            editStatus(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
             await editChain;
-            return worktreeResult.directory;
-        },
-        catch: (e) => {
-            logger.error('[WORKTREE] Unexpected error in createWorktreeInBackground:', e);
-            return new Error(`Worktree creation failed: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
-        },
+            return worktreeResult;
+        }
+        // DB ready update is critical; reaction is best-effort
+        await setWorktreeReady({
+            threadId: thread.id,
+            worktreeDirectory: worktreeResult.directory,
+        });
+        void reactToThread({
+            rest,
+            threadId: thread.id,
+            channelId: thread.parentId || undefined,
+            emoji: '🌳',
+        }).catch(() => { });
+        editStatus(`🌳 **Worktree: ${worktreeName}**\n` +
+            `📁 \`${worktreeResult.directory}\`\n` +
+            `🌿 Branch: \`${worktreeResult.branch}\``);
+        await editChain;
+        return worktreeResult.directory;
+    })().catch((e) => {
+        logger.error('[WORKTREE] Unexpected error in createWorktreeInBackground:', e);
+        return new Error(`Worktree creation failed: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
     });
 }
 async function findExistingWorktreePath({ projectDirectory, worktreeName, }) {
-    const listResult = await errore.tryAsync({
-        try: () => execAsync('git worktree list --porcelain', { cwd: projectDirectory }),
-        catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
-    });
-    if (errore.isError(listResult)) {
+    const listResult = await execAsync('git worktree list --porcelain', { cwd: projectDirectory })
+        .catch((e) => new WorktreeError('Failed to list worktrees', { cause: e }));
+    if (listResult instanceof Error)
         return listResult;
-    }
     const lines = listResult.stdout.split('\n');
     let currentPath = '';
     const branchRef = `refs/heads/${worktreeName}`;
@@ -268,18 +264,15 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
         await command.editReply(projectDirectory.message);
         return;
     }
-    const baseBranch = await resolveRequestedWorktreeBaseRef({
-        projectDirectory,
-        rawBaseBranch,
-    });
+    // Parallelize: base branch validation and existing worktree check are independent
+    const [baseBranch, existingWorktree] = await Promise.all([
+        resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch }),
+        findExistingWorktreePath({ projectDirectory, worktreeName }),
+    ]);
     if (baseBranch instanceof Error) {
         await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``);
         return;
     }
-    const existingWorktree = await findExistingWorktreePath({
-        projectDirectory,
-        worktreeName,
-    });
     if (errore.isError(existingWorktree)) {
         await command.editReply(existingWorktree.message);
         return;
@@ -289,30 +282,29 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
         return;
     }
     // Create thread immediately so user can start typing
-    const result = await errore.tryAsync({
-        try: async () => {
-            const starterMessage = await channel.send({
-                content: worktreeCreatingMessage(worktreeName),
-                flags: SILENT_MESSAGE_FLAGS,
-            });
-            const thread = await starterMessage.startThread({
-                name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`,
-                autoArchiveDuration: 1440,
-                reason: 'Worktree session',
-            });
-            // Add user to thread so it appears in their sidebar
-            await thread.members.add(command.user.id);
-            return { thread, starterMessage };
-        },
-        catch: (e) => new WorktreeError('Failed to create thread', { cause: e }),
-    });
-    if (errore.isError(result)) {
+    const result = await (async () => {
+        const starterMessage = await channel.send({
+            content: worktreeCreatingMessage(worktreeName),
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const thread = await starterMessage.startThread({
+            name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`,
+            autoArchiveDuration: 1440,
+            reason: 'Worktree session',
+        });
+        // Parallelize: member add and editReply are independent
+        await Promise.all([
+            thread.members.add(command.user.id),
+            command.editReply(`Creating worktree in ${thread.toString()}`),
+        ]);
+        return { thread, starterMessage };
+    })().catch((e) => new WorktreeError('Failed to create thread', { cause: e }));
+    if (result instanceof Error) {
         logger.error('[NEW-WORKTREE] Error:', result.cause);
         await command.editReply(result.message);
         return;
     }
     const { thread, starterMessage } = result;
-    await command.editReply(`Creating worktree in ${thread.toString()}`);
     // Create worktree in background (don't await)
     void createWorktreeInBackground({
         thread,
@@ -353,18 +345,18 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
         await command.editReply(projectDirectory.message);
         return;
     }
-    const baseBranch = await resolveRequestedWorktreeBaseRef({
-        projectDirectory,
-        rawBaseBranch,
-    });
+    // Parallelize: base branch validation, existing worktree check, and parent channel
+    // resolve are all independent. resolveTextChannel fetches the parent from Discord
+    // cache/API which can overlap with the git operations.
+    const [baseBranch, existingWorktreePath, textChannel] = await Promise.all([
+        resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch }),
+        findExistingWorktreePath({ projectDirectory, worktreeName }),
+        resolveTextChannel(thread),
+    ]);
     if (baseBranch instanceof Error) {
         await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``);
         return;
     }
-    const existingWorktreePath = await findExistingWorktreePath({
-        projectDirectory,
-        worktreeName,
-    });
     if (errore.isError(existingWorktreePath)) {
         await command.editReply(existingWorktreePath.message);
         return;
@@ -373,33 +365,33 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
         await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``);
         return;
     }
-    const textChannel = await resolveTextChannel(thread);
     if (!textChannel) {
         await command.editReply('Could not resolve parent text channel');
         return;
     }
-    const threadResult = await errore.tryAsync({
-        try: async () => {
-            const worktreeThread = await textChannel.threads.create({
-                name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`.slice(0, 100),
-                autoArchiveDuration: 1440,
-                reason: `Worktree fork from thread ${thread.id}`,
-            });
-            await worktreeThread.members.add(command.user.id);
-            const statusMessage = await worktreeThread.send({
+    const threadResult = await (async () => {
+        const worktreeThread = await textChannel.threads.create({
+            name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`.slice(0, 100),
+            autoArchiveDuration: 1440,
+            reason: `Worktree fork from thread ${thread.id}`,
+        });
+        // Parallelize: member add and status message send are independent
+        const [, statusMessage] = await Promise.all([
+            worktreeThread.members.add(command.user.id),
+            worktreeThread.send({
                 content: worktreeCreatingMessage(worktreeName),
                 flags: SILENT_MESSAGE_FLAGS,
-            });
-            return { worktreeThread, statusMessage };
-        },
-        catch: (e) => new WorktreeError('Failed to create worktree thread', { cause: e }),
-    });
+            }),
+        ]);
+        return { worktreeThread, statusMessage };
+    })().catch((e) => new WorktreeError('Failed to create worktree thread', { cause: e }));
     if (threadResult instanceof Error) {
         await command.editReply(threadResult.message);
         return;
     }
     const { worktreeThread, statusMessage } = threadResult;
-    await command.editReply(`Creating worktree in ${worktreeThread.toString()}`);
+    // Fire-and-forget: don't block background worktree creation on editReply
+    void command.editReply(`Creating worktree in ${worktreeThread.toString()}`).catch(() => { });
     void createWorktreeInBackground({
         thread: worktreeThread,
         starterMessage: statusMessage,
@@ -409,9 +401,8 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
         rest: command.client.rest,
     })
         .then(async (result) => {
-        if (result instanceof Error) {
+        if (result instanceof Error)
             return;
-        }
         const sourceSessionId = await getThreadSession(thread.id);
         if (!sourceSessionId) {
             await sendThreadMessage(worktreeThread, 'Worktree is ready. Send a message here to start a fresh session in this checkout.');
@@ -425,12 +416,10 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
             await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to initialize OpenCode for context reuse: ${getClient.message}`);
             return;
         }
-        const forkResponse = await errore.tryAsync(() => {
-            return getClient().session.fork({
-                sessionID: sourceSessionId,
-                directory: result,
-            });
-        });
+        const forkResponse = await getClient().session.fork({
+            sessionID: sourceSessionId,
+            directory: result,
+        }).catch((e) => new OpenCodeSdkError({ operation: 'session.fork', cause: e }));
         if (forkResponse instanceof Error) {
             logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', forkResponse);
             void notifyError(forkResponse, 'Failed to fork session into worktree');
@@ -445,16 +434,14 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
             await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${error.message}`);
             return;
         }
-        const permissionResponse = await errore.tryAsync(() => {
-            return getClient().session.update({
-                sessionID: forkedSession.id,
+        const permissionResponse = await getClient().session.update({
+            sessionID: forkedSession.id,
+            directory: result,
+            permission: buildSessionPermissions({
                 directory: result,
-                permission: buildSessionPermissions({
-                    directory: result,
-                    originalRepoDirectory: projectDirectory,
-                }),
-            });
-        });
+                originalRepoDirectory: projectDirectory,
+            }),
+        }).catch((e) => new OpenCodeSdkError({ operation: 'session.update', cause: e }));
         if (permissionResponse instanceof Error || permissionResponse.error) {
             const error = permissionResponse instanceof Error
                 ? permissionResponse

package/dist/commands/permissions.js

@@ -1,6 +1,11 @@
 // Permission button handler - Shows buttons for permission requests.
 // When OpenCode asks for permission, this module renders 3 buttons:
 // Accept, Accept Always, and Deny.
+//
+// The `directory` stored in PendingPermissionContext is the session directory
+// (sdkDirectory), which equals the worktree path for worktree threads.
+// This is used for both getOpencodeClient() (so the client header matches)
+// and for explicit `directory` params in SDK calls.
 import { ButtonBuilder, ButtonStyle, ActionRowBuilder, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
 import { getOpencodeClient } from '../opencode.js';
@@ -77,13 +82,12 @@ function takePendingPermissionContext(contextHash) {
  * Displays 3 buttons in a row: Accept, Accept Always, Deny.
  * Returns the message ID and context hash for tracking.
  */
-export async function showPermissionButtons({ thread, permission, directory, permissionDirectory, subtaskLabel, }) {
+export async function showPermissionButtons({ thread, permission, directory, subtaskLabel, }) {
     const contextHash = crypto.randomBytes(8).toString('hex');
     const context = {
         permission,
         requestIds: [permission.id],
         directory,
-        permissionDirectory,
         thread,
         contextHash,
     };
@@ -111,7 +115,7 @@ export async function showPermissionButtons({ thread, permission, directory, per
             await Promise.all(requestIds.map((requestId) => {
                 return client.permission.reply({
                     requestID: requestId,
-                    directory: ctx.permissionDirectory,
+                    directory: ctx.directory,
                     reply: 'reject',
                     message: timeoutFeedback,
                 });
@@ -207,7 +211,7 @@ export async function cancelPendingPermission(threadId) {
         const result = await Promise.all(requestIds.map((requestId) => {
             return client.permission.reply({
                 requestID: requestId,
-                directory: pendingContext.permissionDirectory,
+                directory: pendingContext.directory,
                 reply: 'reject',
             });
         })).then(() => {
@@ -266,7 +270,7 @@ export async function handlePermissionButton(interaction) {
         await Promise.all(requestIds.map((requestId) => {
             return permClient.permission.reply({
                 requestID: requestId,
-                directory: context.permissionDirectory,
+                directory: context.directory,
                 reply: response,
             });
         }));
@@ -274,7 +278,7 @@ export async function handlePermissionButton(interaction) {
             const resumed = await resumeSessionIfIdleAfterPermission({
                 client: permClient,
                 sessionId: context.permission.sessionID,
-                directory: context.permissionDirectory,
+                directory: context.directory,
             });
             if (resumed instanceof Error) {
                 logger.error('Failed to resume idle session after permission:', resumed);

package/dist/commands/remove-project.js

@@ -1,7 +1,7 @@
 // /remove-project command - Remove Discord channels for a project.
 import path from 'node:path';
-import * as errore from 'errore';
 import { findChannelsByDirectory, deleteChannelDirectoriesByDirectory, getAllTextChannelDirectories, } from '../database.js';
+import { DiscordOperationError } from '../errors.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { abbreviatePath } from '../utils.js';
 const logger = createLogger(LogPrefix.REMOVE_PROJECT);
@@ -23,10 +23,8 @@ export async function handleRemoveProjectCommand({ command, appId, }) {
         const deletedChannels = [];
         const failedChannels = [];
         for (const { channel_id, channel_type } of channels) {
-            const channel = await errore.tryAsync({
-                try: () => guild.channels.fetch(channel_id),
-                catch: (e) => e,
-            });
+            const channel = await guild.channels.fetch(channel_id)
+                .catch((e) => new DiscordOperationError({ operation: 'fetchChannel', cause: e }));
             if (channel instanceof Error) {
                 logger.error(`Failed to fetch channel ${channel_id}:`, channel);
                 failedChannels.push(`${channel_type}: ${channel_id}`);
@@ -80,10 +78,8 @@ export async function handleRemoveProjectAutocomplete({ interaction, appId, }) {
         // Filter to only channels that exist in this guild
         const projectsInGuild = [];
         for (const { directory, channel_id } of allChannels) {
-            const channel = await errore.tryAsync({
-                try: () => guild.channels.fetch(channel_id),
-                catch: (e) => e,
-            });
+            const channel = await guild.channels.fetch(channel_id)
+                .catch((e) => new DiscordOperationError({ operation: 'fetchChannel', cause: e }));
             if (channel instanceof Error) {
                 // Channel not in this guild, skip
                 continue;

package/dist/commands/undo-redo.js

@@ -1,7 +1,7 @@
 // Undo/Redo commands - /undo, /redo
 import { ChannelType, MessageFlags, } from 'discord.js';
 import { getThreadSession } from '../database.js';
-import { initializeOpencodeForDirectory } from '../opencode.js';
+import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.UNDO_REDO);
@@ -59,13 +59,17 @@ export async function handleUndoCommand({ command, }) {
         return;
     }
     await command.deferReply();
-    const getClient = await initializeOpencodeForDirectory(projectDirectory);
-    if (getClient instanceof Error) {
-        await command.editReply(`Failed to undo: ${getClient.message}`);
+    const serverResult = await initializeOpencodeForDirectory(projectDirectory);
+    if (serverResult instanceof Error) {
+        await command.editReply(`Failed to undo: ${serverResult.message}`);
         return;
     }
     try {
-        const client = getClient();
+        const client = getOpencodeClient(workingDirectory);
+        if (!client) {
+            await command.editReply('Failed to get OpenCode client');
+            return;
+        }
         // Fetch session to check existing revert state
         const sessionResponse = await client.session.get({
             sessionID: sessionId,
@@ -210,13 +214,17 @@ export async function handleRedoCommand({ command, }) {
         return;
     }
     await command.deferReply();
-    const getClient = await initializeOpencodeForDirectory(projectDirectory);
-    if (getClient instanceof Error) {
-        await command.editReply(`Failed to redo: ${getClient.message}`);
+    const serverResult = await initializeOpencodeForDirectory(projectDirectory);
+    if (serverResult instanceof Error) {
+        await command.editReply(`Failed to redo: ${serverResult.message}`);
         return;
     }
     try {
-        const client = getClient();
+        const client = getOpencodeClient(workingDirectory);
+        if (!client) {
+            await command.editReply('Failed to get OpenCode client');
+            return;
+        }
         // Fetch session to check existing revert state
         const sessionResponse = await client.session.get({
             sessionID: sessionId,