@otto-assistant/bridge 0.4.92

package/src/unnest-code-blocks.ts

@@ -0,0 +1,185 @@
+// Unnest code blocks from list items for Discord.
+// Discord doesn't render code blocks inside lists, so this hoists them
+// to root level while preserving list structure.
+
+import { Lexer, type Token, type Tokens } from 'marked'
+
+type Segment =
+  | { type: 'list-item'; prefix: string; content: string }
+  | { type: 'code'; content: string }
+
+export function unnestCodeBlocksFromLists(markdown: string): string {
+  const lexer = new Lexer()
+  const tokens = lexer.lex(markdown)
+
+  const result: string[] = []
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i]!
+    const next = tokens[i + 1]
+
+    const chunk = (() => {
+      if (token.type === 'list') {
+        const segments = processListToken(token as Tokens.List)
+        return renderSegments(segments)
+      }
+      return token.raw
+    })()
+
+    if (!chunk) {
+      continue
+    }
+
+    const nextRaw = next?.raw ?? ''
+    const needsNewline =
+      nextRaw &&
+      !chunk.endsWith('\n') &&
+      typeof nextRaw === 'string' &&
+      !nextRaw.startsWith('\n')
+
+    result.push(needsNewline ? chunk + '\n' : chunk)
+  }
+  return result.join('')
+}
+
+function processListToken(list: Tokens.List): Segment[] {
+  const segments: Segment[] = []
+  const start =
+    typeof list.start === 'number' ? list.start : parseInt(list.start, 10) || 1
+  const prefix = list.ordered ? (i: number) => `${start + i}. ` : () => '- '
+
+  for (let i = 0; i < list.items.length; i++) {
+    const item = list.items[i]!
+    const itemSegments = processListItem(item, prefix(i))
+    segments.push(...itemSegments)
+  }
+
+  return segments
+}
+
+function processListItem(item: Tokens.ListItem, prefix: string): Segment[] {
+  const segments: Segment[] = []
+  let currentText: string[] = []
+  // Track if we've seen a code block - text after code uses continuation prefix
+  let seenCodeBlock = false
+
+  const taskMarker = item.task ? (item.checked ? '[x] ' : '[ ] ') : ''
+  let wroteFirstListItem = false
+
+  const flushText = (): void => {
+    const rawText = currentText.join('')
+    const text = rawText.trimEnd()
+    if (text.trim()) {
+      // After a code block, use '-' as continuation prefix to avoid repeating numbers
+      const effectivePrefix = seenCodeBlock ? '- ' : prefix
+      const marker = !wroteFirstListItem ? taskMarker : ''
+      const normalizedText = normalizeListItemText({
+        text,
+        isTaskItem: item.task,
+      })
+      segments.push({
+        type: 'list-item',
+        prefix: effectivePrefix,
+        content: marker + normalizedText,
+      })
+      wroteFirstListItem = true
+    }
+    currentText = []
+  }
+
+  for (const token of item.tokens) {
+    if (token.type === 'code') {
+      flushText()
+      const codeToken = token as Tokens.Code
+      const lang = codeToken.lang || ''
+      segments.push({
+        type: 'code',
+        content: '```' + lang + '\n' + codeToken.text + '\n```\n',
+      })
+      seenCodeBlock = true
+      continue
+    }
+
+    if (token.type === 'list') {
+      flushText()
+      // Recursively process nested list - segments bubble up
+      const nestedSegments = processListToken(token as Tokens.List)
+      segments.push(...nestedSegments)
+      continue
+    }
+
+    currentText.push(extractText(token))
+  }
+
+  flushText()
+
+  // If no segments were created (empty item), return empty
+  if (segments.length === 0) {
+    return []
+  }
+
+  // If item had no code blocks (all segments are list-items from this level),
+  // return original raw to preserve formatting
+  const hasCode = segments.some((s) => s.type === 'code')
+  if (!hasCode) {
+    return [{ type: 'list-item', prefix: '', content: item.raw }]
+  }
+
+  return segments
+}
+
+function extractText(token: Token): string {
+  // Prefer raw to preserve newlines and markdown markers.
+  if ('raw' in token && typeof token.raw === 'string') {
+    return token.raw
+  }
+
+  if (token.type === 'text') {
+    return (token as Tokens.Text).text
+  }
+
+  return ''
+}
+
+function normalizeListItemText({
+  text,
+  isTaskItem,
+}: {
+  text: string
+  isTaskItem: boolean
+}): string {
+  const withoutIndent = text.replace(/^\s+/, '')
+  if (!isTaskItem) {
+    return withoutIndent
+  }
+  return withoutIndent.replace(/^\[(?: |x|X)\]\s+/, '')
+}
+
+function renderSegments(segments: Segment[]): string {
+  const result: string[] = []
+
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]!
+    const prev = segments[i - 1]
+
+    if (segment.type === 'code') {
+      // Add newline before code if previous was a list item
+      if (prev && prev.type === 'list-item') {
+        result.push('\n')
+      }
+      result.push(segment.content)
+    } else {
+      // list-item
+      if (segment.prefix) {
+        result.push(segment.prefix + segment.content + '\n')
+      } else {
+        // Raw content (no prefix means it's original raw)
+        // Ensure raw ends with newline for proper separation from next segment
+        const raw = segment.content.trimEnd()
+        result.push(raw + '\n')
+      }
+    }
+  }
+
+  return result.join('').trimEnd()
+}

package/src/upgrade.ts

@@ -0,0 +1,127 @@
+// Kimaki self-upgrade utilities.
+// Detects the package manager used to install kimaki, checks npm for newer versions,
+// and runs the global upgrade command. Used by both CLI `kimaki upgrade` and
+// the Discord `/upgrade-and-restart` command, plus background auto-upgrade on startup.
+
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import { createLogger, LogPrefix } from './logger.js'
+import { execAsync } from './worktrees.js'
+
+const logger = createLogger(LogPrefix.CLI)
+
+type Pm = 'bun' | 'pnpm' | 'npm'
+
+// Detects which package manager globally installed kimaki, used to run the
+// correct `<pm> i -g kimaki@latest` upgrade command.
+//
+// Detection order:
+// 1. npm_config_user_agent — set by npx/bunx/pnpm dlx, reliable for those cases
+// 2. Realpath of the running script — resolve symlinks and check if the path
+//    lives under a known PM global directory (e.g. ~/.bun, ~/Library/pnpm,
+//    /usr/local/lib/node_modules). Inspired by sindresorhus/global-directory.
+// 3. process.versions.bun — if the runtime itself is Bun, likely bun ecosystem
+// 4. Default to npm — safest fallback since npm is the most common global installer
+export function detectPm(): Pm {
+  const ua = process.env.npm_config_user_agent
+  if (ua?.startsWith('bun/')) {
+    return 'bun'
+  }
+  if (ua?.startsWith('pnpm/')) {
+    return 'pnpm'
+  }
+  if (ua?.startsWith('npm/')) {
+    return 'npm'
+  }
+
+  const scriptPath = resolveScriptRealpath()
+  if (scriptPath) {
+    const p = scriptPath.toLowerCase()
+    // bun global installs live under ~/.bun or $BUN_INSTALL
+    if (p.includes('.bun/') || p.includes('/bun/install/')) {
+      return 'bun'
+    }
+    // pnpm global installs live under ~/Library/pnpm, ~/.local/share/pnpm, or $PNPM_HOME
+    if (p.includes('/pnpm/')) {
+      return 'pnpm'
+    }
+    // npm global installs typically live under lib/node_modules/kimaki without
+    // any pnpm or bun path segments, so if we reach here it's likely npm
+  }
+
+  if (process.versions.bun) {
+    return 'bun'
+  }
+
+  return 'npm'
+}
+
+function resolveScriptRealpath(): string | null {
+  try {
+    const script = process.argv[1]
+    if (!script) {
+      return null
+    }
+    return fs.realpathSync(script)
+  } catch {
+    return null
+  }
+}
+
+export function getCurrentVersion(): string {
+  const require = createRequire(import.meta.url)
+  const pkg = require('../package.json') as { version: string }
+  return pkg.version
+}
+
+export async function getLatestNpmVersion(): Promise<string | null> {
+  try {
+    const res = await fetch('https://registry.npmjs.org/kimaki/latest', {
+      signal: AbortSignal.timeout(15_000),
+    })
+    if (!res.ok) {
+      return null
+    }
+    const data = (await res.json()) as { version: string }
+    return data.version
+  } catch {
+    return null
+  }
+}
+
+// Returns the new version string if upgraded, null if already up to date.
+export async function upgrade(): Promise<string | null> {
+  const current = getCurrentVersion()
+  const latest = await getLatestNpmVersion()
+  if (!latest) {
+    throw new Error('Failed to check latest version from npm')
+  }
+  if (current === latest) {
+    return null
+  }
+
+  const pm = detectPm()
+  logger.log(`Upgrading kimaki from v${current} to v${latest} using ${pm}...`)
+  await execAsync(`${pm} i -g kimaki@latest`, { timeout: 120_000 })
+
+  return latest
+}
+
+// Fire-and-forget background upgrade check on bot startup.
+// Only upgrades if a newer version is available. Errors are silently ignored.
+export async function backgroundUpgradeKimaki(): Promise<void> {
+  try {
+    const current = getCurrentVersion()
+    const latest = await getLatestNpmVersion()
+    if (!latest || current === latest) {
+      return
+    }
+
+    const pm = detectPm()
+    logger.debug(`Background kimaki upgrade started: v${current} -> v${latest}`)
+    await execAsync(`${pm} i -g kimaki@latest`, { timeout: 120_000 })
+    logger.debug(`Background kimaki upgrade completed: v${latest}`)
+  } catch {
+    // silently ignored, non-critical
+  }
+}

package/src/utils.ts

@@ -0,0 +1,212 @@
+// General utility functions for the bot.
+// Includes Discord OAuth URL generation, array deduplication,
+// abort error detection, and date/time formatting helpers.
+
+import os from 'node:os'
+import { PermissionsBitField } from 'discord.js'
+import type { BotMode } from './database.js'
+import * as errore from 'errore'
+
+type GenerateInstallUrlOptions = {
+  clientId: string
+  permissions?: bigint[]
+  scopes?: string[]
+  guildId?: string
+  disableGuildSelect?: boolean
+  state?: string
+  redirectUri?: string
+  responseType?: string
+}
+
+export function generateBotInstallUrl({
+  clientId,
+  permissions = [
+    PermissionsBitField.Flags.ViewChannel,
+    PermissionsBitField.Flags.ManageChannels,
+    PermissionsBitField.Flags.SendMessages,
+    PermissionsBitField.Flags.SendMessagesInThreads,
+    PermissionsBitField.Flags.CreatePublicThreads,
+    PermissionsBitField.Flags.ManageThreads,
+    PermissionsBitField.Flags.ReadMessageHistory,
+    PermissionsBitField.Flags.AddReactions,
+    PermissionsBitField.Flags.ManageMessages,
+    PermissionsBitField.Flags.UseExternalEmojis,
+    PermissionsBitField.Flags.AttachFiles,
+    PermissionsBitField.Flags.Connect,
+    PermissionsBitField.Flags.Speak,
+    PermissionsBitField.Flags.ManageRoles,
+    PermissionsBitField.Flags.ManageEvents,
+    PermissionsBitField.Flags.CreateEvents,
+  ],
+  scopes = ['bot', 'applications.commands', 'identify', 'email'],
+  guildId,
+  disableGuildSelect = false,
+  state,
+  redirectUri,
+  responseType,
+}: GenerateInstallUrlOptions): string {
+  const permissionsBitField = new PermissionsBitField(permissions)
+  const permissionsValue = permissionsBitField.bitfield.toString()
+
+  const url = new URL('https://discord.com/api/oauth2/authorize')
+  url.searchParams.set('client_id', clientId)
+  url.searchParams.set('permissions', permissionsValue)
+  url.searchParams.set('scope', scopes.join(' '))
+
+  if (guildId) {
+    url.searchParams.set('guild_id', guildId)
+  }
+
+  if (disableGuildSelect) {
+    url.searchParams.set('disable_guild_select', 'true')
+  }
+
+  if (state) {
+    url.searchParams.set('state', state)
+  }
+
+  if (redirectUri) {
+    url.searchParams.set('redirect_uri', redirectUri)
+  }
+
+  if (responseType) {
+    url.searchParams.set('response_type', responseType)
+  }
+
+  return url.toString()
+}
+
+export const KIMAKI_GATEWAY_APP_ID =
+  process.env.KIMAKI_GATEWAY_APP_ID || '1477605701202481173'
+export const KIMAKI_WEBSITE_URL = process.env.KIMAKI_WEBSITE_URL || 'https://kimaki.xyz'
+
+export function generateDiscordInstallUrlForBot({
+  appId,
+  mode,
+  clientId,
+  clientSecret,
+  gatewayCallbackUrl,
+  reachableUrl,
+}: {
+  appId: string
+  mode: BotMode
+  clientId: string | null
+  clientSecret: string | null
+  /** Optional external URL to redirect to after OAuth completes instead of the
+   *  default success page. The website appends ?guild_id=<id> before redirecting. */
+  gatewayCallbackUrl?: string
+  /** When set (KIMAKI_INTERNET_REACHABLE_URL), the website stores this URL in
+   *  gateway_clients.reachable_url so the gateway-proxy connects outbound. */
+  reachableUrl?: string
+}): Error | string {
+  if (mode !== 'gateway') {
+    return generateBotInstallUrl({ clientId: appId })
+  }
+
+  if (!clientId || !clientSecret) {
+    return new Error('Gateway credentials are missing from local database')
+  }
+
+  // In gateway mode, redirect to the website's /discord-install route.
+  // This initiates the better-auth OAuth flow with clientId/clientSecret
+  // as additionalData, which better-auth stores in its verification table
+  // and recovers after Discord redirects back to the callback.
+  // Use a kimaki-specific callback field name to avoid ambiguity with
+  // better-auth's own callbackURL state field.
+  const url = new URL(`${KIMAKI_WEBSITE_URL}/discord-install`)
+  url.searchParams.set('clientId', clientId)
+  url.searchParams.set('clientSecret', clientSecret)
+  if (gatewayCallbackUrl) {
+    url.searchParams.set('kimakiCallbackUrl', gatewayCallbackUrl)
+  }
+  if (reachableUrl) {
+    url.searchParams.set('reachableUrl', reachableUrl)
+  }
+  return url.toString()
+}
+
+export function deduplicateByKey<T, K>(arr: T[], keyFn: (item: T) => K): T[] {
+  const seen = new Set<K>()
+  return arr.filter((item) => {
+    const key = keyFn(item)
+    if (seen.has(key)) {
+      return false
+    }
+    seen.add(key)
+    return true
+  })
+}
+
+// Delegates to errore.isAbortError (walks cause chain for AbortError instances),
+// then falls back to opencode server-specific abort patterns that aren't
+// errore.AbortError but still represent aborted operations.
+export function isAbortError(error: unknown): error is Error {
+  if (errore.isAbortError(error)) return true
+  if (!(error instanceof Error)) return false
+  return (
+    error.name === 'MessageAbortedError' ||
+    error.message?.includes('aborted') === true
+  )
+}
+
+const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' })
+
+const TIME_DIVISIONS: Array<{
+  amount: number
+  name: Intl.RelativeTimeFormatUnit
+}> = [
+  { amount: 60, name: 'seconds' },
+  { amount: 60, name: 'minutes' },
+  { amount: 24, name: 'hours' },
+  { amount: 7, name: 'days' },
+  { amount: 4.34524, name: 'weeks' },
+  { amount: 12, name: 'months' },
+  { amount: Number.POSITIVE_INFINITY, name: 'years' },
+]
+
+export function formatDistanceToNow(date: Date): string {
+  let duration = (date.getTime() - Date.now()) / 1000
+
+  for (const division of TIME_DIVISIONS) {
+    if (Math.abs(duration) < division.amount) {
+      return rtf.format(Math.round(duration), division.name)
+    }
+    duration /= division.amount
+  }
+  return rtf.format(Math.round(duration), 'years')
+}
+
+const dtf = new Intl.DateTimeFormat('en-US', {
+  month: 'short',
+  day: 'numeric',
+  year: 'numeric',
+  hour: 'numeric',
+  minute: '2-digit',
+  hour12: true,
+})
+
+export function formatDateTime(date: Date): string {
+  return dtf.format(date)
+}
+
+// Comprehensive ANSI escape sequence regex covering CSI, OSC, and related sequences.
+// Valid string terminator sequences are BEL, ESC\, and 0x9c.
+const ANSI_REGEX = (() => {
+  const ST = '(?:\\u0007|\\u001B\\u005C|\\u009C)'
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`
+  const csi =
+    '[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]'
+  return new RegExp(`${osc}|${csi}`, 'g')
+})()
+
+export function stripAnsi(str: string): string {
+  return str.replace(ANSI_REGEX, '')
+}
+
+export function abbreviatePath(fullPath: string): string {
+  const home = os.homedir()
+  if (fullPath.startsWith(home)) {
+    return '~' + fullPath.slice(home.length)
+  }
+  return fullPath
+}

package/src/voice-attachment.ts

@@ -0,0 +1,51 @@
+// Voice attachment detection helpers.
+// Normalizes Discord attachment heuristics for voice-message detection so
+// message routing, transcription, and empty-prompt guards all agree even when
+// Discord omits contentType on uploaded audio attachments.
+
+import path from 'node:path'
+
+const VOICE_ATTACHMENT_EXTENSIONS = new Set<string>([
+  '.m4a',
+  '.mp3',
+  '.mp4',
+  '.oga',
+  '.ogg',
+  '.opus',
+  '.wav',
+])
+
+export type VoiceAttachmentLike = {
+  contentType?: string | null
+  name?: string | null
+  duration?: number | null
+  waveform?: string | null
+}
+
+export function getVoiceAttachmentMatchReason(
+  attachment: VoiceAttachmentLike,
+): string | null {
+  const contentType = attachment.contentType?.trim().toLowerCase() || ''
+  if (contentType.startsWith('audio/')) {
+    return `contentType:${contentType}`
+  }
+
+  if (typeof attachment.duration === 'number' && attachment.duration > 0) {
+    return `duration:${attachment.duration}`
+  }
+
+  if (attachment.waveform?.trim()) {
+    return 'waveform'
+  }
+
+  const extension = path.extname(attachment.name || '').toLowerCase()
+  if (VOICE_ATTACHMENT_EXTENSIONS.has(extension)) {
+    return `extension:${extension}`
+  }
+
+  return null
+}
+
+export function isVoiceAttachment(attachment: VoiceAttachmentLike): boolean {
+  return getVoiceAttachmentMatchReason(attachment) !== null
+}