@vantaloom/cli 0.1.0

package/README.md

@@ -0,0 +1,12 @@
+# Vantaloom CLI
+
+Command-line manager for installing, updating, starting, stopping, and inspecting a local Vantaloom runtime.
+
+```sh
+npm install -g @vantaloom/cli
+vantaloom install
+vantaloom status
+vantaloom update
+```
+
+The CLI downloads platform-specific runtime packages produced by the Vantaloom GitHub CI pipeline.

package/bin/vantaloom.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { main } from "../src/cli.mjs"
+
+main(process.argv.slice(2)).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error)
+  console.error(`vantaloom: ${message}`)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@vantaloom/cli",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Vantaloom local runtime manager.",
+  "bin": {
+    "vantaloom": "bin/vantaloom.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "package.json",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/cli.mjs

@@ -0,0 +1,677 @@
+import { execFileSync, spawnSync } from "node:child_process"
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { cp, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const cliRoot = path.resolve(fileURLToPath(import.meta.url), "..", "..")
+const repoCandidate = path.resolve(cliRoot, "..", "..")
+const installedConfigPath = path.join(cliRoot, "config.json")
+const defaultDistBranch = "vantaloom-dist"
+const defaultRepo = "Timefiles404/Vantaloom-next"
+
+const runtimePackages = [
+  "@next/env",
+  "@swc/helpers",
+  "baseline-browser-mapping",
+  "caniuse-lite",
+  "client-only",
+  "postcss",
+  "react",
+  "react-dom",
+  "scheduler",
+  "styled-jsx",
+]
+
+export async function main(argv) {
+  const command = argv[0] ?? "help"
+  const options = parseOptions(argv.slice(1))
+
+  switch (command) {
+    case "install":
+      if (options.package) {
+        await installFromPackage({ ...options, update: false })
+      } else {
+        await installFromSource(options)
+      }
+      return
+    case "update":
+      if (options.package) {
+        await installFromPackage({ ...options, update: true })
+      } else if (shouldUseDistUpdate(options)) {
+        await updateFromDist(options)
+      } else {
+        await installFromSource({ ...options, update: true })
+      }
+      return
+    case "package":
+      await packageRuntime(options)
+      return
+    case "platform":
+      console.log(platformId())
+      return
+    case "start":
+    case "stop":
+    case "restart":
+    case "status":
+    case "ports":
+      runCtl(command, options)
+      return
+    case "path":
+      printPaths(options)
+      return
+    case "help":
+    case "-h":
+    case "--help":
+      printHelp()
+      return
+    default:
+      throw new Error(`unknown command "${command}"`)
+  }
+}
+
+async function installFromSource(options) {
+  const sourceRoot = findSourceRoot(options.source)
+  const prefix = safeDirectory(options.prefix ?? defaultPrefix())
+  const buildRoot = path.join(sourceRoot, "artifacts", "local-install", platformId())
+
+  const { version } = await buildRuntimePackage(sourceRoot, buildRoot, {
+    buildWeb: options.buildWeb,
+  })
+
+  await applyPackage(buildRoot, prefix, {
+    noStart: options.noStart,
+    sourceRoot,
+    update: options.update,
+  })
+
+  console.log(`${options.update ? "updated" : "installed"} Vantaloom: ${prefix}`)
+  console.log(`version: ${version}`)
+  console.log(`run: ${displayCommand(prefix)} status`)
+}
+
+async function installFromPackage(options) {
+  const prefix = safeDirectory(options.prefix ?? defaultPrefix())
+  const packageRoot = safeDirectory(options.package)
+  const version = await applyPackage(packageRoot, prefix, {
+    noStart: options.noStart,
+    update: options.update,
+  })
+
+  console.log(`${options.update ? "updated" : "installed"} Vantaloom: ${prefix}`)
+  console.log(`version: ${version}`)
+  console.log(`run: ${displayCommand(prefix)} status`)
+}
+
+async function packageRuntime(options) {
+  const sourceRoot = findSourceRoot(options.source)
+  const packageRoot = safeDirectory(
+    options.output ?? path.join(sourceRoot, "artifacts", "packages", `vantaloom-${platformId()}`)
+  )
+  const { platform: builtPlatform, version } = await buildRuntimePackage(sourceRoot, packageRoot, {
+    buildWeb: options.buildWeb,
+  })
+
+  if (options.archive) {
+    const archivePath = `${packageRoot}.tar.gz`
+    removeKnownPath(archivePath, path.dirname(archivePath))
+    run("tar", [
+      "-czf",
+      archivePath,
+      "-C",
+      path.dirname(packageRoot),
+      path.basename(packageRoot),
+    ])
+    console.log(`archive: ${archivePath}`)
+  }
+
+  console.log(`packaged Vantaloom: ${packageRoot}`)
+  console.log(`platform: ${builtPlatform}`)
+  console.log(`version: ${version}`)
+}
+
+async function buildRuntimePackage(sourceRoot, packageRoot, options) {
+  const version = gitVersion(sourceRoot)
+  const platform = platformId()
+  const buildBin = path.join(packageRoot, "bin")
+  const buildWeb = path.join(packageRoot, "web")
+
+  removeKnownPath(packageRoot, path.dirname(packageRoot))
+  mkdirSync(buildBin, { recursive: true })
+
+  buildGo(sourceRoot, buildBin, "vantaloom-api")
+  buildGo(sourceRoot, buildBin, "vantaloom-agent")
+  buildGo(sourceRoot, buildBin, "vantaloomctl")
+
+  if (options.buildWeb) {
+    run("pnpm", ["--filter", "vantaloom-app", "build"], { cwd: sourceRoot })
+  }
+
+  await copyStandaloneWeb(sourceRoot, buildWeb)
+  await copyCliDirectory(path.join(packageRoot, "cli"), sourceRoot, runtimeConfigFromSource(sourceRoot))
+  writeBuildManifest(packageRoot, version, platform)
+
+  return { platform, version }
+}
+
+async function applyPackage(packageRoot, prefix, options) {
+  assertRuntimePackage(packageRoot)
+
+  const existingConfig = readInstalledConfig(prefix)
+  const packageConfig = readJSONIfExists(path.join(packageRoot, "cli", "config.json"))
+  const mergedConfig = mergeRuntimeConfig(packageConfig, existingConfig, {
+    sourceRoot: options.sourceRoot,
+  })
+  const version = readVersion(packageRoot)
+
+  mkdirSync(prefix, { recursive: true })
+  const existingCtl = path.join(prefix, "bin", binaryName("vantaloomctl"))
+  if (existsSync(existingCtl)) {
+    spawnSync(existingCtl, ["stop", "--prefix", prefix], { stdio: "inherit" })
+  }
+
+  for (const name of ["bin", "web", "cli"]) {
+    removeKnownPath(path.join(prefix, name), prefix)
+    await cp(path.join(packageRoot, name), path.join(prefix, name), {
+      recursive: true,
+      force: true,
+      dereference: true,
+    })
+  }
+
+  await writeLauncher(prefix)
+  await writeText(path.join(prefix, "cli", "config.json"), `${JSON.stringify(mergedConfig, null, 2)}\n`)
+  await writeText(path.join(prefix, "VERSION"), `${version}\n`)
+  await cp(path.join(packageRoot, "manifest.json"), path.join(prefix, "manifest.json"), {
+    force: true,
+  })
+
+  run(path.join(prefix, "bin", binaryName("vantaloomctl")), [
+    "install",
+    "--prefix",
+    prefix,
+    "--version",
+    version,
+  ])
+
+  if (!options.noStart) {
+    run(path.join(prefix, "bin", binaryName("vantaloomctl")), [
+      "start",
+      "--prefix",
+      prefix,
+    ])
+  }
+
+  return version
+}
+
+async function updateFromDist(options) {
+  const prefix = safeDirectory(options.prefix ?? defaultPrefix())
+  const installedConfig = readInstalledConfig(prefix)
+  const sourceRoot = installedConfig.sourceRoot
+    ? tryAssertSourceRoot(installedConfig.sourceRoot)
+    : tryFindSourceRoot()
+  const sourceRemote = sourceRoot ? gitRemoteUrl(sourceRoot) : ""
+  const remote = options.remote ?? installedConfig.remote ?? sourceRemote
+  const repo = options.repo || installedConfig.repo || inferGitHubRepo(remote) || defaultRepo
+  const distBranch = options.distBranch ?? installedConfig.distBranch ?? defaultDistBranch
+  const cloneUrl = remote || sshRemoteFromRepo(repo)
+  const tempRoot = mkdtempSync(path.join(os.tmpdir(), "vantaloom-update-"))
+
+  try {
+    const distRoot = path.join(tempRoot, "dist")
+    const extractRoot = path.join(tempRoot, "extract")
+    mkdirSync(extractRoot, { recursive: true })
+
+    run("git", [
+      "clone",
+      "--depth",
+      "1",
+      "--branch",
+      distBranch,
+      cloneUrl,
+      distRoot,
+    ])
+
+    const archive = findPackageArchive(distRoot, platformId())
+    run("tar", ["-xzf", archive, "-C", extractRoot])
+
+    const packageRoot = findExtractedPackage(extractRoot, platformId())
+    const version = await applyPackage(packageRoot, prefix, {
+      noStart: options.noStart,
+      sourceRoot: installedConfig.sourceRoot,
+      update: true,
+    })
+
+    console.log(`updated Vantaloom: ${prefix}`)
+    console.log(`version: ${version}`)
+    console.log(`source: ${repo}#${distBranch}`)
+    console.log(`run: ${displayCommand(prefix)} status`)
+  } finally {
+    removeKnownPath(tempRoot, os.tmpdir())
+  }
+}
+
+function shouldUseDistUpdate(options) {
+  return !options.local && !options.source && !options.buildWeb
+}
+
+function assertRuntimePackage(packageRoot) {
+  for (const name of ["bin", "web", "cli", "manifest.json"]) {
+    if (!existsSync(path.join(packageRoot, name))) {
+      throw new Error(`invalid Vantaloom package, missing ${name}: ${packageRoot}`)
+    }
+  }
+}
+
+function readVersion(packageRoot) {
+  const versionPath = path.join(packageRoot, "VERSION")
+  if (existsSync(versionPath)) {
+    return readFileSync(versionPath, "utf8").trim() || "dev"
+  }
+  const manifest = readJSONIfExists(path.join(packageRoot, "manifest.json"))
+  return manifest.version ?? "dev"
+}
+
+function readInstalledConfig(prefix) {
+  return readJSONIfExists(path.join(prefix, "cli", "config.json"))
+}
+
+function readJSONIfExists(filePath) {
+  if (!existsSync(filePath)) {
+    return {}
+  }
+  return JSON.parse(readFileSync(filePath, "utf8"))
+}
+
+function mergeRuntimeConfig(packageConfig, existingConfig, overrides) {
+  const merged = { ...packageConfig }
+  for (const key of ["sourceRoot", "remote", "repo", "distBranch"]) {
+    if (!merged[key] && existingConfig[key]) {
+      merged[key] = existingConfig[key]
+    }
+  }
+  if (overrides.sourceRoot) {
+    merged.sourceRoot = overrides.sourceRoot
+  }
+  if (!merged.repo) {
+    merged.repo = defaultRepo
+  }
+  if (!merged.distBranch) {
+    merged.distBranch = defaultDistBranch
+  }
+  return merged
+}
+
+function runtimeConfigFromSource(sourceRoot) {
+  const remote = gitRemoteUrl(sourceRoot)
+  const repo = inferGitHubRepo(remote) || defaultRepo
+  return {
+    ...(process.env.GITHUB_ACTIONS ? {} : { sourceRoot }),
+    ...(remote ? { remote } : {}),
+    repo,
+    distBranch: defaultDistBranch,
+  }
+}
+
+function findPackageArchive(distRoot, platform) {
+  const candidates = [
+    path.join(distRoot, "packages", `vantaloom-${platform}.tar.gz`),
+    path.join(distRoot, `vantaloom-${platform}.tar.gz`),
+  ]
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate
+    }
+  }
+  throw new Error(`missing CI package for ${platform} in ${distRoot}`)
+}
+
+function findExtractedPackage(extractRoot, platform) {
+  const expected = path.join(extractRoot, `vantaloom-${platform}`)
+  if (existsSync(expected)) {
+    return expected
+  }
+
+  const directories = readdirSync(extractRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(extractRoot, entry.name))
+  if (directories.length === 1) {
+    return directories[0]
+  }
+
+  throw new Error(`could not find extracted Vantaloom package in ${extractRoot}`)
+}
+
+function tryFindSourceRoot() {
+  try {
+    return findSourceRoot()
+  } catch {
+    return ""
+  }
+}
+
+function tryAssertSourceRoot(sourceRoot) {
+  try {
+    return assertSourceRoot(sourceRoot)
+  } catch {
+    return ""
+  }
+}
+
+function gitRemoteUrl(sourceRoot) {
+  const result = spawnSync("git", ["remote", "get-url", "origin"], {
+    cwd: sourceRoot,
+    encoding: "utf8",
+  })
+  if (result.status === 0) {
+    return result.stdout.trim()
+  }
+  return ""
+}
+
+function inferGitHubRepo(remote) {
+  if (!remote) {
+    return ""
+  }
+  const normalized = remote.replace(/\.git$/, "")
+  const httpsMatch = normalized.match(/github\.com[:/]([^/]+\/[^/]+)$/)
+  if (httpsMatch) {
+    return httpsMatch[1]
+  }
+  const sshMatch = normalized.match(/^[^:]+:([^/]+\/[^/]+)$/)
+  return sshMatch?.[1] ?? ""
+}
+
+function sshRemoteFromRepo(repo) {
+  return `git@github.com:${repo}.git`
+}
+
+async function copyStandaloneWeb(sourceRoot, buildWeb) {
+  const standalone = path.join(sourceRoot, "apps", "vantaloom", ".next", "standalone")
+  const staticSource = path.join(sourceRoot, "apps", "vantaloom", ".next", "static")
+  const publicSource = path.join(sourceRoot, "apps", "vantaloom", "public")
+  if (!existsSync(standalone)) {
+    throw new Error(
+      "missing Next standalone output; let GitHub CI run production build, or pass --build-web for a local one-off build"
+    )
+  }
+
+  removeKnownPath(buildWeb, path.dirname(buildWeb))
+  await copyDir(standalone, buildWeb)
+  await copyDir(staticSource, path.join(buildWeb, "apps", "vantaloom", ".next", "static"))
+  await copyDir(publicSource, path.join(buildWeb, "apps", "vantaloom", "public"))
+
+  const appNodeModules = path.join(buildWeb, "apps", "vantaloom", "node_modules")
+  for (const packageName of runtimePackages) {
+    await copyPnpmRuntimePackage(sourceRoot, packageName, appNodeModules)
+  }
+}
+
+async function copyCliDirectory(target, sourceRoot, config) {
+  const sourceCliRoot = path.join(sourceRoot, "packages", "cli")
+  if (!existsSync(path.join(sourceCliRoot, "bin", "vantaloom.mjs"))) {
+    throw new Error(`missing source CLI package: ${sourceCliRoot}`)
+  }
+  removeKnownPath(target, path.dirname(target))
+  mkdirSync(target, { recursive: true })
+  await copyDir(sourceCliRoot, target)
+  await writeText(
+    path.join(target, "config.json"),
+    `${JSON.stringify(config, null, 2)}\n`
+  )
+}
+
+async function writeLauncher(prefix) {
+  if (process.platform === "win32") {
+    await writeText(
+      path.join(prefix, "vantaloom.cmd"),
+      `@echo off\r\nnode "%~dp0cli\\bin\\vantaloom.mjs" %*\r\n`
+    )
+  } else {
+    const launcher = `#!/usr/bin/env sh\nexec node "$(dirname "$0")/cli/bin/vantaloom.mjs" "$@"\n`
+    const launcherPath = path.join(prefix, "vantaloom")
+    await writeText(launcherPath, launcher)
+    chmodSync(launcherPath, 0o755)
+  }
+}
+
+function runCtl(command, options) {
+  const prefix = safeDirectory(options.prefix ?? defaultPrefix())
+  const ctl = path.join(prefix, "bin", binaryName("vantaloomctl"))
+  if (!existsSync(ctl)) {
+    throw new Error(`missing installed runtime at ${prefix}; run "vantaloom install" first`)
+  }
+
+  const args = [command, "--prefix", prefix]
+  if (options.component) {
+    args.push("--component", options.component)
+  }
+  run(ctl, args)
+}
+
+function printPaths(options) {
+  const sourceRoot = findSourceRoot(options.source)
+  const prefix = safeDirectory(options.prefix ?? defaultPrefix())
+  console.log(JSON.stringify({ sourceRoot, prefix }, null, 2))
+}
+
+function buildGo(sourceRoot, buildBin, name) {
+  run("go", [
+    "build",
+    "-o",
+    path.join(buildBin, binaryName(name)),
+    `./apps/api/cmd/${name}`,
+  ], { cwd: sourceRoot })
+}
+
+async function copyPnpmRuntimePackage(sourceRoot, packageName, destinationNodeModules) {
+  const pnpmRoot = path.join(sourceRoot, "node_modules", ".pnpm")
+  const storeName = packageName.replace("/", "+")
+  const packageRoot = readdirSync(pnpmRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.startsWith(`${storeName}@`))
+    .map((entry) => path.join(pnpmRoot, entry.name))
+    .sort()
+    .reverse()[0]
+  if (!packageRoot) {
+    throw new Error(`missing pnpm runtime package: ${packageName}`)
+  }
+
+  const source = path.join(packageRoot, "node_modules", ...packageName.split("/"))
+  if (!existsSync(source)) {
+    throw new Error(`missing pnpm runtime package source: ${source}`)
+  }
+
+  await copyDir(source, path.join(destinationNodeModules, ...packageName.split("/")))
+}
+
+async function copyDir(source, destination) {
+  if (!existsSync(source)) {
+    throw new Error(`missing source directory: ${source}`)
+  }
+  removeKnownPath(destination, path.dirname(destination))
+  mkdirSync(destination, { recursive: true })
+  await cp(source, destination, { recursive: true, force: true, dereference: true })
+}
+
+function writeBuildManifest(buildRoot, version, platform) {
+  writeFileSync(path.join(buildRoot, "VERSION"), `${version}\n`)
+  writeFileSync(
+    path.join(buildRoot, "manifest.json"),
+    `${JSON.stringify(
+      {
+        name: "Vantaloom Local Runtime",
+        version,
+        platform,
+        updatedAt: new Date().toISOString(),
+        components: ["api", "agent", "web", "ctl"],
+      },
+      null,
+      2
+    )}\n`
+  )
+}
+
+function findSourceRoot(sourceOption) {
+  if (sourceOption) {
+    return assertSourceRoot(path.resolve(sourceOption))
+  }
+  if (process.env.VANTALOOM_SOURCE) {
+    return assertSourceRoot(path.resolve(process.env.VANTALOOM_SOURCE))
+  }
+  if (existsSync(installedConfigPath)) {
+    const config = JSON.parse(readFileSync(installedConfigPath, "utf8"))
+    if (config.sourceRoot) {
+      return assertSourceRoot(path.resolve(config.sourceRoot))
+    }
+  }
+  return assertSourceRoot(repoCandidate)
+}
+
+function assertSourceRoot(sourceRoot) {
+  if (!existsSync(path.join(sourceRoot, "apps", "api", "go.mod"))) {
+    throw new Error(`not a Vantaloom source root: ${sourceRoot}`)
+  }
+  return sourceRoot
+}
+
+function gitVersion(sourceRoot) {
+  const result = spawnSync("git", ["rev-parse", "--short", "HEAD"], {
+    cwd: sourceRoot,
+    encoding: "utf8",
+  })
+  if (result.status === 0) {
+    return result.stdout.trim() || "dev"
+  }
+  return "dev"
+}
+
+function parseOptions(args) {
+  const options = {}
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]
+    if (!arg.startsWith("--")) {
+      throw new Error(`unexpected argument "${arg}"`)
+    }
+    const [key, inlineValue] = arg.slice(2).split("=", 2)
+    switch (key) {
+      case "prefix":
+      case "source":
+      case "component":
+      case "package":
+      case "output":
+      case "repo":
+      case "remote":
+      case "dist-branch":
+        options[toCamel(key)] = inlineValue ?? args[++index]
+        if (!options[toCamel(key)]) {
+          throw new Error(`missing value for --${key}`)
+        }
+        break
+      case "build-web":
+        options.buildWeb = true
+        break
+      case "no-start":
+        options.noStart = true
+        break
+      case "archive":
+        options.archive = true
+        break
+      case "local":
+        options.local = true
+        break
+      default:
+        throw new Error(`unknown option --${key}`)
+    }
+  }
+  return options
+}
+
+function safeDirectory(value) {
+  const full = path.resolve(value)
+  const parsed = path.parse(full)
+  if (full === parsed.root) {
+    throw new Error(`refusing to operate on unsafe directory: ${value}`)
+  }
+  return full
+}
+
+function removeKnownPath(target, expectedParent) {
+  if (!existsSync(target)) {
+    return
+  }
+  const full = path.resolve(target)
+  const parent = path.resolve(expectedParent)
+  const prefix = parent.endsWith(path.sep) ? parent : `${parent}${path.sep}`
+  if (!full.startsWith(prefix)) {
+    throw new Error(`refusing to remove path outside expected parent: ${full}`)
+  }
+  rmSync(full, { recursive: true, force: true })
+}
+
+function run(command, args, options = {}) {
+  try {
+    execFileSync(command, args, { stdio: "inherit", ...options })
+  } catch (error) {
+    if (error && typeof error.status === "number") {
+      throw new Error(`${command} exited with ${error.status}`)
+    }
+    throw error
+  }
+}
+
+function binaryName(name) {
+  return process.platform === "win32" ? `${name}.exe` : name
+}
+
+function platformId() {
+  return `${process.platform}-${process.arch}`
+}
+
+function defaultPrefix() {
+  if (process.env.VANTALOOM_HOME) {
+    return process.env.VANTALOOM_HOME
+  }
+  if (process.platform === "win32") {
+    return "D:\\Vantaloom"
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Applications", "Vantaloom")
+  }
+  return path.join(os.homedir(), ".local", "vantaloom")
+}
+
+function displayCommand(prefix) {
+  if (process.platform === "win32") {
+    return path.join(prefix, "vantaloom.cmd")
+  }
+  return path.join(prefix, "vantaloom")
+}
+
+function toCamel(value) {
+  return value.replace(/-([a-z])/g, (_, char) => char.toUpperCase())
+}
+
+async function writeText(filePath, content) {
+  mkdirSync(path.dirname(filePath), { recursive: true })
+  await writeFile(filePath, content)
+}
+
+function printHelp() {
+  console.log(`Vantaloom CLI
+
+Usage:
+  vantaloom install  [--prefix <dir>] [--source <repo>] [--build-web] [--package <dir>] [--no-start]
+  vantaloom update   [--prefix <dir>] [--repo <owner/name>] [--remote <git-url>] [--dist-branch <branch>] [--no-start]
+  vantaloom update   --local [--prefix <dir>] [--source <repo>] [--build-web] [--no-start]
+  vantaloom package  [--source <repo>] [--output <dir>] [--build-web] [--archive]
+  vantaloom start    [--prefix <dir>] [--component all|api|agent|web]
+  vantaloom stop     [--prefix <dir>] [--component all|api|agent|web]
+  vantaloom restart  [--prefix <dir>] [--component all|api|agent|web]
+  vantaloom status   [--prefix <dir>]
+  vantaloom ports    [--prefix <dir>]
+  vantaloom path     [--prefix <dir>] [--source <repo>]
+  vantaloom platform
+`)
+}