docks-kit 0.1.5 → 0.3.0

package/cli/src/engine-native/codexSync.ts

@@ -4,26 +4,26 @@
  * change. Guard order, message strings, and backup behavior are golden-tested.
  */
 import { spawnSync } from "node:child_process"
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs"
 
 import { syncCodexModel, replaceTopLevelSettingInFile } from "./codexToml"
-import { capture, commandExists, p } from "./exec"
+import { p } from "./exec"
 import type { Ctx } from "./index"
 import { compareCodepoints, isObject, jqStringify, parseJson, type Json } from "./jq"
-import { echo, err, log, warn } from "./output"
+import { payloadBytes, payloadDisplayPath, payloadPaths, payloadText, type PayloadPath } from "../payload"
 
 export function codexSync(ctx: Ctx): void {
   const codexDir = p(ctx.home, ".codex")
-  const sotConfig = p(ctx.repoDir, "SoT", ".codex", "config.toml")
+  const sotConfig = payloadText("SoT/.codex/config.toml")
   const userConfig = p(codexDir, "config.toml")
 
   ensureBubblewrap(ctx)
   if (!ctx.dryRun) mkdirSync(codexDir, { recursive: true })
   syncConfig(ctx, sotConfig, userConfig)
   syncCodexModel(ctx, ctx.codexModel)
-  syncRules(ctx, p(ctx.repoDir, "SoT", ".codex", "rules"), p(codexDir, "rules"))
-  syncAgentsMd(ctx, p(ctx.repoDir, "SoT", ".codex", "AGENTS.md"), p(codexDir, "AGENTS.md"))
-  syncMarketplace(ctx, p(ctx.repoDir, "SoT", ".codex", "plugins", "marketplace.json"), p(ctx.agentsDir, "plugins", "marketplace.json"))
+  syncRules(ctx, payloadPaths("SoT/.codex/rules/"), p(codexDir, "rules"))
+  syncAgentsMd(ctx, payloadText("SoT/.codex/AGENTS.md"), p(codexDir, "AGENTS.md"))
+  syncMarketplace(ctx, payloadText("SoT/.codex/plugins/marketplace.json"), p(ctx.agentsDir, "plugins", "marketplace.json"))
   removeLegacyDocksMarketplace(ctx, userConfig)
   syncPlugins(ctx, sotConfig)
 }
@@ -31,14 +31,15 @@ export function codexSync(ctx: Ctx): void {
 // ---------------------------------------------------------- bubblewrap ----
 
 function ensureBubblewrap(ctx: Ctx): void {
-  if (!bwrapSupportedOs()) return
+  const { change, echo, warn } = ctx.services.logger
+  if (!bwrapSupportedOs(ctx)) return
 
   if (ctx.dryRun) {
     echo("[dry-run] verify bubblewrap installed (recommended Codex Linux sandbox runtime)")
     return
   }
 
-  if (commandExists("bwrap")) return
+  if (ctx.services.deps.probe("bwrap").state === "present") return
 
   if (ctx.skipRtk) {
     warn(
@@ -47,7 +48,7 @@ function ensureBubblewrap(ctx: Ctx): void {
     return
   }
 
-  const pmInstall = bwrapDetectPmInstallCmd()
+  const pmInstall = bwrapDetectPmInstallCmd(ctx)
   if (pmInstall === "") {
     warn(
       "bubblewrap not installed and no supported package manager found (apt-get/dnf/pacman/zypper). Codex may use its bundled helper if user namespaces work; install system bubblewrap manually when possible."
@@ -62,14 +63,13 @@ function ensureBubblewrap(ctx: Ctx): void {
     return
   }
 
-  if (!commandExists("bwrap")) {
+  if (ctx.services.deps.probe("bwrap").state === "missing") {
     warn("Package install reported success but bwrap not on PATH — check installation manually")
     return
   }
 
   if (spawnSync("unshare", ["-Ur", "true"], { stdio: "ignore" }).status === 0) {
-    const version = capture("bwrap", ["--version"]).split("\n")[0] ?? ""
-    log(`bubblewrap installed and functional (${version})`)
+    change(`bubblewrap installed and functional (${ctx.services.deps.version("bwrap")})`)
   } else {
     warn(
       "bubblewrap installed but unprivileged user namespaces appear blocked. On Ubuntu 24.04+, prefer loading the AppArmor bwrap-userns-restrict profile; fallback: sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0"
@@ -77,25 +77,28 @@ function ensureBubblewrap(ctx: Ctx): void {
   }
 }
 
-function bwrapSupportedOs(): boolean {
-  if (process.platform === "linux") return true
-  if (process.platform === "darwin" || process.platform === "win32") return false
+function bwrapSupportedOs(ctx: Ctx): boolean {
+  const { warn } = ctx.services.logger
+  const pn = ctx.services.platform.name()
+  if (pn === "linux") return true
+  if (pn === "darwin" || pn === "windows") return false
   warn("Unknown OS — skipping bubblewrap check; Codex sandbox may not work")
   return false
 }
 
-function bwrapDetectPmInstallCmd(): string {
-  if (commandExists("apt-get")) return "sudo apt-get install -y bubblewrap"
-  if (commandExists("dnf")) return "sudo dnf install -y bubblewrap"
-  if (commandExists("pacman")) return "sudo pacman -S --noconfirm bubblewrap"
-  if (commandExists("zypper")) return "sudo zypper install -y bubblewrap"
+function bwrapDetectPmInstallCmd(ctx: Ctx): string {
+  if (ctx.services.deps.probe("apt-get").state === "present") return "sudo apt-get install -y bubblewrap"
+  if (ctx.services.deps.probe("dnf").state === "present") return "sudo dnf install -y bubblewrap"
+  if (ctx.services.deps.probe("pacman").state === "present") return "sudo pacman -S --noconfirm bubblewrap"
+  if (ctx.services.deps.probe("zypper").state === "present") return "sudo zypper install -y bubblewrap"
   return ""
 }
 
 // --------------------------------------------------------------- config ----
 
-function syncConfig(ctx: Ctx, sotConfig: string, userConfig: string): void {
-  if (!existsSync(sotConfig)) return
+function syncConfig(ctx: Ctx, sotConfigText: string, userConfig: string): void {
+  const { change, echo, verbose } = ctx.services.logger
+  const sotConfig = payloadDisplayPath("SoT/.codex/config.toml", ctx.repoDir)
 
   if (ctx.dryRun) {
     echo(`[dry-run] merge ${sotConfig} -> ${userConfig}`)
@@ -103,18 +106,32 @@ function syncConfig(ctx: Ctx, sotConfig: string, userConfig: string): void {
   }
 
   if (!existsSync(userConfig)) {
-    copyFileSync(sotConfig, userConfig)
-    log("Codex config installed")
+    writeFileSync(userConfig, sotConfigText)
+    change("Codex config installed")
+    ctx.nextStepTriggers.codexRestart = true
     return
   }
 
-  copyFileSync(userConfig, `${userConfig}.bak`)
+  // Merge into a staging copy so `.bak` is written only when the config
+  // actually changes — an unconditional early backup lets a later no-op run
+  // overwrite the recovery copy with already-merged content.
+  const before = readFileSync(userConfig, "utf8")
+  const staging = `${userConfig}.merge.tmp`
+  writeFileSync(staging, before)
 
-  scrubDeprecatedFeatures(userConfig)
-  mergeTopLevelSettings(sotConfig, userConfig)
-  mergeTableSettings(sotConfig, userConfig)
+  scrubDeprecatedFeatures(ctx, staging)
+  mergeTopLevelSettings(sotConfigText, staging)
+  mergeTableSettings(sotConfigText, staging)
 
-  log("Codex config merged (backup at config.toml.bak; user-only keys/tables preserved)")
+  if (readFileSync(staging, "utf8") === before) {
+    rmSync(staging, { force: true })
+    verbose("Codex config already in sync")
+  } else {
+    copyFileSync(userConfig, `${userConfig}.bak`)
+    renameSync(staging, userConfig)
+    change("Codex config merged (backup at config.toml.bak; user-only keys/tables preserved)")
+    ctx.nextStepTriggers.codexRestart = true
+  }
 }
 
 /** codex::scrub_deprecated_features — the [features].use_legacy_landlock awk pass. */
@@ -152,18 +169,19 @@ export function scrubDeprecatedFeaturesText(content: string): string {
   return out
 }
 
-function scrubDeprecatedFeatures(userConfig: string): void {
+function scrubDeprecatedFeatures(ctx: Ctx, userConfig: string): void {
+  const { change } = ctx.services.logger
   if (!existsSync(userConfig)) return
   const content = readFileSync(userConfig, "utf8")
   if (!content.split("\n").some((l) => /^use_legacy_landlock[ \t]*=/.test(l))) return
 
   writeFileSync(`${userConfig}.tmp`, scrubDeprecatedFeaturesText(content))
   renameSync(`${userConfig}.tmp`, userConfig)
-  log("Codex: scrubbed deprecated [features].use_legacy_landlock")
+  change("Codex: scrubbed deprecated [features].use_legacy_landlock")
 }
 
-function mergeTopLevelSettings(sotConfig: string, userConfig: string): void {
-  for (const line of readFileSync(sotConfig, "utf8").split("\n")) {
+function mergeTopLevelSettings(sotConfigText: string, userConfig: string): void {
+  for (const line of sotConfigText.split("\n")) {
     if (line.startsWith("[")) break
     if (/^[ \t]*($|#)/.test(line)) continue
     if (!/^[A-Za-z0-9_.-]+[ \t]*=/.test(line)) continue
@@ -172,8 +190,8 @@ function mergeTopLevelSettings(sotConfig: string, userConfig: string): void {
   }
 }
 
-function mergeTableSettings(sotConfig: string, userConfig: string): void {
-  const sotLines = readFileSync(sotConfig, "utf8").split("\n")
+function mergeTableSettings(sotConfigText: string, userConfig: string): void {
+  const sotLines = sotConfigText.split("\n")
   for (const tableHeader of sotLines.filter((l) => /^\[[^\]]+\]/.test(l))) {
     // Extract the SoT block: from the exact header line to (excluding) the
     // next table header; `$(...)` strips trailing newlines.
@@ -208,8 +226,12 @@ function mergeTableSettings(sotConfig: string, userConfig: string): void {
 
 // ------------------------------------------------------- rules + agents ----
 
-function syncRules(ctx: Ctx, sotRulesDir: string, userRulesDir: string): void {
-  if (!existsSync(sotRulesDir)) return
+function syncRules(ctx: Ctx, sotRules: ReadonlyArray<PayloadPath>, userRulesDir: string): void {
+  const { change, echo, verbose } = ctx.services.logger
+  const firstRule = sotRules[0]
+  if (firstRule === undefined) return
+  const firstDisplay = payloadDisplayPath(firstRule, ctx.repoDir)
+  const sotRulesDir = firstDisplay.slice(0, firstDisplay.lastIndexOf("/"))
 
   if (ctx.dryRun) {
     echo(`[dry-run] cp ${sotRulesDir}/*.rules -> ${userRulesDir}/`)
@@ -217,37 +239,49 @@ function syncRules(ctx: Ctx, sotRulesDir: string, userRulesDir: string): void {
   }
 
   mkdirSync(userRulesDir, { recursive: true })
-  let rulesSynced = false
-  const ruleFiles = readdirSync(sotRulesDir, { withFileTypes: true })
-    .filter((e) => e.isFile() && e.name.endsWith(".rules"))
-    .map((e) => p(sotRulesDir, e.name))
-    .sort(compareCodepoints)
+  let sawRules = false
+  let rulesChanged = false
+  const ruleFiles = sotRules.filter((path) => path.endsWith(".rules")).sort(compareCodepoints)
   for (const ruleFile of ruleFiles) {
+    sawRules = true
     const userRuleFile = p(userRulesDir, ruleFile.slice(ruleFile.lastIndexOf("/") + 1))
+    const content = payloadBytes(ruleFile)
+    const identical = existsSync(userRuleFile) && readFileSync(userRuleFile).equals(content)
+    if (identical) continue
     if (existsSync(userRuleFile)) copyFileSync(userRuleFile, `${userRuleFile}.bak`)
-    copyFileSync(ruleFile, userRuleFile)
-    rulesSynced = true
+    writeFileSync(userRuleFile, content)
+    rulesChanged = true
   }
-  if (rulesSynced) log("Codex rules synced")
+  if (rulesChanged) {
+    change("Codex rules synced")
+    ctx.nextStepTriggers.codexRestart = true
+  } else if (sawRules) verbose("Codex rules already in sync")
 }
 
-function syncAgentsMd(ctx: Ctx, sotAgentsMd: string, userAgentsMd: string): void {
-  if (!existsSync(sotAgentsMd)) return
+function syncAgentsMd(ctx: Ctx, sotAgentsMdText: string, userAgentsMd: string): void {
+  const { change, echo, verbose } = ctx.services.logger
+  const sotAgentsMd = payloadDisplayPath("SoT/.codex/AGENTS.md", ctx.repoDir)
 
   if (ctx.dryRun) {
     echo(`[dry-run] cp ${sotAgentsMd} -> ${userAgentsMd}`)
     return
   }
 
+  if (existsSync(userAgentsMd) && readFileSync(userAgentsMd, "utf8") === sotAgentsMdText) {
+    verbose("Codex AGENTS.md already in sync")
+    return
+  }
   if (existsSync(userAgentsMd)) copyFileSync(userAgentsMd, `${userAgentsMd}.bak`)
-  copyFileSync(sotAgentsMd, userAgentsMd)
-  log("Codex AGENTS.md synced")
+  writeFileSync(userAgentsMd, sotAgentsMdText)
+  change("Codex AGENTS.md synced")
+  ctx.nextStepTriggers.codexRestart = true
 }
 
 // ---------------------------------------------------------- marketplace ----
 
-function syncMarketplace(ctx: Ctx, sotMarketplace: string, userMarketplace: string): void {
-  if (!existsSync(sotMarketplace)) return
+function syncMarketplace(ctx: Ctx, sotMarketplaceText: string, userMarketplace: string): void {
+  const { change, echo, err, verbose } = ctx.services.logger
+  const sotMarketplace = payloadDisplayPath("SoT/.codex/plugins/marketplace.json", ctx.repoDir)
 
   if (ctx.dryRun) {
     echo(`[dry-run] cp ${sotMarketplace} -> ${userMarketplace}`)
@@ -255,7 +289,7 @@ function syncMarketplace(ctx: Ctx, sotMarketplace: string, userMarketplace: stri
   }
 
   mkdirSync(p(ctx.agentsDir, "plugins"), { recursive: true })
-  const repo = parseJson(readFileSync(sotMarketplace, "utf8"))
+  const repo = parseJson(sotMarketplaceText)
   if (repo === undefined) throw new Error(`invalid SoT marketplace JSON: ${sotMarketplace}`)
 
   if (existsSync(userMarketplace)) {
@@ -264,13 +298,20 @@ function syncMarketplace(ctx: Ctx, sotMarketplace: string, userMarketplace: stri
       err(`Skipping marketplace sync: ${userMarketplace} is not valid JSON. Fix or delete it.`)
       return
     }
+    const out = jqStringify(mergeMarketplace(repo, user))
+    if (out === readFileSync(userMarketplace, "utf8")) {
+      verbose("Codex marketplace already in sync")
+      return
+    }
     copyFileSync(userMarketplace, `${userMarketplace}.bak`)
-    writeFileSync(`${userMarketplace}.tmp`, jqStringify(mergeMarketplace(repo, user)))
+    writeFileSync(`${userMarketplace}.tmp`, out)
     renameSync(`${userMarketplace}.tmp`, userMarketplace)
-    log("Codex marketplace merged (backup at marketplace.json.bak)")
+    change("Codex marketplace merged (backup at marketplace.json.bak)")
+    ctx.nextStepTriggers.codexRestart = true
   } else {
-    copyFileSync(sotMarketplace, userMarketplace)
-    log("Codex marketplace installed")
+    writeFileSync(userMarketplace, sotMarketplaceText)
+    change("Codex marketplace installed")
+    ctx.nextStepTriggers.codexRestart = true
   }
 }
 
@@ -326,39 +367,42 @@ export function marketplaceSource(marketplace: string, configFile: string): stri
 }
 
 function removeLegacyDocksMarketplace(ctx: Ctx, userConfig: string): void {
+  const { change, echo, warn } = ctx.services.logger
   if (ctx.dryRun) {
     echo("[dry-run] remove legacy configured Codex Docks marketplace when personal marketplace is deployed")
     return
   }
 
-  if (!commandExists("codex")) return
+  if (ctx.services.deps.probe("codex").state === "missing") return
 
   const source = marketplaceSource("docks", userConfig)
   if (source !== "https://github.com/DocksDocks/docks.git" && source !== "DocksDocks/docks") return
   const res = spawnSync("codex", ["plugin", "marketplace", "remove", "docks"], { stdio: "ignore" })
   if (res.error === undefined && res.status === 0) {
-    log("Removed legacy configured Codex Docks marketplace; using personal marketplace file")
+    change("Removed legacy configured Codex Docks marketplace; using personal marketplace file")
+    ctx.nextStepTriggers.codexRestart = true
   } else {
     warn("Failed to remove legacy configured Codex Docks marketplace")
   }
 }
 
 /** codex::_standalone_install_command — per-OS official standalone installer. */
-const standaloneInstallCommand = (): string =>
-  process.platform === "win32"
-    ? `powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"`
-    : 'tmp=$(mktemp) && curl -fsSL https://chatgpt.com/codex/install.sh -o "$tmp" && CODEX_NON_INTERACTIVE=1 sh "$tmp"'
+const standaloneInstallCommand = (ctx: Ctx): string => ctx.services.deps.spec("codex").installHint()
 
 /** codex::_enabled_plugin_ids — [plugins."<id>"] tables with enabled = true. */
 export function enabledPluginIds(configFile: string): Array<string> {
   if (!existsSync(configFile)) return []
+  return enabledPluginIdsFromText(readFileSync(configFile, "utf8"))
+}
+
+export function enabledPluginIdsFromText(configText: string): Array<string> {
   const ids: Array<string> = []
   let plugin = ""
   let enabled = false
   const flush = (): void => {
     if (plugin !== "" && enabled) ids.push(plugin)
   }
-  for (const line of readFileSync(configFile, "utf8").split("\n")) {
+  for (const line of configText.split("\n")) {
     const m = /^\[plugins\."([^"]+)"\][ \t]*$/.exec(line)
     if (m !== null) {
       flush()
@@ -380,39 +424,43 @@ export function enabledPluginIds(configFile: string): Array<string> {
   return ids
 }
 
-function manualPluginRefreshCommand(sotConfig: string): string {
-  const first = enabledPluginIds(sotConfig)[0]
+function manualPluginRefreshCommand(sotConfigText: string): string {
+  const first = enabledPluginIdsFromText(sotConfigText)[0]
   return first !== undefined ? `codex plugin add ${first}` : "codex plugin add <plugin@marketplace>"
 }
 
-function syncPlugins(ctx: Ctx, sotConfig: string): void {
+function syncPlugins(ctx: Ctx, sotConfigText: string): void {
+  const { change, echo, warn } = ctx.services.logger
   if (ctx.dryRun) {
     echo("[dry-run] add enabled Codex plugins from SoT")
     return
   }
 
-  if (!commandExists("codex")) {
+  if (ctx.services.deps.probe("codex").state === "missing") {
     warn(
-      `codex CLI not in PATH - deployed config/marketplace only; install Codex with: ${standaloneInstallCommand()} | docs: https://developers.openai.com/codex/cli; then run: ${manualPluginRefreshCommand(sotConfig)}`
+      `codex CLI not in PATH - deployed config/marketplace only; install Codex with: ${standaloneInstallCommand(ctx)} | docs: https://developers.openai.com/codex/cli; then run: ${manualPluginRefreshCommand(sotConfigText)}`
     )
     return
   }
-  if (!commandExists("git")) {
-    const hint = process.platform === "win32" ? "winget install Git.Git (then open a new terminal)" : "install git via your package manager"
-    warn(`git not found — Codex plugin marketplaces are git repos, so plugin refresh would fail. Skipping. Install: ${hint}, then re-run sync`)
+  if (ctx.services.deps.probe("git").state === "missing") {
+    ctx.services.deps.warnMissing(
+      "git",
+      ctx.services.logger,
+      "plugin marketplaces are git repos — Codex plugin refresh skipped; re-run sync after installing"
+    )
     return
   }
 
   let refreshed = 0
   let failed = 0
-  for (const pluginId of enabledPluginIds(sotConfig)) {
+  for (const pluginId of enabledPluginIdsFromText(sotConfigText)) {
     const res = spawnSync("codex", ["plugin", "add", pluginId], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] })
     const addOut = `${res.stdout ?? ""}${res.stderr ?? ""}`
     if (res.error === undefined && res.status === 0) {
       refreshed++
     } else if (addOut.includes("could not find a Codex CLI binary")) {
       warn(
-        `Codex plugin refresh hit a stale launcher/wrapper on PATH - install current standalone Codex with: ${standaloneInstallCommand()}`
+        `Codex plugin refresh hit a stale launcher/wrapper on PATH - install current standalone Codex with: ${standaloneInstallCommand(ctx)}`
       )
       failed++
     } else {
@@ -424,13 +472,17 @@ function syncPlugins(ctx: Ctx, sotConfig: string): void {
     }
   }
 
-  if (refreshed > 0) log(`Codex plugins synced (plugins: ~${refreshed})`)
+  if (refreshed > 0) {
+    change(`Codex plugins synced (plugins: ~${refreshed})`)
+    ctx.nextStepTriggers.codexRestart = true
+  }
   if (failed > 0) warn(`${failed} Codex plugin operation(s) failed — re-run sync or install manually`)
 }
 
 // -------------------------------------------------------------- summary ----
 
 export function codexSummary(ctx: Ctx): void {
+  const { echo } = ctx.services.logger
   const codexDir = p(ctx.home, ".codex")
   echo(`Codex:    ${codexDir}`)
   if (!ctx.dryRun) {
@@ -439,6 +491,8 @@ export function codexSummary(ctx: Ctx): void {
   }
 }
 
-export function codexNextSteps(): void {
-  echo("Restart Codex to load any refreshed plugins, skills, or tools.")
+export function codexNextSteps(ctx: Ctx): Array<string> {
+  return ctx.verbose || ctx.nextStepTriggers.codexRestart
+    ? ["Restart Codex to load any refreshed plugins, skills, or tools."]
+    : []
 }

package/cli/src/engine-native/codexToml.ts

@@ -8,7 +8,6 @@ import { p } from "./exec"
 import { readFileSync, renameSync, writeFileSync } from "node:fs"
 
 import type { Ctx } from "./index"
-import { echo, log, warn } from "./output"
 
 export function replaceTopLevelSetting(content: string, key: string, replacement: string): string {
   const lines = content.split("\n")
@@ -40,13 +39,17 @@ export function replaceTopLevelSetting(content: string, key: string, replacement
   return `${out.join("\n")}\n`
 }
 
-export function replaceTopLevelSettingInFile(file: string, key: string, replacement: string): void {
-  const next = replaceTopLevelSetting(readFileSync(file, "utf8"), key, replacement)
+export function replaceTopLevelSettingInFile(file: string, key: string, replacement: string): boolean {
+  const before = readFileSync(file, "utf8")
+  const next = replaceTopLevelSetting(before, key, replacement)
+  if (next === before) return false
   writeFileSync(`${file}.tmp`, next)
   renameSync(`${file}.tmp`, file)
+  return true
 }
 
 export function syncCodexModel(ctx: Ctx, model: string): void {
+  const { change, echo, verbose, warn } = ctx.services.logger
   const userCodexSettings = p(ctx.home, ".codex", "config.toml")
 
   if (model === "") return
@@ -62,6 +65,10 @@ export function syncCodexModel(ctx: Ctx, model: string): void {
     warn(`(--codex-model) ${userCodexSettings} missing — skipped`)
     return
   }
-  replaceTopLevelSettingInFile(userCodexSettings, "model", `model = "${model}"`)
-  log(`Model: deployed Codex model set to ${model} (SoT unchanged; flag-less sync reverts)`)
+  if (replaceTopLevelSettingInFile(userCodexSettings, "model", `model = "${model}"`)) {
+    change(`Model: deployed Codex model set to ${model} (SoT unchanged; flag-less sync reverts)`)
+    ctx.nextStepTriggers.codexRestart = true
+  } else {
+    verbose(`Model: deployed Codex model already ${model}`)
+  }
 }