@otto-assistant/otto 0.1.1 → 0.7.15

package/src/otto/branding.ts

@@ -0,0 +1,23 @@
+/**
+ * Otto branding overrides
+ *
+ * These values can be used throughout the distribution
+ * to customize the CLI appearance and messaging.
+ */
+export const OTTO_BRANDING = {
+  /** Display name shown in UI */
+  name: "Otto",
+  /** Short description */
+  tagline: "AI agent distribution",
+  /** Organization URL */
+  homepage: "https://github.com/otto-assistant/otto",
+  /** Version of the otto distribution (updated by CI) */
+  ottoVersion: "0.1.0",
+} as const
+
+/**
+ * Check if running as Otto distribution
+ */
+export function isOttoDistribution(): boolean {
+  return true // This file only exists in the Otto fork
+}

package/src/otto/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Otto distribution extensions
+ *
+ * Custom branding, features, and integrations for the Otto AI distribution.
+ * This module is imported by the upstream entry point.
+ * Upstream code is NOT modified beyond a single import line at the end of cli.ts.
+ */
+export { OTTO_BRANDING } from "./branding.js"
+
+/**
+ * Otto-specific configuration for the distribution
+ */
+export const OTTO_CONFIG = {
+  /** GitHub organization */
+  org: "otto-assistant",
+  /** Upstream repository */
+  upstream: "otto-assistant/otto",
+  /** Distribution name */
+  distributionName: "Otto",
+  /** Homepage */
+  homepage: "https://github.com/otto-assistant/otto",
+} as const

package/src/otto-digital-twin.e2e.test.ts

@@ -0,0 +1,199 @@
+// End-to-end test using discord-digital-twin + real Otto bot runtime.
+// Verifies onboarding channel creation, message -> thread creation, and assistant reply.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { expect, test } from 'vitest'
+import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js'
+import { DigitalDiscord } from 'discord-digital-twin/src'
+import { CachedOpencodeProviderProxy } from 'opencode-cached-provider'
+import { setDataDir } from './config.js'
+import { startDiscordBot } from './discord-bot.js'
+import {
+  setBotToken,
+  initDatabase,
+  closeDatabase,
+  setChannelDirectory,
+} from './database.js'
+import { startHranaServer, stopHranaServer } from './hrana-server.js'
+import { cleanupTestSessions, chooseLockPort, initTestGitRepo } from './test-utils.js'
+import { stopOpencodeServer } from './opencode.js'
+
+const geminiApiKey =
+  process.env['GEMINI_API_KEY'] ||
+  process.env['GOOGLE_GENERATIVE_AI_API_KEY'] ||
+  ''
+const geminiModel = process.env['GEMINI_FLASH_MODEL'] || 'gemini-2.5-flash'
+const e2eTest = geminiApiKey.length > 0 ? test : test.skip
+
+function createRunDirectories() {
+  const root = path.resolve(process.cwd(), 'tmp', 'otto-digital-twin-e2e')
+  fs.mkdirSync(root, { recursive: true })
+
+  const dataDir = fs.mkdtempSync(path.join(root, 'data-'))
+  const projectDirectory = path.join(root, 'project')
+  const providerCacheDbPath = path.join(root, 'provider-cache.db')
+  fs.mkdirSync(projectDirectory, { recursive: true })
+  initTestGitRepo(projectDirectory)
+
+  return {
+    root,
+    dataDir,
+    projectDirectory,
+    providerCacheDbPath,
+  }
+}
+
+function createDiscordJsClient({ restUrl }: { restUrl: string }) {
+  return new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.GuildVoiceStates,
+    ],
+    partials: [
+      Partials.Channel,
+      Partials.Message,
+      Partials.User,
+      Partials.ThreadMember,
+    ],
+    rest: {
+      api: restUrl,
+      version: '10',
+    },
+  })
+}
+
+e2eTest(
+  'onboarding then message creates thread and assistant reply via digital twin',
+  async () => {
+    const testStartTime = Date.now()
+    const directories = createRunDirectories()
+    const lockPort = chooseLockPort({ key: 'otto-digital-twin-e2e' })
+
+    process.env['OTTO_LOCK_PORT'] = String(lockPort)
+    setDataDir(directories.dataDir)
+
+    const proxy = new CachedOpencodeProviderProxy({
+      cacheDbPath: directories.providerCacheDbPath,
+      targetBaseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+      apiKey: geminiApiKey,
+      cacheMethods: ['POST'],
+    })
+
+    const testUserId = '100000000000000777'
+    const textChannelId = '100000000000000778'
+    const digitalDiscordDbPath = path.join(
+      directories.dataDir,
+      'digital-discord.db',
+    )
+    const discord = new DigitalDiscord({
+      guild: {
+        name: 'Otto E2E Guild',
+        ownerId: testUserId,
+      },
+      channels: [
+        {
+          id: textChannelId,
+          name: 'otto-e2e',
+          type: ChannelType.GuildText,
+        },
+      ],
+      users: [
+        {
+          id: testUserId,
+          username: 'e2e-user',
+        },
+      ],
+      dbUrl: `file:${digitalDiscordDbPath}`,
+    })
+
+    let botClient: Client | null = null
+
+    try {
+      await Promise.all([proxy.start(), discord.start()])
+
+      const opencodeConfig = proxy.buildOpencodeConfig({
+        providerName: 'cached-google',
+        providerNpm: '@ai-sdk/google',
+        model: geminiModel,
+        smallModel: geminiModel,
+      })
+      fs.writeFileSync(
+        path.join(directories.projectDirectory, 'opencode.json'),
+        JSON.stringify(opencodeConfig, null, 2),
+      )
+
+      const dbPath = path.join(directories.dataDir, 'discord-sessions.db')
+      const hranaResult = await startHranaServer({ dbPath })
+      if (hranaResult instanceof Error) {
+        throw hranaResult
+      }
+      process.env['OTTO_DB_URL'] = hranaResult
+      await initDatabase()
+      await setBotToken(discord.botUserId, discord.botToken)
+
+      await setChannelDirectory({
+        channelId: textChannelId,
+        directory: directories.projectDirectory,
+        channelType: 'text',
+      })
+
+      botClient = createDiscordJsClient({ restUrl: discord.restUrl })
+      await startDiscordBot({
+        token: discord.botToken,
+        appId: discord.botUserId,
+        discordClient: botClient,
+      })
+
+      await discord.channel(textChannelId).user(testUserId).sendMessage({
+        content: 'Reply with exactly: otto digital twin ok',
+      })
+
+      const createdThread = await discord.channel(textChannelId).waitForThread({
+        timeout: 60_000,
+        predicate: (thread) => {
+          return thread.name === 'Reply with exactly: otto digital twin ok'
+        },
+      })
+
+      const botReply = await discord.thread(createdThread.id).waitForBotReply({
+        timeout: 120_000,
+      })
+
+      expect(createdThread.id.length).toBeGreaterThan(0)
+      expect(botReply.content.trim().length).toBeGreaterThan(0)
+    } finally {
+      await cleanupTestSessions({
+        projectDirectory: directories.projectDirectory,
+        testStartTime,
+      })
+
+      if (botClient) {
+        botClient.destroy()
+      }
+
+      await stopOpencodeServer()
+      await Promise.all([
+        closeDatabase().catch(() => {
+          return
+        }),
+        stopHranaServer().catch(() => {
+          return
+        }),
+        proxy.stop().catch(() => {
+          return
+        }),
+        discord.stop().catch(() => {
+          return
+        }),
+      ])
+
+      delete process.env['OTTO_LOCK_PORT']
+      delete process.env['OTTO_DB_URL']
+      fs.rmSync(directories.dataDir, { recursive: true, force: true })
+    }
+  },
+  360_000,
+)

package/src/otto-opencode-plugin-loading.e2e.test.ts

@@ -0,0 +1,117 @@
+// E2e test for OpenCode plugin loading.
+// Spawns `opencode serve` directly with our plugin in OPENCODE_CONFIG_CONTENT,
+// waits for the health endpoint, then checks stderr for plugin errors.
+// No Discord infrastructure needed — just the OpenCode server process.
+
+import { spawn, type ChildProcess } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { test, expect } from 'vitest'
+import { resolveOpencodeCommand } from './opencode.js'
+import { getSpawnCommandAndArgs } from './opencode-command.js'
+import { chooseLockPort } from './test-utils.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+async function waitForHealth({
+  port,
+  maxAttempts = 30,
+}: {
+  port: number
+  maxAttempts?: number
+}): Promise<boolean> {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/api/health`)
+      if (response.status < 500) {
+        return true
+      }
+    } catch {
+      // connection refused, retry
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 1000)
+    })
+  }
+  return false
+}
+
+test(
+  'opencode server loads plugin without errors',
+  async () => {
+    const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e')
+    fs.mkdirSync(projectDir, { recursive: true })
+
+    const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' })
+    const pluginPath = new URL('../src/otto-opencode-plugin.ts', import.meta.url).href
+    const stderrLines: string[] = []
+    const isolatedOpencodeRoot = path.join(projectDir, 'opencode-test-home')
+    const xdgDirectories = {
+      OPENCODE_CONFIG_DIR: path.join(isolatedOpencodeRoot, '.opencode-otto'),
+      XDG_CONFIG_HOME: path.join(isolatedOpencodeRoot, '.config'),
+      XDG_DATA_HOME: path.join(isolatedOpencodeRoot, '.local', 'share'),
+      XDG_CACHE_HOME: path.join(isolatedOpencodeRoot, '.cache'),
+      XDG_STATE_HOME: path.join(isolatedOpencodeRoot, '.local', 'state'),
+    }
+
+    fs.mkdirSync(isolatedOpencodeRoot, { recursive: true })
+    Object.values(xdgDirectories).forEach((directory) => {
+      fs.mkdirSync(directory, { recursive: true })
+    })
+
+    const {
+      command,
+      args,
+      windowsVerbatimArguments,
+    } = getSpawnCommandAndArgs({
+      resolvedCommand: resolveOpencodeCommand(),
+      baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
+    })
+
+    const serverProcess: ChildProcess = spawn(command, args, {
+      stdio: 'pipe',
+      cwd: projectDir,
+      windowsVerbatimArguments,
+      env: {
+        ...process.env,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          $schema: 'https://opencode.ai/config.json',
+          lsp: false,
+          formatter: false,
+          plugin: [pluginPath],
+        }),
+        OPENCODE_TEST_HOME: isolatedOpencodeRoot,
+        ...xdgDirectories,
+      },
+    })
+
+    serverProcess.stderr?.on('data', (data) => {
+      stderrLines.push(...data.toString().split('\n').filter(Boolean))
+    })
+
+    try {
+      const healthy = await waitForHealth({ port })
+      expect(healthy).toBe(true)
+
+      // Check no plugin-related errors in stderr
+      const pluginErrorPatterns = [
+        /plugin.*error/i,
+        /failed to load plugin/i,
+        /cannot find module/i,
+        /ERR_MODULE_NOT_FOUND/i,
+        /plugin.*failed/i,
+        /plugin.*crash/i,
+      ]
+      const errorLines = stderrLines.filter((line) => {
+        return pluginErrorPatterns.some((pattern) => {
+          return pattern.test(line)
+        })
+      })
+      expect(errorLines).toEqual([])
+    } finally {
+      serverProcess.kill('SIGTERM')
+    }
+  },
+  60_000,
+)

package/src/otto-opencode-plugin.test.ts

@@ -0,0 +1,108 @@
+import { test, expect, describe } from 'vitest'
+import { condenseMemoryMd } from './condense-memory.js'
+
+describe('condenseMemoryMd', () => {
+  test('multiple headings with body content', () => {
+    const content = [
+      '# Project Overview',
+      '',
+      'This is a big project with many things.',
+      'It does X, Y, and Z.',
+      '',
+      '## Auth Architecture',
+      '',
+      'JWT tokens with 15min expiry.',
+      'Refresh tokens in httpOnly cookies.',
+      'Session stored in Redis.',
+      '',
+      '## User Preferences',
+      '',
+      '- kebab-case filenames',
+      '- errore-style errors',
+      '- no emojis',
+      '',
+      '### API Conventions',
+      '',
+      'All routes return { data, error }.',
+      'Use spiceflow for the server.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # Project Overview
+      ...
+      6: ## Auth Architecture
+      ...
+      12: ## User Preferences
+      ...
+      18: ### API Conventions
+      ..."
+    `)
+  })
+
+  test('body text before first heading', () => {
+    const content = [
+      'Some preamble notes.',
+      '',
+      '# First Heading',
+      '',
+      'Content here.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "...
+      3: # First Heading
+      ..."
+    `)
+  })
+
+  test('no headings at all', () => {
+    const content = 'Just some notes.\nMore notes.\n'
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`"..."`)
+  })
+
+  test('empty content', () => {
+    expect(condenseMemoryMd('')).toMatchInlineSnapshot(`""`)
+  })
+
+  test('consecutive headings without body', () => {
+    const content = [
+      '# H1',
+      '## H2',
+      '### H3',
+      '',
+      'Some body.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # H1
+      2: ## H2
+      3: ### H3
+      ..."
+    `)
+  })
+
+  test('heading with code block body', () => {
+    const content = [
+      '# Config',
+      '',
+      '```json',
+      '{ "key": "value" }',
+      '```',
+      '',
+      '## Notes',
+      '',
+      'Some text.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # Config
+      ...
+      7: ## Notes
+      ..."
+    `)
+  })
+})

package/src/otto-opencode-plugin.ts

@@ -0,0 +1,22 @@
+// OpenCode plugin entry point for Otto Discord bot.
+// Each export is treated as a separate plugin by OpenCode's plugin loader.
+// CRITICAL: never export utility functions from this file — only plugin
+// initializer functions. OpenCode calls every export as a plugin.
+//
+// Plugins are split into focused modules:
+// - ipc-tools-plugin: file upload + action buttons (IPC-based Discord tools)
+// - context-awareness-plugin: branch, pwd, memory reminder, onboarding tutorial
+// - memory-overview-plugin: frozen MEMORY.md heading overview per session
+// - opencode-interrupt-plugin: interrupt queued messages at step boundaries
+// - subagent-rate-limit-plugin: aborts only task subagents after rate limits
+// - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
+
+export { ipcToolsPlugin } from './ipc-tools-plugin.js'
+export { contextAwarenessPlugin } from './context-awareness-plugin.js'
+export { memoryOverviewPlugin } from './memory-overview-plugin.js'
+export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js'
+export { anthropicAuthPlugin } from './anthropic-auth-plugin.js'
+export { imageOptimizerPlugin } from './image-optimizer-plugin.js'
+export { subagentRateLimitPlugin } from './subagent-rate-limit-plugin.js'
+export { kittyGraphicsPlugin } from 'kitty-graphics-agent'
+export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard'

package/src/parse-permission-rules.test.ts

@@ -0,0 +1,127 @@
+// Tests for parsePermissionRules() from opencode.ts
+import { describe, test, expect } from 'vitest'
+import { parsePermissionRules } from './opencode.js'
+
+describe('parsePermissionRules', () => {
+  test('simple tool:action format', () => {
+    expect(parsePermissionRules(['bash:deny'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+      ]
+    `)
+  })
+
+  test('multiple rules', () => {
+    expect(parsePermissionRules(['bash:deny', 'edit:deny', 'read:allow'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "edit",
+        },
+        {
+          "action": "allow",
+          "pattern": "*",
+          "permission": "read",
+        },
+      ]
+    `)
+  })
+
+  test('tool:pattern:action format', () => {
+    expect(parsePermissionRules(['bash:git *:allow'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "allow",
+          "pattern": "git *",
+          "permission": "bash",
+        },
+      ]
+    `)
+  })
+
+  test('wildcard permission', () => {
+    expect(parsePermissionRules(['*:deny'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "*",
+        },
+      ]
+    `)
+  })
+
+  test('case-insensitive action', () => {
+    expect(parsePermissionRules(['bash:DENY', 'edit:Allow'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+        {
+          "action": "allow",
+          "pattern": "*",
+          "permission": "edit",
+        },
+      ]
+    `)
+  })
+
+  test('trims whitespace', () => {
+    expect(parsePermissionRules([' bash : deny '])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+      ]
+    `)
+  })
+
+  test('skips invalid entries', () => {
+    expect(parsePermissionRules(['', 'bash', 'bash:invalid', ':deny'])).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('handles non-array input defensively', () => {
+    expect(parsePermissionRules(undefined)).toMatchInlineSnapshot(`[]`)
+    expect(parsePermissionRules(null)).toMatchInlineSnapshot(`[]`)
+    expect(parsePermissionRules('bash:deny')).toMatchInlineSnapshot(`[]`)
+    expect(parsePermissionRules(123)).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('handles non-string array items', () => {
+    expect(parsePermissionRules([123, null, 'bash:deny'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+      ]
+    `)
+  })
+
+  test('ask action', () => {
+    expect(parsePermissionRules(['webfetch:ask'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "ask",
+          "pattern": "*",
+          "permission": "webfetch",
+        },
+      ]
+    `)
+  })
+})