@brianli/kimaki 0.4.72-brianli.1

package/src/commands/restart-opencode-server.ts

@@ -0,0 +1,162 @@
+// /restart-opencode-server command - Restart the opencode server for the current channel.
+// Used for resolving opencode state issues, internal bugs, refreshing auth state, plugins, etc.
+// Aborts all in-progress sessions in this channel before restarting to avoid orphaned requests.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type ThreadChannel,
+  type TextChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import {
+  initializeOpencodeForDirectory,
+  restartOpencodeServer,
+} from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { getAllThreadSessionIds, getThreadIdBySessionId } from '../database.js'
+import { abortControllers } from '../session-handler.js'
+import { SessionAbortError } from '../errors.js'
+import * as errore from 'errore'
+
+const logger = createLogger(LogPrefix.OPENCODE)
+
+export async function handleRestartOpencodeServerCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  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 text channels or threads',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const { projectDirectory, channelAppId } = resolved
+
+  if (channelAppId && channelAppId !== appId) {
+    await command.reply({
+      content: 'This channel is not configured for this bot',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  // Defer reply since restart may take a moment
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  // Abort all in-progress sessions in this channel before restarting.
+  // Find sessions with active abort controllers, check if their thread belongs
+  // to this channel (thread parentId matches, or command was run in the thread itself).
+  const parentChannelId = isThread
+    ? (channel as ThreadChannel).parentId
+    : channel.id
+  const activeSessionIds = [...abortControllers.keys()]
+  let abortedCount = 0
+
+  if (activeSessionIds.length > 0) {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    const client = !(getClient instanceof Error) ? getClient : null
+
+    for (const sessionId of activeSessionIds) {
+      const threadId = await getThreadIdBySessionId(sessionId)
+      if (!threadId) {
+        continue
+      }
+      // Check if thread belongs to this channel: either the thread IS this channel,
+      // or the thread's parent matches the parent channel
+      const threadChannel = await errore.tryAsync(() => {
+        return command.client.channels.fetch(threadId)
+      })
+      if (threadChannel instanceof Error || !threadChannel) {
+        continue
+      }
+      const threadParentId =
+        'parentId' in threadChannel ? threadChannel.parentId : null
+      if (threadId !== channel.id && threadParentId !== parentChannelId) {
+        continue
+      }
+
+      const controller = abortControllers.get(sessionId)
+      if (controller) {
+        logger.log(
+          `[RESTART] Aborting session ${sessionId} in thread ${threadId}`,
+        )
+        controller.abort(new SessionAbortError({ reason: 'server-restart' }))
+        abortControllers.delete(sessionId)
+        abortedCount++
+      }
+      if (client) {
+        await errore.tryAsync(() => {
+          return client().session.abort({ sessionID: sessionId })
+        })
+      }
+    }
+  }
+
+  if (abortedCount > 0) {
+    logger.log(
+      `[RESTART] Aborted ${abortedCount} active session(s) before restart`,
+    )
+  }
+
+  logger.log(
+    `[RESTART] Restarting opencode server for directory: ${projectDirectory}`,
+  )
+
+  const result = await restartOpencodeServer(projectDirectory)
+
+  if (result instanceof Error) {
+    logger.error('[RESTART] Failed:', result)
+    await command.editReply({
+      content: `Failed to restart opencode server: ${result.message}`,
+    })
+    return
+  }
+
+  const abortMsg =
+    abortedCount > 0
+      ? ` (aborted ${abortedCount} active session${abortedCount > 1 ? 's' : ''})`
+      : ''
+  await command.editReply({
+    content: `Opencode server **restarted** successfully${abortMsg}`,
+  })
+  logger.log(
+    `[RESTART] Opencode server restarted for directory: ${projectDirectory}`,
+  )
+}

package/src/commands/resume.ts

@@ -0,0 +1,242 @@
+// /resume command - Resume an existing OpenCode session.
+
+import {
+  ChannelType,
+  ThreadAutoArchiveDuration,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import fs from 'node:fs'
+import type { CommandContext, AutocompleteContext } from './types.js'
+import {
+  getChannelDirectory,
+  setThreadSession,
+  setPartMessagesBatch,
+  getAllThreadSessionIds,
+} from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { sendThreadMessage, resolveTextChannel } from '../discord-utils.js'
+import { collectLastAssistantParts } from '../message-formatting.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import * as errore from 'errore'
+
+const logger = createLogger(LogPrefix.RESUME)
+
+export async function handleResumeCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const sessionId = command.options.getString('session', true)
+  const channel = command.channel
+
+  const isThread =
+    channel &&
+    [
+      ChannelType.PublicThread,
+      ChannelType.PrivateThread,
+      ChannelType.AnnouncementThread,
+    ].includes(channel.type)
+
+  if (isThread) {
+    await command.editReply(
+      'This command can only be used in project channels, not threads',
+    )
+    return
+  }
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in text channels')
+    return
+  }
+
+  const textChannel = channel as TextChannel
+
+  const channelConfig = await getChannelDirectory(textChannel.id)
+  const projectDirectory = channelConfig?.directory
+  const channelAppId = channelConfig?.appId || undefined
+
+  if (channelAppId && channelAppId !== appId) {
+    await command.editReply('This channel is not configured for this bot')
+    return
+  }
+
+  if (!projectDirectory) {
+    await command.editReply(
+      'This channel is not configured with a project directory',
+    )
+    return
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    await command.editReply(`Directory does not exist: ${projectDirectory}`)
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await command.editReply(getClient.message)
+      return
+    }
+
+    const sessionResponse = await getClient().session.get({
+      sessionID: sessionId,
+    })
+
+    if (!sessionResponse.data) {
+      await command.editReply('Session not found')
+      return
+    }
+
+    const sessionTitle = sessionResponse.data.title
+
+    const thread = await textChannel.threads.create({
+      name: `Resume: ${sessionTitle}`.slice(0, 100),
+      autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+      reason: `Resuming session ${sessionId}`,
+    })
+
+    // Add user to thread so it appears in their sidebar
+    await thread.members.add(command.user.id)
+
+    await setThreadSession(thread.id, sessionId)
+
+    logger.log(`[RESUME] Created thread ${thread.id} for session ${sessionId}`)
+
+    const messagesResponse = await getClient().session.messages({
+      sessionID: sessionId,
+    })
+
+    if (!messagesResponse.data) {
+      throw new Error('Failed to fetch session messages')
+    }
+
+    const messages = messagesResponse.data
+
+    await command.editReply(
+      `Resumed session "${sessionTitle}" in ${thread.toString()}`,
+    )
+
+    await sendThreadMessage(
+      thread,
+      `**Resumed session:** ${sessionTitle}\n**Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`,
+    )
+
+    try {
+      const { partIds, content, skippedCount } = collectLastAssistantParts({
+        messages,
+      })
+
+      if (skippedCount > 0) {
+        await sendThreadMessage(
+          thread,
+          `*Skipped ${skippedCount} older assistant parts...*`,
+        )
+      }
+
+      if (content.trim()) {
+        const discordMessage = await sendThreadMessage(thread, content)
+
+        // Store part-message mappings atomically
+        await setPartMessagesBatch(
+          partIds.map((partId) => ({
+            partId,
+            messageId: discordMessage.id,
+            threadId: thread.id,
+          })),
+        )
+      }
+
+      const messageCount = messages.length
+
+      await sendThreadMessage(
+        thread,
+        `**Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`,
+      )
+    } catch (sendError) {
+      logger.error('[RESUME] Error sending messages to thread:', sendError)
+      await sendThreadMessage(
+        thread,
+        `Failed to load message history, but session is connected. You can still send new messages.`,
+      )
+    }
+  } catch (error) {
+    logger.error('[RESUME] Error:', error)
+    await command.editReply(
+      `Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleResumeAutocomplete({
+  interaction,
+  appId,
+}: 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)
+      if (channelConfig?.appId && channelConfig.appId !== appId) {
+        await interaction.respond([])
+        return
+      }
+      projectDirectory = channelConfig?.directory
+    }
+  }
+
+  if (!projectDirectory) {
+    await interaction.respond([])
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await interaction.respond([])
+      return
+    }
+
+    const sessionsResponse = await getClient().session.list()
+    if (!sessionsResponse.data) {
+      await interaction.respond([])
+      return
+    }
+
+    const existingSessionIds = new Set(await getAllThreadSessionIds())
+
+    const sessions = sessionsResponse.data
+      .filter((session) => !existingSessionIds.has(session.id))
+      .filter((session) =>
+        session.title.toLowerCase().includes(focusedValue.toLowerCase()),
+      )
+      .slice(0, 25)
+      .map((session) => {
+        const dateStr = new Date(session.time.updated).toLocaleString()
+        const suffix = ` (${dateStr})`
+        const maxTitleLength = 100 - suffix.length
+
+        let title = session.title
+        if (title.length > maxTitleLength) {
+          title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…'
+        }
+
+        return {
+          name: `${title}${suffix}`,
+          value: session.id,
+        }
+      })
+
+    await interaction.respond(sessions)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching sessions:', error)
+    await interaction.respond([])
+  }
+}

package/src/commands/run-command.ts

@@ -0,0 +1,123 @@
+// /run-shell-command command - Run an arbitrary shell command in the project directory.
+// Resolves the project directory from the channel and executes the command with it as cwd.
+// Also used by the ! prefix shortcut in discord messages (e.g. "!ls -la").
+// Messages starting with ! are intercepted before session handling and routed here.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { execAsync } from '../worktree-utils.js'
+import { stripAnsi } from '../utils.js'
+
+const logger = createLogger(LogPrefix.INTERACTION)
+
+const MAX_OUTPUT_CHARS = 1900
+
+export async function runShellCommand({
+  command,
+  directory,
+}: {
+  command: string
+  directory: string
+}): Promise<string> {
+  try {
+    const { stdout, stderr } = await execAsync(command, { cwd: directory })
+    const output = stripAnsi([stdout, stderr].filter(Boolean).join('\n').trim())
+
+    const header = `\`${command}\` exited with 0`
+    if (!output) {
+      return header
+    }
+    return formatOutput(output, header)
+  } catch (error) {
+    const execError = error as {
+      stdout?: string
+      stderr?: string
+      message?: string
+      code?: number | string
+    }
+    const output = stripAnsi(
+      [execError.stdout, execError.stderr].filter(Boolean).join('\n').trim(),
+    )
+    const exitCode = execError.code ?? 1
+    logger.error(
+      `[RUN-COMMAND] Command "${command}" exited with ${exitCode}:`,
+      error,
+    )
+
+    const header = `\`${command}\` exited with ${exitCode}`
+    return formatOutput(output || execError.message || 'Unknown error', header)
+  }
+}
+
+export async function handleRunCommand({
+  command,
+}: CommandContext): Promise<void> {
+  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 as TextChannel | ThreadChannel,
+  })
+
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel.',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const input = command.options.getString('command', true)
+
+  await command.deferReply()
+
+  const result = await runShellCommand({
+    command: input,
+    directory: resolved.workingDirectory,
+  })
+  await command.editReply({ content: result })
+}
+
+function formatOutput(output: string, header: string): string {
+  // Reserve space for header + newline + code block delimiters (```\n...\n```)
+  const overhead = header.length + 1 + 3 + 1 + 1 + 3 // header\n```\n...\n```
+  const maxContent = MAX_OUTPUT_CHARS - overhead
+  const truncated =
+    output.length > maxContent
+      ? output.slice(0, maxContent - 14) + '\n... truncated'
+      : output
+  return `${header}\n\`\`\`\n${truncated}\n\`\`\``
+}

package/src/commands/session-id.ts

@@ -0,0 +1,109 @@
+// /session-id command - Show current session ID and an opencode attach command.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getThreadSession } from '../database.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import {
+  getOpencodeServerPort,
+  initializeOpencodeForDirectory,
+} from '../opencode.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.SESSION)
+
+function shellQuote(value: string): string {
+  if (!value) {
+    return "''"
+  }
+  return `'${value.replaceAll("'", `'"'"'`)}'`
+}
+
+export async function handleSessionIdCommand({
+  command,
+}: CommandContext): Promise<void> {
+  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 as TextChannel | ThreadChannel,
+  })
+
+  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
+  }
+
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  let port = getOpencodeServerPort(projectDirectory)
+  if (!port) {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await command.editReply({
+        content: `Session ID: \`${sessionId}\`\nFailed to resolve OpenCode server port: ${getClient.message}`,
+      })
+      return
+    }
+    port = getOpencodeServerPort(projectDirectory)
+  }
+
+  if (!port) {
+    await command.editReply({
+      content: `Session ID: \`${sessionId}\`\nCould not determine OpenCode server port`,
+    })
+    return
+  }
+
+  const attachUrl = `http://127.0.0.1:${port}`
+  const attachCommand = `opencode attach ${attachUrl} --session ${sessionId} --dir ${shellQuote(workingDirectory)}`
+
+  await command.editReply({
+    content: `**Session ID:** \`${sessionId}\`\n**Attach command:**\n\`\`\`bash\n${attachCommand}\n\`\`\``,
+  })
+  logger.log(`Session ID shown for thread ${channel.id}: ${sessionId}`)
+}