@otto-assistant/otto 0.1.1 → 0.7.15

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,185 @@
+// Otto self-upgrade utilities.
+// Detects the package manager used to install otto, checks npm for newer versions,
+// and runs the global upgrade command. Used by both CLI `otto 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'
+type CliPackageJson = { version: string; name: string }
+
+// Detects which package manager globally installed otto, used to run the
+// correct `<pm> i -g @otto-assistant/otto@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/@otto-assistant 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
+  }
+}
+
+function getCliPackageJson(): CliPackageJson {
+  const require = createRequire(import.meta.url)
+  return require('../package.json') as CliPackageJson
+}
+
+export function getCurrentVersion(): string {
+  return getCliPackageJson().version
+}
+
+function getPackageName(): string {
+  return getCliPackageJson().name
+}
+
+export async function getLatestNpmVersion(): Promise<string | null> {
+  try {
+    const packageName = encodeURIComponent(getPackageName())
+    const res = await fetch(`https://registry.npmjs.org/${packageName}/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
+  }
+}
+
+const LEGACY_PACKAGE_NAME = '@otto-assistant/bridge'
+const CURRENT_PACKAGE_NAME = '@otto-assistant/otto'
+
+// Returns true if running under the old @otto-assistant/bridge package name.
+// When true, `upgrade()` will migrate to @otto-assistant/otto automatically.
+export function isLegacyPackageName(): boolean {
+  return getPackageName() === LEGACY_PACKAGE_NAME
+}
+
+// Returns the new version string if upgraded (or migrated), null if already up to date.
+// If running as the legacy @otto-assistant/bridge package, migrates to
+// @otto-assistant/otto by installing the new package name globally.
+export async function upgrade(): Promise<string | null> {
+  const current = getCurrentVersion()
+
+  // Migrate legacy package name: install @otto-assistant/otto and remove @otto-assistant/bridge
+  if (isLegacyPackageName()) {
+    const latest = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(CURRENT_PACKAGE_NAME)}/latest`,
+      { signal: AbortSignal.timeout(15_000) },
+    )
+      .then((r) => (r.ok ? (r.json() as Promise<{ version: string }>) : null))
+      .then((d) => d?.version ?? null)
+      .catch(() => null)
+
+    const pm = detectPm()
+    logger.log(
+      `Migrating from ${LEGACY_PACKAGE_NAME} to ${CURRENT_PACKAGE_NAME}${latest ? ` v${latest}` : ''} using ${pm}...`,
+    )
+    await execAsync(`${pm} i -g ${CURRENT_PACKAGE_NAME}@latest`, {
+      timeout: 120_000,
+    })
+    // Best-effort removal of the old package — non-fatal if it fails
+    await execAsync(`${pm} remove -g ${LEGACY_PACKAGE_NAME}`, {
+      timeout: 60_000,
+    }).catch(() => {})
+    return latest ?? current
+  }
+
+  const latest = await getLatestNpmVersion()
+  if (!latest) {
+    throw new Error('Failed to check latest version from npm')
+  }
+  if (current === latest) {
+    return null
+  }
+
+  const pm = detectPm()
+  const packageName = getPackageName()
+  logger.log(`Upgrading ${packageName} from v${current} to v${latest} using ${pm}...`)
+  await execAsync(`${pm} i -g ${packageName}@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 backgroundUpgradeOtto(): Promise<void> {
+  try {
+    // Silently migrate legacy package name in the background
+    if (isLegacyPackageName()) {
+      const pm = detectPm()
+      logger.debug(`Background migration from ${LEGACY_PACKAGE_NAME} to ${CURRENT_PACKAGE_NAME}`)
+      await execAsync(`${pm} i -g ${CURRENT_PACKAGE_NAME}@latest`, { timeout: 120_000 })
+      await execAsync(`${pm} remove -g ${LEGACY_PACKAGE_NAME}`, { timeout: 60_000 }).catch(() => {})
+      return
+    }
+
+    const current = getCurrentVersion()
+    const latest = await getLatestNpmVersion()
+    if (!latest || current === latest) {
+      return
+    }
+
+    const pm = detectPm()
+    const packageName = getPackageName()
+    logger.debug(
+      `Background ${packageName} upgrade started: v${current} -> v${latest}`,
+    )
+    await execAsync(`${pm} i -g ${packageName}@latest`, { timeout: 120_000 })
+    logger.debug(`Background ${packageName} upgrade completed: v${latest}`)
+  } catch {
+    // silently ignored, non-critical
+  }
+}

package/src/utils.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, test } from 'vitest'
+import {
+  buildOpenUrlCommand,
+  generateDiscordInstallUrlForBot,
+  getGatewayInstallTargetName,
+  getGatewayPlatformDisplayName,
+  shouldRegisterSlashCommands,
+} from './utils.js'
+
+describe('generateDiscordInstallUrlForBot', () => {
+  test('uses telegram install path in gateway mode', () => {
+    const result = generateDiscordInstallUrlForBot({
+      appId: 'app-id',
+      mode: 'gateway',
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      gatewayPlatform: 'telegram',
+    })
+
+    expect(result).toBeTypeOf('string')
+    if (typeof result !== 'string') {
+      throw new Error('Expected install URL string')
+    }
+
+    const url = new URL(result)
+    expect(url.pathname).toBe('/telegram-install')
+    expect(url.searchParams.get('clientId')).toBe('client-id')
+    expect(url.searchParams.get('clientSecret')).toBe('client-secret')
+  })
+
+  test('uses discord install path by default in gateway mode', () => {
+    const result = generateDiscordInstallUrlForBot({
+      appId: 'app-id',
+      mode: 'gateway',
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+    })
+
+    expect(result).toBeTypeOf('string')
+    if (typeof result !== 'string') {
+      throw new Error('Expected install URL string')
+    }
+
+    const url = new URL(result)
+    expect(url.pathname).toBe('/discord-install')
+    expect(url.searchParams.get('clientId')).toBe('client-id')
+    expect(url.searchParams.get('clientSecret')).toBe('client-secret')
+  })
+
+  test('includes callback and reachable URL query params when provided', () => {
+    const callbackUrl = 'https://example.com/callback?foo=bar'
+    const reachableUrl = 'https://example-ngrok.test'
+    const result = generateDiscordInstallUrlForBot({
+      appId: 'app-id',
+      mode: 'gateway',
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      gatewayPlatform: 'telegram',
+      gatewayCallbackUrl: callbackUrl,
+      reachableUrl,
+    })
+
+    expect(result).toBeTypeOf('string')
+    if (typeof result !== 'string') {
+      throw new Error('Expected install URL string')
+    }
+
+    const url = new URL(result)
+    expect(url.searchParams.get('ottoCallbackUrl')).toBe(callbackUrl)
+    expect(url.searchParams.get('reachableUrl')).toBe(reachableUrl)
+  })
+
+  test('returns error when gateway credentials are missing', () => {
+    const result = generateDiscordInstallUrlForBot({
+      appId: 'app-id',
+      mode: 'gateway',
+      clientId: null,
+      clientSecret: null,
+      gatewayPlatform: 'telegram',
+    })
+
+    expect(result).toBeInstanceOf(Error)
+    if (!(result instanceof Error)) {
+      throw new Error('Expected Error result')
+    }
+    expect(result.message).toContain('Gateway credentials are missing')
+  })
+})
+
+describe('gateway platform helpers', () => {
+  test('returns display names and install target names', () => {
+    expect(getGatewayPlatformDisplayName({ gatewayPlatform: 'discord' })).toBe('Discord')
+    expect(getGatewayPlatformDisplayName({ gatewayPlatform: 'telegram' })).toBe('Telegram')
+    expect(getGatewayInstallTargetName({ gatewayPlatform: 'discord' })).toBe('server')
+    expect(getGatewayInstallTargetName({ gatewayPlatform: 'telegram' })).toBe('chat')
+  })
+
+  test('registers slash commands only for discord gateway', () => {
+    expect(shouldRegisterSlashCommands({ gatewayPlatform: 'discord' })).toBe(true)
+    expect(shouldRegisterSlashCommands({ gatewayPlatform: 'telegram' })).toBe(false)
+  })
+})
+
+describe('buildOpenUrlCommand', () => {
+  test('uses cmd start on windows', () => {
+    const result = buildOpenUrlCommand({
+      platform: 'win32',
+      url: 'https://example.com/path?x=1',
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "args": [
+          "/c",
+          "start",
+          "",
+          "https://example.com/path?x=1",
+        ],
+        "command": "cmd",
+      }
+    `)
+  })
+
+  test('uses open on macOS', () => {
+    const result = buildOpenUrlCommand({
+      platform: 'darwin',
+      url: 'https://example.com/path?x=1',
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "args": [
+          "https://example.com/path?x=1",
+        ],
+        "command": "open",
+      }
+    `)
+  })
+
+  test('uses xdg-open on linux', () => {
+    const result = buildOpenUrlCommand({
+      platform: 'linux',
+      url: 'https://example.com/path?x=1',
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "args": [
+          "https://example.com/path?x=1",
+        ],
+        "command": "xdg-open",
+      }
+    `)
+  })
+})