kimaki 0.4.82 → 0.4.84

package/src/commands/screenshare.ts

@@ -19,6 +19,7 @@ import { execAsync } from '../worktrees.js'
 import type { WebSocketServer } from 'ws'
 
 const logger = createLogger('SCREEN')
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS
 
 export type ScreenshareSession = {
   tunnelClient: TunnelClient
@@ -37,8 +38,10 @@ export type ScreenshareSession = {
 const activeSessions = new Map<string, ScreenshareSession>()
 
 const VNC_PORT = 5900
-const MAX_SESSION_MS = 60 * 60 * 1000 // 1 hour
+const MAX_SESSION_MINUTES = 30
+const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000
 const TUNNEL_BASE_DOMAIN = 'kimaki.xyz'
+const SCREENSHARE_TUNNEL_ID_BYTES = 16
 
 // Public noVNC client — we point it at our tunnel URL
 export function buildNoVncUrl({ tunnelHost }: { tunnelHost: string }): string {
@@ -53,6 +56,10 @@ export function buildNoVncUrl({ tunnelHost }: { tunnelHost: string }): string {
   return `https://novnc.com/noVNC/vnc.html?${params.toString()}`
 }
 
+export function createScreenshareTunnelId(): string {
+  return crypto.randomBytes(SCREENSHARE_TUNNEL_ID_BYTES).toString('hex')
+}
+
 // macOS has two separate services:
 // - "Screen Sharing" = view-only VNC (com.apple.screensharing)
 // - "Remote Management" = full control VNC with mouse/keyboard (ARDAgent)
@@ -212,7 +219,7 @@ export async function startScreenshare({
   }
 
   // Step 3: create tunnel
-  const tunnelId = crypto.randomBytes(8).toString('hex')
+  const tunnelId = createScreenshareTunnelId()
   const tunnelClient = new TunnelClient({
     localPort: wsInstance.port,
     tunnelId,
@@ -241,9 +248,11 @@ export async function startScreenshare({
   const tunnelUrl = `https://${tunnelHost}`
   const noVncUrl = buildNoVncUrl({ tunnelHost })
 
-  // Auto-kill after 1 hour
+  // Auto-kill after a short session so a leaked URL does not stay usable all day.
   const timeoutTimer = setTimeout(() => {
-    logger.log(`Screen share auto-stopped after 1 hour (key: ${sessionKey})`)
+    logger.log(
+      `Screen share auto-stopped after ${MAX_SESSION_MINUTES} minutes (key: ${sessionKey})`,
+    )
     stopScreenshare({ sessionKey })
   }, MAX_SESSION_MS)
   // Don't keep the process alive just for this timer
@@ -292,7 +301,7 @@ export async function handleScreenshareCommand({
     return
   }
 
-  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+  await command.deferReply({ flags: SECURE_REPLY_FLAGS })
 
   try {
     const session = await startScreenshare({
@@ -300,7 +309,10 @@ export async function handleScreenshareCommand({
       startedBy: command.user.tag,
     })
     await command.editReply({
-      content: `Screen sharing started\n${session.noVncUrl}`,
+      content:
+        `Screen sharing started. This reply is private and the URL uses a high-entropy tunnel id. ` +
+        `It will auto-stop after ${MAX_SESSION_MINUTES} minutes. Use /screenshare-stop to stop sooner.\n` +
+        `${session.noVncUrl}`,
     })
   } catch (err) {
     logger.error('Failed to start screen share:', err)

package/src/commands/session.ts

@@ -17,7 +17,7 @@ export async function handleSessionCommand({
   command,
   appId,
 }: CommandContext): Promise<void> {
-  await command.deferReply({ ephemeral: false })
+  await command.deferReply()
 
   const prompt = command.options.getString('prompt', true)
   const filesString = command.options.getString('files') || ''

package/src/commands/undo-redo.ts

@@ -6,6 +6,7 @@ import {
   type TextChannel,
   type ThreadChannel,
 } from 'discord.js'
+import type { OpencodeClient } from '@opencode-ai/sdk/v2'
 import type { CommandContext } from './types.js'
 import { getThreadSession } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
@@ -17,6 +18,30 @@ import { createLogger, LogPrefix } from '../logger.js'
 
 const logger = createLogger(LogPrefix.UNDO_REDO)
 
+async function waitForSessionIdle({
+  client,
+  sessionId,
+  directory,
+  timeoutMs = 2_000,
+}: {
+  client: OpencodeClient
+  sessionId: string
+  directory: string
+  timeoutMs?: number
+}): Promise<void> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    const statusResponse = await client.session.status({ directory })
+    const sessionStatus = statusResponse.data?.[sessionId]
+    if (!sessionStatus || sessionStatus.type === 'idle') {
+      return
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 50)
+    })
+  }
+}
+
 export async function handleUndoCommand({
   command,
 }: CommandContext): Promise<void> {
@@ -57,7 +82,7 @@ export async function handleUndoCommand({
     return
   }
 
-  const { projectDirectory } = resolved
+  const { projectDirectory, workingDirectory } = resolved
 
   const sessionId = await getThreadSession(channel.id)
 
@@ -79,18 +104,41 @@ export async function handleUndoCommand({
 
   try {
     const client = getClient()
-
     // Fetch session to check existing revert state
     const sessionResponse = await client.session.get({
       sessionID: sessionId,
+      directory: workingDirectory,
     })
     if (sessionResponse.error) {
       await command.editReply(`Failed to undo: ${JSON.stringify(sessionResponse.error)}`)
       return
     }
 
+    // Abort if session is busy before reverting, matching TUI behavior
+    // (use-session-commands.tsx always aborts non-idle sessions before revert).
+    // session.status() returns a sparse map — only non-idle sessions have entries,
+    // so a missing key means idle.
+    const statusResponse = await client.session.status({
+      directory: workingDirectory,
+    })
+    const sessionStatus = statusResponse.data?.[sessionId]
+    if (sessionStatus && sessionStatus.type !== 'idle') {
+      await client.session.abort({
+        sessionID: sessionId,
+        directory: workingDirectory,
+      }).catch((error) => {
+        logger.warn(`[UNDO] abort failed for ${sessionId}`, error)
+      })
+      await waitForSessionIdle({
+        client,
+        sessionId,
+        directory: workingDirectory,
+      })
+    }
+
     const messagesResponse = await client.session.messages({
       sessionID: sessionId,
+      directory: workingDirectory,
     })
     if (messagesResponse.error) {
       await command.editReply(`Failed to undo: ${JSON.stringify(messagesResponse.error)}`)
@@ -119,21 +167,44 @@ export async function handleUndoCommand({
       return
     }
 
+    const targetAssistantMessage = [...messagesResponse.data].reverse().find((m) => {
+      return m.info.role === 'assistant' && m.info.parentID === targetUserMessage.info.id
+    })
+    const revertMessageId = targetAssistantMessage?.info.id || targetUserMessage.info.id
+
     // session.revert() reverts filesystem patches (file edits, writes) and
     // marks the session with revert.messageID. Messages are NOT deleted — they
     // get cleaned up automatically on the next promptAsync() call via
     // SessionRevert.cleanup(). The model only sees messages before the revert
     // point when processing the next prompt.
-    const response = await client.session.revert({
+    logger.log(`[UNDO] session.revert start messageId=${revertMessageId}`)
+    let response = await client.session.revert({
       sessionID: sessionId,
-      messageID: targetUserMessage.info.id,
+      directory: workingDirectory,
+      messageID: revertMessageId,
     })
+    logger.log(`[UNDO] session.revert done error=${Boolean(response.error)}`)
 
     if (response.error) {
-      await command.editReply(
-        `Failed to undo: ${JSON.stringify(response.error)}`,
-      )
-      return
+      logger.log('[UNDO] retry wait idle before revert retry')
+      await waitForSessionIdle({
+        client,
+        sessionId,
+        directory: workingDirectory,
+      })
+      logger.log('[UNDO] retry revert start')
+      response = await client.session.revert({
+        sessionID: sessionId,
+        directory: workingDirectory,
+        messageID: revertMessageId,
+      })
+      logger.log(`[UNDO] retry revert done error=${Boolean(response.error)}`)
+      if (response.error) {
+        await command.editReply(
+          `Failed to undo: ${JSON.stringify(response.error)}`,
+        )
+        return
+      }
     }
 
     const diffInfo = response.data?.revert?.diff
@@ -142,7 +213,7 @@ export async function handleUndoCommand({
 
     await command.editReply(`Undone - reverted last assistant message${diffInfo}`)
     logger.log(
-      `Session ${sessionId} reverted to before user message ${targetUserMessage.info.id}`,
+      `Session ${sessionId} reverted at message ${revertMessageId}`,
     )
   } catch (error) {
     logger.error('[UNDO] Error:', error)
@@ -192,7 +263,7 @@ export async function handleRedoCommand({
     return
   }
 
-  const { projectDirectory } = resolved
+  const { projectDirectory, workingDirectory } = resolved
 
   const sessionId = await getThreadSession(channel.id)
 
@@ -218,6 +289,7 @@ export async function handleRedoCommand({
     // Fetch session to check existing revert state
     const sessionResponse = await client.session.get({
       sessionID: sessionId,
+      directory: workingDirectory,
     })
     if (sessionResponse.error) {
       await command.editReply(`Failed to redo: ${JSON.stringify(sessionResponse.error)}`)
@@ -230,12 +302,36 @@ export async function handleRedoCommand({
       return
     }
 
+    // Abort if session is busy before reverting/unreverting — both enforce
+    // assertNotBusy in OpenCode and would fail with "Session is busy"
+    const redoStatusResponse = await client.session.status({
+      directory: workingDirectory,
+    })
+    const redoSessionStatus = redoStatusResponse.data?.[sessionId]
+    if (redoSessionStatus && redoSessionStatus.type !== 'idle') {
+      await client.session.abort({
+        sessionID: sessionId,
+        directory: workingDirectory,
+      }).catch((error) => {
+        logger.warn(`[REDO] abort failed for ${sessionId}`, error)
+      })
+      await waitForSessionIdle({
+        client,
+        sessionId,
+        directory: workingDirectory,
+      })
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 500)
+    })
+
     // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
     // find the next user message after the current revert point. If one exists,
     // move the revert cursor forward to it (one step redo). If none exists,
     // fully unrevert — we're at the end of the message history.
     const messagesResponse = await client.session.messages({
       sessionID: sessionId,
+      directory: workingDirectory,
     })
     if (messagesResponse.error) {
       await command.editReply(`Failed to redo: ${JSON.stringify(messagesResponse.error)}`)
@@ -252,6 +348,7 @@ export async function handleRedoCommand({
       // No more messages after revert point — fully unrevert
       const response = await client.session.unrevert({
         sessionID: sessionId,
+        directory: workingDirectory,
       })
       if (response.error) {
         await command.editReply(
@@ -267,6 +364,7 @@ export async function handleRedoCommand({
     // Move revert cursor forward one step to the next user message
     const response = await client.session.revert({
       sessionID: sessionId,
+      directory: workingDirectory,
       messageID: nextMessage.info.id,
     })
 

package/src/commands/user-command.ts

@@ -109,7 +109,7 @@ export const handleUserCommand: CommandHandler = async ({
     return
   }
 
-  await command.deferReply({ ephemeral: false })
+  await command.deferReply()
 
   try {
     // Use the dedicated session.command API instead of formatting as text prompt

package/src/config.ts

@@ -49,12 +49,30 @@ export function setDataDir(dir: string): void {
 
 /**
  * Get the projects directory path (for /create-new-project command).
- * Returns <dataDir>/projects
+ * Returns the custom --projects-dir if set, otherwise <dataDir>/projects.
  */
 export function getProjectsDir(): string {
+  const custom = store.getState().projectsDir
+  if (custom) {
+    return custom
+  }
   return path.join(getDataDir(), 'projects')
 }
 
+/**
+ * Set a custom projects directory path (from --projects-dir CLI flag).
+ * Creates the directory if it doesn't exist.
+ */
+export function setProjectsDir(dir: string): void {
+  const resolvedDir = path.resolve(dir)
+
+  if (!fs.existsSync(resolvedDir)) {
+    fs.mkdirSync(resolvedDir, { recursive: true })
+  }
+
+  store.setState({ projectsDir: resolvedDir })
+}
+
 export type { RegisteredUserCommand } from './store.js'
 
 const DEFAULT_LOCK_PORT = 29988

package/src/database.ts

@@ -3,7 +3,7 @@
 // API keys, and model preferences in <dataDir>/discord-sessions.db.
 
 import { getPrisma, closePrisma } from './db.js'
-import type { Prisma, session_events, BotMode, VerbosityLevel, WorktreeStatus, ChannelType as PrismaChannelType } from './generated/client.js'
+import type { Prisma, session_events, BotMode, VerbosityLevel, WorktreeStatus, ChannelType as PrismaChannelType, ThreadSessionSource } from './generated/client.js'
 import crypto from 'node:crypto'
 
 import { store } from './store.js'
@@ -1015,14 +1015,48 @@ export async function setThreadSession(
   threadId: string,
   sessionId: string,
 ): Promise<void> {
+  await upsertThreadSession({
+    threadId,
+    sessionId,
+    source: 'kimaki',
+  })
+}
+
+export async function upsertThreadSession({
+  threadId,
+  sessionId,
+  source,
+}: {
+  threadId: string
+  sessionId: string
+  source: ThreadSessionSource
+}): Promise<void> {
   const prisma = await getPrisma()
   await prisma.thread_sessions.upsert({
     where: { thread_id: threadId },
-    create: { thread_id: threadId, session_id: sessionId },
-    update: { session_id: sessionId },
+    create: {
+      thread_id: threadId,
+      session_id: sessionId,
+      source,
+    },
+    update: {
+      session_id: sessionId,
+      source,
+    },
   })
 }
 
+export async function getThreadSessionSource(
+  threadId: string,
+): Promise<ThreadSessionSource | undefined> {
+  const prisma = await getPrisma()
+  const row = await prisma.thread_sessions.findUnique({
+    where: { thread_id: threadId },
+    select: { source: true },
+  })
+  return row?.source
+}
+
 /**
  * Get the thread ID for a session.
  */
@@ -1564,6 +1598,17 @@ export async function getAllTextChannelDirectories(): Promise<string[]> {
   return rows.map((row) => row.directory)
 }
 
+export async function listTrackedTextChannels(): Promise<
+  Array<{ channel_id: string; directory: string; created_at: Date | null }>
+> {
+  const prisma = await getPrisma()
+  return prisma.channel_directories.findMany({
+    where: { channel_type: 'text' },
+    orderBy: [{ created_at: 'asc' }, { channel_id: 'asc' }],
+    select: { channel_id: true, directory: true, created_at: true },
+  })
+}
+
 /**
  * Delete all channel directories for a specific directory.
  */
@@ -1576,6 +1621,30 @@ export async function deleteChannelDirectoriesByDirectory(
   })
 }
 
+/**
+ * Delete a single channel_directories row and all its child rows
+ * (channel_models, channel_agents, channel_worktrees, channel_verbosity,
+ * channel_mention_mode) in a single transaction. scheduled_tasks has
+ * onDelete:SetNull so Prisma handles it automatically.
+ */
+export async function deleteChannelDirectoryById(
+  channelId: string,
+): Promise<boolean> {
+  const prisma = await getPrisma()
+  const deletedCount = await prisma.$transaction(async (tx) => {
+    await tx.channel_models.deleteMany({ where: { channel_id: channelId } })
+    await tx.channel_agents.deleteMany({ where: { channel_id: channelId } })
+    await tx.channel_worktrees.deleteMany({ where: { channel_id: channelId } })
+    await tx.channel_verbosity.deleteMany({ where: { channel_id: channelId } })
+    await tx.channel_mention_mode.deleteMany({ where: { channel_id: channelId } })
+    const result = await tx.channel_directories.deleteMany({
+      where: { channel_id: channelId },
+    })
+    return result.count
+  })
+  return deletedCount > 0
+}
+
 /**
  * Get the directory for a voice channel.
  */

package/src/db.ts

@@ -191,6 +191,14 @@ async function migrateSchema(prisma: PrismaClient): Promise<void> {
     }
   }
 
+  try {
+    await prisma.$executeRawUnsafe(
+      "ALTER TABLE thread_sessions ADD COLUMN source TEXT DEFAULT 'kimaki'",
+    )
+  } catch {
+    // Column already exists
+  }
+
   // Migration: move session_thinking data into session_models.variant.
   // session_thinking table is left in place (not dropped) so older kimaki versions
   // that still reference it won't crash on the same database.