@ddtcorex/dsh-maestro-review 0.1.0

package/src/settings-rpc.ts

@@ -0,0 +1,249 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/dsh-client-connection'
+import type { RpcErrorDetailsMap, RpcResult } from '@deepseek-ai/dsh-host-apiproxy/api'
+import { existsSync, statSync } from 'node:fs'
+import { loadUserConfig, saveUserConfig, type MaestroUserConfig } from './config-store.js'
+import { listReviews } from './review-history.js'
+import { readPin, rotatePin, readLanPin, rotateLanPin } from './pin-store.js'
+import { pinRotationText, type NotifierLike } from './notify.js'
+
+export const name = 'maestro-settings-rpc'
+export const inject = ['connection', 'maestroTunnel']
+
+/** Keys the Settings card may persist; anything else is a rejected save. */
+const SAVABLE_KEYS = new Set<keyof MaestroUserConfig>([
+  'gitlabBaseUrl', 'gitlabToken', 'botUsername', 'webhookSecret', 'webhookPort',
+  'projectMappings', 'reviewModel', 'autoRereviewOnPush', 'agentTimeoutMs', 'reviewSessionRetentionDays',
+  'tunnelMode', 'quickTarget', 'tunnelId', 'tunnelCredentialsFile', 'tunnelHostname',
+  'proxyPort', 'proxyHost', 'lanPinEnabled', 'telegramBotToken', 'telegramChatId',
+  'telegramReviewNotifications',
+])
+
+function validateReviewModel(value: unknown): string | null {
+  if (value === null || value === undefined) return null
+  if (typeof value !== 'object' || Array.isArray(value)) return 'reviewModel must be an object.'
+  const { provider, model, reasoningEffort } = value as Record<string, unknown>
+  if (typeof provider !== 'string' || provider.trim() === '') return 'reviewModel.provider must be a non-empty string.'
+  if (typeof model !== 'string' || model.trim() === '') return 'reviewModel.model must be a non-empty string.'
+  if (reasoningEffort !== undefined && typeof reasoningEffort !== 'string') return 'reviewModel.reasoningEffort must be a string.'
+  if (typeof reasoningEffort === 'string' && reasoningEffort.trim() === '') return 'reviewModel.reasoningEffort must be a non-empty string when provided.'
+  return null
+}
+
+/** Secrets never returned to the client; the UI learns only their presence. */
+const SECRET_KEYS = ['gitlabToken', 'webhookSecret', 'telegramBotToken'] as const
+
+function maskSecrets(config: MaestroUserConfig): MaestroUserConfig & Record<string, boolean> {
+  const masked: Record<string, unknown> = { ...config }
+  for (const key of SECRET_KEYS) {
+    if (typeof config[key] === 'string' && config[key] !== '') {
+      delete masked[key]
+      masked[`has${key.charAt(0).toUpperCase()}${key.slice(1)}`] = true
+    }
+  }
+  return masked as MaestroUserConfig & Record<string, boolean>
+}
+
+/**
+ * Validate a save payload from the Settings card. Secrets follow a
+ * three-state rule: absent keeps the stored value, `''` clears it, a
+ * non-empty string replaces it. A mapping's `localRepoPath` must be an
+ * existing directory containing a `.git` entry, because reviews check out
+ * worktrees from it.
+ */
+function validateSavePayload(payload: unknown): { ok: true; patch: Partial<MaestroUserConfig> } | { ok: false; message: string } {
+  if (typeof payload !== 'object' || payload === null || Array.isArray(payload)) {
+    return { ok: false, message: 'Settings payload must be a JSON object.' }
+  }
+  const patch: Partial<MaestroUserConfig> = {}
+  for (const [key, value] of Object.entries(payload as Record<string, unknown>)) {
+    if (!SAVABLE_KEYS.has(key as keyof MaestroUserConfig)) {
+      return { ok: false, message: `Unknown settings key "${key}".` }
+    }
+    if (key === 'projectMappings') {
+      if (!Array.isArray(value)) return { ok: false, message: 'projectMappings must be an array.' }
+      for (const mapping of value) {
+        if (typeof mapping !== 'object' || mapping === null) return { ok: false, message: 'Each project mapping must be an object.' }
+        const { projectPath, localRepoPath, reviewModel } = mapping as Record<string, unknown>
+        if (typeof projectPath !== 'string' || projectPath.trim() === '') return { ok: false, message: 'Each mapping needs a non-empty projectPath.' }
+        if (typeof localRepoPath !== 'string' || localRepoPath.trim() === '') return { ok: false, message: 'Each mapping needs a non-empty localRepoPath.' }
+        if (localRepoPath !== '/' && !(localRepoPath as string).startsWith('/')) {
+          return { ok: false, message: `localRepoPath "${String(localRepoPath)}" must be an absolute path.` }
+        }
+        if (!existsSync(localRepoPath) || !statSync(localRepoPath).isDirectory() || !existsSync(`${localRepoPath}/.git`)) {
+          return { ok: false, message: `localRepoPath "${localRepoPath}" is not an existing git repository checkout.` }
+        }
+        if (reviewModel !== undefined) {
+          const err = validateReviewModel(reviewModel)
+          if (err !== null) return { ok: false, message: `projectMappings reviewModel: ${err}` }
+        }
+      }
+    }
+    if (key === 'reviewModel') {
+      if (value === null) {
+        patch[key as keyof MaestroUserConfig] = undefined as never
+        continue
+      }
+      const err = validateReviewModel(value)
+      if (err !== null) return { ok: false, message: err }
+    }
+    if (key === 'webhookPort' && value !== undefined && (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 65535)) {
+      return { ok: false, message: 'webhookPort must be an integer between 1 and 65535.' }
+    }
+    if (key === 'agentTimeoutMs' && value !== undefined && (typeof value !== 'number' || value < 1000)) {
+      return { ok: false, message: 'agentTimeoutMs must be at least 1000 ms.' }
+    }
+    if (key === 'reviewSessionRetentionDays' && value !== undefined && (typeof value !== 'number' || value < 0)) {
+      return { ok: false, message: 'reviewSessionRetentionDays must be 0 (off) or a positive number of days.' }
+    }
+    patch[key as keyof MaestroUserConfig] = value as never
+  }
+  return { ok: true, patch }
+}
+
+export const MAESTRO_RPC_CHANNEL = '/dsh-maestro-review'
+export const MAESTRO_ENDPOINTS = Object.freeze({
+  status: 'maestro.status',
+  getConfig: 'maestro.getConfig',
+  saveConfig: 'maestro.saveConfig',
+  tunnelStart: 'maestro.tunnelStart',
+  tunnelStop: 'maestro.tunnelStop',
+  proxyStatus: 'maestro.proxyStatus',
+  getPin: 'maestro.getPin',
+  rotatePin: 'maestro.rotatePin',
+  lanPinStatus: 'maestro.lanPin.status',
+  lanPinSetEnabled: 'maestro.lanPin.setEnabled',
+  lanPinRotate: 'maestro.lanPin.rotate',
+  reviewsList: 'maestro.reviews.list',
+  modelsList: 'maestro.models.list',
+  modelsCurrent: 'maestro.models.current',
+})
+
+function ok<T>(value: T): RpcResult<T> {
+  return { ok: true, value }
+}
+
+function fail(message: string): RpcResult<never> {
+  return {
+    ok: false,
+    error: {
+      code: 'bad-request',
+      message,
+      // Synthetic details, not real Zod validation output: `bad-request`'s real `details`
+      // shape is `{ issues: ZodIssue[] }` from the `zod` package (a specific discriminated
+      // union), but this is an app-level "unknown endpoint" error being shoehorned into
+      // DSH's shared RPC error taxonomy, not an actual Zod-validated payload. Constructing
+      // a byte-perfect ZodIssue here would be disproportionate, so we cast this one value
+      // to the narrow per-code details type (not the wider `RpcError['details']` union,
+      // which doesn't satisfy the 'bad-request' discriminant on its own).
+      details: { issues: [{ message }] } as RpcErrorDetailsMap['bad-request'],
+    },
+  }
+}
+
+export function apply(ctx: Context): void {
+  const handler = async (endpoint: string, payload: unknown) => {
+    if (endpoint === MAESTRO_ENDPOINTS.status) {
+      return ok(ctx.maestroTunnel.status())
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.getConfig) {
+      return ok(maskSecrets(await loadUserConfig()))
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.saveConfig) {
+      const validated = validateSavePayload(payload)
+      if (!validated.ok) return fail(validated.message)
+      const merged = await saveUserConfig(validated.patch)
+      return ok(maskSecrets(merged))
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.tunnelStart) {
+      return ok(await ctx.maestroTunnel.start())
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.tunnelStop) {
+      return ok(await ctx.maestroTunnel.stop())
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.proxyStatus) {
+      return ok(ctx.maestroTunnel.proxyStatus())
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.getPin) {
+      return ok({ pin: await readPin() })
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.rotatePin) {
+      const pin = await rotatePin()
+      // Delivery is deliberately detached: a slow/unavailable notifier cannot make the
+      // explicit security operation appear to fail or hold the Settings UI open.
+      void loadUserConfig().then((config) => {
+        const notifier = ctx.get?.('maestroNotifier') as NotifierLike | undefined
+        if (notifier === undefined) return undefined
+        return notifier.send(
+          'telegram',
+          { botToken: config.telegramBotToken, chatId: config.telegramChatId },
+          { text: pinRotationText(pin) },
+        )
+      }).then((delivery) => {
+        if (!delivery) return
+        if (delivery.sent) {
+          ctx.logger?.info?.('maestro-telegram: PIN rotation notification delivered')
+        } else if (delivery.reason === 'request-failed') {
+          ctx.logger?.warn?.('maestro-telegram: PIN rotation notification failed')
+        }
+      }).catch(() => {
+        ctx.logger?.warn?.('maestro-telegram: PIN rotation notification failed')
+      })
+      return ok({ pin })
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.lanPinStatus) {
+      const config = await loadUserConfig()
+      // Disabled by default; the LAN PIN is only read (and generated) once the
+      // user opts in, so an untouched install keeps LAN access open.
+      if (config.lanPinEnabled !== true) return ok({ enabled: false })
+      return ok({ enabled: true, pin: await readLanPin() })
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.lanPinSetEnabled) {
+      const enabled = (payload as { enabled?: unknown } | undefined)?.enabled === true
+      await saveUserConfig({ lanPinEnabled: enabled })
+      // The proxy reads lanPinEnabled at boot; a reload applies the new gate
+      // without waiting for a harness restart.
+      await ctx.maestroTunnel.reloadConfig()
+      return ok({ enabled })
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.lanPinRotate) {
+      return ok({ pin: await rotateLanPin() })
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.reviewsList) {
+      return ok(await listReviews(20))
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.modelsCurrent) {
+      const agentDefaultModel = ctx.get('agentDefaultModel') as { currentSelection(): { provider: string; model: string; reasoningEffort?: string } } | undefined
+      const fallback = agentDefaultModel?.currentSelection() ?? { provider: 'deepseek-official', model: 'deepseek-chat' }
+      return ok(fallback)
+    }
+    if (endpoint === MAESTRO_ENDPOINTS.modelsList) {
+      const agentDefaultModel = ctx.get('agentDefaultModel') as { currentSelection(): { provider: string; model: string; reasoningEffort?: string } } | undefined
+      const fallbackSelection = agentDefaultModel?.currentSelection() ?? { provider: 'deepseek-official', model: 'deepseek-chat' }
+      const llm = ctx.get('llm') as { listProviders?: () => Array<{ id: string; name: string }>; listModels?: (provider: string) => Promise<Array<{ id: string; name?: string }>> } | undefined
+      if (llm?.listProviders !== undefined && llm?.listModels !== undefined) {
+        try {
+          const providers = llm.listProviders()
+          const groups: Array<{ provider: string; name: string; models: string[] }> = []
+          for (const p of providers) {
+            try {
+              const models = await llm.listModels(p.id)
+              groups.push({ provider: p.id, name: p.name, models: models.map(m => m.id) })
+            } catch {
+              groups.push({ provider: p.id, name: p.name, models: [] })
+            }
+          }
+          if (groups.length > 0) return ok({ groups, current: fallbackSelection })
+        } catch {
+          // fall through to fallback
+        }
+      }
+      // Fallback: single group containing the current selection so dropdown still works
+      return ok({ groups: [{ provider: fallbackSelection.provider, name: fallbackSelection.provider, models: [fallbackSelection.model] }], current: fallbackSelection })
+    }
+    return fail(`Unknown endpoint: ${endpoint}`)
+  }
+  const disposeRpc = ctx.connection.rpc.handle(MAESTRO_RPC_CHANNEL, handler, { authority: 'loopback' })
+
+  ctx.effect(() => () => { disposeRpc(); }, 'maestro-settings-rpc teardown')
+}

package/src/skills-tool.ts

@@ -0,0 +1,193 @@
+import type { Context } from '@deepseek-ai/cordis'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import type {} from '@deepseek-ai/dsh-agent'
+
+export const name = 'maestro-skills-tool'
+export const inject = ['skills', 'tools']
+
+export type ReviewSkillProfile = 'magento2' | 'generic'
+
+/**
+ * Exact skill names rather than a fuzzy search: a review must not silently
+ * omit a security or quality pass just because a similarly named skill exists.
+ */
+export const REVIEW_PROFILE_SKILLS: Record<ReviewSkillProfile, readonly string[]> = {
+  magento2: [
+    'govard-toolbox',
+    'govard-magento',
+    'magento2-dev-core',
+    'magento2-code-review',
+    'magento2-linter',
+    'magento2-security-scan',
+    'magento2-performance-audit',
+  ],
+  /** Diff review against general best practices; no project skill set required. */
+  generic: [],
+}
+
+export const MAESTRO_SKILLS_INSTALL_COMMAND = 'curl -fsSL https://raw.githubusercontent.com/ddtcorex/maestro-skills/master/install.sh | bash -s -- --scope personal --target dsh --skills govard-toolbox,govard-magento,magento2-dev-core,magento2-code-review,magento2-linter,magento2-security-scan,magento2-performance-audit -y'
+
+// This is deliberately process-local and keyed by the reviewer Agent object,
+// which every Cordis child context inherits. Preset mounting inserts child
+// contexts, so keying on the plugin's context would make a successful load
+// invisible to the orchestrator's agent context.
+const loadedReviewProfiles = new WeakMap<object, ReviewSkillProfile>()
+
+export function loadedReviewProfile(ctx: Context): ReviewSkillProfile | undefined {
+  return ctx.agent === undefined ? undefined : loadedReviewProfiles.get(ctx.agent)
+}
+
+// Mirrors @deepseek-ai/dsh-skill's consumer-facing `SkillRegistry` (verified
+// against ../../deepseek-harness/packages/skill/skill/lib/types/index.d.ts):
+// `list()` returns bare `SkillSummary`-shaped entries (no `locator`/`rank` —
+// those belong only to the `SkillProvider` interface a provider implements
+// inside `registerProvider()`), and `get()` takes a plain name string, not a
+// candidate object.
+interface SkillSummaryLike {
+  name: string
+  description: string
+}
+
+interface SkillDefinitionLike {
+  name: string
+  description: string
+  content: string
+}
+
+interface SkillsServiceLike {
+  list(): Promise<SkillSummaryLike[]>
+  get(name: string): Promise<SkillDefinitionLike | undefined>
+}
+
+/** Single owned access path to the skills service (declared via `inject`). */
+export function skillsService(ctx: Context): SkillsServiceLike {
+  return (ctx as unknown as { skills: SkillsServiceLike }).skills
+}
+
+export function apply(ctx: Context): void {
+  ctx.tools.register(defineTool({
+    name: 'maestro_get_skills',
+    description: 'Search the DSH skill knowledge base by keyword (matches skill name or description) and return the full content of every matching skill.',
+    parameters: {
+      query: { type: 'string', required: true, description: 'Keyword to match against skill name/description, e.g. "magento2" or "govard-laravel".' },
+    },
+    output: {
+      // The resolved skill content is part of the validated schema (matching
+      // dsh-tools' own `job_output` pattern of declaring every render-needed
+      // field on `output.schema`) rather than smuggled past validation on a
+      // key excluded from `properties`: `render(args, value)` has no third
+      // `extra` argument (verified against
+      // node_modules/@deepseek-ai/dsh-tools/lib/types/schema.d.ts), and an
+      // `additionalProperties: false` object schema REJECTS undeclared keys
+      // outright rather than merely leaving them unvalidated, so a hidden
+      // field would fail every call at the registry's output-validation step.
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          matches: { type: 'number', required: true },
+          skills: {
+            type: 'array',
+            required: true,
+            items: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                name: { type: 'string', required: true },
+                content: { type: 'string', required: true },
+              },
+            },
+          },
+        },
+      },
+      render: (_args, value) => {
+        if (value.skills.length === 0) {
+          return [{ type: 'text', text: 'No skills matched that query.' }]
+        }
+        const text = value.skills
+          .map(s => `## ${s.name}\n\n${s.content}`)
+          .join('\n\n---\n\n')
+        return [{ type: 'text', text }]
+      },
+    },
+    async execute(args) {
+      const skills = skillsService(ctx)
+      const summaries = await skills.list()
+      const query = args.query.toLowerCase()
+      const matched = summaries.filter(s =>
+        s.name.toLowerCase().includes(query) || s.description.toLowerCase().includes(query))
+      if (matched.length === 0) {
+        throw new Error(`No skill matched query "${args.query}".`)
+      }
+      const resolved: SkillDefinitionLike[] = []
+      for (const summary of matched) {
+        const def = await skills.get(summary.name)
+        if (def !== undefined) resolved.push(def)
+      }
+      return {
+        matches: resolved.length,
+        skills: resolved.map(s => ({ name: s.name, content: s.content })),
+      }
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'maestro_load_review_profile',
+    description: 'Load the complete, exact skill set required for a configured review profile. Fails if any required skill is unavailable.',
+    parameters: {
+      profile: { type: 'string', required: true, description: 'Review profile configured for the project. Supported: "magento2" (full Magento skill set), "generic" (no skills required).' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          profile: { type: 'string', required: true },
+          skills: {
+            type: 'array',
+            required: true,
+            items: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                name: { type: 'string', required: true },
+                content: { type: 'string', required: true },
+              },
+            },
+          },
+        },
+      },
+      render: (_args, value) => [{
+        type: 'text',
+        text: value.skills.length === 0
+          ? `Review profile "${value.profile}" loaded. No project-specific skills are required; review the diff against general correctness, security, and performance best practices.`
+          : value.skills.map(s => `## ${s.name}\n\n${s.content}`).join('\n\n---\n\n'),
+      }],
+    },
+    async execute(args, exec) {
+      const required = REVIEW_PROFILE_SKILLS[args.profile as ReviewSkillProfile]
+      if (required === undefined) {
+        throw new Error(`Unsupported review skill profile "${args.profile}". Supported profiles: ${Object.keys(REVIEW_PROFILE_SKILLS).map(name => `"${name}"`).join(', ')}.`)
+      }
+      if (exec.agent === undefined) {
+        throw new Error('Review profile loader is not running inside an agent context.')
+      }
+      const skills = skillsService(ctx)
+      const available = new Set((await skills.list()).map(skill => skill.name))
+      const missing = required.filter(skill => !available.has(skill))
+      if (missing.length > 0) {
+        throw new Error(`Missing required review skill(s) for profile "${args.profile}": ${missing.join(', ')}. Install maestro-skills for DSH with: ${MAESTRO_SKILLS_INSTALL_COMMAND}`)
+      }
+      const resolved = await Promise.all(required.map(skill => skills.get(skill)))
+      const unavailable = required.filter((_, index) => resolved[index] === undefined)
+      if (unavailable.length > 0) {
+        throw new Error(`Required review skill(s) could not be loaded: ${unavailable.join(', ')}. Reinstall maestro-skills for DSH with: ${MAESTRO_SKILLS_INSTALL_COMMAND}`)
+      }
+      loadedReviewProfiles.set(exec.agent, args.profile as ReviewSkillProfile)
+      return {
+        profile: args.profile,
+        skills: resolved.map(skill => ({ name: skill!.name, content: skill!.content })),
+      }
+    },
+  }))
+}

package/src/workspace-tool.ts

@@ -0,0 +1,90 @@
+import { basename, dirname, resolve, sep } from 'node:path'
+import { mkdir, readFile, realpath, writeFile } from 'node:fs/promises'
+import type { Context } from '@deepseek-ai/cordis'
+import z from '@deepseek-ai/schemastery'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+
+export const name = 'maestro-workspace-tool'
+export const inject = ['tools']
+
+export interface Config {
+  rootPath?: string
+}
+
+export const Config: z<Config> = z.object({
+  rootPath: z.string(),
+})
+
+async function resolveInRoot(rootPath: string, requestedPath: string): Promise<string | undefined> {
+  const absoluteRoot = resolve(rootPath)
+  const target = resolve(absoluteRoot, requestedPath)
+  if (target !== absoluteRoot && !target.startsWith(absoluteRoot + sep)) return undefined
+
+  let realRoot: string
+  try {
+    realRoot = await realpath(absoluteRoot)
+  } catch {
+    return undefined
+  }
+
+  let existing = target
+  const pending: string[] = []
+  while (true) {
+    let real: string
+    try {
+      real = await realpath(existing)
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') return undefined
+      const parent = dirname(existing)
+      if (parent === existing) return undefined
+      pending.unshift(basename(existing))
+      existing = parent
+      continue
+    }
+    const realTarget = pending.length > 0 ? resolve(real, ...pending) : real
+    if (realTarget !== realRoot && !realTarget.startsWith(realRoot + sep)) return undefined
+    return target
+  }
+}
+
+export function apply(ctx: Context, config: Config = {}): void {
+  const rootPath = config.rootPath ?? process.cwd()
+
+  ctx.tools.register(defineTool({
+    name: 'maestro_read_file',
+    description: 'Read a text file relative to the current workspace root.',
+    parameters: {
+      path: { type: 'string', required: true, description: 'Path relative to the workspace root.' },
+    },
+    output: {
+      schema: { type: 'object', additionalProperties: false, properties: { text: { type: 'string', required: true } } },
+      render: (_args, value) => [{ type: 'text', text: value.text }],
+    },
+    async execute(args) {
+      const target = await resolveInRoot(rootPath, args.path)
+      if (target === undefined) return { isError: true, text: `Path "${args.path}" escapes the workspace root.` } as never
+      const text = await readFile(target, 'utf-8')
+      return { text }
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'maestro_write_file',
+    description: 'Write a text file relative to the current workspace root, creating parent directories as needed.',
+    parameters: {
+      path: { type: 'string', required: true, description: 'Path relative to the workspace root.' },
+      content: { type: 'string', required: true, description: 'File content to write.' },
+    },
+    output: {
+      schema: { type: 'object', additionalProperties: false, properties: { written: { type: 'boolean', required: true } } },
+      render: (args) => [{ type: 'text', text: `Wrote ${args.path}` }],
+    },
+    async execute(args) {
+      const target = await resolveInRoot(rootPath, args.path)
+      if (target === undefined) return { isError: true, text: `Path "${args.path}" escapes the workspace root.` } as never
+      await mkdir(dirname(target), { recursive: true })
+      await writeFile(target, args.content, 'utf-8')
+      return { written: true }
+    },
+  }))
+}