@astryxdesign/cli 0.0.0-bootstrap.0 → 0.0.15

package/src/lib/component-loader.test.mjs

@@ -0,0 +1,107 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Tests for mergeTranslation — overlaying translation docs onto base docs.
+ *
+ * Covers the hook param/return description merge (HookTranslationDoc) added so
+ * dense translations of hook params/returns are actually consumed, plus a
+ * regression guard for the existing component prop-description merge.
+ */
+
+import {describe, it, expect} from 'vitest';
+import {mergeTranslation} from './component-loader.mjs';
+
+/** Minimal HookDoc-shaped fixture with params + returns. */
+function hookDocs() {
+  return {
+    name: 'useFocusTrap',
+    usage: {description: 'English description.'},
+    params: [
+      {name: 'options', type: 'UseFocusTrapOptions', description: 'Config object.', required: true},
+      {name: 'options.isActive', type: 'boolean', description: 'Whether active.', required: true},
+      {name: 'options.onEscape', type: '() => void', description: 'Escape callback.', required: false},
+    ],
+    returns: [
+      {name: 'containerRef', type: 'React.RefObject<HTMLElement | null>', description: 'Ref to attach.'},
+      {name: 'focusFirst', type: '() => void', description: 'Focuses first element.'},
+    ],
+  };
+}
+
+describe('mergeTranslation — hook param/return descriptions', () => {
+  it('overrides param and return descriptions by name, preserving other fields', () => {
+    const merged = mergeTranslation(hookDocs(), {
+      paramDescriptions: {
+        options: 'Cfg.',
+        'options.onEscape': 'Esc cb.',
+      },
+      returnDescriptions: {
+        containerRef: 'Attach ref.',
+      },
+    });
+
+    // Translated params get the compressed description.
+    const options = merged.params.find(p => p.name === 'options');
+    expect(options.description).toBe('Cfg.');
+    expect(options.type).toBe('UseFocusTrapOptions');
+    expect(options.required).toBe(true);
+
+    // Untranslated param keeps original description.
+    const isActive = merged.params.find(p => p.name === 'options.isActive');
+    expect(isActive.description).toBe('Whether active.');
+    expect(isActive.required).toBe(true);
+
+    // Translated return.
+    const containerRef = merged.returns.find(r => r.name === 'containerRef');
+    expect(containerRef.description).toBe('Attach ref.');
+    expect(containerRef.type).toBe('React.RefObject<HTMLElement | null>');
+
+    // Untranslated return unchanged.
+    const focusFirst = merged.returns.find(r => r.name === 'focusFirst');
+    expect(focusFirst.description).toBe('Focuses first element.');
+  });
+
+  it('overrides a nested (dotted) param name correctly', () => {
+    const merged = mergeTranslation(hookDocs(), {
+      paramDescriptions: {'options.isActive': 'Active?'},
+    });
+
+    const isActive = merged.params.find(p => p.name === 'options.isActive');
+    expect(isActive.description).toBe('Active?');
+    expect(isActive.type).toBe('boolean');
+
+    // Sibling params untouched.
+    expect(merged.params.find(p => p.name === 'options').description).toBe('Config object.');
+  });
+
+  it('leaves params/returns untouched when translation has no param/return descriptions', () => {
+    const base = hookDocs();
+    const merged = mergeTranslation(base, {usage: {description: 'Dense desc.'}});
+
+    expect(merged.params).toEqual(base.params);
+    expect(merged.returns).toEqual(base.returns);
+    expect(merged.usage.description).toBe('Dense desc.');
+  });
+});
+
+describe('mergeTranslation — component prop descriptions (regression)', () => {
+  it('overrides prop descriptions by name, leaving others unchanged', () => {
+    const docs = {
+      name: 'Button',
+      usage: {description: 'English.'},
+      props: [
+        {name: 'variant', type: 'string', description: 'The variant.'},
+        {name: 'disabled', type: 'boolean', description: 'Disabled state.'},
+      ],
+    };
+
+    const merged = mergeTranslation(docs, {
+      usage: {description: 'Dense.'},
+      propDescriptions: {variant: 'Vrnt.'},
+    });
+
+    expect(merged.usage.description).toBe('Dense.');
+    expect(merged.props.find(p => p.name === 'variant').description).toBe('Vrnt.');
+    expect(merged.props.find(p => p.name === 'disabled').description).toBe('Disabled state.');
+  });
+});

package/src/lib/config.mjs

@@ -0,0 +1,74 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Config loader — reads astryx.config.mjs from project root
+ *
+ * Walks up from cwd looking for astryx.config.mjs.
+ * Returns the config object or defaults if not found.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {pathToFileURL} from 'node:url';
+
+const DEFAULTS = {
+  packages: [],
+};
+
+/**
+ * Find astryx.config.mjs by walking up from startDir.
+ * Returns the absolute path or null.
+ */
+export function findConfigPath(startDir = process.cwd()) {
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    const candidate = path.join(dir, 'astryx.config.mjs');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Load and return the config from astryx.config.mjs.
+ * Returns defaults if no config file is found.
+ */
+export async function loadConfig(startDir = process.cwd()) {
+  const configPath = findConfigPath(startDir);
+  if (!configPath) return {...DEFAULTS};
+
+  try {
+    const mod = await import(pathToFileURL(configPath).href);
+    const config = mod.default || {};
+    return {
+      ...DEFAULTS,
+      ...config,
+      packages: normalizePackages(config.packages, path.dirname(configPath)),
+    };
+  } catch {
+    return {...DEFAULTS};
+  }
+}
+
+/**
+ * Normalize packages to an array of unique absolute paths.
+ * Filters out empty strings and non-string values.
+ * Relative paths resolved from config file directory.
+ * Deduplicates by resolved path.
+ */
+function normalizePackages(packages, configDir) {
+  if (!packages) return [];
+  const arr = Array.isArray(packages) ? packages : [packages];
+  const seen = new Set();
+  const result = [];
+  for (const p of arr) {
+    if (typeof p !== 'string' || p === '') continue;
+    const resolved = path.isAbsolute(p) ? p : path.resolve(configDir, p);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    result.push(resolved);
+  }
+  return result;
+}

package/src/lib/error-codes.mjs

@@ -0,0 +1,197 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Astryx CLI — stable machine-readable error codes.
+ *
+ * ## Why codes exist
+ *
+ * The JSON error envelope (see json.mjs) carries a human-readable `error`
+ * string. That string is for people. It changes whenever we improve the
+ * wording, add detail, or localize. AI agents and CI scripts that consume
+ * `xds --json` must NOT branch on prose — string-matching "No component
+ * named X" is brittle and silently breaks the moment we reword it.
+ *
+ * The `code` field is the stable contract. Every error — whether raised by a
+ * command, the API layer (`AstryxError`), or Commander's own parse machinery —
+ * carries one of the identifiers below. Codes are append-only: once shipped,
+ * a code's meaning never changes and the code is never removed. The message
+ * may change freely; the code never does.
+ *
+ * ## Naming
+ *
+ * `ERR_<SUBJECT>[_<QUALIFIER>]`, SCREAMING_SNAKE_CASE, always prefixed
+ * `ERR_`. Group by subject (component, hook, docs, template, theme, …).
+ *
+ * ## Usage
+ *
+ *   import {ERROR_CODES} from './error-codes.mjs';
+ *   cliError('No component named "Buton"', {code: ERROR_CODES.ERR_UNKNOWN_COMPONENT});
+ *   throw new AstryxError('No component named "Buton"', suggestions, ERROR_CODES.ERR_UNKNOWN_COMPONENT);
+ *
+ * Consumers read `envelope.code` and compare against the published list in
+ * packages/cli/README.md.
+ */
+
+/**
+ * Stable error-code string union. Append-only.
+ *
+ * @typedef {(
+ *   | 'ERR_UNKNOWN'
+ *   | 'ERR_UNKNOWN_COMMAND'
+ *   | 'ERR_UNKNOWN_SUBCOMMAND'
+ *   | 'ERR_INVALID_OPTION'
+ *   | 'ERR_INVALID_ARGUMENT'
+ *   | 'ERR_MISSING_ARGUMENT'
+ *   | 'ERR_INVALID_LANG'
+ *   | 'ERR_INVALID_DETAIL'
+ *   | 'ERR_NODE_VERSION'
+ *   | 'ERR_CORE_NOT_FOUND'
+ *   | 'ERR_UNKNOWN_COMPONENT'
+ *   | 'ERR_UNKNOWN_HOOK'
+ *   | 'ERR_UNKNOWN_TOPIC'
+ *   | 'ERR_UNKNOWN_SECTION'
+ *   | 'ERR_UNKNOWN_CATEGORY'
+ *   | 'ERR_UNKNOWN_TEMPLATE'
+ *   | 'ERR_UNKNOWN_PACKAGE'
+ *   | 'ERR_UNKNOWN_AGENT'
+ *   | 'ERR_UNKNOWN_FEATURE'
+ *   | 'ERR_UNKNOWN_CODEMOD'
+ *   | 'ERR_NOT_FOUND'
+ *   | 'ERR_NO_DOC'
+ *   | 'ERR_NO_SHOWCASE'
+ *   | 'ERR_NO_SOURCE'
+ *   | 'ERR_INVALID_DOC'
+ *   | 'ERR_FILE_NOT_FOUND'
+ *   | 'ERR_FILE_EXISTS'
+ *   | 'ERR_PATH_TRAVERSAL'
+ *   | 'ERR_WRITE_FAILED'
+ *   | 'ERR_THEME_INVALID'
+ *   | 'ERR_THEME_LOAD'
+ *   | 'ERR_TEMPLATE_CONFIG'
+ *   | 'ERR_TEMPLATE_GET'
+ *   | 'ERR_VERSION_DETECT'
+ *   | 'ERR_INVALID_VERSION'
+ *   | 'ERR_DEP_MISSING'
+ *   | 'ERR_GH_CLI'
+ *   | 'ERR_GAP_REPORT_FAILED'
+ * )} ErrorCode
+ */
+
+/**
+ * The complete, frozen set of Astryx CLI error codes. Append-only.
+ * @type {Readonly<Record<ErrorCode, ErrorCode>>}
+ */
+export const ERROR_CODES = Object.freeze({
+  // ── Generic ──────────────────────────────────────────────────────
+  /** Fallback for any error without a more specific code. */
+  ERR_UNKNOWN: 'ERR_UNKNOWN',
+
+  // ── CLI parsing / dispatch (Commander + bare invocation) ─────────
+  /** A top-level command name was not recognized (e.g. `astryx bogus`). */
+  ERR_UNKNOWN_COMMAND: 'ERR_UNKNOWN_COMMAND',
+  /** A subcommand under a command group was not recognized (e.g. `astryx theme bogus`). */
+  ERR_UNKNOWN_SUBCOMMAND: 'ERR_UNKNOWN_SUBCOMMAND',
+  /** An unknown flag/option was passed (Commander `unknownOption`). */
+  ERR_INVALID_OPTION: 'ERR_INVALID_OPTION',
+  /** An option/argument had a value Commander's parser rejected. */
+  ERR_INVALID_ARGUMENT: 'ERR_INVALID_ARGUMENT',
+  /** A required positional argument was omitted (Commander `missingArgument`). */
+  ERR_MISSING_ARGUMENT: 'ERR_MISSING_ARGUMENT',
+  /** `--lang` was given a value outside its choices (en, zh, dense). */
+  ERR_INVALID_LANG: 'ERR_INVALID_LANG',
+  /** `--detail` was given a value outside its choices (full, compact, brief). */
+  ERR_INVALID_DETAIL: 'ERR_INVALID_DETAIL',
+
+  // ── Environment / runtime ────────────────────────────────────────
+  /** The running Node.js version is below the supported minimum. */
+  ERR_NODE_VERSION: 'ERR_NODE_VERSION',
+  /** `@astryxdesign/core` could not be located (not installed / not in a monorepo). */
+  ERR_CORE_NOT_FOUND: 'ERR_CORE_NOT_FOUND',
+
+  // ── "Unknown <subject>" lookups ──────────────────────────────────
+  /** No component matched the requested name. */
+  ERR_UNKNOWN_COMPONENT: 'ERR_UNKNOWN_COMPONENT',
+  /** No hook matched the requested name. */
+  ERR_UNKNOWN_HOOK: 'ERR_UNKNOWN_HOOK',
+  /** No docs topic matched the requested name. */
+  ERR_UNKNOWN_TOPIC: 'ERR_UNKNOWN_TOPIC',
+  /** A docs topic exists but the requested section within it does not. */
+  ERR_UNKNOWN_SECTION: 'ERR_UNKNOWN_SECTION',
+  /** A `--category` filter value did not match any known category. */
+  ERR_UNKNOWN_CATEGORY: 'ERR_UNKNOWN_CATEGORY',
+  /** No template matched the requested name. */
+  ERR_UNKNOWN_TEMPLATE: 'ERR_UNKNOWN_TEMPLATE',
+  /** No package matched the requested name (discover). */
+  ERR_UNKNOWN_PACKAGE: 'ERR_UNKNOWN_PACKAGE',
+  /** An unrecognized `--agent` value was passed to agent-docs/init. */
+  ERR_UNKNOWN_AGENT: 'ERR_UNKNOWN_AGENT',
+  /** An unrecognized `--features` value was passed to init. */
+  ERR_UNKNOWN_FEATURE: 'ERR_UNKNOWN_FEATURE',
+  /** A `--codemod` value did not match any registered codemod (upgrade). */
+  ERR_UNKNOWN_CODEMOD: 'ERR_UNKNOWN_CODEMOD',
+  /** A generic discover/lookup query matched nothing in any package. */
+  ERR_NOT_FOUND: 'ERR_NOT_FOUND',
+
+  // ── Resource shape problems (subject exists, artifact missing) ───
+  /** A component exists but has no typed `.doc.mjs` file. */
+  ERR_NO_DOC: 'ERR_NO_DOC',
+  /** No showcase exists for the requested component. */
+  ERR_NO_SHOWCASE: 'ERR_NO_SHOWCASE',
+  /** No source file could be located for the requested component/template. */
+  ERR_NO_SOURCE: 'ERR_NO_SOURCE',
+  /** A component's docs failed validation (malformed `.doc.mjs`). */
+  ERR_INVALID_DOC: 'ERR_INVALID_DOC',
+
+  // ── Filesystem ───────────────────────────────────────────────────
+  /** A required input file did not exist. */
+  ERR_FILE_NOT_FOUND: 'ERR_FILE_NOT_FOUND',
+  /** Refused to overwrite an existing file in non-interactive mode. */
+  ERR_FILE_EXISTS: 'ERR_FILE_EXISTS',
+  /** A path escaped its allowed root, or a name contained traversal markers. */
+  ERR_PATH_TRAVERSAL: 'ERR_PATH_TRAVERSAL',
+  /** Writing output files failed (and was rolled back). */
+  ERR_WRITE_FAILED: 'ERR_WRITE_FAILED',
+
+  // ── Theme build ──────────────────────────────────────────────────
+  /** A theme definition was missing a required property (e.g. `name`). */
+  ERR_THEME_INVALID: 'ERR_THEME_INVALID',
+  /** A theme file could not be loaded / parsed into a defineTheme result. */
+  ERR_THEME_LOAD: 'ERR_THEME_LOAD',
+
+  // ── Template config ──────────────────────────────────────────────
+  /** `template.get` is not configured in astryx.config.mjs (fetch-by-id). */
+  ERR_TEMPLATE_CONFIG: 'ERR_TEMPLATE_CONFIG',
+  /** A configured `template.get` threw or returned an invalid value. */
+  ERR_TEMPLATE_GET: 'ERR_TEMPLATE_GET',
+
+  // ── Upgrade ──────────────────────────────────────────────────────
+  /** The current `@astryxdesign/core` version could not be detected. */
+  ERR_VERSION_DETECT: 'ERR_VERSION_DETECT',
+  /** A `--from`/`--to` value was not a valid semver string. */
+  ERR_INVALID_VERSION: 'ERR_INVALID_VERSION',
+  /** A required external dependency (e.g. jscodeshift) is missing. */
+  ERR_DEP_MISSING: 'ERR_DEP_MISSING',
+
+  // ── Gap report ───────────────────────────────────────────────────
+  /** GitHub CLI (`gh`) is not installed or not authenticated. */
+  ERR_GH_CLI: 'ERR_GH_CLI',
+  /** Filing a gap report failed at the command/integration boundary. */
+  ERR_GAP_REPORT_FAILED: 'ERR_GAP_REPORT_FAILED',
+});
+
+/**
+ * Type guard: is `value` one of the known error codes?
+ * @param {unknown} value
+ * @returns {value is ErrorCode}
+ */
+export function isErrorCode(value) {
+  return typeof value === 'string' && Object.hasOwn(ERROR_CODES, value);
+}
+
+/**
+ * All error code string values, sorted. Handy for tests and tooling.
+ * @returns {string[]}
+ */
+export function allErrorCodes() {
+  return Object.values(ERROR_CODES).sort();
+}

package/src/lib/error-codes.test.mjs

@@ -0,0 +1,152 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Tests for the stable error-code contract.
+ *
+ * Two layers:
+ *
+ *   1. Unit — the taxonomy itself: every code is a non-empty, unique,
+ *      stable string; the object is frozen; helpers behave.
+ *
+ *   2. End-to-end — spawn the CLI as a subprocess and assert that
+ *      representative error paths emit the right `code` in their JSON
+ *      envelope. Spawning is the only way to exercise Commander hooks,
+ *      the json-shim, and the bin error boundary together.
+ */
+
+import {describe, it, expect} from 'vitest';
+import {spawnSync} from 'node:child_process';
+import * as path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {ERROR_CODES, isErrorCode, allErrorCodes} from './error-codes.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_BIN = path.resolve(__dirname, '../../bin/astryx.mjs');
+
+function runCli(args, {cwd} = {}) {
+  const res = spawnSync('node', [CLI_BIN, ...args], {
+    cwd: cwd || process.cwd(),
+    encoding: 'utf-8',
+    timeout: 20_000,
+  });
+  return {
+    status: res.status,
+    stdout: res.stdout || '',
+    stderr: res.stderr || '',
+  };
+}
+
+/** Parse the JSON envelope from stdout. Throws if stdout isn't clean JSON. */
+function envelope(stdout) {
+  return JSON.parse(stdout);
+}
+
+describe('error-codes taxonomy', () => {
+  it('every code is a non-empty string', () => {
+    for (const [key, value] of Object.entries(ERROR_CODES)) {
+      expect(typeof value).toBe('string');
+      expect(value.length).toBeGreaterThan(0);
+      // Key and value must match — the object is a string enum.
+      expect(value).toBe(key);
+    }
+  });
+
+  it('every code follows the ERR_ naming convention', () => {
+    for (const value of Object.values(ERROR_CODES)) {
+      expect(value).toMatch(/^ERR_[A-Z0-9_]+$/);
+    }
+  });
+
+  it('all codes are unique', () => {
+    const values = Object.values(ERROR_CODES);
+    expect(new Set(values).size).toBe(values.length);
+  });
+
+  it('includes the generic fallback', () => {
+    expect(ERROR_CODES.ERR_UNKNOWN).toBe('ERR_UNKNOWN');
+  });
+
+  it('the taxonomy object is frozen (codes are stable, append-only)', () => {
+    expect(Object.isFrozen(ERROR_CODES)).toBe(true);
+    expect(() => {
+      // @ts-expect-error - intentional mutation attempt
+      ERROR_CODES.ERR_NEW = 'ERR_NEW';
+    }).toThrow();
+    expect(ERROR_CODES.ERR_NEW).toBeUndefined();
+  });
+
+  it('isErrorCode recognizes known codes and rejects others', () => {
+    expect(isErrorCode('ERR_UNKNOWN_COMPONENT')).toBe(true);
+    expect(isErrorCode('ERR_UNKNOWN')).toBe(true);
+    expect(isErrorCode('ERR_NOT_A_REAL_CODE')).toBe(false);
+    expect(isErrorCode('')).toBe(false);
+    expect(isErrorCode(42)).toBe(false);
+    expect(isErrorCode(undefined)).toBe(false);
+  });
+
+  it('allErrorCodes returns the sorted, complete set', () => {
+    const codes = allErrorCodes();
+    expect(codes.length).toBe(Object.keys(ERROR_CODES).length);
+    expect(codes).toEqual([...codes].sort());
+    expect(codes).toContain('ERR_UNKNOWN');
+    expect(codes).toContain('ERR_UNKNOWN_COMPONENT');
+  });
+});
+
+describe('error codes: end-to-end JSON envelopes', () => {
+  const cases = [
+    {name: 'unknown component', args: ['component', 'Bogus', '--json'], code: 'ERR_UNKNOWN_COMPONENT'},
+    {name: 'unknown hook', args: ['hook', 'bogusHook', '--json'], code: 'ERR_UNKNOWN_HOOK'},
+    {name: 'unknown topic', args: ['docs', 'bogusTopic', '--json'], code: 'ERR_UNKNOWN_TOPIC'},
+    {name: 'unknown template', args: ['template', 'bogusTemplate', '--json'], code: 'ERR_UNKNOWN_TEMPLATE'},
+    {name: 'unknown command', args: ['bogus-cmd', '--json'], code: 'ERR_UNKNOWN_COMMAND'},
+    {name: 'invalid --lang', args: ['docs', 'color', '--lang', 'fr', '--json'], code: 'ERR_INVALID_LANG'},
+    {name: 'invalid --detail', args: ['docs', 'color', '--detail', 'bogus', '--json'], code: 'ERR_INVALID_DETAIL'},
+    {name: 'unknown option', args: ['component', 'Button', '--bogus-flag', '--json'], code: 'ERR_INVALID_OPTION'},
+    {name: 'missing argument', args: ['theme', 'build', '--json'], code: 'ERR_MISSING_ARGUMENT'},
+    // `theme` is not on the --json allowlist, so --json on any theme subcommand
+    // is rejected at the preAction gate with a stable invalid-option code.
+    {name: 'json not supported', args: ['theme', 'bogus-sub', '--json'], code: 'ERR_INVALID_OPTION'},
+  ];
+
+  for (const {name, args, code} of cases) {
+    it(`${name} → ${code}`, () => {
+      const {status, stdout} = runCli(args);
+      expect(status).toBe(1);
+      const env = envelope(stdout);
+      expect(env).toHaveProperty('apiVersion');
+      expect(env).toHaveProperty('error');
+      expect(env.code).toBe(code);
+      // The code must be a recognized member of the taxonomy.
+      expect(isErrorCode(env.code)).toBe(true);
+    });
+  }
+
+  it('every error envelope carries a code (even unmatched paths fall back to ERR_UNKNOWN)', () => {
+    const {stdout} = runCli(['component', 'Bogus', '--json']);
+    const env = envelope(stdout);
+    expect(typeof env.code).toBe('string');
+    expect(env.code.length).toBeGreaterThan(0);
+  });
+});
+
+describe('error codes: human mode stays clean', () => {
+  it('the code is NOT printed in the human-facing error line', () => {
+    const {status, stderr, stdout} = runCli(['component', 'Bogus']);
+    expect(status).toBe(1);
+    // Human output goes to stderr and must not leak the machine code.
+    expect(stderr).toContain('No component named');
+    expect(stderr).not.toContain('ERR_UNKNOWN_COMPONENT');
+    expect(stdout).not.toContain('ERR_UNKNOWN_COMPONENT');
+  });
+
+  it('unknown subcommand exits 1 in human mode (code carried internally)', () => {
+    // `theme` is not JSON-capable, so this path is human-only; we assert the
+    // failure surfaces with exit 1 and a helpful message. The stable
+    // ERR_UNKNOWN_SUBCOMMAND code rides along on the cliError call.
+    const {status, stderr} = runCli(['theme', 'bogus-sub']);
+    expect(status).toBe(1);
+    expect(stderr).toContain("unknown subcommand 'theme bogus-sub'");
+    expect(stderr).not.toContain('ERR_UNKNOWN_SUBCOMMAND');
+  });
+});