@otto-assistant/otto 0.1.1 → 0.7.15

package/src/patch-text-parser.ts

@@ -0,0 +1,107 @@
+// Shared apply_patch text parsing utilities.
+// Used by diff-patch-plugin.ts (file path extraction for snapshots) and
+// message-formatting.ts (per-file addition/deletion counts for Discord display).
+//
+// The apply_patch tool uses three path header formats:
+//   *** Add File: path    — new file
+//   *** Update File: path — existing file edit
+//   *** Delete File: path — file removal
+//   *** Move to: path     — rename destination
+//   --- a/path / +++ b/path — unified diff headers (fallback)
+
+/**
+ * Extract all file paths referenced in a patchText string.
+ * Handles custom apply_patch headers, move targets, and unified diff headers.
+ * Returns deduplicated paths.
+ */
+export function extractPatchFilePaths(patchText: string): string[] {
+  const custom = [
+    ...patchText.matchAll(
+      /^\*\*\* (?:Add|Update|Delete) File:\s+(.+)$/gm,
+    ),
+  ].map((m) => {
+    return (m[1] ?? '').trim()
+  })
+  const moved = [
+    ...patchText.matchAll(/^\*\*\* Move to:\s+(.+)$/gm),
+  ].map((m) => {
+    return (m[1] ?? '').trim()
+  })
+  const unified = [
+    ...patchText.matchAll(/^(?:---|\+\+\+) [ab]\/(.+)$/gm),
+  ].map((m) => {
+    return (m[1] ?? '').trim()
+  })
+  const all = [...custom, ...moved, ...unified].filter(Boolean)
+  return all.filter((v, i, a) => {
+    return a.indexOf(v) === i
+  })
+}
+
+/**
+ * Parse a patchText string and count additions/deletions per file.
+ * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
+ * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
+ */
+export function parsePatchFileCounts(
+  patchText: string,
+): Map<string, { additions: number; deletions: number }> {
+  const counts = new Map<string, { additions: number; deletions: number }>()
+  const lines = patchText.split('\n')
+  let currentFile = ''
+  let currentType = ''
+  let inHunk = false
+
+  for (const line of lines) {
+    const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/)
+    const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/)
+    const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/)
+
+    if (addMatch || updateMatch || deleteMatch) {
+      const match = addMatch || updateMatch || deleteMatch
+      currentFile = (match?.[1] ?? '').trim()
+      currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete'
+      counts.set(currentFile, { additions: 0, deletions: 0 })
+      inHunk = false
+      continue
+    }
+
+    if (line.startsWith('@@')) {
+      inHunk = true
+      continue
+    }
+
+    if (line.startsWith('*** ')) {
+      inHunk = false
+      continue
+    }
+
+    if (!currentFile) {
+      continue
+    }
+
+    const entry = counts.get(currentFile)
+    if (!entry) {
+      continue
+    }
+
+    if (currentType === 'add') {
+      // all content lines in Add File are additions
+      if (line.length > 0 && !line.startsWith('*** ')) {
+        entry.additions++
+      }
+    } else if (currentType === 'delete') {
+      // all content lines in Delete File are deletions
+      if (line.length > 0 && !line.startsWith('*** ')) {
+        entry.deletions++
+      }
+    } else if (inHunk) {
+      if (line.startsWith('+')) {
+        entry.additions++
+      } else if (line.startsWith('-')) {
+        entry.deletions++
+      }
+    }
+  }
+  return counts
+}

package/src/plugin-logger.ts

@@ -0,0 +1,84 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import util from 'node:util'
+import { sanitizeSensitiveText, sanitizeUnknownValue } from './privacy-sanitizer.js'
+
+let pluginLogFilePath: string | null = null
+
+export function setPluginLogFilePath(dataDir: string): void {
+  pluginLogFilePath = path.join(dataDir, 'otto.log')
+}
+
+function formatArg(arg: unknown): string {
+  if (typeof arg === 'string') {
+    return sanitizeSensitiveText(arg, { redactPaths: false })
+  }
+  const safeArg = sanitizeUnknownValue(arg, { redactPaths: false })
+  return util.inspect(safeArg, { colors: false, depth: 4 })
+}
+
+export function formatPluginErrorWithStack(error: unknown): string {
+  if (error instanceof Error) {
+    return sanitizeSensitiveText(
+      error.stack ?? `${error.name}: ${error.message}`,
+      { redactPaths: false },
+    )
+  }
+  if (typeof error === 'string') {
+    return sanitizeSensitiveText(error, { redactPaths: false })
+  }
+
+  const safeError = sanitizeUnknownValue(error, { redactPaths: false })
+  return sanitizeSensitiveText(util.inspect(safeError, { colors: false, depth: 4 }), {
+    redactPaths: false,
+  })
+}
+
+function writeToFile(level: string, prefix: string, args: unknown[]) {
+  if (!pluginLogFilePath) {
+    return
+  }
+  const timestamp = new Date().toISOString()
+  const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`
+  try {
+    fs.appendFileSync(pluginLogFilePath, message)
+  } catch {
+    // Plugin logging must never break the OpenCode plugin process.
+  }
+}
+
+export function createPluginLogger(prefix: string) {
+  return {
+    log: (...args: unknown[]) => {
+      writeToFile('LOG', prefix, args)
+    },
+    info: (...args: unknown[]) => {
+      writeToFile('INFO', prefix, args)
+    },
+    warn: (...args: unknown[]) => {
+      writeToFile('WARN', prefix, args)
+    },
+    error: (...args: unknown[]) => {
+      writeToFile('ERROR', prefix, args)
+    },
+    debug: (...args: unknown[]) => {
+      writeToFile('DEBUG', prefix, args)
+    },
+  }
+}
+
+// Append a session ID marker at the end of a toast message so the bot-side
+// handleTuiToast can route the toast to the correct Discord thread.
+// Without this marker the toast is silently dropped.
+export function appendToastSessionMarker({
+  message,
+  sessionId,
+}: {
+  message: string
+  sessionId: string | undefined
+}): string {
+  if (!sessionId) {
+    return message
+  }
+  return `${message} ${sessionId}`
+}

package/src/privacy-sanitizer.ts

@@ -0,0 +1,142 @@
+// Sensitive data redaction helpers for logs and telemetry payloads.
+// Redacts common secrets, identifiers, emails, and can optionally redact paths.
+
+const CORE_SENSITIVE_REPLACEMENTS: Array<{
+  pattern: RegExp
+  replacement: string
+}> = [
+  {
+    pattern: /\bBearer\s+[A-Za-z0-9._-]{10,}\b/gi,
+    replacement: 'Bearer [REDACTED]',
+  },
+  {
+    pattern: /\bsk-[A-Za-z0-9]{16,}\b/g,
+    replacement: '[REDACTED_OPENAI_KEY]',
+  },
+  {
+    pattern: /\bAIza[0-9A-Za-z_-]{20,}\b/g,
+    replacement: '[REDACTED_GOOGLE_KEY]',
+  },
+  {
+    pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g,
+    replacement: '[REDACTED_GITHUB_TOKEN]',
+  },
+  {
+    pattern:
+      /([?&](?:token|api[_-]?key|key|secret|password|authorization)=)[^&\s]+/gi,
+    replacement: '$1[REDACTED]',
+  },
+  {
+    pattern:
+      /(\b(?:token|api[_-]?key|secret|password|authorization)\b\s*[:=]\s*")([^"]+)(")/gi,
+    replacement: '$1[REDACTED]$3',
+  },
+  {
+    pattern:
+      /(\b(?:token|api[_-]?key|secret|password|authorization)\b\s*[:=]\s*)([^\s,;]+)/gi,
+    replacement: '$1[REDACTED]',
+  },
+]
+
+const PATH_REPLACEMENTS: Array<{
+  pattern: RegExp
+  replacement: string
+}> = [
+  {
+    pattern: /\/(?:Users|home)\/[^/\s]+\/[^\s'"`)]*/g,
+    replacement: '[REDACTED_PATH]',
+  },
+  {
+    pattern: /[A-Za-z]:\\[^\s'"`)]*/g,
+    replacement: '[REDACTED_PATH]',
+  },
+]
+
+export function sanitizeSensitiveText(
+  value: string,
+  { redactPaths = false }: { redactPaths?: boolean } = {},
+): string {
+  const replacements = redactPaths
+    ? [...CORE_SENSITIVE_REPLACEMENTS, ...PATH_REPLACEMENTS]
+    : CORE_SENSITIVE_REPLACEMENTS
+  return replacements.reduce((current, entry) => {
+    return current.replace(entry.pattern, entry.replacement)
+  }, value)
+}
+
+export function sanitizeUnknownValue(
+  value: unknown,
+  {
+    depth = 0,
+    seen = new WeakSet<object>(),
+    redactPaths = false,
+  }: {
+    depth?: number
+    seen?: WeakSet<object>
+    redactPaths?: boolean
+  } = {},
+): unknown {
+  if (depth > 8) {
+    return '[REDACTED_DEPTH_LIMIT]'
+  }
+
+  if (typeof value === 'string') {
+    return sanitizeSensitiveText(value, { redactPaths })
+  }
+
+  if (
+    typeof value === 'number' ||
+    typeof value === 'boolean' ||
+    value === null ||
+    value === undefined
+  ) {
+    return value
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString()
+  }
+
+  if (value instanceof Error) {
+    const sanitizedStack = value.stack
+      ? sanitizeSensitiveText(value.stack, { redactPaths })
+      : undefined
+    return {
+      name: value.name,
+      message: sanitizeSensitiveText(value.message, { redactPaths }),
+      stack: sanitizedStack,
+      cause: sanitizeUnknownValue(value.cause, {
+        depth: depth + 1,
+        seen,
+        redactPaths,
+      }),
+    }
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      return sanitizeUnknownValue(item, { depth: depth + 1, seen, redactPaths })
+    })
+  }
+
+  if (typeof value === 'object') {
+    if (seen.has(value)) {
+      return '[REDACTED_CIRCULAR]'
+    }
+    seen.add(value)
+
+    const sanitizedEntries = Object.entries(value).map(([key, entryValue]) => {
+      return [
+        key,
+        sanitizeUnknownValue(entryValue, {
+          depth: depth + 1,
+          seen,
+          redactPaths,
+        }),
+      ]
+    })
+    return Object.fromEntries(sanitizedEntries)
+  }
+
+  return sanitizeSensitiveText(String(value), { redactPaths })
+}

package/src/queue-advanced-abort.e2e.test.ts

@@ -0,0 +1,382 @@
+// E2e tests for abort, model-switch, and retry scenarios.
+// Split from thread-queue-advanced.e2e.test.ts for parallelization.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  getRuntime,
+} from './session-handler/thread-session-runtime.js'
+import { getThreadState } from './session-handler/thread-runtime-state.js'
+import { setSessionModel } from './database.js'
+import {
+  waitForFooterMessage,
+  waitForBotMessageContaining,
+  waitForBotReplyAfterUserMessage,
+} from './test-utils.js'
+
+const TEXT_CHANNEL_ID = '200000000000001003'
+
+const e2eTest = describe
+
+e2eTest('queue advanced: abort and retry', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-abort-e2e',
+    dirName: 'qa-abort-e2e',
+    username: 'queue-advanced-tester',
+  })
+
+  test(
+    'slow tool call (sleep) gets aborted by explicit abort, then queue continues',
+    async () => {
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: oscar',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: oscar'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+      const firstReply = await th.waitForBotReply({ timeout: 4_000 })
+      expect(firstReply.content.trim().length).toBeGreaterThan(0)
+
+      // Wait for the first completion footer so it lands in a deterministic position
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+      })
+
+      const before = await th.getMessages()
+      const beforeBotCount = before.filter((m) => {
+        return m.author.id === ctx.discord.botUserId
+      }).length
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+      })
+
+      // The matcher emits "starting sleep 100" text before the long delay.
+      // Wait for it to land in Discord BEFORE aborting so the message is in a
+      // deterministic position and the abort produces no further stray messages.
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'starting sleep',
+        afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        timeout: 4_000,
+      })
+
+      const runtime = getRuntime(thread.id)
+      expect(runtime).toBeDefined()
+      if (!runtime) {
+        throw new Error('Expected runtime to exist for explicit-abort test')
+      }
+
+      runtime.abortActiveRun('test-explicit-abort')
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: papa',
+      })
+
+      const after = await waitForBotReplyAfterUserMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        userMessageIncludes: 'papa',
+        timeout: 8_000,
+      })
+
+      const afterBotMessages = after.filter((m) => {
+        return m.author.id === ctx.discord.botUserId
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 8_000,
+        afterMessageIncludes: 'papa',
+        afterAuthorId: TEST_USER_ID,
+      })
+
+      // Assert ordering invariants instead of exact snapshot — the papa reply
+      // and footer can interleave non-deterministically.
+      const timeline = await th.text()
+      expect(timeline).toContain('Reply with exactly: oscar')
+      expect(timeline).toContain('PLUGIN_TIMEOUT_SLEEP_MARKER')
+      expect(timeline).toContain('⬥ starting sleep 100')
+      expect(timeline).toContain('Reply with exactly: papa')
+      expect(timeline).toContain('*project ⋅ main ⋅')
+      // oscar comes before the sleep marker, sleep before papa
+      const oscarIdx = timeline.indexOf('oscar')
+      const sleepIdx = timeline.indexOf('PLUGIN_TIMEOUT_SLEEP_MARKER')
+      const papaIdx = timeline.indexOf('papa')
+      expect(oscarIdx).toBeLessThan(sleepIdx)
+      expect(sleepIdx).toBeLessThan(papaIdx)
+      expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1)
+
+      const sleepToolIndex = after.findIndex((m) => {
+        return (
+          m.author.id === TEST_USER_ID &&
+          m.content.includes('PLUGIN_TIMEOUT_SLEEP_MARKER')
+        )
+      })
+      expect(sleepToolIndex).toBeGreaterThan(-1)
+
+      const userPapaIndex = after.findIndex((m) => {
+        return m.author.id === TEST_USER_ID && m.content.includes('papa')
+      })
+      expect(userPapaIndex).toBeGreaterThan(-1)
+      expect(sleepToolIndex).toBeLessThan(userPapaIndex)
+      const lastBotIndex = after.findLastIndex((m) => {
+        return m.author.id === ctx.discord.botUserId
+      })
+      expect(userPapaIndex).toBeLessThan(lastBotIndex)
+    },
+    12_000,
+  )
+
+  test(
+    'explicit abort emits MessageAbortedError and does not emit footer',
+    async () => {
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: abort-no-footer-setup',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: abort-no-footer-setup'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+      await th.waitForBotReply({ timeout: 4_000 })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: '⋅',
+        timeout: 4_000,
+      })
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'SLOW_ABORT_MARKER run long response',
+      })
+
+      const runtime = getRuntime(thread.id)
+      expect(runtime).toBeDefined()
+      if (!runtime) {
+        throw new Error('Expected runtime to exist for abort no-footer test')
+      }
+
+      const beforeAbortMessages = await th.getMessages()
+      const baselineCount = beforeAbortMessages.length
+
+      runtime.abortActiveRun('test-no-footer-on-abort')
+
+      for (let i = 0; i < 10; i++) {
+        await new Promise((resolve) => {
+          setTimeout(resolve, 20)
+        })
+        const msgs = await th.getMessages()
+        const newMsgs = msgs.slice(baselineCount)
+        const hasFooter = newMsgs.some((m) => {
+          return m.author.id === ctx.discord.botUserId
+            && m.content.startsWith('*')
+            && m.content.includes('⋅')
+        })
+        expect(hasFooter).toBe(false)
+      }
+
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-advanced-tester)
+        Reply with exactly: abort-no-footer-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        --- from: user (queue-advanced-tester)
+        SLOW_ABORT_MARKER run long response"
+      `)
+    },
+    10_000,
+  )
+
+  test.skip(
+    'explicit abort stale-idle window: follow-up prompt still gets assistant text',
+    async () => {
+      const setupPrompt = 'Reply with exactly: race-setup-1'
+      const raceFinalPrompt = 'Reply with exactly: race-final-1'
+
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: setupPrompt,
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === setupPrompt
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+      const setupReply = await th.waitForBotReply({ timeout: 4_000 })
+      expect(setupReply.content.trim().length).toBeGreaterThan(0)
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'SLOW_ABORT_MARKER run long response',
+      })
+
+      const runtime = getRuntime(thread.id)
+      expect(runtime).toBeDefined()
+      if (!runtime) {
+        throw new Error('Expected runtime to exist for race abort scenario')
+      }
+
+      runtime.abortActiveRun('test-race-abort')
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: raceFinalPrompt,
+      })
+
+      await waitForBotReplyAfterUserMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        userMessageIncludes: raceFinalPrompt,
+        timeout: 4_000,
+      })
+    },
+    8_000,
+  )
+
+  test(
+    'model switch mid-session aborts and restarts from same session history',
+    async () => {
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: retry-setup',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: retry-setup'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+      const firstReply = await th.waitForBotReply({ timeout: 4_000 })
+      expect(firstReply.content.trim().length).toBeGreaterThan(0)
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'starting sleep',
+        afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        timeout: 4_000,
+      })
+
+      const sessionId = getThreadState(thread.id)?.sessionId
+      expect(sessionId).toBeDefined()
+      if (!sessionId) {
+        throw new Error('Expected active session id for model switch test')
+      }
+
+      await setSessionModel({
+        sessionId,
+        modelId: 'deterministic-provider/deterministic-v3',
+        variant: null,
+      })
+
+      const runtime = getRuntime(thread.id)
+      expect(runtime).toBeDefined()
+      if (!runtime) {
+        throw new Error('Expected runtime to exist for model switch test')
+      }
+      const retried = await runtime.retryLastUserPrompt()
+      expect(retried).toBe(true)
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: model-switch-followup',
+      })
+
+      await waitForBotReplyAfterUserMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        userMessageIncludes: 'model-switch-followup',
+        timeout: 4_000,
+      })
+
+      // Wait for potential footer to arrive (race between step-finish interrupt
+      // and model switch settling means footer may or may not appear).
+      await new Promise((resolve) => {
+        setTimeout(resolve, 200)
+      })
+
+      const text = await th.text()
+      // The follow-up reply ("ok") must be present with deterministic-v3
+      expect(text).toContain('Reply with exactly: model-switch-followup')
+      expect(text).toContain('⬥ ok')
+      // The old sleep text should be visible from the first turn
+      expect(text).toContain('starting sleep 100')
+    },
+    10_000,
+  )
+
+  test(
+    'abortActiveRun settles correctly during long-running request',
+    async () => {
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: force-abort-setup',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: force-abort-setup'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+      const setupReply = await th.waitForBotReply({ timeout: 4_000 })
+      expect(setupReply.content.trim().length).toBeGreaterThan(0)
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'SLOW_ABORT_MARKER run long response',
+      })
+
+      const runtime = getRuntime(thread.id)
+      expect(runtime).toBeDefined()
+      if (!runtime) {
+        throw new Error('Expected runtime to exist for forced-abort test')
+      }
+
+      runtime.abortActiveRun('force-abort-test')
+
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-advanced-tester)
+        Reply with exactly: force-abort-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        --- from: user (queue-advanced-tester)
+        SLOW_ABORT_MARKER run long response"
+      `)
+    },
+    10_000,
+  )
+})