@otto-assistant/bridge 0.4.92

package/src/commands/screenshare.ts

@@ -0,0 +1,366 @@
+// /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')
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS
+
+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_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 {
+  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()}`
+}
+
+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)
+// 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 = createScreenshareTunnelId()
+  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 a short session so a leaked URL does not stay usable all day.
+  const timeoutTimer = setTimeout(() => {
+    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
+  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: SECURE_REPLY_FLAGS })
+
+  try {
+    const session = await startScreenshare({
+      sessionKey: guildId,
+      startedBy: command.user.tag,
+    })
+    await command.editReply({
+      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)
+    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/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}`)
+}

package/src/commands/session.ts

@@ -0,0 +1,227 @@
+// /new-session command - Start a new OpenCode session.
+
+import { ChannelType, type TextChannel } from 'discord.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import type { CommandContext, AutocompleteContext } from './types.js'
+import { getChannelDirectory } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { SILENT_MESSAGE_FLAGS, resolveProjectDirectoryFromAutocomplete } from '../discord-utils.js'
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import * as errore from 'errore'
+
+const logger = createLogger(LogPrefix.SESSION)
+
+export async function handleSessionCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply()
+
+  const prompt = command.options.getString('prompt', true)
+  const filesString = command.options.getString('files') || ''
+  const agent = command.options.getString('agent') || undefined
+  const channel = command.channel
+
+  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
+
+  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 files = filesString
+      .split(',')
+      .map((f) => f.trim())
+      .filter((f) => f)
+
+    let fullPrompt = prompt
+    if (files.length > 0) {
+      fullPrompt = `${prompt}\n\n@${files.join(' @')}`
+    }
+
+    const starterMessage = await textChannel.send({
+      content: `🚀 **Starting OpenCode session**\n📝 ${prompt}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+
+    const thread = await starterMessage.startThread({
+      name: prompt.slice(0, 100),
+      autoArchiveDuration: 1440,
+      reason: 'OpenCode session',
+    })
+
+    // Add user to thread so it appears in their sidebar
+    await thread.members.add(command.user.id)
+
+    await command.editReply(`Created new session in ${thread.toString()}`)
+
+    const runtime = getOrCreateRuntime({
+      threadId: thread.id,
+      thread,
+      projectDirectory,
+      sdkDirectory: projectDirectory,
+      channelId: textChannel.id,
+      appId,
+    })
+    await runtime.enqueueIncoming({
+      prompt: fullPrompt,
+      userId: command.user.id,
+      username: command.user.displayName,
+      agent,
+      appId,
+      mode: 'opencode',
+    })
+  } catch (error) {
+    logger.error('[SESSION] Error:', error)
+    await command.editReply(
+      `Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+async function handleAgentAutocomplete({
+  interaction,
+}: {
+  interaction: AutocompleteContext['interaction']
+}): Promise<void> {
+  const focusedValue = interaction.options.getFocused()
+
+  // 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([])
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await interaction.respond([])
+      return
+    }
+
+    const agentsResponse = await getClient().app.agents({
+      directory: projectDirectory,
+    })
+
+    if (!agentsResponse.data || agentsResponse.data.length === 0) {
+      await interaction.respond([])
+      return
+    }
+
+    const agents = agentsResponse.data
+      .filter((a) => {
+        const hidden = (a as { hidden?: boolean }).hidden
+        return (a.mode === 'primary' || a.mode === 'all') && !hidden
+      })
+      .filter((a) => a.name.toLowerCase().includes(focusedValue.toLowerCase()))
+      .slice(0, 25)
+
+    const choices = agents.map((agent) => ({
+      name: agent.name.slice(0, 100),
+      value: agent.name,
+    }))
+
+    await interaction.respond(choices)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching agents:', error)
+    await interaction.respond([])
+  }
+}
+
+export async function handleSessionAutocomplete({
+  interaction,
+}: AutocompleteContext): Promise<void> {
+  const focusedOption = interaction.options.getFocused(true)
+
+  if (focusedOption.name === 'agent') {
+    await handleAgentAutocomplete({ interaction })
+    return
+  }
+
+  if (focusedOption.name !== 'files') {
+    return
+  }
+
+  const focusedValue = focusedOption.value
+
+  const parts = focusedValue.split(',')
+  const previousFiles = parts
+    .slice(0, -1)
+    .map((f) => f.trim())
+    .filter((f) => f)
+  const currentQuery = (parts[parts.length - 1] || '').trim()
+
+  const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction)
+
+  if (!projectDirectory) {
+    await interaction.respond([])
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await interaction.respond([])
+      return
+    }
+
+    const response = await getClient().find.files({
+      query: currentQuery || '',
+    })
+
+    const files = response.data || []
+
+    const prefix =
+      previousFiles.length > 0 ? previousFiles.join(', ') + ', ' : ''
+
+    const choices = files
+      .map((file: string) => {
+        const fullValue = prefix + file
+        const allFiles = [...previousFiles, file]
+        const allBasenames = allFiles.map((f) => f.split('/').pop() || f)
+        let displayName = allBasenames.join(', ')
+        if (displayName.length > 100) {
+          displayName = '…' + displayName.slice(-97)
+        }
+        return {
+          name: displayName,
+          value: fullValue,
+        }
+      })
+      .filter((choice) => choice.value.length <= 100)
+      .slice(0, 25)
+
+    await interaction.respond(choices)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching files:', error)
+    await interaction.respond([])
+  }
+}