@otto-assistant/otto 0.1.2 → 0.7.15

package/src/session-handler.ts

@@ -0,0 +1,15 @@
+// Thin re-export shim for backward compatibility.
+// Logic lives in:
+//   - session-handler/thread-session-runtime.ts (runtime class + registry)
+//   - session-handler/thread-runtime-state.ts (state transitions)
+//   - session-handler/model-utils.ts (getDefaultModel, types)
+//   - session-handler/agent-utils.ts (resolveValidatedAgentPreference)
+// New code should import from the specific module directly.
+
+export type { QueuedMessage } from './session-handler/thread-runtime-state.js'
+export {
+  getDefaultModel,
+  type DefaultModelSource,
+  type SessionStartSourceContext,
+} from './session-handler/model-utils.js'
+export { resolveValidatedAgentPreference } from './session-handler/agent-utils.js'

package/src/session-search.test.ts

@@ -0,0 +1,50 @@
+// Tests for session search query parsing and snippet matching helpers.
+
+import { describe, expect, test } from 'vitest'
+import {
+  buildSessionSearchSnippet,
+  findFirstSessionSearchHit,
+  parseSessionSearchPattern,
+} from './session-search.js'
+
+describe('session search helpers', () => {
+  test('returns error for invalid regex query', () => {
+    const parsed = parseSessionSearchPattern('/(unclosed/')
+    expect(parsed).toBeInstanceOf(Error)
+  })
+
+  test('returns snippets that include the matched substring', () => {
+    const cases = [
+      {
+        query: 'panic',
+        text: 'There was a PANIC in production',
+        expectedSubstring: 'PANIC',
+      },
+      {
+        query: '/error\\s+42/i',
+        text: 'Request failed with ERROR 42 in worker',
+        expectedSubstring: 'ERROR 42',
+      },
+    ]
+
+    cases.forEach(({ query, text, expectedSubstring }) => {
+      const parsed = parseSessionSearchPattern(query)
+      if (parsed instanceof Error) {
+        throw parsed
+      }
+      const hit = findFirstSessionSearchHit({ text, searchPattern: parsed })
+      expect(hit).toBeDefined()
+      if (!hit) {
+        return
+      }
+
+      const snippet = buildSessionSearchSnippet({
+        text,
+        hit,
+        contextLength: 8,
+      })
+
+      expect(snippet.toUpperCase()).toContain(expectedSubstring.toUpperCase())
+    })
+  })
+})

package/src/session-search.ts

@@ -0,0 +1,148 @@
+// Session search helpers for otto CLI commands.
+// Parses string/regex queries and builds readable snippets from matched content.
+
+import type { Part } from '@opencode-ai/sdk/v2'
+
+export type SessionSearchPattern =
+  | {
+      mode: 'literal'
+      raw: string
+      normalizedNeedle: string
+    }
+  | {
+      mode: 'regex'
+      raw: string
+      regex: RegExp
+    }
+
+export type SessionSearchHit = {
+  index: number
+  length: number
+}
+
+export function parseSessionSearchPattern(
+  query: string,
+): SessionSearchPattern | Error {
+  const trimmedQuery = query.trim()
+  if (!trimmedQuery) {
+    return new Error('Search query cannot be empty')
+  }
+
+  const regexMatch = trimmedQuery.match(/^\/([\s\S]+)\/([a-z]*)$/)
+  if (!regexMatch) {
+    return {
+      mode: 'literal',
+      raw: trimmedQuery,
+      normalizedNeedle: trimmedQuery.toLowerCase(),
+    }
+  }
+
+  const pattern = regexMatch[1] || ''
+  const flags = regexMatch[2] || ''
+
+  try {
+    return {
+      mode: 'regex',
+      raw: trimmedQuery,
+      regex: new RegExp(pattern, flags),
+    }
+  } catch (error) {
+    return new Error(
+      `Invalid regex query "${trimmedQuery}": ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+}
+
+export function findFirstSessionSearchHit({
+  text,
+  searchPattern,
+}: {
+  text: string
+  searchPattern: SessionSearchPattern
+}): SessionSearchHit | undefined {
+  if (searchPattern.mode === 'literal') {
+    const index = text.toLowerCase().indexOf(searchPattern.normalizedNeedle)
+    if (index < 0) {
+      return undefined
+    }
+    return {
+      index,
+      length: searchPattern.raw.length,
+    }
+  }
+
+  searchPattern.regex.lastIndex = 0
+  const match = searchPattern.regex.exec(text)
+  if (!match || match.index < 0) {
+    return undefined
+  }
+
+  return {
+    index: match.index,
+    length: Math.max(match[0]?.length || 0, 1),
+  }
+}
+
+export function buildSessionSearchSnippet({
+  text,
+  hit,
+  contextLength = 90,
+}: {
+  text: string
+  hit: SessionSearchHit
+  contextLength?: number
+}): string {
+  const start = Math.max(0, hit.index - contextLength)
+  const end = Math.min(text.length, hit.index + hit.length + contextLength)
+
+  const prefix = start > 0 ? '...' : ''
+  const suffix = end < text.length ? '...' : ''
+  const body = text
+    .slice(start, end)
+    .replace(/[\r\n\t]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+
+  return `${prefix}${body}${suffix}`
+}
+
+function stringifyUnknown(value: unknown): string {
+  if (value === undefined || value === null) {
+    return ''
+  }
+  if (typeof value === 'string') {
+    return value
+  }
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return String(value)
+  }
+}
+
+export function getPartSearchTexts(part: Part): string[] {
+  switch (part.type) {
+    case 'text':
+      return part.text ? [part.text] : []
+    case 'reasoning':
+      return part.text ? [part.text] : []
+    case 'tool': {
+      const inputText = stringifyUnknown(part.state.input)
+      const outputText =
+        part.state.status === 'completed'
+          ? stringifyUnknown(part.state.output)
+          : part.state.status === 'error'
+            ? part.state.error || ''
+            : ''
+      return [`tool:${part.tool}`, inputText, outputText].filter((entry) => {
+        return entry.trim().length > 0
+      })
+    }
+    case 'file':
+      return [part.filename || '', part.url || ''].filter((entry) => {
+        return entry.trim().length > 0
+      })
+    default:
+      return []
+  }
+}

package/src/session-title-rename.test.ts

@@ -0,0 +1,130 @@
+// Unit tests for deriveThreadNameFromSessionTitle — the pure helper that
+// decides whether (and how) to rename a Discord thread based on an
+// OpenCode session title. Kept focused and deterministic; no Discord mocks.
+
+import { describe, test, expect } from 'vitest'
+import { deriveThreadNameFromSessionTitle } from './session-handler/thread-session-runtime.js'
+
+describe('deriveThreadNameFromSessionTitle', () => {
+  test('returns trimmed title for plain thread', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: '  Fix auth bug  ',
+        currentName: 'fix the auth',
+      }),
+    ).toMatchInlineSnapshot(`"Fix auth bug"`)
+  })
+
+  test('preserves worktree prefix from current name', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: 'Refactor queue',
+        currentName: '⬦ refactor queue old',
+      }),
+    ).toMatchInlineSnapshot(`"⬦ Refactor queue"`)
+  })
+
+  test('ignores placeholder "New Session -" titles', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: 'New Session - 2025-01-02',
+        currentName: 'whatever',
+      }),
+    ).toMatchInlineSnapshot(`undefined`)
+  })
+
+  test('ignores case-insensitive placeholder titles', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: 'new session -abc',
+        currentName: 'whatever',
+      }),
+    ).toMatchInlineSnapshot(`undefined`)
+  })
+
+  test('returns undefined when candidate already matches current name', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: 'Fix auth bug',
+        currentName: 'Fix auth bug',
+      }),
+    ).toMatchInlineSnapshot(`undefined`)
+  })
+
+  test('returns undefined when candidate (with worktree prefix) already matches', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: 'Refactor queue',
+        currentName: '⬦ Refactor queue',
+      }),
+    ).toMatchInlineSnapshot(`undefined`)
+  })
+
+  test('truncates to 100 chars including worktree prefix', () => {
+    const result = deriveThreadNameFromSessionTitle({
+      sessionTitle: 'x'.repeat(200),
+      currentName: '⬦ seed',
+    })
+    expect(result?.length).toMatchInlineSnapshot(`100`)
+    expect(result?.startsWith('⬦ ')).toMatchInlineSnapshot(`true`)
+  })
+
+  test('truncates to 100 chars without prefix', () => {
+    const result = deriveThreadNameFromSessionTitle({
+      sessionTitle: 'y'.repeat(200),
+      currentName: 'seed',
+    })
+    expect(result?.length).toMatchInlineSnapshot(`100`)
+  })
+
+  test('returns undefined for empty string', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: '',
+        currentName: 'seed',
+      }),
+    ).toMatchInlineSnapshot(`undefined`)
+  })
+
+  test('returns undefined for whitespace-only title', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: '   ',
+        currentName: 'seed',
+      }),
+    ).toMatchInlineSnapshot(`undefined`)
+  })
+
+  test('preserves btw: prefix from current name', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: 'Side question about auth',
+        currentName: 'btw: why is auth broken',
+      }),
+    ).toMatchInlineSnapshot(`"btw: Side question about auth"`)
+  })
+
+  test('preserves Fork: prefix from current name', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: 'Forked task title',
+        currentName: 'Fork: old session title',
+      }),
+    ).toMatchInlineSnapshot(`"Fork: Forked task title"`)
+  })
+
+  test('returns undefined for null/undefined title', () => {
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: null,
+        currentName: 'seed',
+      }),
+    ).toMatchInlineSnapshot(`undefined`)
+    expect(
+      deriveThreadNameFromSessionTitle({
+        sessionTitle: undefined,
+        currentName: 'seed',
+      }),
+    ).toMatchInlineSnapshot(`undefined`)
+  })
+})

package/src/skill-filter.test.ts

@@ -0,0 +1,83 @@
+import { describe, test, expect } from 'vitest'
+import { computeSkillPermission } from './skill-filter.js'
+
+describe('computeSkillPermission', () => {
+  test('empty inputs returns undefined (no filtering)', () => {
+    expect(
+      computeSkillPermission({ enabledSkills: [], disabledSkills: [] }),
+    ).toMatchInlineSnapshot(`undefined`)
+  })
+
+  test('whitelist single skill', () => {
+    expect(
+      computeSkillPermission({
+        enabledSkills: ['npm-package'],
+        disabledSkills: [],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "*": "deny",
+        "npm-package": "allow",
+      }
+    `)
+  })
+
+  test('whitelist multiple skills', () => {
+    expect(
+      computeSkillPermission({
+        enabledSkills: ['npm-package', 'playwriter', 'errore'],
+        disabledSkills: [],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "*": "deny",
+        "errore": "allow",
+        "npm-package": "allow",
+        "playwriter": "allow",
+      }
+    `)
+  })
+
+  test('blacklist single skill', () => {
+    expect(
+      computeSkillPermission({
+        enabledSkills: [],
+        disabledSkills: ['jitter'],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "jitter": "deny",
+      }
+    `)
+  })
+
+  test('blacklist multiple skills', () => {
+    expect(
+      computeSkillPermission({
+        enabledSkills: [],
+        disabledSkills: ['jitter', 'termcast'],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "jitter": "deny",
+        "termcast": "deny",
+      }
+    `)
+  })
+
+  test('whitelist takes precedence when both are set (cli.ts is expected to reject this upstream)', () => {
+    // cli.ts validates mutual exclusion before reaching this helper. This
+    // test documents the defensive behavior if both arrays ever leak through.
+    expect(
+      computeSkillPermission({
+        enabledSkills: ['npm-package'],
+        disabledSkills: ['jitter'],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "*": "deny",
+        "npm-package": "allow",
+      }
+    `)
+  })
+})

package/src/skill-filter.ts

@@ -0,0 +1,42 @@
+// Computes opencode permission.skill rules from otto's --enable-skill /
+// --disable-skill CLI flags.
+//
+// OpenCode filters skills available to the model via
+// Permission.evaluate("skill", skill.name, agent.permission). We inject a
+// top-level permission.skill ruleset into the generated opencode-config.json
+// so every agent inherits the same whitelist/blacklist via Permission.merge.
+//
+// Whitelist mode: { '*': 'deny', 'name': 'allow', ... }
+// Blacklist mode: { 'name': 'deny', ... }
+// Neither set:    undefined (skills are unfiltered)
+//
+// cli.ts validates mutual exclusion of the two flags at startup, so this
+// helper assumes at most one of the two arrays is non-empty.
+
+type PermissionAction = 'ask' | 'allow' | 'deny'
+
+export type SkillPermissionRule = Record<string, PermissionAction>
+
+export function computeSkillPermission({
+  enabledSkills,
+  disabledSkills,
+}: {
+  enabledSkills: string[]
+  disabledSkills: string[]
+}): SkillPermissionRule | undefined {
+  if (enabledSkills.length > 0) {
+    const rules: SkillPermissionRule = { '*': 'deny' }
+    for (const name of enabledSkills) {
+      rules[name] = 'allow'
+    }
+    return rules
+  }
+  if (disabledSkills.length > 0) {
+    const rules: SkillPermissionRule = {}
+    for (const name of disabledSkills) {
+      rules[name] = 'deny'
+    }
+    return rules
+  }
+  return undefined
+}

package/src/startup-service.ts

@@ -0,0 +1,200 @@
+// Cross-platform startup service registration for otto daemon.
+// Vendored from startup-run (MIT, github.com/vilicvane/startup-run) with
+// significant simplifications: no abstract classes, no fs-extra, no winreg
+// npm dep, no separate daemon process (otto's bin.ts already handles
+// respawn/crash-loop). Just writes/deletes the platform service file.
+//
+// macOS:   ~/Library/LaunchAgents/xyz.otto.plist  (launchd)
+// Linux:   ~/.config/autostart/otto.desktop       (XDG autostart)
+// Windows: HKCU\Software\Microsoft\Windows\CurrentVersion\Run  (registry)
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { execAsync } from './worktrees.js'
+
+const SERVICE_NAME = 'xyz.otto'
+
+function getServiceFilePath(): string {
+  switch (process.platform) {
+    case 'darwin':
+      return path.join(
+        os.homedir(),
+        'Library',
+        'LaunchAgents',
+        `${SERVICE_NAME}.plist`,
+      )
+    case 'linux':
+      return path.join(
+        os.homedir(),
+        '.config',
+        'autostart',
+        'otto.desktop',
+      )
+    case 'win32':
+      // No file — registry key, return a descriptive string for status display
+      return 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\otto'
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`)
+  }
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+}
+
+// Shell-escape a string for use in a Linux .desktop Exec= line.
+// Wraps in double quotes if it contains spaces or special chars.
+function shellEscape(value: string): string {
+  if (/^[a-zA-Z0-9._/=-]+$/.test(value)) {
+    return value
+  }
+  return `"${value.replace(/"/g, '\\"')}"`
+}
+
+function buildMacOSPlist({
+  command,
+  args,
+}: {
+  command: string
+  args: string[]
+}): string {
+  const segments = [command, ...args]
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>
+${segments.map((s) => `    <string>${escapeXml(s)}</string>`).join('\n')}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+</dict>
+</plist>
+`
+}
+
+function buildLinuxDesktop({
+  command,
+  args,
+}: {
+  command: string
+  args: string[]
+}): string {
+  const execLine = [command, ...args].map(shellEscape).join(' ')
+  return `[Desktop Entry]
+Type=Application
+Version=1.0
+Name=Otto
+Comment=Otto Discord Bot Daemon
+Exec=${execLine}
+StartupNotify=false
+Terminal=false
+`
+}
+
+export type StartupServiceOptions = {
+  command: string
+  args: string[]
+}
+
+/**
+ * Register otto to start on user login.
+ * Writes the appropriate service file for the current platform.
+ */
+export async function enableStartupService({
+  command,
+  args,
+}: StartupServiceOptions): Promise<void> {
+  const platform = process.platform
+
+  if (platform === 'darwin') {
+    const filePath = getServiceFilePath()
+    fs.mkdirSync(path.dirname(filePath), { recursive: true })
+    fs.writeFileSync(filePath, buildMacOSPlist({ command, args }))
+  } else if (platform === 'linux') {
+    const filePath = getServiceFilePath()
+    fs.mkdirSync(path.dirname(filePath), { recursive: true })
+    fs.writeFileSync(filePath, buildLinuxDesktop({ command, args }))
+  } else if (platform === 'win32') {
+    const execLine = [command, ...args]
+      .map((s) => {
+        return s.includes(' ') ? `"${s}"` : s
+      })
+      .join(' ')
+    await execAsync(
+      `reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v otto /t REG_SZ /d "${execLine}" /f`,
+    )
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`)
+  }
+}
+
+/**
+ * Unregister otto from user login startup.
+ */
+export async function disableStartupService(): Promise<void> {
+  const platform = process.platform
+
+  if (platform === 'darwin' || platform === 'linux') {
+    const filePath = getServiceFilePath()
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath)
+    }
+  } else if (platform === 'win32') {
+    await execAsync(
+      `reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v otto /f`,
+    ).catch(() => {
+      // Key may not exist, ignore
+    })
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`)
+  }
+}
+
+/**
+ * Check if otto is registered as a startup service.
+ */
+export async function isStartupServiceEnabled(): Promise<boolean> {
+  const platform = process.platform
+
+  if (platform === 'darwin' || platform === 'linux') {
+    return fs.existsSync(getServiceFilePath())
+  }
+
+  if (platform === 'win32') {
+    const result = await execAsync(
+      `reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v otto`,
+    ).catch(() => {
+      return null
+    })
+    return result !== null
+  }
+
+  return false
+}
+
+/**
+ * Get a human-readable description of the service location for status display.
+ */
+export function getServiceLocationDescription(): string {
+  const platform = process.platform
+  if (platform === 'darwin') {
+    return `launchd: ${getServiceFilePath()}`
+  }
+  if (platform === 'linux') {
+    return `XDG autostart: ${getServiceFilePath()}`
+  }
+  if (platform === 'win32') {
+    return `registry: ${getServiceFilePath()}`
+  }
+  return `unsupported platform: ${platform}`
+}