@a5c-ai/babysitter-cursor 5.0.1-staging.e4f17eff → 5.0.1-staging.e920fef118ef

package/README.md

@@ -19,13 +19,13 @@ hooks so Cursor can execute Babysitter commands and hook scripts directly.
 
 ## Installation
 
-Install the SDK CLI first:
+Install the Babysitter CLI once:
 
 ```bash
-npm install -g @a5c-ai/babysitter-sdk
+npm install -g @a5c-ai/babysitter
 ```
 
-### Via Cursor Marketplace (recommended)
+### Via Cursor Marketplace
 
 Install through Cursor's marketplace UI using the repo-root
 `/.cursor-plugin/marketplace.json` manifest:
@@ -34,10 +34,16 @@ Install through Cursor's marketplace UI using the repo-root
 2. Open the marketplace entry named **a5c-ai**
 3. Install the plugin named **babysitter**
 
-### Via Babysitter harness install
+### Via Babysitter harness install (recommended for automation)
+
+Use the SDK helper for scriptable global or workspace installs. This resolves to `npx --yes @a5c-ai/babysitter-cursor install ...` under the hood:
 
 ```bash
+# Global install
 babysitter harness:install-plugin cursor
+
+# Workspace install
+babysitter harness:install-plugin cursor --workspace /path/to/repo
 ```
 
 If the workspace does not already have an active process-library binding, the
@@ -51,18 +57,18 @@ babysitter process-library:active --json
 
 For local development or environments without marketplace access:
 
-#### Via npm
+#### Via the published package installer
 
 ```bash
-npm install -g @a5c-ai/babysitter-cursor
-babysitter-cursor install
+npx --yes @a5c-ai/babysitter-cursor install --global
+npx --yes @a5c-ai/babysitter-cursor install --workspace /path/to/repo
 ```
 
-#### From source
+#### From generated source
 
 ```bash
-cd plugins/babysitter-cursor
-node bin/install.js
+npm run generate:plugins
+node artifacts/generated-plugins/cursor/bin/install.js
 ```
 
 #### Manual installation
@@ -70,9 +76,9 @@ node bin/install.js
 Copy the plugin directory to your local Cursor plugins path:
 
 ```bash
-cp -r plugins/babysitter-cursor ~/.cursor/plugins/local/babysitter-cursor
+cp -r artifacts/generated-plugins/cursor ~/.cursor/plugins/local/babysitter-cursor
 # Or symlink for faster iteration:
-ln -s "$(pwd)/plugins/babysitter-cursor" ~/.cursor/plugins/local/babysitter-cursor
+ln -s "$(pwd)/artifacts/generated-plugins/cursor" ~/.cursor/plugins/local/babysitter-cursor
 ```
 
 ## Uninstallation
@@ -90,7 +96,7 @@ npm uninstall -g @a5c-ai/babysitter-cursor
 ## Plugin Structure (Directory Layout)
 
 ```
-plugins/babysitter-cursor/
+artifacts/generated-plugins/cursor/
   .cursor-plugin/
     plugin.json              # Cursor plugin manifest (skills, commands, hooks, metadata)
   plugin.json                # Babysitter plugin manifest (skills dir, hooks path, metadata)
@@ -311,7 +317,7 @@ The Cursor marketplace manifest lives at `.cursor-plugin/plugin.json`:
     "email": "support@a5c.ai",
     "url": "https://github.com/a5c-ai/babysitter"
   },
-  "homepage": "https://github.com/a5c-ai/babysitter/tree/main/plugins/babysitter-cursor#readme",
+  "homepage": "https://github.com/a5c-ai/babysitter/tree/main/plugins/babysitter-unified/per-harness/cursor#readme",
   "repository": "https://github.com/a5c-ai/babysitter",
   "license": "MIT",
   "skills": "skills/",
@@ -438,14 +444,14 @@ or WSL. The Cursor hook manifest includes explicit `powershell` entries alongsid
 git clone https://github.com/a5c-ai/babysitter.git
 cd babysitter
 npm install
-cd plugins/babysitter-cursor
+npm run generate:plugins
 node bin/install.js
 ```
 
 ### Publishing
 
 ```bash
-cd plugins/babysitter-cursor
+cd artifacts/generated-plugins/cursor
 npm run deploy            # Publish to npm (public)
 npm run deploy:staging    # Publish to npm with staging tag
 ```
@@ -453,7 +459,7 @@ npm run deploy:staging    # Publish to npm with staging tag
 ### Team installation
 
 ```bash
-cd plugins/babysitter-cursor
+cd artifacts/generated-plugins/cursor
 npm run team:install
 ```
 

package/bin/cli.js

@@ -5,6 +5,8 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
+let shared;
+try { shared = require('./install-shared'); } catch {}
 
 function printUsage() {
   console.error([
@@ -23,16 +25,10 @@ function parseInstallArgs(argv) {
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === '--global') {
-      if (scope === 'workspace') {
-        throw new Error('install accepts either --global or --workspace, not both');
-      }
       scope = 'global';
       continue;
     }
     if (arg === '--workspace') {
-      if (scope === 'global' && workspace !== null) {
-        throw new Error('install accepts either --global or --workspace, not both');
-      }
       scope = 'workspace';
       const next = argv[i + 1];
       if (next && !next.startsWith('-')) {
@@ -46,21 +42,14 @@ function parseInstallArgs(argv) {
     passthrough.push(arg);
   }
 
-  return {
-    scope,
-    workspace,
-    passthrough,
-  };
+  return { scope, workspace, passthrough };
 }
 
 function runNodeScript(scriptPath, args, extraEnv = {}) {
   const result = spawnSync(process.execPath, [scriptPath, ...args], {
     cwd: process.cwd(),
     stdio: 'inherit',
-    env: {
-      ...process.env,
-      ...extraEnv,
-    },
+    env: { ...process.env, ...extraEnv },
   });
   process.exitCode = result.status ?? 1;
 }
@@ -74,6 +63,9 @@ function main() {
   }
 
   if (command === 'install') {
+    if (shared && typeof shared.harnessCliRoute === 'function' && shared.harnessCliRoute(rest, PACKAGE_ROOT, runNodeScript)) {
+      return;
+    }
     const parsed = parseInstallArgs(rest);
     if (parsed.scope === 'workspace') {
       const args = [];
@@ -84,7 +76,7 @@ function main() {
       runNodeScript(
         path.join(PACKAGE_ROOT, 'scripts', 'team-install.js'),
         args,
-        { BABYSITTER_PACKAGE_ROOT: PACKAGE_ROOT },
+        { PLUGIN_PACKAGE_ROOT: PACKAGE_ROOT },
       );
       return;
     }

package/bin/install-shared.js

@@ -5,14 +5,205 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
-const PLUGIN_NAME = 'babysitter';
+const PLUGIN_NAME = "babysitter";
 const PLUGIN_CATEGORY = 'Coding';
+
+function getUserHome() {
+  return os.homedir();
+}
+
+function getHarnessHome() {
+  return path.join(os.homedir(), ".cursor");
+}
+
+function getHomePluginRoot(scope) {
+  if (scope === 'workspace') return path.join(process.cwd(), '.a5c', 'plugins', PLUGIN_NAME);
+  return path.join(path.join(getHarnessHome(), 'plugins'), PLUGIN_NAME);
+}
+
+function getHomeMarketplacePath() {
+  return path.join(getHarnessHome(), 'plugins', 'marketplace.json');
+}
+
+function writeFileIfChanged(filePath, contents) {
+  try {
+    const existing = fs.readFileSync(filePath, 'utf8');
+    if (existing === contents) return false;
+  } catch {}
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+  return true;
+}
+
+function copyRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue;
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyRecursive(s, d);
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+function copyPluginBundle(packageRoot, pluginRoot) {
+  const bundleEntries = fs.readdirSync(packageRoot).filter(
+    e => !['node_modules', '.git', 'test', 'dist'].includes(e)
+  );
+  fs.mkdirSync(pluginRoot, { recursive: true });
+  for (const entry of bundleEntries) {
+    const src = path.join(packageRoot, entry);
+    const dest = path.join(pluginRoot, entry);
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      copyRecursive(src, dest);
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n');
+}
+
+function ensureExecutable(filePath) {
+  try {
+    fs.chmodSync(filePath, 0o755);
+  } catch {}
+}
+
+function normalizeMarketplaceSourcePath(source, marketplacePath) {
+  if (typeof source === 'string') {
+    return path.relative(path.dirname(marketplacePath), source).replace(/\\/g, '/');
+  }
+  return source;
+}
+
+function ensureMarketplaceEntry(marketplacePath, pluginRoot) {
+  let marketplace = readJson(marketplacePath) || {
+    name: "a5c.ai",
+    plugins: [],
+  };
+  if (!Array.isArray(marketplace.plugins)) marketplace.plugins = [];
+  const idx = marketplace.plugins.findIndex(p => p.name === PLUGIN_NAME);
+  const relSource = './' + normalizeMarketplaceSourcePath(pluginRoot, marketplacePath);
+  const entry = {
+    name: PLUGIN_NAME,
+    source: relSource,
+    description: "Orchestrate complex, multi-step workflows with event-sourced state management, hook-based extensibility, and human-in-the-loop approval",
+    version: "5.0.1-staging.e920fef118ef",
+    author: { name: "a5c.ai" },
+  };
+  if (idx >= 0) marketplace.plugins[idx] = entry;
+  else marketplace.plugins.push(entry);
+  writeJson(marketplacePath, marketplace);
+}
+
+function removeMarketplaceEntry(marketplacePath) {
+  const marketplace = readJson(marketplacePath);
+  if (!marketplace || !Array.isArray(marketplace.plugins)) return;
+  marketplace.plugins = marketplace.plugins.filter(p => p.name !== PLUGIN_NAME);
+  writeJson(marketplacePath, marketplace);
+}
+
+function warnWindowsHooks() {
+  if (process.platform === 'win32') {
+    console.warn('[' + PLUGIN_NAME + '] Windows detected — shell hooks (.sh) require Git Bash or WSL.');
+  }
+}
+
+function runPostInstall(pluginRoot) {
+  const postInstall = path.join(pluginRoot, 'scripts', 'post-install.js');
+  if (fs.existsSync(postInstall)) {
+    spawnSync(process.execPath, [postInstall], {
+      cwd: pluginRoot, stdio: 'inherit',
+      env: { ...process.env, PLUGIN_ROOT: pluginRoot },
+    });
+  }
+}
+
+function getGlobalStateDir() {
+  return process.env.BABYSITTER_GLOBAL_STATE_DIR || path.join(getUserHome(), '.a5c');
+}
+
+function resolveCliCommand(packageRoot) {
+  try {
+    const result = spawnSync('babysitter', ['--version'], { stdio: 'pipe', timeout: 10000 });
+    if (result.status === 0) return 'babysitter';
+  } catch {}
+  const versionsPath = path.join(packageRoot, 'versions.json');
+  const versions = readJson(versionsPath) || {};
+  const ver = versions.sdkVersion || 'latest';
+  return `npx -y @a5c-ai/babysitter-sdk@${ver}`;
+}
+
+function runCli(packageRoot, cliArgs, options = {}) {
+  const cmd = resolveCliCommand(packageRoot);
+  const parts = cmd.split(' ');
+  const result = spawnSync(parts[0], [...parts.slice(1), ...cliArgs], {
+    stdio: options.stdio || 'inherit',
+    timeout: options.timeout || 120000,
+    cwd: options.cwd || process.cwd(),
+    env: { ...process.env, ...options.env },
+  });
+  return result;
+}
+
+function ensureGlobalProcessLibrary(packageRoot) {
+  const stateDir = getGlobalStateDir();
+  const activeFile = path.join(stateDir, 'active', 'process-library.json');
+  let active = readJson(activeFile);
+  if (active && active.binding && active.binding.dir) {
+    return active;
+  }
+  const defaultSpec = readJson(path.join(stateDir, 'process-library-defaults.json'));
+  const cloneDir = defaultSpec && defaultSpec.cloneDir
+    ? defaultSpec.cloneDir
+    : path.join(stateDir, 'process-library', PLUGIN_NAME + '-repo');
+  runCli(packageRoot, [
+    'process-library:clone',
+    '--dir', cloneDir,
+    '--state-dir', stateDir,
+    '--json',
+  ], { stdio: 'pipe' });
+  runCli(packageRoot, [
+    'process-library:use',
+    '--dir', cloneDir,
+    '--state-dir', stateDir,
+    '--json',
+  ], { stdio: 'pipe' });
+  active = readJson(activeFile);
+  return {
+    binding: active && active.binding ? active.binding : { dir: cloneDir },
+    defaultSpec: defaultSpec || { cloneDir },
+    stateFile: activeFile,
+  };
+}
+
+
+// Cursor-specific install surface.
+// Appended after the compiler base and SDK surface — can override base functions.
+
 const HOOK_SCRIPT_NAMES = [
-  'session-start.sh',
-  'session-start.ps1',
-  'stop-hook.sh',
-  'stop-hook.ps1',
+  'babysitter-proxied-session-start.sh',
+  'babysitter-proxied-session-start.ps1',
+  'babysitter-proxied-stop.sh',
+  'babysitter-proxied-stop.ps1',
 ];
+
 const DEFAULT_MARKETPLACE = {
   name: 'local-plugins',
   interface: {
@@ -20,10 +211,12 @@ const DEFAULT_MARKETPLACE = {
   },
   plugins: [],
 };
+
 const MANAGED_HOOKS_CONFIG_PATHS = [
   path.join('hooks', 'hooks-cursor.json'),
   'hooks.json',
 ];
+
 const PLUGIN_BUNDLE_ENTRIES = [
   '.cursor-plugin',
   'plugin.json',
@@ -40,19 +233,6 @@ function getCursorHome() {
   return path.join(os.homedir(), '.cursor');
 }
 
-function getUserHome() {
-  if (process.env.USERPROFILE) return path.resolve(process.env.USERPROFILE);
-  if (process.env.HOME) return path.resolve(process.env.HOME);
-  return os.homedir();
-}
-
-function getGlobalStateDir() {
-  if (process.env.BABYSITTER_GLOBAL_STATE_DIR) {
-    return path.resolve(process.env.BABYSITTER_GLOBAL_STATE_DIR);
-  }
-  return path.join(getUserHome(), '.a5c');
-}
-
 function getHomePluginRoot() {
   if (process.env.BABYSITTER_CURSOR_PLUGIN_DIR) {
     return path.resolve(process.env.BABYSITTER_CURSOR_PLUGIN_DIR, PLUGIN_NAME);
@@ -67,18 +247,6 @@ function getHomeMarketplacePath() {
   return path.join(getUserHome(), '.agents', 'plugins', 'marketplace.json');
 }
 
-function writeFileIfChanged(filePath, contents) {
-  if (fs.existsSync(filePath)) {
-    const current = fs.readFileSync(filePath, 'utf8');
-    if (current === contents) {
-      return false;
-    }
-  }
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, contents, 'utf8');
-  return true;
-}
-
 function copyRecursive(src, dest) {
   const stat = fs.statSync(src);
   if (stat.isDirectory()) {
@@ -90,6 +258,7 @@ function copyRecursive(src, dest) {
     return;
   }
 
+  // Strip UTF-8 BOM from SKILL.md files
   if (path.basename(src) === 'SKILL.md') {
     const file = fs.readFileSync(src);
     const hasBom = file.length >= 3 && file[0] === 0xef && file[1] === 0xbb && file[2] === 0xbf;
@@ -116,14 +285,6 @@ function copyPluginBundle(packageRoot, pluginRoot) {
   }
 }
 
-function ensureExecutable(filePath) {
-  try {
-    fs.chmodSync(filePath, 0o755);
-  } catch {
-    // Best-effort only. Windows and some filesystems may ignore mode changes.
-  }
-}
-
 function normalizeMarketplaceSourcePath(marketplacePath, pluginSourcePath) {
   let next = pluginSourcePath;
   if (path.isAbsolute(next)) {
@@ -136,24 +297,6 @@ function normalizeMarketplaceSourcePath(marketplacePath, pluginSourcePath) {
   return next;
 }
 
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-}
-
-function getManagedHooksConfigPath(packageRoot) {
-  for (const relativePath of MANAGED_HOOKS_CONFIG_PATHS) {
-    const candidate = path.join(packageRoot, relativePath);
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-
-function writeJson(filePath, value) {
-  writeFileIfChanged(filePath, `${JSON.stringify(value, null, 2)}\n`);
-}
-
 function normalizeMarketplaceName(name) {
   const raw = String(name || '').trim();
   const sanitized = raw
@@ -208,6 +351,16 @@ function removeMarketplaceEntry(marketplacePath) {
   writeJson(marketplacePath, marketplace);
 }
 
+function getManagedHooksConfigPath(packageRoot) {
+  for (const relativePath of MANAGED_HOOKS_CONFIG_PATHS) {
+    const candidate = path.join(packageRoot, relativePath);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
 function mergeManagedHooksConfig(packageRoot, cursorHome) {
   const hooksJsonPath = getManagedHooksConfigPath(packageRoot);
   if (!hooksJsonPath) return;
@@ -313,62 +466,6 @@ function installCursorSurface(packageRoot, cursorHome) {
   }
 }
 
-function resolveBabysitterCommand(packageRoot) {
-  if (process.env.BABYSITTER_SDK_CLI) {
-    return {
-      command: process.execPath,
-      argsPrefix: [path.resolve(process.env.BABYSITTER_SDK_CLI)],
-    };
-  }
-  try {
-    return {
-      command: process.execPath,
-      argsPrefix: [
-        require.resolve('@a5c-ai/babysitter-sdk/dist/cli/main.js', {
-          paths: [packageRoot],
-        }),
-      ],
-    };
-  } catch {
-    return {
-      command: 'babysitter',
-      argsPrefix: [],
-    };
-  }
-}
-
-function runBabysitterCli(packageRoot, cliArgs, options = {}) {
-  const resolved = resolveBabysitterCommand(packageRoot);
-  const result = spawnSync(resolved.command, [...resolved.argsPrefix, ...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 ensureGlobalProcessLibrary(packageRoot) {
-  return JSON.parse(
-    runBabysitterCli(
-      packageRoot,
-      ['process-library:active', '--state-dir', getGlobalStateDir(), '--json'],
-      { cwd: packageRoot },
-    ),
-  );
-}
-
 function warnWindowsHooks() {
   if (process.platform !== 'win32') {
     return;
@@ -377,18 +474,37 @@ function warnWindowsHooks() {
   console.warn(`[${PLUGIN_NAME}] Both bash (.sh) and PowerShell (.ps1) hook scripts are included.`);
 }
 
+
 module.exports = {
-  copyPluginBundle,
+  PLUGIN_NAME,
+  PLUGIN_CATEGORY,
+  getUserHome,
+  getHarnessHome,
+  writeFileIfChanged,
+  readJson,
+  writeJson,
+  ensureExecutable,
+  runPostInstall,
+  getGlobalStateDir,
+  resolveCliCommand,
+  runCli,
   ensureGlobalProcessLibrary,
+  PLUGIN_BUNDLE_ENTRIES,
+  copyRecursive,
+  copyPluginBundle,
+  DEFAULT_MARKETPLACE,
+  normalizeMarketplaceSourcePath,
+  normalizeMarketplaceName,
   ensureMarketplaceEntry,
-  getManagedHooksConfigPath,
+  removeMarketplaceEntry,
+  mergeManagedHooksConfig,
+  warnWindowsHooks,
+  HOOK_SCRIPT_NAMES,
+  MANAGED_HOOKS_CONFIG_PATHS,
   getCursorHome,
-  getHomeMarketplacePath,
   getHomePluginRoot,
-  installCursorSurface,
+  getHomeMarketplacePath,
+  getManagedHooksConfigPath,
   removeManagedHooks,
-  removeMarketplaceEntry,
-  warnWindowsHooks,
-  writeJson,
-  normalizeMarketplaceName,
+  installCursorSurface,
 };

package/bin/install.js

@@ -2,43 +2,27 @@
 'use strict';
 
 const path = require('path');
-const {
-  copyPluginBundle,
-  ensureGlobalProcessLibrary,
-  ensureMarketplaceEntry,
-  getCursorHome,
-  getHomeMarketplacePath,
-  getHomePluginRoot,
-  installCursorSurface,
-  warnWindowsHooks,
-} = require('./install-shared');
+const shared = require('./install-shared');
 
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
 
 function main() {
-  const cursorHome = getCursorHome();
-  const pluginRoot = getHomePluginRoot();
-  const marketplacePath = getHomeMarketplacePath();
+  const pluginRoot = shared.getHomePluginRoot();
+  const marketplacePath = shared.getHomeMarketplacePath();
 
-  console.log(`[babysitter] Installing plugin to ${pluginRoot}`);
+  console.log(`[${shared.PLUGIN_NAME}] Installing plugin to ${pluginRoot}`);
 
   try {
-    copyPluginBundle(PACKAGE_ROOT, pluginRoot);
-    ensureMarketplaceEntry(marketplacePath, pluginRoot);
-    installCursorSurface(PACKAGE_ROOT, cursorHome);
-
-    const active = ensureGlobalProcessLibrary(PACKAGE_ROOT);
-    console.log(`[babysitter]   marketplace: ${marketplacePath}`);
-    console.log(`[babysitter]   process library: ${active.binding?.dir}`);
-    if (active.defaultSpec?.cloneDir) {
-      console.log(`[babysitter]   process library clone: ${active.defaultSpec.cloneDir}`);
+    shared.copyPluginBundle(PACKAGE_ROOT, pluginRoot);
+    shared.ensureMarketplaceEntry(marketplacePath, pluginRoot);
+    if (typeof shared.harnessInstall === 'function') {
+      shared.harnessInstall(PACKAGE_ROOT, pluginRoot);
     }
-    console.log(`[babysitter]   process library state: ${active.stateFile}`);
-    warnWindowsHooks();
-    console.log('[babysitter] Installation complete!');
-    console.log('[babysitter] Restart Cursor to pick up the installed plugin and config changes.');
+    shared.runPostInstall && shared.runPostInstall(pluginRoot);
+    console.log(`[${shared.PLUGIN_NAME}] Installation complete!`);
+    console.log(`[${shared.PLUGIN_NAME}] Restart your IDE/CLI to pick up the plugin.`);
   } catch (err) {
-    console.error(`[babysitter] Failed to install plugin: ${err.message}`);
+    console.error(`[${shared.PLUGIN_NAME}] Failed to install: ${err.message}`);
     process.exitCode = 1;
   }
 }