@otto-assistant/otto 0.1.2 → 0.7.15

package/src/bin.ts

@@ -0,0 +1,182 @@
+// Crash-recovery supervisor for `otto gateway start`.
+//
+// Parents run goke-backed `cli.js` directly for every invocation except top-level
+// `otto gateway start` (without `--help`). Those long-running installs get an
+// outer Node process that restarts `cli.js` on non-clean exits (crash, OOM, etc.).
+// Exit code `0` / `EXIT_NO_RESTART=64` / SIGTERM+SIGINT grace paths suppress restarts.
+//
+// When __OTTO_CHILD is set, we're supervised — import `cli.js` directly.
+//
+// V8 heap snapshot flags:
+// Injects --heapsnapshot-near-heap-limit=3 and --diagnostic-dir so V8 writes
+// heap snapshots internally as it approaches the heap limit. This catches OOM
+// situations where SIGKILL (exit 137) would kill the process before our
+// heap-monitor.ts polling can react. The polling monitor is kept as an early
+// warning system at 85% usage; the V8 flag is the last-resort safety net.
+
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const HEAP_SNAPSHOT_DIR = path.join(os.homedir(), '.otto', 'heap-snapshots')
+const STARTUP_LOG_WAIT_MS = 2_500
+const STARTUP_LOG_POLL_MS = 200
+const STARTUP_LOG_MAX_LINES = 12
+
+const argv = process.argv.slice(2)
+const isHelpFlag = process.argv.includes('--help')
+const isGatewayDaemon = process.env.OTTO_GATEWAY_DAEMON === '1'
+
+function isGatewayStartInvocation(): boolean {
+  return argv[0] === 'gateway' && argv[1] === 'start'
+}
+
+function resolveDataDirFromArgv(): string {
+  const inlineArg = argv.find((entry) => {
+    return entry.startsWith('--data-dir=')
+  })
+  if (inlineArg) {
+    return path.resolve(inlineArg.slice('--data-dir='.length))
+  }
+
+  const dataDirIndex = argv.findIndex((entry) => {
+    return entry === '--data-dir'
+  })
+  if (dataDirIndex !== -1) {
+    const value = argv[dataDirIndex + 1]
+    if (value && !value.startsWith('--')) {
+      return path.resolve(value)
+    }
+  }
+
+  return path.join(os.homedir(), '.otto')
+}
+
+async function printStartupLogs({
+  dataDir,
+}: {
+  dataDir: string
+}): Promise<void> {
+  const logPath = path.join(dataDir, 'otto.log')
+  const seenLines = new Set<string>()
+  const deadline = Date.now() + STARTUP_LOG_WAIT_MS
+
+  while (Date.now() < deadline && seenLines.size < STARTUP_LOG_MAX_LINES) {
+    if (fs.existsSync(logPath)) {
+      const content = fs.readFileSync(logPath, 'utf8')
+      const lines = content
+        .split(/\r?\n/)
+        .map((entry) => {
+          return entry.trim()
+        })
+        .filter((entry) => {
+          return entry.length > 0
+        })
+
+      for (const line of lines) {
+        if (seenLines.has(line)) {
+          continue
+        }
+        seenLines.add(line)
+        console.error(`[gateway] ${line}`)
+        if (seenLines.size >= STARTUP_LOG_MAX_LINES) {
+          return
+        }
+      }
+    }
+
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, STARTUP_LOG_POLL_MS)
+    })
+  }
+}
+
+if (process.env.__OTTO_CHILD || isHelpFlag || !isGatewayStartInvocation()) {
+  await import('./cli.js')
+} else if (!isGatewayDaemon) {
+  const dataDir = resolveDataDirFromArgv()
+  const daemon = spawn(process.execPath, process.argv.slice(1), {
+    stdio: 'ignore',
+    detached: true,
+    env: { ...process.env, OTTO_GATEWAY_DAEMON: '1' },
+    windowsHide: process.platform === 'win32',
+  })
+  daemon.unref()
+  console.error('otto gateway start: launched in background')
+  await printStartupLogs({ dataDir })
+  process.exit(0)
+} else {
+  console.error(
+    'otto gateway start: supervised process will restart the child on crash',
+  )
+  console.error()
+  const EXIT_NO_RESTART = 64
+  const MAX_RAPID_RESTARTS = 5
+  const RAPID_RESTART_WINDOW_MS = 60_000
+  const RESTART_DELAY_MS = 2_000
+
+  const restartTimestamps: number[] = []
+  let child: ReturnType<typeof spawn> | null = null
+  let shutdownRequested = false
+
+  function start() {
+    if (!fs.existsSync(HEAP_SNAPSHOT_DIR)) {
+      fs.mkdirSync(HEAP_SNAPSHOT_DIR, { recursive: true })
+    }
+    const heapArgs = [
+      `--heapsnapshot-near-heap-limit=3`,
+      `--diagnostic-dir=${HEAP_SNAPSHOT_DIR}`,
+    ]
+    const args = [...heapArgs, ...process.execArgv, ...process.argv.slice(1)]
+    child = spawn(process.argv[0]!, args, {
+      stdio: 'ignore',
+      env: { ...process.env, __OTTO_CHILD: '1' },
+      windowsHide: process.platform === 'win32',
+    })
+
+    child.on('exit', (code, signal) => {
+      if (code === 0 || code === EXIT_NO_RESTART || shutdownRequested) {
+        process.exit(code ?? 0)
+        return
+      }
+
+      const now = Date.now()
+      restartTimestamps.push(now)
+      while (
+        restartTimestamps.length > 0 &&
+        restartTimestamps[0]! < now - RAPID_RESTART_WINDOW_MS
+      ) {
+        restartTimestamps.shift()
+      }
+
+      if (restartTimestamps.length > MAX_RAPID_RESTARTS) {
+        console.error(
+          `[otto] Crash loop detected (${MAX_RAPID_RESTARTS} crashes in ${RAPID_RESTART_WINDOW_MS / 1000}s), exiting`,
+        )
+        process.exit(1)
+        return
+      }
+
+      const reason = signal ? `signal ${signal}` : `code ${code}`
+      console.error(
+        `[otto] Process exited with ${reason}, restarting in ${RESTART_DELAY_MS / 1000}s...`,
+      )
+      setTimeout(start, RESTART_DELAY_MS)
+    })
+  }
+
+  for (const sig of ['SIGTERM', 'SIGINT'] as const) {
+    process.on(sig, () => {
+      shutdownRequested = true
+      child?.kill(sig)
+    })
+  }
+  for (const sig of ['SIGUSR1', 'SIGUSR2'] as const) {
+    process.on(sig, () => {
+      child?.kill(sig)
+    })
+  }
+
+  start()
+}

package/src/btw-prefix-detection.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from 'vitest'
+import { extractBtwPrefix } from './btw-prefix-detection.js'
+
+describe('extractBtwPrefix', () => {
+  test('matches lowercase prefix', () => {
+    expect(extractBtwPrefix('btw fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `)
+  })
+
+  test('matches uppercase prefix', () => {
+    expect(extractBtwPrefix('BTW check this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "check this",
+      }
+    `)
+  })
+
+  test('keeps multiline content', () => {
+    expect(extractBtwPrefix('  btw first line\nsecond line  ')).toMatchInlineSnapshot(`
+      {
+        "prompt": "first line
+      second line",
+      }
+    `)
+  })
+
+  test('matches dot separator', () => {
+    expect(extractBtwPrefix('btw. fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `)
+  })
+
+  test('matches comma separator', () => {
+    expect(extractBtwPrefix('btw, fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `)
+  })
+
+  test('matches colon separator', () => {
+    expect(extractBtwPrefix('btw: fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `)
+  })
+
+  test('matches punctuation without trailing space', () => {
+    expect(extractBtwPrefix('btw.fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `)
+  })
+
+  test('does not match without separating whitespace', () => {
+    expect(extractBtwPrefix('btwfix this')).toMatchInlineSnapshot(`null`)
+  })
+
+  test('does not match mid-message', () => {
+    expect(extractBtwPrefix('hello btw fix this')).toMatchInlineSnapshot(`null`)
+  })
+
+  test('does not match empty payload', () => {
+    expect(extractBtwPrefix('btw   ')).toMatchInlineSnapshot(`null`)
+  })
+})

package/src/btw-prefix-detection.ts

@@ -0,0 +1,23 @@
+// Detects the raw `btw ` Discord message shortcut used to fork a side-question
+// thread without invoking the /btw slash command UI.
+
+export function extractBtwPrefix(
+  content: string,
+): { prompt: string } | null {
+  if (!content) {
+    return null
+  }
+
+  // Match "btw" followed by whitespace or punctuation (. , : ; ! ?) then the prompt
+  const match = content.match(/^\s*btw[.,;:!?\s]\s*([\s\S]+)$/i)
+  if (!match) {
+    return null
+  }
+
+  const prompt = match[1]?.trim()
+  if (!prompt) {
+    return null
+  }
+
+  return { prompt }
+}

package/src/channel-management.ts

@@ -0,0 +1,376 @@
+// Discord channel and category management.
+// Creates and manages Otto project channels (text + voice pairs),
+// extracts channel metadata from topic tags, and ensures category structure.
+
+import {
+  ChannelType,
+  type CategoryChannel,
+  type Guild,
+  type TextChannel,
+} from 'discord.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  getChannelDirectory,
+  setChannelDirectory,
+  findChannelsByDirectory,
+} from './database.js'
+import { getProjectsDir } from './config.js'
+import { execAsync } from './worktrees.js'
+import { createLogger, LogPrefix } from './logger.js'
+
+const logger = createLogger(LogPrefix.CHANNEL)
+
+// Legacy category names kept for backward-compat lookup on existing servers.
+// New categories are created with the current "Otto" / "Otto Audio" names.
+const CATEGORY_NAME = 'Otto'
+const CATEGORY_NAME_AUDIO = 'Otto Audio'
+const LEGACY_CATEGORY_NAME = 'Kimaki'
+const LEGACY_CATEGORY_NAME_AUDIO = 'Kimaki Audio'
+
+export async function ensureOttoCategory(
+  guild: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  // Skip appending bot name if it's already "otto" to avoid "Otto otto"
+  const isOttoBot = botName?.toLowerCase() === 'otto'
+  const categoryName = botName && !isOttoBot ? `${CATEGORY_NAME} ${botName}` : CATEGORY_NAME
+  // Legacy names to check when looking up existing categories on older servers
+  const isLegacyKimakiBot = botName?.toLowerCase() === 'otto'
+  const legacyCategoryName =
+    botName && !isLegacyKimakiBot ? `${LEGACY_CATEGORY_NAME} ${botName}` : LEGACY_CATEGORY_NAME
+
+  const existingCategory = guild.channels.cache.find(
+    (channel): channel is CategoryChannel => {
+      if (channel.type !== ChannelType.GuildCategory) {
+        return false
+      }
+      const name = channel.name.toLowerCase()
+      return (
+        name === categoryName.toLowerCase() ||
+        name === legacyCategoryName.toLowerCase()
+      )
+    },
+  )
+
+  if (existingCategory) {
+    return existingCategory
+  }
+
+  return guild.channels.create({
+    name: categoryName,
+    type: ChannelType.GuildCategory,
+  })
+}
+
+// Keep old export name as an alias for any callers that haven't been updated yet
+export const ensureKimakiCategory = ensureOttoCategory
+
+export async function ensureOttoAudioCategory(
+  guild: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  // Skip appending bot name if it's already "otto" to avoid "Otto Audio otto"
+  const isOttoBot = botName?.toLowerCase() === 'otto'
+  const categoryName =
+    botName && !isOttoBot ? `${CATEGORY_NAME_AUDIO} ${botName}` : CATEGORY_NAME_AUDIO
+  const isLegacyKimakiBot = botName?.toLowerCase() === 'otto'
+  const legacyCategoryName =
+    botName && !isLegacyKimakiBot
+      ? `${LEGACY_CATEGORY_NAME_AUDIO} ${botName}`
+      : LEGACY_CATEGORY_NAME_AUDIO
+
+  const existingCategory = guild.channels.cache.find(
+    (channel): channel is CategoryChannel => {
+      if (channel.type !== ChannelType.GuildCategory) {
+        return false
+      }
+      const name = channel.name.toLowerCase()
+      return (
+        name === categoryName.toLowerCase() ||
+        name === legacyCategoryName.toLowerCase()
+      )
+    },
+  )
+
+  if (existingCategory) {
+    return existingCategory
+  }
+
+  return guild.channels.create({
+    name: categoryName,
+    type: ChannelType.GuildCategory,
+  })
+}
+
+export const ensureKimakiAudioCategory = ensureOttoAudioCategory
+
+export async function createProjectChannels({
+  guild,
+  projectDirectory,
+  botName,
+  enableVoiceChannels = false,
+}: {
+  guild: Guild
+  projectDirectory: string
+  botName?: string
+  enableVoiceChannels?: boolean
+}): Promise<{
+  textChannelId: string
+  voiceChannelId: string | null
+  channelName: string
+}> {
+  const baseName = path.basename(projectDirectory)
+  const channelName = `${baseName}`
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .slice(0, 100)
+
+  const ottoCategory = await ensureOttoCategory(guild, botName)
+
+  const textChannel = await guild.channels.create({
+    name: channelName,
+    type: ChannelType.GuildText,
+    parent: ottoCategory,
+    // Channel configuration is stored in SQLite, not in the topic
+  })
+
+  await setChannelDirectory({
+    channelId: textChannel.id,
+    directory: projectDirectory,
+    channelType: 'text',
+  })
+
+  let voiceChannelId: string | null = null
+
+  if (enableVoiceChannels) {
+    const ottoAudioCategory = await ensureOttoAudioCategory(guild, botName)
+
+    const voiceChannel = await guild.channels.create({
+      name: channelName,
+      type: ChannelType.GuildVoice,
+      parent: ottoAudioCategory,
+    })
+
+    await setChannelDirectory({
+      channelId: voiceChannel.id,
+      directory: projectDirectory,
+      channelType: 'voice',
+    })
+
+    voiceChannelId = voiceChannel.id
+  }
+
+  return {
+    textChannelId: textChannel.id,
+    voiceChannelId,
+    channelName,
+  }
+}
+
+export type ChannelWithTags = {
+  id: string
+  name: string
+  description: string | null
+  ottoDirectory?: string
+}
+
+export async function getChannelsWithDescriptions(
+  guild: Guild,
+): Promise<ChannelWithTags[]> {
+  const channels: ChannelWithTags[] = []
+
+  const textChannels = guild.channels.cache.filter((channel) =>
+    channel.isTextBased(),
+  )
+
+  for (const channel of textChannels.values()) {
+    const textChannel = channel as TextChannel
+    const description = textChannel.topic || null
+
+    // Get channel config from database instead of parsing XML from topic
+    const channelConfig = await getChannelDirectory(textChannel.id)
+
+    channels.push({
+      id: textChannel.id,
+      name: textChannel.name,
+      description,
+      ottoDirectory: channelConfig?.directory,
+    })
+  }
+
+  return channels
+}
+
+const DEFAULT_GITIGNORE = `node_modules/
+dist/
+.env
+.env.*
+!.env.example
+.DS_Store
+tmp/
+*.log
+__pycache__/
+*.pyc
+.venv/
+*.egg-info/
+`
+
+const DEFAULT_CHANNEL_TOPIC =
+  'General channel for misc tasks with Otto. Not connected to a specific OpenCode project or repository.'
+
+/**
+ * Create (or find) the default "otto" channel for general-purpose tasks.
+ * Channel name is "otto-{botName}" for self-hosted bots, "otto" for gateway.
+ * Directory is <dataDir>/projects/otto (or the legacy <dataDir>/projects/otto
+ * if that already exists on disk), git-initialized with a .gitignore.
+ *
+ * Idempotency: checks the database for an existing channel mapped to the
+ * otto (or legacy otto) projects directory. Also scans guild channels by
+ * name+category as a fallback for channels created before DB mapping existed.
+ */
+export async function createDefaultOttoChannel({
+  guild,
+  botName,
+  appId,
+  isGatewayMode,
+}: {
+  guild: Guild
+  botName?: string
+  appId: string
+  isGatewayMode: boolean
+}): Promise<{
+  textChannel: TextChannel
+  textChannelId: string
+  channelName: string
+  projectDirectory: string
+} | null> {
+  // Use the legacy "otto" sub-directory if it already exists on disk so
+  // existing users keep their project history. New installs use "otto".
+  const legacyProjectDirectory = path.join(getProjectsDir(), 'otto')
+  const projectDirectory = fs.existsSync(legacyProjectDirectory)
+    ? legacyProjectDirectory
+    : path.join(getProjectsDir(), 'otto')
+
+  // Ensure the project directory exists before any DB mapping restoration
+  // or git setup. Custom data dirs may not have <dataDir>/projects created
+  // yet, and later writes assume the full path is present.
+  if (!fs.existsSync(projectDirectory)) {
+    fs.mkdirSync(projectDirectory, { recursive: true })
+    logger.log(`Created default otto directory: ${projectDirectory}`)
+  }
+
+  // Hydrate guild channels from API so the cache scan is complete
+  try {
+    await guild.channels.fetch()
+  } catch (error) {
+    logger.warn(
+      `Could not fetch guild channels for ${guild.name}: ${error instanceof Error ? error.stack : String(error)}`,
+    )
+  }
+
+  // 1. Check database for existing channel mapped to this directory.
+  // Check ALL mappings (not just the first) since the same directory could
+  // have stale rows from deleted channels or other guilds.
+  const existingMappings = await findChannelsByDirectory({
+    directory: projectDirectory,
+    channelType: 'text',
+  })
+  const mappedChannelInGuild = existingMappings
+    .map((row) => guild.channels.cache.get(row.channel_id))
+    .find((ch): ch is TextChannel => ch?.type === ChannelType.GuildText)
+  if (mappedChannelInGuild) {
+    logger.log(`Default otto channel already exists: ${mappedChannelInGuild.id}`)
+    return null
+  }
+
+  // 2. Fallback: detect existing channel by name+category (handles both the
+  // current "otto"/"otto-*" names and legacy "otto"/"otto-*" names).
+  const ottoCategory = await ensureOttoCategory(guild, botName)
+  const existingByName = guild.channels.cache.find((ch): ch is TextChannel => {
+    if (ch.type !== ChannelType.GuildText) {
+      return false
+    }
+    if (ch.parentId !== ottoCategory.id) {
+      return false
+    }
+    return (
+      ch.name === 'otto' ||
+      ch.name.startsWith('otto-') ||
+      ch.name === 'otto' ||
+      ch.name.startsWith('otto-')
+    )
+  })
+  if (existingByName) {
+    logger.log(
+      `Found existing default channel by name: ${existingByName.id}, restoring DB mapping`,
+    )
+    await setChannelDirectory({
+      channelId: existingByName.id,
+      directory: projectDirectory,
+      channelType: 'text',
+      skipIfExists: true,
+    })
+    return null
+  }
+
+  // Git init — gracefully skip if git is not installed
+  const gitDir = path.join(projectDirectory, '.git')
+  if (!fs.existsSync(gitDir)) {
+    try {
+      await execAsync('git init', { cwd: projectDirectory, timeout: 10_000 })
+      logger.log(`Initialized git in: ${projectDirectory}`)
+    } catch (error) {
+      logger.warn(
+        `Could not initialize git in ${projectDirectory}: ${error instanceof Error ? error.stack : String(error)}`,
+      )
+    }
+  }
+
+  // Write .gitignore if it doesn't exist
+  const gitignorePath = path.join(projectDirectory, '.gitignore')
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, DEFAULT_GITIGNORE)
+  }
+
+  // Channel name: "otto-{botName}" for self-hosted, "otto" for gateway
+  const channelName = (() => {
+    if (isGatewayMode || !botName) {
+      return 'otto'
+    }
+    const sanitized = botName
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '')
+    if (!sanitized || sanitized === 'otto') {
+      return 'otto'
+    }
+    return `otto-${sanitized}`.slice(0, 100)
+  })()
+
+  const textChannel = await guild.channels.create({
+    name: channelName,
+    type: ChannelType.GuildText,
+    parent: ottoCategory,
+    topic: DEFAULT_CHANNEL_TOPIC,
+  })
+
+  await setChannelDirectory({
+    channelId: textChannel.id,
+    directory: projectDirectory,
+    channelType: 'text',
+  })
+
+  logger.log(`Created default otto channel: #${channelName} (${textChannel.id})`)
+
+  return {
+    textChannel,
+    textChannelId: textChannel.id,
+    channelName,
+    projectDirectory,
+  }
+}
+
+// Keep legacy export name so any unupdated callers still compile
+export const createDefaultKimakiChannel = createDefaultOttoChannel