kimaki 0.4.76 → 0.4.78

package/src/cli.ts

@@ -64,6 +64,7 @@ import { WORKTREE_PREFIX } from './commands/merge-worktree.js'
 import type { ThreadStartMarker } from './system-message.js'
 import { sendWelcomeMessage } from './onboarding-welcome.js'
 import { buildOpencodeEventLogLine } from './session-handler/opencode-session-event-log.js'
+import { selectResolvedCommand } from './opencode-command.js'
 import yaml from 'js-yaml'
 import type {
   OpencodeClient,
@@ -552,7 +553,11 @@ async function ensureCommandAvailable({
     env: process.env,
   }).then(
     (result) => {
-      return result.stdout.trim()
+      const resolved = selectResolvedCommand({
+        output: result.stdout,
+        isWindows,
+      })
+      return resolved || ''
     },
     () => {
       return ''
@@ -1084,6 +1089,16 @@ async function registerCommands({
       .setDescription('List and manage MCP servers for this project')
       .setDMPermission(false)
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('screenshare')
+      .setDescription('Start screen sharing via VNC tunnel (auto-stops after 1 hour)')
+      .setDMPermission(false)
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('screenshare-stop')
+      .setDescription('Stop screen sharing')
+      .setDMPermission(false)
+      .toJSON(),
   ]
 
   // Add user-defined commands with source-based suffixes (-cmd / -skill)
@@ -1702,7 +1717,7 @@ async function resolveCredentials({
     }
 
     // Poll until the user installs the bot in a Discord server.
-    // 600 attempts x 2s = 20 minutes timeout.
+    // 100 attempts x 3s = 5 minutes timeout.
     const s = isInteractive ? spinner() : undefined
     s?.start('Waiting for a Discord server with the bot installed...')
 
@@ -1712,9 +1727,9 @@ async function resolveCredentials({
 
     let guildId: string | undefined
     let installerDiscordUserId: string | undefined
-    for (let attempt = 0; attempt < 600; attempt++) {
+    for (let attempt = 0; attempt < 100; attempt++) {
       await new Promise((resolve) => {
-        setTimeout(resolve, 2000)
+        setTimeout(resolve, 3000)
       })
 
       // Progressive hints for interactive users who may be stuck
@@ -1756,10 +1771,10 @@ async function resolveCredentials({
       if (isInteractive) {
         s?.stop('Authorization timed out')
       } else {
-        emitJsonEvent({ type: 'error', message: 'Authorization timed out after 20 minutes' })
+        emitJsonEvent({ type: 'error', message: 'Authorization timed out after 5 minutes' })
       }
       cliLogger.error(
-        'Bot authorization timed out after 20 minutes. Please try again.',
+        'Bot authorization timed out after 5 minutes. Please try again.',
       )
       process.exit(EXIT_NO_RESTART)
     }
@@ -2117,13 +2132,20 @@ async function run({
 
       // Create default kimaki channel + welcome message in each guild.
       // Runs after channel sync so existing channels are detected correctly.
-      await ensureDefaultChannelsWithWelcome({
-        guilds,
-        discordClient,
-        appId,
-        isGatewayMode,
-        installerDiscordUserId,
-      })
+      try {
+        await ensureDefaultChannelsWithWelcome({
+          guilds,
+          discordClient,
+          appId,
+          isGatewayMode,
+          installerDiscordUserId,
+        })
+      } catch (error) {
+        cliLogger.warn(
+          'Background default channel creation failed:',
+          error instanceof Error ? error.message : String(error),
+        )
+      }
     })()
 
     // Background: OpenCode init + slash command registration (non-blocking)
@@ -4126,6 +4148,31 @@ cli
     },
   )
 
+cli
+  .command(
+    'screenshare',
+    'Share your screen via VNC tunnel. Auto-stops after 1 hour. Runs until Ctrl+C. Use tmux to run in background.',
+  )
+  .action(async () => {
+    const { startScreenshare } = await import(
+      './commands/screenshare.js'
+    )
+    try {
+      const session = await startScreenshare({
+        sessionKey: 'cli',
+        startedBy: 'cli',
+      })
+      cliLogger.log(`Screen sharing started: ${session.noVncUrl}`)
+      cliLogger.log('Press Ctrl+C to stop')
+    } catch (err) {
+      cliLogger.error(
+        'Failed to start screen share:',
+        err instanceof Error ? err.message : String(err),
+      )
+      process.exit(EXIT_NO_RESTART)
+    }
+  })
+
 cli
   .command('sqlitedb', 'Show the location of the SQLite database file')
   .action(() => {

package/src/commands/diff.ts

@@ -14,7 +14,7 @@ import {
   SILENT_MESSAGE_FLAGS,
 } from '../discord-utils.js'
 import { createLogger, LogPrefix } from '../logger.js'
-import { execAsync } from '../worktrees.js'
+import { uploadGitDiffViaCritique } from '../critique-utils.js'
 
 const logger = createLogger(LogPrefix.DIFF)
 
@@ -63,103 +63,29 @@ export async function handleDiffCommand({
 
   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: { url?: string; id?: string; error?: string }
-    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 as {
-      stdout?: string
-      stderr?: string
-      message?: string
-    }
-    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) as { error?: string }
-        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)}`,
-    })
+  const projectName = path.basename(workingDirectory)
+  const title = `${projectName}: Discord /diff`
+  const result = await uploadGitDiffViaCritique({
+    title,
+    cwd: workingDirectory,
+  })
+
+  if (!result) {
+    await command.editReply({ content: 'No changes to show' })
+    return
   }
+
+  if (result.error || !result.url) {
+    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}`)
 }

package/src/commands/merge-worktree.ts

@@ -15,7 +15,7 @@ import { mergeWorktree, listBranchesByLastCommit, validateBranchRef } from '../w
 import {
   sendThreadMessage,
   resolveWorkingDirectory,
-  resolveTextChannel,
+  resolveProjectDirectoryFromAutocomplete,
 } from '../discord-utils.js'
 import {
   getOrCreateRuntime,
@@ -189,26 +189,10 @@ export async function handleMergeWorktreeAutocomplete({
   try {
     const focusedValue = interaction.options.getFocused()
 
-    let projectDirectory: string | undefined
-
-    // Try to get directory from worktree info (we're in a thread)
-    if (interaction.channel?.isThread()) {
-      const worktreeInfo = await getThreadWorktree(interaction.channel.id)
-      if (worktreeInfo?.project_directory) {
-        projectDirectory = worktreeInfo.project_directory
-      }
-    }
-
-    // Fallback: resolve from parent channel
-    if (!projectDirectory && interaction.channel) {
-      const textChannel = await resolveTextChannel(
-        interaction.channel as TextChannel | ThreadChannel | null,
-      )
-      if (textChannel) {
-        const channelConfig = await getChannelDirectory(textChannel.id)
-        projectDirectory = channelConfig?.directory
-      }
-    }
+    // interaction.channel can be null when the channel isn't cached
+    // (common with gateway-proxy). Use channelId which is always available
+    // from the raw interaction payload.
+    const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction)
 
     if (!projectDirectory) {
       await interaction.respond([])

package/src/commands/new-worktree.ts

@@ -21,7 +21,7 @@ import {
 import {
   SILENT_MESSAGE_FLAGS,
   reactToThread,
-  resolveTextChannel,
+  resolveProjectDirectoryFromAutocomplete,
 } from '../discord-utils.js'
 import { createLogger, LogPrefix } from '../logger.js'
 import { notifyError } from '../sentry.js'
@@ -452,16 +452,10 @@ export async function handleNewWorktreeAutocomplete({
   try {
     const focusedValue = interaction.options.getFocused()
 
-    let projectDirectory: string | undefined
-    if (interaction.channel) {
-      const textChannel = await resolveTextChannel(
-        interaction.channel as TextChannel | ThreadChannel | null,
-      )
-      if (textChannel) {
-        const channelConfig = await getChannelDirectory(textChannel.id)
-        projectDirectory = channelConfig?.directory
-      }
-    }
+    // interaction.channel can be null when the channel isn't cached
+    // (common with gateway-proxy). Use channelId which is always available
+    // from the raw interaction payload.
+    const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction)
 
     if (!projectDirectory) {
       await interaction.respond([])

package/src/commands/permissions.ts

@@ -70,6 +70,7 @@ type PendingPermissionContext = {
   permissionDirectory: string
   thread: ThreadChannel
   contextHash: string
+  messageId?: string
 }
 
 // Store pending permission contexts by hash.
@@ -189,11 +190,107 @@ export async function showPermissionButtons({
     flags: NOTIFY_MESSAGE_FLAGS | MessageFlags.SuppressEmbeds,
   })
 
+  context.messageId = permissionMessage.id
+
   logger.log(`Showed permission buttons for ${permission.id}`)
 
   return { messageId: permissionMessage.id, contextHash }
 }
 
+function updatePermissionMessage({
+  context,
+  status,
+}: {
+  context: PendingPermissionContext
+  status: string
+}): void {
+  if (!context.messageId) {
+    return
+  }
+  context.thread.messages
+    .fetch(context.messageId)
+    .then((message) => {
+      const patternStr = compactPermissionPatterns(context.permission.patterns).join(', ')
+      const externalDirLine =
+        context.permission.permission === 'external_directory'
+          ? 'Agent is accessing files outside the project. [Learn more](https://opencode.ai/docs/permissions/#external-directories)\n'
+          : ''
+      return message.edit({
+        content:
+          `⚠️ **Permission Required**\n` +
+          `**Type:** \`${context.permission.permission}\`\n` +
+          externalDirLine +
+          (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+          status,
+        components: [],
+      })
+    })
+    .catch((error) => {
+      logger.error('Failed to update permission message:', error)
+    })
+}
+
+export async function cancelPendingPermission(threadId: string): Promise<boolean> {
+  const contexts = Array.from(pendingPermissionContexts.values()).filter((context) => {
+    return context.thread.id === threadId
+  })
+
+  if (contexts.length === 0) {
+    return false
+  }
+
+  let cancelledCount = 0
+  for (const context of contexts) {
+    const pendingContext = takePendingPermissionContext(context.contextHash)
+    if (!pendingContext) {
+      continue
+    }
+
+    const client = getOpencodeClient(pendingContext.directory)
+    if (!client) {
+      pendingPermissionContexts.set(pendingContext.contextHash, pendingContext)
+      logger.error('Failed to dismiss pending permission: OpenCode server not found')
+      continue
+    }
+
+    const requestIds = pendingContext.requestIds.length > 0
+      ? pendingContext.requestIds
+      : [pendingContext.permission.id]
+
+    const result = await Promise.all(
+      requestIds.map((requestId) => {
+        return client.permission.reply({
+          requestID: requestId,
+          directory: pendingContext.permissionDirectory,
+          reply: 'reject',
+        })
+      }),
+    ).then(() => {
+      return 'ok' as const
+    }).catch((error) => {
+      pendingPermissionContexts.set(pendingContext.contextHash, pendingContext)
+      logger.error('Failed to dismiss pending permission:', error)
+      return 'error' as const
+    })
+
+    if (result === 'error') {
+      continue
+    }
+
+    updatePermissionMessage({
+      context: pendingContext,
+      status: '_Permission dismissed - user sent a new message._',
+    })
+    cancelledCount++
+  }
+
+  if (cancelledCount > 0) {
+    logger.log(`Dismissed ${cancelledCount} pending permission request(s) for thread ${threadId}`)
+  }
+
+  return cancelledCount > 0
+}
+
 /**
  * Handle button click for permission.
  */
@@ -256,21 +353,9 @@ export async function handlePermissionButton(
       }
     })()
 
-    const patternStr = compactPermissionPatterns(
-      context.permission.patterns,
-    ).join(', ')
-    const externalDirLine =
-      context.permission.permission === 'external_directory'
-        ? `Agent is accessing files outside the project. [Learn more](https://opencode.ai/docs/permissions/#external-directories)\n`
-        : ''
-    await interaction.editReply({
-      content:
-        `⚠️ **Permission Required**\n` +
-        `**Type:** \`${context.permission.permission}\`\n` +
-        externalDirLine +
-        (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
-        resultText,
-      components: [], // Remove the buttons
+    updatePermissionMessage({
+      context,
+      status: resultText,
     })
 
     logger.log(

package/src/commands/resume.ts

@@ -15,7 +15,7 @@ import {
   getAllThreadSessionIds,
 } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
-import { sendThreadMessage, resolveTextChannel } from '../discord-utils.js'
+import { sendThreadMessage, resolveProjectDirectoryFromAutocomplete } from '../discord-utils.js'
 import { collectLastAssistantParts } from '../message-formatting.js'
 import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
@@ -168,17 +168,10 @@ export async function handleResumeAutocomplete({
 }: AutocompleteContext): Promise<void> {
   const focusedValue = interaction.options.getFocused()
 
-  let projectDirectory: string | undefined
-
-  if (interaction.channel) {
-    const textChannel = await resolveTextChannel(
-      interaction.channel as TextChannel | ThreadChannel | null,
-    )
-    if (textChannel) {
-      const channelConfig = await getChannelDirectory(textChannel.id)
-      projectDirectory = channelConfig?.directory
-    }
-  }
+  // interaction.channel can be null when the channel isn't cached
+  // (common with gateway-proxy). Use channelId which is always available
+  // from the raw interaction payload.
+  const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction)
 
   if (!projectDirectory) {
     await interaction.respond([])