@smoothbricks/cli 0.1.1 → 0.2.0

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@smoothbricks/cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "description": "SmoothBricks monorepo automation CLI",
   "bin": {
     "smoo": "./bin/smoo"
   },
   "scripts": {
-    "test": "bun test"
+    "test": "nx run cli:test"
   },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -53,6 +53,7 @@
     "@smoothbricks/validation": "0.1.1",
     "commander": "^14.0.3",
     "publint": "^0.3.18",
+    "semver": "^7.7.4",
     "sherif": "^1.11.1",
     "tslib": "^2.8.1"
   },
@@ -71,11 +72,22 @@
         "dependsOn": [
           "build"
         ]
+      },
+      "test": {
+        "executor": "nx:run-commands",
+        "dependsOn": [
+          "^build"
+        ],
+        "options": {
+          "command": "bun test",
+          "cwd": "{projectRoot}"
+        }
       }
     },
     "tags": [
       "npm:public"
-    ]
+    ],
+    "name": "cli"
   },
   "license": "MIT",
   "publishConfig": {

package/src/cli.ts

@@ -1,4 +1,5 @@
 import { Command, CommanderError } from 'commander';
+import { cliPackageVersion } from './lib/cli-package.js';
 import { findRepoRoot } from './lib/run.js';
 
 export async function runCli(argv = process.argv.slice(2)): Promise<void> {
@@ -20,7 +21,12 @@ export async function runCli(argv = process.argv.slice(2)): Promise<void> {
 
 function buildProgram(): Command {
   const program = new Command();
-  program.name('smoo').description('SmoothBricks monorepo tooling').exitOverride().showHelpAfterError();
+  program
+    .name('smoo')
+    .description('SmoothBricks monorepo tooling')
+    .version(cliPackageVersion, '-v, --version', 'print smoo version')
+    .exitOverride()
+    .showHelpAfterError();
 
   const monorepo = program.command('monorepo').description('Manage SmoothBricks-style monorepos');
   monorepo
@@ -33,12 +39,21 @@ function buildProgram(): Command {
     });
   monorepo
     .command('validate')
+    .option('--fix', 'apply safe monorepo policy fixes before validation')
     .option('--fail-fast', 'stop after the first failing validation pack')
     .option('--only-if-new-workspace-package', 'skip validation unless a new workspace package manifest is staged')
-    .action(async (options: { failFast?: boolean; onlyIfNewWorkspacePackage?: boolean }) => {
-      const { validateMonorepo } = await import('./monorepo/index.js');
-      await validateMonorepo(await findRepoRoot(), options);
-    });
+    .option('--verbose', 'print validation progress and successful checks')
+    .action(
+      async (options: {
+        fix?: boolean;
+        failFast?: boolean;
+        onlyIfNewWorkspacePackage?: boolean;
+        verbose?: boolean;
+      }) => {
+        const { validateMonorepo } = await import('./monorepo/index.js');
+        await validateMonorepo(await findRepoRoot(), options);
+      },
+    );
   monorepo.command('update').action(async () => {
     const { updateManagedFiles } = await import('./monorepo/index.js');
     updateManagedFiles(await findRepoRoot());
@@ -51,10 +66,13 @@ function buildProgram(): Command {
     const { diffManagedFiles } = await import('./monorepo/index.js');
     diffManagedFiles(await findRepoRoot());
   });
-  monorepo.command('validate-commit-msg <commitMsgFile>').action(async (commitMsgFile: string) => {
-    const { validateCommitMessageFile } = await import('./monorepo/index.js');
-    validateCommitMessageFile(commitMsgFile);
-  });
+  monorepo
+    .command('validate-commit-msg <commitMsgFile>')
+    .option('--fix', 'format the commit message before validation')
+    .action(async (commitMsgFile: string, options: { fix?: boolean }) => {
+      const { validateCommitMessageFile } = await import('./monorepo/index.js');
+      validateCommitMessageFile(commitMsgFile, options, await findRepoRoot());
+    });
   monorepo.command('sync-bun-lockfile-versions').action(async () => {
     const { syncBunLockfileVersions } = await import('./monorepo/index.js');
     syncBunLockfileVersions(await findRepoRoot());
@@ -62,10 +80,10 @@ function buildProgram(): Command {
   monorepo
     .command('list-release-packages')
     .option('--fail-empty', 'fail when no owned release packages are found')
-    .option('--github-output <path>', 'append projects=<packages> to a GitHub Actions output file')
+    .option('--github-output <path>', 'append projects=<nx-projects> to a GitHub Actions output file')
     .action(async (options: { failEmpty?: boolean; githubOutput?: string }) => {
-      const { listReleasePackagesForNx } = await import('./monorepo/index.js');
-      const packages = listReleasePackagesForNx(await findRepoRoot(), options);
+      const { listReleaseProjectNamesForNx } = await import('./monorepo/index.js');
+      const packages = listReleaseProjectNamesForNx(await findRepoRoot(), options);
       if (!options.githubOutput) {
         console.log(packages);
       }
@@ -74,6 +92,30 @@ function buildProgram(): Command {
     const { validatePublicPackageTags } = await import('./monorepo/index.js');
     validatePublicPackageTags(await findRepoRoot());
   });
+  monorepo
+    .command('setup-test-tracing')
+    .description('Configure LMAO Bun test tracing for workspace packages')
+    .option('--all', 'configure every workspace package')
+    .option('--projects <projects>', 'comma-separated Nx project names, package names, or package roots')
+    .option('--op-context-export <exportName>', 'named op context export imported by test-suite-tracer', 'opContext')
+    .option(
+      '--tracer-module <module>',
+      'module specifier that exports defineTestTracer',
+      '@smoothbricks/lmao/testing/bun',
+    )
+    .option('--dry-run', 'print generator invocations without writing files')
+    .action(
+      async (options: {
+        all?: boolean;
+        projects?: string;
+        opContextExport?: string;
+        tracerModule?: string;
+        dryRun?: boolean;
+      }) => {
+        const { setupTestTracing } = await import('./monorepo/index.js');
+        await setupTestTracing(await findRepoRoot(), options);
+      },
+    );
   const release = program.command('release').description('Version, publish, and create GitHub Releases');
   release.command('npm-status').action(async () => {
     const { printReleaseState } = await import('./release/index.js');
@@ -91,7 +133,7 @@ function buildProgram(): Command {
     .command('version')
     .option('--bump <bump>', 'auto, patch, minor, major, or prerelease', 'auto')
     .option('--dry-run [dryRun]', 'run without writing versions or tags')
-    .option('--github-output <path>', 'append mode=<mode> and projects=<packages> to a GitHub Actions output file')
+    .option('--github-output <path>', 'append mode=<mode> and projects=<nx-projects> to a GitHub Actions output file')
     .action(async (options: { bump: string; dryRun?: string | boolean; githubOutput?: string }) => {
       const { releaseVersion } = await import('./release/index.js');
       await releaseVersion(await findRepoRoot(), {
@@ -142,19 +184,91 @@ function buildProgram(): Command {
         });
       },
     );
+  release
+    .command('bootstrap-npm-packages')
+    .alias('bootstrap')
+    .description('Publish minimal npm placeholder packages so trusted publishing can be configured')
+    .option('--dry-run [dryRun]', 'show placeholder publishes without logging in or publishing')
+    .option('--skip-login', 'skip npm browser login before publishing placeholders')
+    .option('--otp <otp>', 'npm one-time password for placeholder publish operations')
+    .option('--package <name...>', 'only bootstrap the selected owned release package names')
+    .action(async (options: { dryRun?: string | boolean; skipLogin?: boolean; otp?: string; package?: string[] }) => {
+      const { releaseBootstrapNpmPackages } = await import('./release/index.js');
+      await releaseBootstrapNpmPackages(await findRepoRoot(), {
+        dryRun: booleanOption(options.dryRun),
+        skipLogin: options.skipLogin === true,
+        otp: options.otp,
+        packages: options.package ?? [],
+      });
+    });
   release
     .command('trust-publisher')
     .description('Configure npm trusted publishing for owned release packages')
     .option('--dry-run [dryRun]', 'show npm trust changes without saving them')
+    .option('--bootstrap', 'publish missing npm placeholder packages before configuring trust')
     .option('--otp <otp>', 'npm one-time password for trust operations')
+    .option('--bootstrap-otp <otp>', 'npm one-time password for placeholder publishes during --bootstrap')
     .option('--skip-login', 'skip npm browser login before configuring trust')
-    .action(async (options: { dryRun?: string | boolean; otp?: string; skipLogin?: boolean }) => {
-      const { releaseTrustPublisher } = await import('./release/index.js');
-      await releaseTrustPublisher(await findRepoRoot(), {
-        dryRun: booleanOption(options.dryRun),
-        otp: options.otp,
-        skipLogin: options.skipLogin === true,
-      });
+    .action(
+      async (options: {
+        dryRun?: string | boolean;
+        bootstrap?: boolean;
+        otp?: string;
+        bootstrapOtp?: string;
+        skipLogin?: boolean;
+      }) => {
+        const { releaseTrustPublisher } = await import('./release/index.js');
+        await releaseTrustPublisher(await findRepoRoot(), {
+          dryRun: booleanOption(options.dryRun),
+          bootstrap: options.bootstrap === true,
+          otp: options.otp,
+          bootstrapOtp: options.bootstrapOtp,
+          skipLogin: options.skipLogin === true,
+        });
+      },
+    );
+
+  const devenv = program.command('devenv').description('Manage the repository devenv shell');
+  devenv.command('update').action(async () => {
+    const { updateDevenv } = await import('./devenv/index.js');
+    await updateDevenv(await findRepoRoot());
+  });
+  devenv.command('reload').action(async () => {
+    const { reloadDevenv } = await import('./devenv/index.js');
+    await reloadDevenv(await findRepoRoot());
+  });
+
+  const nixpkgsOverlay = program.command('nixpkgs-overlay').description('Manage the repository nixpkgs overlay');
+  nixpkgsOverlay.command('update').action(async () => {
+    const { updateNixpkgsOverlay } = await import('./devenv/index.js');
+    await updateNixpkgsOverlay(await findRepoRoot());
+  });
+
+  const nx = program.command('nx').description('Nx workspace helpers');
+  nx.command('list-targets')
+    .description('List project:target entries for every Nx project')
+    .action(async () => {
+      const { listTargets } = await import('./nx/index.js');
+      await listTargets(await findRepoRoot());
+    });
+  nx.command('list-projects')
+    .description('List Nx projects matching filters')
+    .requiredOption('--with-target <target>', 'only include projects defining this target')
+    .action(async (options: { withTarget?: string }) => {
+      const { listProjects } = await import('./nx/index.js');
+      await listProjects(await findRepoRoot(), options);
+    });
+  nx.command('reset-cache')
+    .description('Run nx reset to clear Nx daemon and cache state')
+    .action(async () => {
+      const { resetCache } = await import('./nx/index.js');
+      await resetCache(await findRepoRoot());
+    });
+  nx.command('clean-cache')
+    .description('Remove local Nx cache directories when present')
+    .action(async () => {
+      const { cleanCache } = await import('./nx/index.js');
+      await cleanCache(await findRepoRoot());
     });
 
   const githubCi = program.command('github-ci').description('GitHub Actions helpers');

package/src/devenv/index.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'bun:test';
+import type { DevenvCommandShell } from './index.js';
+import { reloadDevenv, updateDevenv, updateNixpkgsOverlay } from './index.js';
+
+describe('devenv commands', () => {
+  it('runs devenv update in tooling/direnv', async () => {
+    const shell = new RecordingShell();
+
+    await updateDevenv('/repo', shell);
+
+    expect(shell.commands).toEqual([{ command: 'devenv', args: ['update'], cwd: '/repo/tooling/direnv' }]);
+  });
+
+  it('clears cached devenv directories before reloading direnv', async () => {
+    const shell = new RecordingShell();
+
+    await reloadDevenv('/repo', shell);
+
+    expect(shell.removals).toEqual(['/repo/tooling/direnv/.direnv', '/repo/tooling/direnv/.devenv']);
+    expect(shell.commands).toEqual([{ command: 'direnv', args: ['reload'], cwd: '/repo/tooling/direnv' }]);
+  });
+
+  it('runs nvfetcher through nix shell in the overlay directory', async () => {
+    const shell = new RecordingShell();
+
+    await updateNixpkgsOverlay('/repo', shell);
+
+    expect(shell.commands).toEqual([
+      {
+        command: 'nix',
+        args: ['shell', 'nixpkgs#nvfetcher', '-c', 'nvfetcher', '-o', '_sources'],
+        cwd: '/repo/tooling/direnv/nixpkgs-overlay',
+      },
+    ]);
+  });
+});
+
+class RecordingShell implements DevenvCommandShell {
+  readonly commands: { command: string; args: string[]; cwd: string }[] = [];
+  readonly removals: string[] = [];
+
+  async run(command: string, args: string[], cwd: string): Promise<void> {
+    this.commands.push({ command, args, cwd });
+  }
+
+  async remove(path: string): Promise<void> {
+    this.removals.push(path);
+  }
+}

package/src/devenv/index.ts

@@ -0,0 +1,38 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { run } from '../lib/run.js';
+
+export interface DevenvCommandShell {
+  run(command: string, args: string[], cwd: string): Promise<void>;
+  remove(path: string): Promise<void>;
+}
+
+const defaultShell: DevenvCommandShell = {
+  run,
+  async remove(path) {
+    await rm(path, { recursive: true, force: true });
+  },
+};
+
+export async function updateDevenv(root: string, shell: DevenvCommandShell = defaultShell): Promise<void> {
+  await shell.run('devenv', ['update'], direnvRoot(root));
+}
+
+export async function reloadDevenv(root: string, shell: DevenvCommandShell = defaultShell): Promise<void> {
+  const cwd = direnvRoot(root);
+  await shell.remove(join(cwd, '.direnv'));
+  await shell.remove(join(cwd, '.devenv'));
+  await shell.run('direnv', ['reload'], cwd);
+}
+
+export async function updateNixpkgsOverlay(root: string, shell: DevenvCommandShell = defaultShell): Promise<void> {
+  await shell.run('nix', ['shell', 'nixpkgs#nvfetcher', '-c', 'nvfetcher', '-o', '_sources'], nixpkgsOverlayRoot(root));
+}
+
+export function direnvRoot(root: string): string {
+  return join(root, 'tooling', 'direnv');
+}
+
+export function nixpkgsOverlayRoot(root: string): string {
+  return join(direnvRoot(root), 'nixpkgs-overlay');
+}

package/src/lib/cli-package.ts

@@ -0,0 +1,18 @@
+import { fileURLToPath } from 'node:url';
+import { readJsonObject, stringProperty } from './json.js';
+
+export const smoothBricksCodebasePackageName = '@smoothbricks/codebase';
+export const cliPackageVersion = readCliPackageVersion();
+
+function readCliPackageVersion(): string {
+  const pkg = readJsonObject(fileURLToPath(new URL('../../package.json', import.meta.url)));
+  const version = pkg ? stringProperty(pkg, 'version') : null;
+  if (!version) {
+    throw new Error('Unable to read @smoothbricks/cli package version.');
+  }
+  return version;
+}
+
+export function isSmoothBricksCodebasePackageName(name: string | undefined): boolean {
+  return name === smoothBricksCodebasePackageName;
+}

package/src/lib/run.ts

@@ -26,6 +26,25 @@ export async function runStatus(
   return result.exitCode;
 }
 
+export async function runResult(
+  command: string,
+  args: string[],
+  cwd: string,
+  env?: Record<string, string>,
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  const invocation = resolveCommandInvocation(cwd, command, args);
+  let shell = $`${invocation.command} ${invocation.args}`.cwd(cwd).nothrow().quiet();
+  if (env) {
+    shell = shell.env(mergeEnv(env));
+  }
+  const result = await shell;
+  return {
+    exitCode: result.exitCode,
+    stdout: decode(result.stdout),
+    stderr: decode(result.stderr),
+  };
+}
+
 function mergeEnv(env: Record<string, string>): Record<string, string> {
   const merged: Record<string, string> = {};
   for (const [key, value] of Object.entries(process.env)) {

package/src/lib/workspace.ts

@@ -1,9 +1,11 @@
 import { readdirSync, statSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
+import { isSmoothBricksCodebasePackageName } from './cli-package.js';
 import { hasOwn, hasOwnString, isRecord, readJson, readJsonObject, stringProperty } from './json.js';
 
 export interface PackageInfo {
   name: string;
+  projectName: string;
   version: string;
   private: boolean;
   tags: string[];
@@ -12,12 +14,28 @@ export interface PackageInfo {
   json: Record<string, unknown>;
 }
 
+export interface PackageJson extends Record<string, unknown> {
+  name?: string;
+  version?: string;
+  private?: boolean;
+  workspaces?: unknown;
+  devDependencies?: unknown;
+  dependencies?: unknown;
+  nx?: unknown;
+  repository?: unknown;
+}
+
 export interface RepositoryInfo {
   type: string;
   url: string;
 }
 
-export const workspaceDependencyFields = ['dependencies', 'devDependencies', 'optionalDependencies'] as const;
+export const workspaceDependencyFields = [
+  'dependencies',
+  'devDependencies',
+  'peerDependencies',
+  'optionalDependencies',
+] as const;
 
 export function listPublicPackages(root: string): PackageInfo[] {
   return getWorkspacePackages(root).filter((pkg) => !pkg.private && pkg.tags.includes('npm:public'));
@@ -44,6 +62,15 @@ export function rootRepositoryInfo(root: string): RepositoryInfo | null {
   return rootPackage ? repositoryInfo(rootPackage) : null;
 }
 
+export function rootPackageName(root: string): string | null {
+  const rootPackage = readPackageJsonObject(join(root, 'package.json'));
+  return rootPackage ? stringProperty(rootPackage, 'name') : null;
+}
+
+export function isSmoothBricksCodebase(root: string): boolean {
+  return isSmoothBricksCodebasePackageName(rootPackageName(root) ?? undefined);
+}
+
 export function packageRepositoryInfo(pkg: PackageInfo): RepositoryInfo | null {
   return repositoryInfo(pkg.json);
 }
@@ -79,6 +106,7 @@ function getWorkspacePackagesForPatterns(root: string, workspacePatterns: string
       }
       packages.push({
         name: pkg.name,
+        projectName: pkg.projectName,
         version: pkg.version,
         private: pkg.private,
         tags: pkg.tags,
@@ -122,7 +150,7 @@ function getWorkspacePatternsFromPackageJson(pkg: Record<string, unknown>): stri
 }
 
 export function readPackageJson(path: string): PackageInfo | null {
-  const parsed = readJsonObject(path);
+  const parsed = readPackageJsonObject(path);
   if (!isRecord(parsed) || !hasOwnString(parsed, 'name') || !hasOwnString(parsed, 'version')) {
     return null;
   }
@@ -130,6 +158,7 @@ export function readPackageJson(path: string): PackageInfo | null {
   const tags = getNxTags(parsed);
   return {
     name: parsed.name,
+    projectName: packageNxProjectName(parsed),
     version: parsed.version,
     private: privateValue,
     tags,
@@ -139,6 +168,16 @@ export function readPackageJson(path: string): PackageInfo | null {
   };
 }
 
+function packageNxProjectName(pkg: Record<string, unknown>): string {
+  const nx = isRecord(pkg.nx) ? pkg.nx : null;
+  return (nx ? stringProperty(nx, 'name') : null) ?? stringProperty(pkg, 'name') ?? '';
+}
+
+export function readPackageJsonObject(path: string): PackageJson | null {
+  const parsed = readJsonObject(path);
+  return parsed;
+}
+
 export function getNxTags(pkg: Record<string, unknown>): string[] {
   if (!hasOwn(pkg, 'nx') || !isRecord(pkg.nx) || !hasOwn(pkg.nx, 'tags') || !Array.isArray(pkg.nx.tags)) {
     return [];

package/src/monorepo/__tests__/publish-workflow.test.ts

@@ -20,6 +20,14 @@ describe('publish workflow definition', () => {
     );
   });
 
+  it('does not wire npm token secrets into repair or publish steps', () => {
+    const rendered = renderPublishWorkflowYaml({ repoName: '@smoothbricks/codebase' });
+
+    expect(rendered).not.toContain('NODE_AUTH_TOKEN');
+    expect(rendered).not.toContain('secrets.NPM_TOKEN');
+    expect(rendered).toContain('packages must already exist on npm and use trusted publishing/OIDC');
+  });
+
   it('bootstraps the self-hosted CLI before release commands only for the SmoothBricks repo', async () => {
     const smoothbricks = await publishWorkflowScenario({
       repoName: '@smoothbricks/codebase',
@@ -79,16 +87,16 @@ describe('publish workflow definition', () => {
       ],
       bump: 'patch',
       dryRun: false,
-      version: { mode: 'new', projects: ['@scope/a', '@scope/b'] },
+      version: { mode: 'new', projects: ['a', 'b'] },
     });
 
     const outcome = await scenario.run();
 
     expect(outcome.validation).toEqual({
       checks: 1,
-      builds: ['@scope/a', '@scope/b'],
-      lints: ['@scope/a', '@scope/b'],
-      tests: ['@scope/a', '@scope/b'],
+      builds: ['a', 'b'],
+      lints: ['a', 'b'],
+      tests: ['a', 'b'],
       validates: 1,
     });
     expect(outcome.publishSawValidatedRelease).toBe(true);
@@ -102,7 +110,7 @@ describe('publish workflow definition', () => {
       current: [{ tag: '@scope/a@1.2.0', npmMissing: true, githubMissing: true }],
       bump: 'prerelease',
       dryRun: true,
-      version: { mode: 'new', projects: ['@scope/a'] },
+      version: { mode: 'new', projects: ['a'] },
     });
 
     const outcome = await scenario.run();
@@ -112,9 +120,9 @@ describe('publish workflow definition', () => {
     expect(outcome.repairBuildArtifacts).toEqual([]);
     expect(outcome.validation).toEqual({
       checks: 1,
-      builds: ['@scope/a'],
-      lints: ['@scope/a'],
-      tests: ['@scope/a'],
+      builds: ['a'],
+      lints: ['a'],
+      tests: ['a'],
       validates: 1,
     });
     expect(outcome.publishRan).toBe(true);
@@ -164,7 +172,6 @@ function publishWorkflowScenario(config: WorkflowScenarioConfig): { run(): Promi
       const state = new WorkflowScenarioState(config);
       await runPublishWorkflow(definePublishWorkflow({ repoName: config.repoName }), {
         inputs: { bump: config.bump, dryRun: config.dryRun },
-        nodeAuthToken: true,
         callbacks: state.callbacks(),
       });
       return state.outcome();

package/src/monorepo/commit-msg.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'bun:test';
+import { formatCommitMessage, validateCommitMessage } from './commit-msg.js';
+
+describe('commit message validation', () => {
+  it('accepts Nx conventional commit types and configured scopes', () => {
+    expect(validateCommitMessage('types(cli): expose public API\n', { validScopes: new Set(['cli']) })).toBeNull();
+  });
+
+  it('rejects scopes outside configured Nx names', () => {
+    expect(
+      validateCommitMessage('fix(@smoothbricks/cli): repair release\n', { validScopes: new Set(['cli']) }),
+    ).toContain('Invalid conventional commit scope');
+  });
+});
+
+describe('commit message formatting', () => {
+  it('wraps prose and preserves markdown blocks', () => {
+    const message = formatCommitMessage(
+      [
+        'fix(cli): wrap commit bodies   ',
+        '',
+        'This paragraph is intentionally long enough to be wrapped by the injected formatter callback while preserving non-prose markdown sections.',
+        '',
+        '```',
+        'long log errors should stay exactly as they are because this is a fenced block',
+        '```',
+        '',
+        '> quoted markdown should also stay as a single untouched line even when it is long enough to otherwise need wrapping',
+      ].join('\n'),
+      { wrapBody: (paragraph) => paragraph.replace(' while ', '\nwhile ') },
+    );
+
+    expect(message).toBe(`fix(cli): wrap commit bodies
+
+This paragraph is intentionally long enough to be wrapped by the injected formatter callback
+while preserving non-prose markdown sections.
+
+\`\`\`
+long log errors should stay exactly as they are because this is a fenced block
+\`\`\`
+
+> quoted markdown should also stay as a single untouched line even when it is long enough to otherwise need wrapping
+`);
+  });
+});