kimaki 0.4.82 → 0.4.84

package/src/cli.ts

@@ -55,6 +55,7 @@ import {
   getScheduledTask,
   updateScheduledTask,
   getSessionStartSourcesBySessionIds,
+  deleteChannelDirectoryById,
 } from './database.js'
 import { ShareMarkdown } from './markdown.js'
 import {
@@ -102,6 +103,7 @@ import { spawn, execSync, type ExecSyncOptions } from 'node:child_process'
 
 import {
   setDataDir,
+  setProjectsDir,
   getDataDir,
   getProjectsDir,
 } from './config.js'
@@ -1834,6 +1836,10 @@ cli
     '--data-dir <path>',
     'Data directory for config and database (default: ~/.kimaki)',
   )
+  .option(
+    '--projects-dir <path>',
+    'Directory where new projects are created (default: <data-dir>/projects)',
+  )
   .option('--install-url', 'Print the bot install URL and exit')
   .option(
     '--use-worktrees',
@@ -1877,6 +1883,7 @@ cli
       restartOnboarding?: boolean
       addChannels?: boolean
       dataDir?: string
+      projectsDir?: string
       installUrl?: boolean
       useWorktrees?: boolean
       enableVoiceChannels?: boolean
@@ -1908,6 +1915,11 @@ cli
           cliLogger.log(`Using data directory: ${getDataDir()}`)
         }
 
+        if (options.projectsDir) {
+          setProjectsDir(options.projectsDir)
+          cliLogger.log(`Using projects directory: ${getProjectsDir()}`)
+        }
+
         // Initialize file logging to <dataDir>/kimaki.log
         initLogFile(getDataDir())
 
@@ -3336,7 +3348,8 @@ cli
     'List all registered projects with their Discord channels',
   )
   .option('--json', 'Output as JSON')
-  .action(async (options: { json?: boolean }) => {
+  .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
+  .action(async (options: { json?: boolean; prune?: boolean }) => {
     await initDatabase()
 
     const prisma = await getPrisma()
@@ -3357,26 +3370,62 @@ cli
     const enriched = await Promise.all(
       channels.map(async (ch) => {
         let channelName = ''
+        let deleted = false
         if (rest) {
           try {
             const data = (await rest.get(Routes.channel(ch.channel_id))) as {
               name?: string
             }
             channelName = data.name || ''
-          } catch {
-            // Channel may have been deleted from Discord
+          } catch (error) {
+            // Only mark as deleted for Unknown Channel (10003) or 404,
+            // not transient errors like rate limits or 5xx
+            const isUnknownChannel =
+              error instanceof Error &&
+              'code' in error &&
+              'status' in error &&
+              ((error as { code: number | string }).code === 10003 ||
+                (error as { status: number }).status === 404)
+            deleted = isUnknownChannel
           }
         }
-        return { ...ch, channelName }
+        return { ...ch, channelName, deleted }
       }),
     )
 
+    // Prune stale entries if requested
+    if (options.prune) {
+      const stale = enriched.filter((ch) => {
+        return ch.deleted
+      })
+      if (stale.length === 0) {
+        cliLogger.log('No stale channels to prune')
+      } else {
+        for (const ch of stale) {
+          await deleteChannelDirectoryById(ch.channel_id)
+          cliLogger.log(`Pruned stale channel ${ch.channel_id} (${path.basename(ch.directory)})`)
+        }
+        cliLogger.log(`Pruned ${stale.length} stale channel(s)`)
+      }
+      // Re-filter to only show live entries after pruning
+      const live = enriched.filter((ch) => {
+        return !ch.deleted
+      })
+      if (live.length === 0) {
+        cliLogger.log('No projects registered')
+        process.exit(0)
+      }
+      enriched.length = 0
+      enriched.push(...live)
+    }
+
     if (options.json) {
       const output = enriched.map((ch) => ({
         channel_id: ch.channel_id,
         channel_name: ch.channelName,
         directory: ch.directory,
         folder_name: path.basename(ch.directory),
+        deleted: ch.deleted,
       }))
       console.log(JSON.stringify(output, null, 2))
       process.exit(0)
@@ -3384,8 +3433,9 @@ cli
 
     for (const ch of enriched) {
       const folderName = path.basename(ch.directory)
+      const deletedTag = ch.deleted ? ' (deleted from Discord)' : ''
       const channelLabel = ch.channelName ? `#${ch.channelName}` : ch.channel_id
-      console.log(`\n${channelLabel}`)
+      console.log(`\n${channelLabel}${deletedTag}`)
       console.log(`   Folder: ${folderName}`)
       console.log(`   Directory: ${ch.directory}`)
       console.log(`   Channel ID: ${ch.channel_id}`)
@@ -3642,12 +3692,14 @@ cli
   )
   .option('-h, --host [host]', 'Local host (default: localhost)')
   .option('-s, --server [url]', 'Tunnel server URL')
+  .option('-k, --kill', 'Kill any existing process on the port before starting')
   .action(
     async (options: {
       port?: string
       tunnelId?: string
       host?: string
       server?: string
+      kill?: boolean
     }) => {
       const { runTunnel, parseCommandFromArgv, CLI_NAME } = await import(
         'traforo/run-tunnel'
@@ -3675,6 +3727,7 @@ cli
         baseDomain: 'kimaki.xyz',
         serverUrl: options.server,
         command: command.length > 0 ? command : undefined,
+        kill: options.kill,
       })
     },
   )
@@ -3682,7 +3735,7 @@ 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.',
+    'Share your screen via VNC tunnel. Auto-stops after 30 minutes. Runs until Ctrl+C. Use tmux to run in background.',
   )
   .action(async () => {
     const { startScreenshare } = await import(

package/src/commands/abort.ts

@@ -46,15 +46,14 @@ export async function handleAbortCommand({
     return
   }
 
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
   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,
-    })
+    await command.editReply('Could not determine project directory for this channel')
     return
   }
 
@@ -63,10 +62,7 @@ export async function handleAbortCommand({
   const sessionId = await getThreadSession(channel.id)
 
   if (!sessionId) {
-    await command.reply({
-      content: 'No active session in this thread',
-      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
-    })
+    await command.editReply('No active session in this thread')
     return
   }
 
@@ -78,10 +74,7 @@ export async function handleAbortCommand({
     // No runtime but session exists — fall back to direct API abort
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
     if (getClient instanceof Error) {
-      await command.reply({
-        content: `Failed to abort: ${getClient.message}`,
-        flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
-      })
+      await command.editReply(`Failed to abort: ${getClient.message}`)
       return
     }
     try {
@@ -91,9 +84,6 @@ export async function handleAbortCommand({
     }
   }
 
-  await command.reply({
-    content: `Request **aborted**`,
-    flags: SILENT_MESSAGE_FLAGS,
-  })
+  await command.editReply('Request **aborted**')
   logger.log(`Session ${sessionId} aborted by user`)
 }

package/src/commands/action-buttons.ts

@@ -14,6 +14,7 @@ import crypto from 'node:crypto'
 import { getThreadSession } from '../database.js'
 import {
   NOTIFY_MESSAGE_FLAGS,
+  SILENT_MESSAGE_FLAGS,
   resolveWorkingDirectory,
   sendThreadMessage,
 } from '../discord-utils.js'
@@ -185,11 +186,14 @@ export async function showActionButtons({
   sessionId,
   directory,
   buttons,
+  silent,
 }: {
   thread: ThreadChannel
   sessionId: string
   directory: string
   buttons: ActionButtonOption[]
+  /** Suppress notification when queue has pending items */
+  silent?: boolean
 }): Promise<void> {
   const safeButtons = buttons
     .slice(0, 3)
@@ -242,7 +246,7 @@ export async function showActionButtons({
     const message = await thread.send({
       content: '**Action Required**',
       components: [row],
-      flags: NOTIFY_MESSAGE_FLAGS,
+      flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
     })
 
     context.messageId = message.id

package/src/commands/add-project.ts

@@ -18,7 +18,7 @@ const logger = createLogger(LogPrefix.ADD_PROJECT)
 export async function handleAddProjectCommand({
   command,
 }: CommandContext): Promise<void> {
-  await command.deferReply({ ephemeral: false })
+  await command.deferReply()
 
   const projectId = command.options.getString('project', true)
   const guild = command.guild

package/src/commands/ask-question.ts

@@ -10,7 +10,7 @@ import {
   MessageFlags,
 } from 'discord.js'
 import crypto from 'node:crypto'
-import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { getOpencodeClient } from '../opencode.js'
 import { createLogger, LogPrefix } from '../logger.js'
 
@@ -59,12 +59,15 @@ export async function showAskUserQuestionDropdowns({
   directory,
   requestId,
   input,
+  silent,
 }: {
   thread: ThreadChannel
   sessionId: string
   directory: string
   requestId: string // OpenCode question request ID
   input: AskUserQuestionInput
+  /** Suppress notification when queue has pending items */
+  silent?: boolean
 }): Promise<void> {
   const contextHash = crypto.randomBytes(8).toString('hex')
 
@@ -144,7 +147,7 @@ export async function showAskUserQuestionDropdowns({
     await thread.send({
       content: `**${(q.header || '').slice(0, 200)}**\n${q.question.slice(0, 1700)}`,
       components: [actionRow],
-      flags: NOTIFY_MESSAGE_FLAGS,
+      flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
     })
   }
 

package/src/commands/context-usage.ts

@@ -117,7 +117,7 @@ export async function handleContextUsageCommand({
       if (m.info.role !== 'assistant') {
         return false
       }
-      if (!('tokens' in m.info) || !m.info.tokens) {
+      if (!m.info.tokens) {
         return false
       }
       return getTokenTotal(m.info.tokens) > 0

package/src/commands/create-new-project.ts

@@ -90,7 +90,7 @@ export async function handleCreateNewProjectCommand({
   command,
   appId,
 }: CommandContext): Promise<void> {
-  await command.deferReply({ ephemeral: false })
+  await command.deferReply()
 
   const projectName = command.options.getString('name', true)
   const guild = command.guild

package/src/commands/fork.ts

@@ -21,7 +21,7 @@ import {
   resolveTextChannel,
   sendThreadMessage,
 } from '../discord-utils.js'
-import { collectLastAssistantParts } from '../message-formatting.js'
+import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js'
 import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
@@ -200,7 +200,7 @@ export async function handleForkSelectMenu(
     return
   }
 
-  await interaction.deferReply({ ephemeral: false })
+  await interaction.deferReply()
 
   const threadChannel = interaction.channel
   if (!threadChannel) {
@@ -265,11 +265,13 @@ export async function handleForkSelectMenu(
       reason: `Forked from session ${sessionId}`,
     })
 
+    // Claim the forked session immediately so external polling does not race
+    // and create a duplicate Sync thread before the rest of this setup runs.
+    await setThreadSession(thread.id, forkedSession.id)
+
     // Add user to thread so it appears in their sidebar
     await thread.members.add(interaction.user.id)
 
-    await setThreadSession(thread.id, forkedSession.id)
-
     sessionLogger.log(
       `Created forked session ${forkedSession.id} in thread ${thread.id}`,
     )
@@ -285,16 +287,15 @@ export async function handleForkSelectMenu(
     })
 
     if (messagesResponse.data) {
-      const { partIds, content } = collectLastAssistantParts({
+      const { chunks } = collectSessionChunks({
         messages: messagesResponse.data,
+        limit: 30,
       })
-
-      if (content.trim()) {
-        const discordMessage = await sendThreadMessage(thread, content)
-
-        // Store part-message mappings atomically
+      const batched = batchChunksForDiscord(chunks)
+      for (const batch of batched) {
+        const discordMessage = await sendThreadMessage(thread, batch.content)
         await setPartMessagesBatch(
-          partIds.map((partId) => ({
+          batch.partIds.map((partId) => ({
             partId,
             messageId: discordMessage.id,
             threadId: thread.id,

package/src/commands/merge-worktree.ts

@@ -92,7 +92,7 @@ export async function handleMergeWorktreeCommand({
   command,
   appId,
 }: CommandContext): Promise<void> {
-  await command.deferReply({ ephemeral: false })
+  await command.deferReply()
 
   const channel = command.channel
   if (!channel || !channel.isThread()) {

package/src/commands/new-worktree.ts

@@ -37,6 +37,11 @@ import * as errore from 'errore'
 
 const logger = createLogger(LogPrefix.WORKTREE)
 
+/** Status message shown while a worktree is being created. */
+export function worktreeCreatingMessage(worktreeName: string): string {
+  return `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`
+}
+
 class WorktreeError extends Error {
   constructor(message: string, options?: { cause?: unknown }) {
     super(message, options)
@@ -105,9 +110,18 @@ async function getProjectDirectoryFromChannel(
 }
 
 /**
- * Create worktree in background and update starter message when done.
+ * Create worktree and update the status message when done.
+ * Handles the full lifecycle: pending DB entry, git creation, DB ready/error,
+ * tree emoji reaction, and editing the status message.
+ *
+ * starterMessage is optional — if omitted, status edits are skipped (creation
+ * still proceeds). This keeps worktree creation independent of Discord message
+ * delivery, so a transient send failure never silently skips the worktree.
+ *
+ * Returns the worktree directory on success, or an Error on failure.
+ * Never throws — all internal errors are caught and returned as Error values.
  */
-async function createWorktreeInBackground({
+export async function createWorktreeInBackground({
   thread,
   starterMessage,
   worktreeName,
@@ -116,50 +130,69 @@ async function createWorktreeInBackground({
   rest,
 }: {
   thread: ThreadChannel
-  starterMessage: Message
+  starterMessage?: Message
   worktreeName: string
   projectDirectory: string
   baseBranch?: string
   rest: REST
-}): Promise<void> {
-  logger.log(
-    `Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`,
-  )
-  const worktreeResult = await createWorktreeWithSubmodules({
-    directory: projectDirectory,
-    name: worktreeName,
-    baseBranch,
-  })
+}): Promise<string | Error> {
+  return errore.tryAsync({
+    try: async () => {
+      logger.log(
+        `Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`,
+      )
+
+      await createPendingWorktree({
+        threadId: thread.id,
+        worktreeName,
+        projectDirectory,
+      })
 
-  if (worktreeResult instanceof Error) {
-    const errorMsg = worktreeResult.message
-    logger.error('[NEW-WORKTREE] Error:', worktreeResult)
-    await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg })
-    await starterMessage.edit(
-      `🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`,
-    )
-    return
-  }
+      const worktreeResult = await createWorktreeWithSubmodules({
+        directory: projectDirectory,
+        name: worktreeName,
+        baseBranch,
+      })
 
-  // Success - update database and edit starter message
-  await setWorktreeReady({
-    threadId: thread.id,
-    worktreeDirectory: worktreeResult.directory,
-  })
+      if (worktreeResult instanceof Error) {
+        const errorMsg = worktreeResult.message
+        logger.error('[WORKTREE] Creation failed:', worktreeResult)
+        await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg })
+        await starterMessage
+          ?.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`)
+          .catch(() => {})
+        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: '🌳',
-  })
+      // React with tree emoji to mark as worktree thread
+      await reactToThread({
+        rest,
+        threadId: thread.id,
+        channelId: thread.parentId || undefined,
+        emoji: '🌳',
+      })
 
-  await starterMessage.edit(
-    `🌳 **Worktree: ${worktreeName}**\n` +
-      `📁 \`${worktreeResult.directory}\`\n` +
-      `🌿 Branch: \`${worktreeResult.branch}\``,
-  )
+      await starterMessage
+        ?.edit(
+          `🌳 **Worktree: ${worktreeName}**\n` +
+            `📁 \`${worktreeResult.directory}\`\n` +
+            `🌿 Branch: \`${worktreeResult.branch}\``,
+        )
+        .catch(() => {})
+
+      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({
@@ -201,7 +234,7 @@ async function findExistingWorktreePath({
 export async function handleNewWorktreeCommand({
   command,
 }: CommandContext): Promise<void> {
-  await command.deferReply({ ephemeral: false })
+  await command.deferReply()
 
   const channel = command.channel
   if (!channel) {
@@ -289,7 +322,7 @@ export async function handleNewWorktreeCommand({
   const result = await errore.tryAsync({
     try: async () => {
       const starterMessage = await textChannel.send({
-        content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+        content: worktreeCreatingMessage(worktreeName),
         flags: SILENT_MESSAGE_FLAGS,
       })
 
@@ -315,13 +348,6 @@ export async function handleNewWorktreeCommand({
 
   const { thread, starterMessage } = result
 
-  // Store pending worktree in database
-  await createPendingWorktree({
-    threadId: thread.id,
-    worktreeName,
-    projectDirectory,
-  })
-
   await command.editReply(`Creating worktree in ${thread.toString()}`)
 
   // Create worktree in background (don't await)
@@ -412,16 +438,9 @@ async function handleWorktreeInThread({
     return
   }
 
-  // Store pending worktree in database for this existing thread
-  await createPendingWorktree({
-    threadId: thread.id,
-    worktreeName,
-    projectDirectory,
-  })
-
   // Send status message in thread
   const statusMessage = await thread.send({
-    content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+    content: worktreeCreatingMessage(worktreeName),
     flags: SILENT_MESSAGE_FLAGS,
   })
 

package/src/commands/remove-project.ts

@@ -17,7 +17,7 @@ export async function handleRemoveProjectCommand({
   command,
   appId,
 }: CommandContext): Promise<void> {
-  await command.deferReply({ ephemeral: false })
+  await command.deferReply()
 
   const directory = command.options.getString('project', true)
   const guild = command.guild

package/src/commands/resume.ts

@@ -20,7 +20,7 @@ import {
   resolveProjectDirectoryFromAutocomplete,
   NOTIFY_MESSAGE_FLAGS,
 } from '../discord-utils.js'
-import { collectLastAssistantParts } from '../message-formatting.js'
+import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js'
 import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
@@ -29,7 +29,7 @@ const logger = createLogger(LogPrefix.RESUME)
 export async function handleResumeCommand({
   command,
 }: CommandContext): Promise<void> {
-  await command.deferReply({ ephemeral: false })
+  await command.deferReply()
 
   const sessionId = command.options.getString('session', true)
   const channel = command.channel
@@ -95,11 +95,13 @@ export async function handleResumeCommand({
       reason: `Resuming session ${sessionId}`,
     })
 
+    // Claim the resumed session immediately so external polling does not race
+    // and create a duplicate Sync thread before the rest of this setup runs.
+    await setThreadSession(thread.id, 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({
@@ -122,8 +124,9 @@ export async function handleResumeCommand({
     )
 
     try {
-      const { partIds, content, skippedCount } = collectLastAssistantParts({
+      const { chunks, skippedCount } = collectSessionChunks({
         messages,
+        limit: 30,
       })
 
       if (skippedCount > 0) {
@@ -133,12 +136,11 @@ export async function handleResumeCommand({
         )
       }
 
-      if (content.trim()) {
-        const discordMessage = await sendThreadMessage(thread, content)
-
-        // Store part-message mappings atomically
+      const batched = batchChunksForDiscord(chunks)
+      for (const batch of batched) {
+        const discordMessage = await sendThreadMessage(thread, batch.content)
         await setPartMessagesBatch(
-          partIds.map((partId) => ({
+          batch.partIds.map((partId) => ({
             partId,
             messageId: discordMessage.id,
             threadId: thread.id,

package/src/commands/screenshare.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'vitest'
+import { buildNoVncUrl, createScreenshareTunnelId } from './screenshare.js'
+
+describe('screenshare security defaults', () => {
+  test('generates a 128-bit tunnel id', () => {
+    const ids = new Set(
+      Array.from({ length: 32 }, () => {
+        return createScreenshareTunnelId()
+      }),
+    )
+
+    expect(ids.size).toBe(32)
+    for (const id of ids) {
+      expect(id).toMatch(/^[0-9a-f]{32}$/)
+    }
+  })
+
+  test('builds a secure noVNC URL', () => {
+    const url = new URL(
+      buildNoVncUrl({ tunnelHost: '0123456789abcdef-tunnel.kimaki.xyz' }),
+    )
+
+    expect(url.origin).toBe('https://novnc.com')
+    expect(url.searchParams.get('host')).toBe(
+      '0123456789abcdef-tunnel.kimaki.xyz',
+    )
+    expect(url.searchParams.get('port')).toBe('443')
+    expect(url.searchParams.get('encrypt')).toBe('1')
+  })
+})