kimaki 0.4.77 → 0.4.78

package/src/commands/screenshare.ts

@@ -0,0 +1,354 @@
+// /screenshare command - Start screen sharing via VNC + WebSocket bridge + kimaki tunnel.
+// On macOS: uses built-in Screen Sharing (port 5900).
+// On Linux: spawns x11vnc against the current $DISPLAY.
+// Exposes the VNC stream via an in-process websockify bridge and a traforo tunnel,
+// then sends the user a noVNC URL they can open in a browser.
+//
+// /screenshare-stop command - Stops the active screen share for this guild.
+
+import { MessageFlags } from 'discord.js'
+import crypto from 'node:crypto'
+import { spawn, type ChildProcess } from 'node:child_process'
+import net from 'node:net'
+import { TunnelClient } from 'traforo/client'
+import type { CommandContext } from './types.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { startWebsockify } from '../websockify.js'
+import { createLogger } from '../logger.js'
+import { execAsync } from '../worktrees.js'
+import type { WebSocketServer } from 'ws'
+
+const logger = createLogger('SCREEN')
+
+export type ScreenshareSession = {
+  tunnelClient: TunnelClient
+  wss: WebSocketServer
+  /** x11vnc child process, only on Linux */
+  vncProcess: ChildProcess | undefined
+  url: string
+  noVncUrl: string
+  startedBy: string
+  startedAt: number
+  /** Auto-kill timer */
+  timeoutTimer: ReturnType<typeof setTimeout>
+}
+
+/** One active screenshare per guild (Discord) or per machine (CLI) */
+const activeSessions = new Map<string, ScreenshareSession>()
+
+const VNC_PORT = 5900
+const MAX_SESSION_MS = 60 * 60 * 1000 // 1 hour
+const TUNNEL_BASE_DOMAIN = 'kimaki.xyz'
+
+// Public noVNC client — we point it at our tunnel URL
+export function buildNoVncUrl({ tunnelHost }: { tunnelHost: string }): string {
+  const params = new URLSearchParams({
+    autoconnect: 'true',
+    host: tunnelHost,
+    port: '443',
+    encrypt: '1',
+    resize: 'scale',
+    view_only: 'false',
+  })
+  return `https://novnc.com/noVNC/vnc.html?${params.toString()}`
+}
+
+// macOS has two separate services:
+// - "Screen Sharing" = view-only VNC (com.apple.screensharing)
+// - "Remote Management" = full control VNC with mouse/keyboard (ARDAgent)
+// We need Remote Management for interactive control, not just Screen Sharing.
+export async function ensureMacRemoteManagement(): Promise<void> {
+  // Check if port 5900 is listening via netstat (no sudo needed).
+  // lsof and launchctl list both require sudo for system daemons.
+  try {
+    const { stdout } = await execAsync(
+      'netstat -an | grep "\\.5900 " | grep LISTEN',
+      { timeout: 5000 },
+    )
+    if (stdout.trim()) {
+      return
+    }
+  } catch {
+    // not listening
+  }
+
+  throw new Error(
+    'macOS Remote Management is not enabled.\n' +
+    'Enable it: **System Settings > General > Sharing > Remote Management**\n' +
+    'Make sure "VNC viewers may control screen with password" is enabled.\n' +
+    'Or via terminal:\n' +
+    '```\nsudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart \\\n' +
+    '  -activate -configure -allowAccessFor -allUsers -privs -all \\\n' +
+    '  -clientopts -setvnclegacy -vnclegacy yes \\\n' +
+    '  -restart -agent -console\n```',
+  )
+}
+
+export function spawnX11Vnc(): ChildProcess {
+  const display = process.env['DISPLAY'] || ':0'
+  const child = spawn('x11vnc', [
+    '-display', display,
+    '-nopw',
+    '-localhost',
+    '-rfbport', String(VNC_PORT),
+    '-shared',
+    '-forever',
+  ], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+
+  child.stdout?.on('data', (data: Buffer) => {
+    logger.log(`x11vnc: ${data.toString().trim()}`)
+  })
+  child.stderr?.on('data', (data: Buffer) => {
+    logger.error(`x11vnc: ${data.toString().trim()}`)
+  })
+
+  return child
+}
+
+function waitForPort({
+  port,
+  process: proc,
+  timeoutMs,
+}: {
+  port: number
+  process: ChildProcess
+  timeoutMs: number
+}): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const maxAttempts = Math.ceil(timeoutMs / 100)
+    let attempts = 0
+    const check = () => {
+      if (proc.exitCode !== null) {
+        reject(new Error(`x11vnc exited with code ${proc.exitCode} before becoming ready`))
+        return
+      }
+      const sock = net.createConnection(port, 'localhost')
+      sock.on('connect', () => {
+        sock.destroy()
+        resolve()
+      })
+      sock.on('error', () => {
+        sock.destroy()
+        if (++attempts >= maxAttempts) {
+          reject(new Error(`Port ${port} not reachable after ${timeoutMs}ms`))
+        } else {
+          setTimeout(check, 100)
+        }
+      })
+    }
+    check()
+  })
+}
+
+export function cleanupSession(session: ScreenshareSession): void {
+  clearTimeout(session.timeoutTimer)
+  try {
+    session.tunnelClient.close()
+  } catch {}
+  try {
+    session.wss.close()
+  } catch {}
+  if (session.vncProcess) {
+    try {
+      session.vncProcess.kill()
+    } catch {}
+  }
+}
+
+/**
+ * Core screenshare start logic, reused by both Discord command and CLI.
+ * Returns the session or throws on failure.
+ */
+export async function startScreenshare({
+  sessionKey,
+  startedBy,
+}: {
+  sessionKey: string
+  startedBy: string
+}): Promise<ScreenshareSession> {
+  const existing = activeSessions.get(sessionKey)
+  if (existing) {
+    throw new Error(`Screen sharing is already active: ${existing.noVncUrl}`)
+  }
+
+  const platform = process.platform
+  let vncProcess: ChildProcess | undefined
+
+  // Step 1: ensure VNC server is running
+  if (platform === 'darwin') {
+    await ensureMacRemoteManagement()
+  } else if (platform === 'linux') {
+    if (!process.env['DISPLAY']) {
+      throw new Error('No $DISPLAY found. Screen sharing requires a running X11 display.')
+    }
+    try {
+      await execAsync('which x11vnc', { timeout: 3000 })
+    } catch {
+      throw new Error('x11vnc is not installed. Install it with: sudo apt install x11vnc')
+    }
+    vncProcess = spawnX11Vnc()
+    // Wait for x11vnc to actually be ready (port 5900 accepting connections)
+    // instead of a blind 1s sleep. Polls every 100ms, fails if process exits first.
+    await waitForPort({ port: VNC_PORT, process: vncProcess, timeoutMs: 3000 })
+  } else {
+    throw new Error(`Screen sharing is not supported on ${platform}. Only macOS and Linux are supported.`)
+  }
+
+  // Step 2: start in-process websockify bridge
+  let wsInstance: Awaited<ReturnType<typeof startWebsockify>>
+  try {
+    wsInstance = await startWebsockify({
+      wsPort: 0,
+      tcpHost: 'localhost',
+      tcpPort: VNC_PORT,
+    })
+  } catch (err) {
+    if (vncProcess) {
+      vncProcess.kill()
+    }
+    throw err
+  }
+
+  // Step 3: create tunnel
+  const tunnelId = crypto.randomBytes(8).toString('hex')
+  const tunnelClient = new TunnelClient({
+    localPort: wsInstance.port,
+    tunnelId,
+    baseDomain: TUNNEL_BASE_DOMAIN,
+  })
+
+  try {
+    await Promise.race([
+      tunnelClient.connect(),
+      new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          reject(new Error('Tunnel connection timed out after 15s'))
+        }, 15000)
+      }),
+    ])
+  } catch (err) {
+    tunnelClient.close()
+    wsInstance.close()
+    if (vncProcess) {
+      vncProcess.kill()
+    }
+    throw err
+  }
+
+  const tunnelHost = `${tunnelId}-tunnel.${TUNNEL_BASE_DOMAIN}`
+  const tunnelUrl = `https://${tunnelHost}`
+  const noVncUrl = buildNoVncUrl({ tunnelHost })
+
+  // Auto-kill after 1 hour
+  const timeoutTimer = setTimeout(() => {
+    logger.log(`Screen share auto-stopped after 1 hour (key: ${sessionKey})`)
+    stopScreenshare({ sessionKey })
+  }, MAX_SESSION_MS)
+  // Don't keep the process alive just for this timer
+  timeoutTimer.unref()
+
+  const session: ScreenshareSession = {
+    tunnelClient,
+    wss: wsInstance.wss,
+    vncProcess,
+    url: tunnelUrl,
+    noVncUrl,
+    startedBy,
+    startedAt: Date.now(),
+    timeoutTimer,
+  }
+
+  activeSessions.set(sessionKey, session)
+  logger.log(`Screen share started by ${startedBy}: ${tunnelUrl}`)
+
+  return session
+}
+
+/**
+ * Core screenshare stop logic, reused by both Discord command and CLI.
+ */
+export function stopScreenshare({ sessionKey }: { sessionKey: string }): boolean {
+  const session = activeSessions.get(sessionKey)
+  if (!session) {
+    return false
+  }
+  cleanupSession(session)
+  activeSessions.delete(sessionKey)
+  logger.log(`Screen share stopped (key: ${sessionKey})`)
+  return true
+}
+
+export async function handleScreenshareCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const guildId = command.guildId
+  if (!guildId) {
+    await command.reply({
+      content: 'This command can only be used in a server',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  try {
+    const session = await startScreenshare({
+      sessionKey: guildId,
+      startedBy: command.user.tag,
+    })
+    await command.editReply({
+      content: `Screen sharing started\n${session.noVncUrl}`,
+    })
+  } catch (err) {
+    logger.error('Failed to start screen share:', err)
+    await command.editReply({
+      content: `Failed to start screen share: ${err instanceof Error ? err.message : String(err)}`,
+    })
+  }
+}
+
+export async function handleScreenshareStopCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const guildId = command.guildId
+  if (!guildId) {
+    await command.reply({
+      content: 'This command can only be used in a server',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const stopped = stopScreenshare({ sessionKey: guildId })
+  if (!stopped) {
+    await command.reply({
+      content: 'No active screen share to stop',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  await command.reply({
+    content: 'Screen sharing stopped',
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+}
+
+/** Cleanup all sessions on bot shutdown */
+export function cleanupAllScreenshares(): void {
+  for (const [guildId, session] of activeSessions) {
+    cleanupSession(session)
+    activeSessions.delete(guildId)
+  }
+}
+
+// Kill all screenshares when the process exits (Ctrl+C, SIGTERM, etc.)
+function onProcessExit(): void {
+  cleanupAllScreenshares()
+}
+process.on('SIGINT', onProcessExit)
+process.on('SIGTERM', onProcessExit)
+process.on('exit', onProcessExit)

package/src/critique-utils.ts

@@ -0,0 +1,139 @@
+// Shared utilities for invoking the critique CLI and parsing its JSON output.
+// Used by /diff command and footer diff link uploads.
+
+import { execAsync } from './worktrees.js'
+import { createLogger, LogPrefix } from './logger.js'
+
+const logger = createLogger(LogPrefix.DIFF)
+
+const CRITIQUE_TIMEOUT_MS = 30_000
+
+/**
+ * Shell-quote a string by wrapping in single quotes and escaping embedded
+ * single quotes. Prevents injection when interpolating into shell commands.
+ */
+function shellQuote(s: string): string {
+  return `'${s.replace(/'/g, "'\\''")}'`
+}
+
+export type CritiqueResult = {
+  url: string
+  id: string
+  error?: undefined
+} | {
+  url?: undefined
+  id?: undefined
+  error: string
+}
+
+/**
+ * Parse critique --json output. Critique prints progress to stderr and JSON
+ * to stdout. The JSON line contains { url, id } on success or { error } on
+ * failure. We scan all lines for the first valid JSON object with a url or
+ * error field, falling back to searching for a critique.work URL in the raw
+ * output.
+ */
+export function parseCritiqueOutput(output: string): CritiqueResult | undefined {
+  const lines = output.trim().split('\n')
+  for (const line of lines) {
+    if (!line.startsWith('{')) {
+      continue
+    }
+    try {
+      const parsed = JSON.parse(line) as {
+        url?: string
+        id?: string
+        error?: string
+      }
+      if (parsed.error) {
+        return { error: parsed.error }
+      }
+      if (parsed.url && parsed.id) {
+        return { url: parsed.url, id: parsed.id }
+      }
+    } catch {
+      // not valid JSON, try next line
+    }
+  }
+  // Fallback: try to find a URL in the raw output
+  const urlMatch = output.match(/https?:\/\/critique\.work\/[^\s]+/)
+  if (urlMatch) {
+    const url = urlMatch[0]
+    // Extract ID from URL path: /v/{id}
+    const idMatch = url.match(/\/v\/([a-f0-9]+)/)
+    const id = idMatch?.[1]
+    if (id) {
+      return { url, id }
+    }
+    // URL without parseable id — return as error so callers don't build
+    // broken OG image URLs from an empty id
+    return { error: url }
+  }
+  return undefined
+}
+
+/**
+ * Run critique on the current git working tree diff and return the result.
+ * Used by the /diff slash command.
+ */
+export async function uploadGitDiffViaCritique({
+  title,
+  cwd,
+}: {
+  title: string
+  cwd: string
+}): Promise<CritiqueResult | undefined> {
+  try {
+    const { stdout, stderr } = await execAsync(
+      `critique --web ${shellQuote(title)} --json`,
+      { cwd, timeout: CRITIQUE_TIMEOUT_MS },
+    )
+    return parseCritiqueOutput(stdout || stderr)
+  } catch (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 || ''
+    const parsed = parseCritiqueOutput(output)
+    if (parsed) {
+      return parsed
+    }
+    const message = execError.message || 'Unknown error'
+    if (message.includes('command not found') || message.includes('ENOENT')) {
+      return { error: 'critique not available' }
+    }
+    return { error: `Failed to generate diff: ${message.slice(0, 200)}` }
+  }
+}
+
+/**
+ * Upload a .patch file to critique.work via critique --stdin.
+ * Returns the critique URL on success, undefined on failure.
+ * Default timeout is 10s since this runs in the background (footer edit).
+ */
+export async function uploadPatchViaCritique({
+  patchPath,
+  title,
+  cwd,
+  timeoutMs = 10_000,
+}: {
+  patchPath: string
+  title: string
+  cwd: string
+  timeoutMs?: number
+}): Promise<string | undefined> {
+  try {
+    const { stdout } = await execAsync(
+      `critique --stdin --web ${shellQuote(title)} --json < ${shellQuote(patchPath)}`,
+      { cwd, timeout: timeoutMs },
+    )
+    const result = parseCritiqueOutput(stdout)
+    return result?.url
+  } catch (error) {
+    logger.error('critique upload failed:', error)
+    return undefined
+  }
+}

package/src/discord-bot.ts

@@ -813,7 +813,7 @@ export async function startDiscordBot({
           },
         })
       } else {
-        discordLogger.log(`Channel type ${channel.type} is not supported`)
+        // discordLogger.log(`Channel type ${channel.type} is not supported`)
       }
     } catch (error) {
       voiceLogger.error('Discord handler error:', error)

package/src/interaction-handler.ts

@@ -90,6 +90,10 @@ import { handleContextUsageCommand } from './commands/context-usage.js'
 import { handleSessionIdCommand } from './commands/session-id.js'
 import { handleUpgradeAndRestartCommand } from './commands/upgrade.js'
 import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js'
+import {
+  handleScreenshareCommand,
+  handleScreenshareStopCommand,
+} from './commands/screenshare.js'
 import { handleModelVariantSelectMenu } from './commands/model.js'
 import {
   handleModelVariantCommand,
@@ -328,6 +332,17 @@ export function registerInteractionHandler({
             case 'mcp':
               await handleMcpCommand({ command: interaction, appId })
               return
+
+            case 'screenshare':
+              await handleScreenshareCommand({ command: interaction, appId })
+              return
+
+            case 'screenshare-stop':
+              await handleScreenshareStopCommand({
+                command: interaction,
+                appId,
+              })
+              return
           }
 
           // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)

package/src/message-formatting.ts

@@ -13,6 +13,7 @@ import * as errore from 'errore'
 import { createLogger, LogPrefix } from './logger.js'
 import { FetchError } from './errors.js'
 import { processImage } from './image-utils.js'
+import { parsePatchFileCounts } from './patch-text-parser.js'
 
 // Generic message type compatible with both v1 and v2 SDK
 type GenericSessionMessage = {
@@ -61,73 +62,7 @@ function escapeInlineMarkdown(text: string): string {
   return text.replace(/([*_~|`\\])/g, '\\$1')
 }
 
-/**
- * Parses a patchText string (apply_patch format) and counts additions/deletions per file.
- * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
- * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
- */
-function parsePatchCounts(
-  patchText: string,
-): Map<string, { additions: number; deletions: number }> {
-  const counts = new Map<string, { additions: number; deletions: number }>()
-  const lines = patchText.split('\n')
-  let currentFile = ''
-  let currentType = ''
-  let inHunk = false
-
-  for (const line of lines) {
-    const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/)
-    const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/)
-    const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/)
-
-    if (addMatch || updateMatch || deleteMatch) {
-      const match = addMatch || updateMatch || deleteMatch
-      currentFile = (match?.[1] ?? '').trim()
-      currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete'
-      counts.set(currentFile, { additions: 0, deletions: 0 })
-      inHunk = false
-      continue
-    }
-
-    if (line.startsWith('@@')) {
-      inHunk = true
-      continue
-    }
-
-    if (line.startsWith('*** ')) {
-      inHunk = false
-      continue
-    }
-
-    if (!currentFile) {
-      continue
-    }
-
-    const entry = counts.get(currentFile)
-    if (!entry) {
-      continue
-    }
-
-    if (currentType === 'add') {
-      // all content lines in Add File are additions
-      if (line.length > 0 && !line.startsWith('*** ')) {
-        entry.additions++
-      }
-    } else if (currentType === 'delete') {
-      // all content lines in Delete File are deletions
-      if (line.length > 0 && !line.startsWith('*** ')) {
-        entry.deletions++
-      }
-    } else if (inHunk) {
-      if (line.startsWith('+')) {
-        entry.additions++
-      } else if (line.startsWith('-')) {
-        entry.deletions++
-      }
-    }
-  }
-  return counts
-}
+// parsePatchCounts → imported from patch-text-parser.ts as parsePatchFileCounts
 
 /**
  * Normalize whitespace: convert newlines to spaces and collapse consecutive spaces.
@@ -299,7 +234,7 @@ export function getToolSummaryText(part: Part): string {
     if (!patchText) {
       return ''
     }
-    const patchCounts = parsePatchCounts(patchText)
+    const patchCounts = parsePatchFileCounts(patchText)
     return [...patchCounts.entries()]
       .map(([filePath, { additions, deletions }]) => {
         const fileName = filePath.split('/').pop() || ''

package/src/onboarding-tutorial-plugin.ts

@@ -58,7 +58,7 @@ const onboardingTutorialPlugin: Plugin = async () => {
           }
 
           output.parts.push({
-            id: crypto.randomUUID(),
+            id: `prt_${crypto.randomUUID()}`,
             sessionID,
             messageID: firstText.messageID,
             type: 'text' as const,

package/src/opencode-plugin.ts

@@ -344,7 +344,7 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
             if (memoryContent) {
               const condensed = condenseMemoryMd(memoryContent)
               output.parts.push({
-                id: crypto.randomUUID(),
+                id: `prt_${crypto.randomUUID()}`,
                 sessionID,
                 messageID,
                 type: 'text' as const,
@@ -386,7 +386,7 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
               })
 
               output.parts.push({
-                id: crypto.randomUUID(),
+                id: `prt_${crypto.randomUUID()}`,
                 sessionID,
                 messageID,
                 type: 'text' as const,
@@ -398,7 +398,7 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
               // When the user comes back after a long break, remind the model
               // to save any important context from the previous conversation.
               output.parts.push({
-                id: crypto.randomUUID(),
+                id: `prt_${crypto.randomUUID()}`,
                 sessionID,
                 messageID,
                 type: 'text' as const,
@@ -425,7 +425,7 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
 
               sessionGitStates.set(sessionID, gitState)
               output.parts.push({
-                id: crypto.randomUUID(),
+                id: `prt_${crypto.randomUUID()}`,
                 sessionID,
                 messageID,
                 type: 'text' as const,
@@ -481,3 +481,4 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
 export { kimakiPlugin }
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js'
 export { onboardingTutorialPlugin } from './onboarding-tutorial-plugin.js'
+