@a5c-ai/babysitter-codex 0.1.6-staging.2dca8387

package/commands/yolo.md

@@ -0,0 +1,28 @@
+---
+description: Start a non-interactive autonomous orchestration run (no breakpoints).
+argument-hint: Specific instructions for the run
+---
+
+# babysitter:yolo
+
+## Purpose
+
+Start a non-interactive autonomous orchestration run (no breakpoints).
+
+## Usage
+
+```text
+babysitter yolo Specific instructions for the run
+```
+
+## Example
+
+```text
+babysitter yolo fix lint and failing tests
+```
+
+## Notes
+
+- Use command phrases in Codex chat (`babysitter ...`), not custom slash commands.
+- Autonomous progression still uses the hook-first runtime; yolo mode only auto-approves breakpoints.
+- If SDK capabilities are missing in your installed version, babysitter-codex falls back to compatibility behavior where possible.

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@a5c-ai/babysitter-codex",
+  "version": "0.1.6-staging.2dca8387",
+  "description": "Babysitter Codex skill bundle and integration package for OpenAI Codex CLI with SDK-managed process-library bootstrapping, 15 orchestration modes, and BOM-safe SKILL installation",
+  "scripts": {
+    "test": "node test/integration.test.js && node test/packaged-install.test.js",
+    "test:integration": "node test/integration.test.js",
+    "check:mapping": "node scripts/check-mapping-contract.js",
+    "team:install": "node scripts/team-install.js",
+    "lint": "find .codex -name '*.js' | xargs -I{} node --check {}",
+    "deploy": "npm publish --access public",
+    "deploy:staging": "npm publish --access public --tag staging",
+    "postinstall": "node bin/postinstall.js",
+    "preuninstall": "node bin/uninstall.js"
+  },
+  "files": [
+    "SKILL.md",
+    "AGENTS.md",
+    "CHANGELOG.md",
+    "agents/",
+    "commands/",
+    ".codex/",
+    "bin/",
+    "scripts/",
+    "test/",
+    "babysitter.lock.json",
+    "README.md"
+  ],
+  "keywords": [
+    "babysitter",
+    "codex",
+    "orchestration",
+    "ai-agent",
+    "sdk-integration",
+    "codex-skill"
+  ],
+  "author": "a5c.ai",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/a5c-ai/babysitter"
+  },
+  "homepage": "https://github.com/a5c-ai/babysitter/tree/main/plugins/babysitter-codex#readme",
+  "dependencies": {
+    "@a5c-ai/babysitter-sdk": "0.0.183-staging.2dca8387"
+  }
+}

package/scripts/team-install.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function parseArgs(argv) {
+  const args = {
+    workspace: process.cwd(),
+    dryRun: false,
+  };
+  for (let i = 2; i < argv.length; i += 1) {
+    if (argv[i] === '--workspace' && argv[i + 1]) {
+      args.workspace = path.resolve(argv[++i]);
+    } else if (argv[i] === '--dry-run') {
+      args.dryRun = true;
+    }
+  }
+  return args;
+}
+
+function renderWorkspaceConfigToml() {
+  return [
+    'approval_policy = "on-request"',
+    'sandbox_mode = "workspace-write"',
+    'project_doc_max_bytes = 65536',
+    '',
+    '[sandbox_workspace_write]',
+    'writable_roots = [".a5c", ".codex"]',
+    '',
+    '[features]',
+    'codex_hooks = true',
+    'multi_agent = true',
+    '',
+    '[agents]',
+    'max_depth = 3',
+    'max_threads = 4',
+    '',
+  ].join('\n');
+}
+
+function resolveSdkCli(packageRoot) {
+  if (process.env.BABYSITTER_SDK_CLI) {
+    return path.resolve(process.env.BABYSITTER_SDK_CLI);
+  }
+  try {
+    return require.resolve('@a5c-ai/babysitter-sdk/dist/cli/main.js', {
+      paths: [packageRoot],
+    });
+  } catch (error) {
+    throw new Error(`could not resolve Babysitter SDK CLI entrypoint: ${error.message}`);
+  }
+}
+
+function runBabysitterCli(packageRoot, cliArgs, options = {}) {
+  const cliMain = resolveSdkCli(packageRoot);
+  const result = spawnSync(process.execPath, [cliMain, ...cliArgs], {
+    cwd: options.cwd || process.cwd(),
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ...(options.env || {}),
+    },
+  });
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '').trim();
+    const stdout = (result.stdout || '').trim();
+    throw new Error(
+      `babysitter ${cliArgs.join(' ')} failed` +
+      (stderr ? `: ${stderr}` : stdout ? `: ${stdout}` : ''),
+    );
+  }
+  return result.stdout;
+}
+
+function resolveProcessLibrarySpec(lock, workspaceRoot) {
+  const processLibraryConfig = (lock && lock.content && (lock.content.processLibrary || lock.content.upstream)) || {};
+  const repo = process.env.BABYSITTER_PROCESS_LIBRARY_REPO || processLibraryConfig.repo;
+  if (!repo) {
+    throw new Error('missing process-library repo configuration in babysitter.lock.json');
+  }
+  const ref = process.env.BABYSITTER_PROCESS_LIBRARY_REF || processLibraryConfig.ref || '';
+  const cloneDir = path.join(workspaceRoot, '.a5c', 'process-library', 'babysitter-repo');
+  const processSubpath = process.env.BABYSITTER_PROCESS_LIBRARY_SUBPATH ||
+    processLibraryConfig.processSubpath ||
+    'library';
+  const referenceSubpath = process.env.BABYSITTER_PROCESS_LIBRARY_REFERENCE_SUBPATH ||
+    processLibraryConfig.referenceSubpath ||
+    'library/reference';
+  return {
+    repo,
+    ref: ref || undefined,
+    cloneDir,
+    processRoot: path.join(cloneDir, ...processSubpath.split('/')),
+    referenceRoot: path.join(cloneDir, ...referenceSubpath.split('/')),
+    stateDir: path.join(workspaceRoot, '.a5c'),
+  };
+}
+
+function ensureActiveProcessLibrary(packageRoot, lock, workspaceRoot, dryRun) {
+  const spec = resolveProcessLibrarySpec(lock, workspaceRoot);
+  const cloneExists = fs.existsSync(path.join(spec.cloneDir, '.git'));
+  const cloneArgs = cloneExists
+    ? ['process-library:update', '--dir', spec.cloneDir, '--json']
+    : ['process-library:clone', '--repo', spec.repo, '--dir', spec.cloneDir, '--json'];
+  if (spec.ref) {
+    cloneArgs.splice(cloneExists ? 3 : 5, 0, '--ref', spec.ref);
+  }
+  const useArgs = ['process-library:use', '--dir', spec.processRoot, '--state-dir', spec.stateDir, '--json'];
+  const activeArgs = ['process-library:active', '--state-dir', spec.stateDir, '--json'];
+
+  if (dryRun) {
+    return {
+      ...spec,
+      plannedCommands: [
+        `babysitter ${cloneArgs.join(' ')}`,
+        `babysitter ${useArgs.join(' ')}`,
+        `babysitter ${activeArgs.join(' ')}`,
+      ],
+      activeStateFile: path.join(spec.stateDir, 'active', 'process-library.json'),
+      binding: null,
+    };
+  }
+
+  runBabysitterCli(packageRoot, cloneArgs, { cwd: workspaceRoot });
+  if (!fs.existsSync(spec.processRoot)) {
+    throw new Error(`fetched process library root is missing: ${spec.processRoot}`);
+  }
+  runBabysitterCli(packageRoot, useArgs, { cwd: workspaceRoot });
+  const active = JSON.parse(runBabysitterCli(packageRoot, activeArgs, { cwd: workspaceRoot }));
+  return {
+    ...spec,
+    plannedCommands: [],
+    activeStateFile: active.stateFile,
+    binding: active.binding || null,
+  };
+}
+
+function buildHooksConfig(packageRoot) {
+  return {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: '*',
+          hooks: [
+            {
+              type: 'command',
+              command: path.join(packageRoot, '.codex', 'hooks', 'babysitter-session-start.sh'),
+            },
+          ],
+        },
+      ],
+      UserPromptSubmit: [
+        {
+          matcher: '*',
+          hooks: [
+            {
+              type: 'command',
+              command: path.join(packageRoot, '.codex', 'hooks', 'user-prompt-submit.sh'),
+            },
+          ],
+        },
+      ],
+      Stop: [
+        {
+          matcher: '*',
+          hooks: [
+            {
+              type: 'command',
+              command: path.join(packageRoot, '.codex', 'hooks', 'babysitter-stop-hook.sh'),
+            },
+          ],
+        },
+      ],
+    },
+  };
+}
+
+function main() {
+  const packageRoot = path.resolve(__dirname, '..');
+  const args = parseArgs(process.argv);
+  const workspaceRoot = args.workspace;
+  const lockPath = path.join(packageRoot, 'babysitter.lock.json');
+  if (!fs.existsSync(lockPath)) {
+    throw new Error(`missing lock file: ${lockPath}`);
+  }
+  const lock = readJson(lockPath);
+  const workspaceHooksConfigPath = path.join(workspaceRoot, '.codex', 'hooks.json');
+  const workspaceConfigPath = path.join(workspaceRoot, '.codex', 'config.toml');
+  const processLibrary = ensureActiveProcessLibrary(packageRoot, lock, workspaceRoot, args.dryRun);
+  const installInfo = {
+    installedAt: new Date().toISOString(),
+    runtime: lock.runtime,
+    content: lock.content,
+    lockVersion: lock.version,
+    packageRoot,
+    workspaceRoot,
+    workspaceConfigPath,
+    workspaceHooksConfigPath,
+    hookScriptsRoot: path.join(packageRoot, '.codex', 'hooks'),
+    processLibraryRepo: processLibrary.repo,
+    ...(processLibrary.ref ? { processLibraryRef: processLibrary.ref } : {}),
+    processLibraryCloneDir: processLibrary.cloneDir,
+    processLibraryRoot: processLibrary.processRoot,
+    processLibraryReferenceRoot: processLibrary.referenceRoot,
+    processLibraryStateFile: processLibrary.activeStateFile,
+  };
+
+  if (args.dryRun) {
+    console.log(JSON.stringify({
+      ok: true,
+      dryRun: true,
+      installInfo,
+      processLibrary: {
+        repo: processLibrary.repo,
+        ...(processLibrary.ref ? { ref: processLibrary.ref } : {}),
+        cloneDir: processLibrary.cloneDir,
+        processRoot: processLibrary.processRoot,
+        referenceRoot: processLibrary.referenceRoot,
+        stateFile: processLibrary.activeStateFile,
+        plannedCommands: processLibrary.plannedCommands,
+      },
+    }, null, 2));
+    return;
+  }
+
+  const outDir = path.join(workspaceRoot, '.a5c', 'team');
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.mkdirSync(path.dirname(workspaceHooksConfigPath), { recursive: true });
+  fs.writeFileSync(workspaceHooksConfigPath, JSON.stringify(buildHooksConfig(packageRoot), null, 2), 'utf8');
+  if (!fs.existsSync(workspaceConfigPath)) {
+    fs.writeFileSync(workspaceConfigPath, renderWorkspaceConfigToml(), 'utf8');
+  }
+  fs.writeFileSync(path.join(outDir, 'install.json'), JSON.stringify(installInfo, null, 2), 'utf8');
+
+  const profilePath = path.join(outDir, 'profile.json');
+  if (!fs.existsSync(profilePath)) {
+    fs.writeFileSync(profilePath, JSON.stringify({
+      teamName: 'default',
+      installedSkillRoot: packageRoot,
+      workspaceConfigPath,
+      workspaceHooksConfigPath,
+      hookScriptsRoot: path.join(packageRoot, '.codex', 'hooks'),
+      processLibraryLookupCommand: 'babysitter process-library:active --state-dir .a5c --json',
+    }, null, 2), 'utf8');
+  }
+
+  console.log('[team-install] complete');
+}
+
+main();

package/test/integration.test.js

@@ -0,0 +1,69 @@
+'use strict';
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+const CODEX_DIR = path.join(PROJECT_ROOT, '.codex');
+const BIN_DIR = path.join(PROJECT_ROOT, 'bin');
+
+// Test: All JS files pass node --check
+function testSyntax() {
+  const jsFiles = [];
+  // Collect all JS files
+  function collectJs(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== 'node_modules') collectJs(full);
+      else if (entry.isFile() && entry.name.endsWith('.js')) jsFiles.push(full);
+    }
+  }
+  collectJs(CODEX_DIR);
+  if (fs.existsSync(BIN_DIR)) collectJs(BIN_DIR);
+
+  let passed = 0;
+  for (const file of jsFiles) {
+    try {
+      execFileSync('node', ['--check', file], { encoding: 'utf8' });
+      passed++;
+    } catch (err) {
+      console.error(`  ✗ Syntax error in ${path.relative(PROJECT_ROOT, file)}`);
+      throw err;
+    }
+  }
+  console.log(`  ✓ syntax: ${passed} JS files pass node --check`);
+}
+
+// Test: Shell hook scripts have valid syntax
+function testShellSyntax() {
+  const shellScripts = [
+    'hooks/babysitter-session-start.sh',
+    'hooks/babysitter-stop-hook.sh',
+    'hooks/user-prompt-submit.sh',
+  ];
+
+  for (const script of shellScripts) {
+    const shellFile = path.join(CODEX_DIR, script);
+    if (!fs.existsSync(shellFile)) {
+      throw new Error(`Expected shell script not found: ${script}`);
+    }
+    try {
+      execFileSync('sh', ['-n', shellFile], { encoding: 'utf8' });
+      console.log(`  ✓ shell: ${script} passes sh -n`);
+    } catch (err) {
+      console.error(`  ✗ ${script} has syntax errors`);
+      throw err;
+    }
+  }
+}
+
+console.log('Integration Tests:');
+try {
+  testSyntax();
+  testShellSyntax();
+  console.log('\nAll integration tests passed!');
+} catch (err) {
+  console.error('\nTest failed:', err.message);
+  process.exit(1);
+}

package/test/packaged-install.test.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+
+function run(cmd, args, options = {}) {
+  const execOptions = {
+    cwd: PROJECT_ROOT,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    maxBuffer: 20 * 1024 * 1024,
+    ...options,
+  };
+  if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(cmd)) {
+    return execFileSync(cmd, args, {
+      ...execOptions,
+      shell: true,
+    });
+  }
+  return execFileSync(cmd, args, execOptions);
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function copyTree(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.cpSync(src, dest, { recursive: true });
+}
+
+function assertExists(root, relativePath) {
+  const full = path.join(root, relativePath);
+  assert.ok(fs.existsSync(full), `Missing installed payload: ${relativePath}`);
+  return full;
+}
+
+function cliPath(filePath) {
+  return process.platform === 'win32' ? String(filePath).replace(/\\/g, '/') : filePath;
+}
+
+function resolveNpmCommand() {
+  if (process.platform !== 'win32') return 'npm';
+  return path.join(path.dirname(process.execPath), 'npm.cmd');
+}
+
+console.log('Packaged Install Tests:');
+
+let tmpRoot;
+let packedTgzPath;
+try {
+  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'babysitter-codex-pack-'));
+  const extractDir = path.join(tmpRoot, 'extract');
+  const codexHome = path.join(tmpRoot, 'codex-home');
+  const workspaceRoot = path.join(tmpRoot, 'workspace');
+  const processLibraryRepoRoot = path.join(tmpRoot, 'process-library-source');
+  fs.mkdirSync(extractDir, { recursive: true });
+  fs.mkdirSync(codexHome, { recursive: true });
+  fs.mkdirSync(workspaceRoot, { recursive: true });
+  copyTree(
+    path.join(PROJECT_ROOT, '..', '..', 'library'),
+    path.join(processLibraryRepoRoot, 'library'),
+  );
+  run('git', ['init'], { cwd: processLibraryRepoRoot });
+  run('git', ['config', 'gc.auto', '0'], { cwd: processLibraryRepoRoot });
+  run('git', ['config', 'maintenance.auto', 'false'], { cwd: processLibraryRepoRoot });
+  run('git', ['add', '.'], { cwd: processLibraryRepoRoot });
+  run(
+    'git',
+    ['-c', 'user.name=Babysitter Test', '-c', 'user.email=test@example.com', 'commit', '-m', 'seed process library'],
+    { cwd: processLibraryRepoRoot },
+  );
+
+  const packInfo = JSON.parse(run(resolveNpmCommand(), ['pack', '--json']).trim());
+  packedTgzPath = path.join(PROJECT_ROOT, packInfo[0].filename);
+  const tarArgs = process.platform === 'win32'
+    ? ['--force-local', '-xf', cliPath(packedTgzPath), '-C', cliPath(extractDir)]
+    : ['-xf', packedTgzPath, '-C', extractDir];
+  run('tar', tarArgs);
+
+  const packagedRoot = path.join(extractDir, 'package');
+  const installOutput = run(process.execPath, ['bin/postinstall.js'], {
+    cwd: packagedRoot,
+    env: {
+      ...process.env,
+      BABYSITTER_SDK_CLI: path.join(PROJECT_ROOT, '..', '..', 'packages', 'sdk', 'dist', 'cli', 'main.js'),
+      BABYSITTER_PROCESS_LIBRARY_REPO: processLibraryRepoRoot,
+      CODEX_HOME: codexHome,
+      INIT_CWD: workspaceRoot,
+    },
+  });
+  assert.ok(installOutput.includes('Installation complete!'));
+
+  const installedSkillRoot = path.join(codexHome, 'skills', 'babysitter-codex');
+  [
+    'SKILL.md',
+    'AGENTS.md',
+    'README.md',
+    'agents',
+    '.codex',
+    'bin',
+    'commands',
+    'scripts',
+    'babysitter.lock.json',
+  ].forEach((relativePath) => assertExists(installedSkillRoot, relativePath));
+  assert.ok(!fs.existsSync(path.join(installedSkillRoot, 'upstream')), 'installed package should not bundle upstream content');
+  assert.ok(!fs.existsSync(path.join(installedSkillRoot, 'config')), 'installed package should not ship redundant config payload');
+  assert.ok(!fs.existsSync(path.join(installedSkillRoot, 'docs')), 'installed package should not ship redundant docs payload');
+
+  const skillBytes = fs.readFileSync(path.join(installedSkillRoot, 'SKILL.md'));
+  const hasBom = skillBytes.length >= 3 && skillBytes[0] === 0xef && skillBytes[1] === 0xbb && skillBytes[2] === 0xbf;
+  assert.strictEqual(hasBom, false, 'Installed SKILL.md should not contain a UTF-8 BOM');
+  const installedSkill = fs.readFileSync(path.join(installedSkillRoot, 'SKILL.md'), 'utf8');
+  assert.ok(installedSkill.includes('SessionStart'));
+  assert.ok(installedSkill.includes('Stop'));
+  const homeConfig = fs.readFileSync(path.join(codexHome, 'config.toml'), 'utf8');
+  assert.ok(homeConfig.includes('codex_hooks = true'));
+  assert.ok(homeConfig.includes('multi_agent = true'));
+
+  const teamInstallOutput = run(process.execPath, [path.join(installedSkillRoot, 'scripts', 'team-install.js')], {
+    cwd: workspaceRoot,
+    env: {
+      ...process.env,
+      BABYSITTER_PACKAGE_ROOT: installedSkillRoot,
+      BABYSITTER_SDK_CLI: path.join(PROJECT_ROOT, '..', '..', 'packages', 'sdk', 'dist', 'cli', 'main.js'),
+      BABYSITTER_PROCESS_LIBRARY_REPO: processLibraryRepoRoot,
+    },
+  });
+  assert.ok(teamInstallOutput.includes('[team-install] complete'));
+  assert.ok(fs.existsSync(path.join(workspaceRoot, '.codex', 'hooks.json')));
+  assert.ok(fs.existsSync(path.join(workspaceRoot, '.codex', 'config.toml')));
+
+  const installJson = readJson(path.join(workspaceRoot, '.a5c', 'team', 'install.json'));
+  const profileJson = readJson(path.join(workspaceRoot, '.a5c', 'team', 'profile.json'));
+
+  assert.strictEqual(path.resolve(installJson.packageRoot), path.resolve(installedSkillRoot));
+  assert.strictEqual(path.resolve(installJson.workspaceRoot), path.resolve(workspaceRoot));
+  assert.strictEqual(
+    path.resolve(installJson.workspaceHooksConfigPath),
+    path.resolve(path.join(workspaceRoot, '.codex', 'hooks.json')),
+  );
+  assert.strictEqual(
+    path.resolve(installJson.workspaceConfigPath),
+    path.resolve(path.join(workspaceRoot, '.codex', 'config.toml')),
+  );
+  assert.strictEqual(
+    path.resolve(installJson.hookScriptsRoot),
+    path.resolve(path.join(installedSkillRoot, '.codex', 'hooks')),
+  );
+  assert.strictEqual(path.resolve(installJson.processLibraryCloneDir), path.resolve(path.join(workspaceRoot, '.a5c', 'process-library', 'babysitter-repo')));
+  assert.strictEqual(path.resolve(installJson.processLibraryRoot), path.resolve(path.join(installJson.processLibraryCloneDir, 'library')));
+  assert.strictEqual(path.resolve(installJson.processLibraryReferenceRoot), path.resolve(path.join(installJson.processLibraryCloneDir, 'library', 'reference')));
+  assert.strictEqual(
+    path.resolve(installJson.processLibraryStateFile),
+    path.resolve(path.join(workspaceRoot, '.a5c', 'active', 'process-library.json')),
+  );
+  assert.strictEqual(path.resolve(profileJson.installedSkillRoot), path.resolve(installedSkillRoot));
+  assert.ok(!('processLibraryRoot' in profileJson), 'team profile should not pin an active process-library root');
+  assert.ok(!('rulesLayer' in profileJson), 'team profile should not emit a missing rules layer path');
+  assert.ok(String(profileJson.processLibraryLookupCommand || '').includes('process-library:active'));
+  assert.strictEqual(
+    path.resolve(profileJson.workspaceHooksConfigPath),
+    path.resolve(path.join(workspaceRoot, '.codex', 'hooks.json')),
+  );
+  assert.strictEqual(
+    path.resolve(profileJson.workspaceConfigPath),
+    path.resolve(path.join(workspaceRoot, '.codex', 'config.toml')),
+  );
+  assert.strictEqual(
+    path.resolve(profileJson.hookScriptsRoot),
+    path.resolve(path.join(installedSkillRoot, '.codex', 'hooks')),
+  );
+
+  console.log('  ok packed install includes the portable skill payload and team-install paths');
+  console.log('\nPackaged install tests passed!');
+} catch (err) {
+  console.error('\nTest failed:', err.message);
+  process.exitCode = 1;
+} finally {
+  if (packedTgzPath && fs.existsSync(packedTgzPath)) {
+    fs.rmSync(packedTgzPath, { force: true });
+  }
+  if (tmpRoot) {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+}