@a5c-ai/babysitter-cursor 0.1.1-staging.d0170171

package/bin/install-shared.js

@@ -0,0 +1,369 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PLUGIN_NAME = 'babysitter-cursor';
+const PLUGIN_CATEGORY = 'Coding';
+const HOOK_SCRIPT_NAMES = [
+  'session-start.sh',
+  'session-start.ps1',
+  'stop-hook.sh',
+  'stop-hook.ps1',
+];
+const DEFAULT_MARKETPLACE = {
+  name: 'local-plugins',
+  interface: {
+    displayName: 'Local Plugins',
+  },
+  plugins: [],
+};
+const PLUGIN_BUNDLE_ENTRIES = [
+  '.cursor-plugin',
+  'plugin.json',
+  'hooks.json',
+  'hooks',
+  'skills',
+  'versions.json',
+  '.cursorrules',
+];
+
+function getCursorHome() {
+  if (process.env.CURSOR_HOME) return path.resolve(process.env.CURSOR_HOME);
+  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);
+  }
+  return path.join(getCursorHome(), 'plugins', PLUGIN_NAME);
+}
+
+function getHomeMarketplacePath() {
+  if (process.env.BABYSITTER_CURSOR_MARKETPLACE_PATH) {
+    return path.resolve(process.env.BABYSITTER_CURSOR_MARKETPLACE_PATH);
+  }
+  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()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      if (['node_modules', '.git', 'test', '.a5c'].includes(entry)) continue;
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+    return;
+  }
+
+  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;
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, hasBom ? file.subarray(3) : file);
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function copyPluginBundle(packageRoot, pluginRoot) {
+  if (path.resolve(packageRoot) === path.resolve(pluginRoot)) {
+    return;
+  }
+  fs.rmSync(pluginRoot, { recursive: true, force: true });
+  fs.mkdirSync(pluginRoot, { recursive: true });
+  for (const entry of PLUGIN_BUNDLE_ENTRIES) {
+    const src = path.join(packageRoot, entry);
+    if (fs.existsSync(src)) {
+      copyRecursive(src, path.join(pluginRoot, entry));
+    }
+  }
+}
+
+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)) {
+    next = path.relative(path.dirname(marketplacePath), next);
+  }
+  next = String(next || '').replace(/\\/g, '/');
+  if (!next.startsWith('./') && !next.startsWith('../')) {
+    next = `./${next}`;
+  }
+  return next;
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, value) {
+  writeFileIfChanged(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function ensureMarketplaceEntry(marketplacePath, pluginSourcePath) {
+  const marketplace = fs.existsSync(marketplacePath)
+    ? readJson(marketplacePath)
+    : { ...DEFAULT_MARKETPLACE, plugins: [] };
+  marketplace.name = marketplace.name || DEFAULT_MARKETPLACE.name;
+  marketplace.interface = marketplace.interface || {};
+  marketplace.interface.displayName =
+    marketplace.interface.displayName || DEFAULT_MARKETPLACE.interface.displayName;
+  const nextEntry = {
+    name: PLUGIN_NAME,
+    source: {
+      source: 'local',
+      path: normalizeMarketplaceSourcePath(marketplacePath, pluginSourcePath),
+    },
+    policy: {
+      installation: 'AVAILABLE',
+      authentication: 'ON_INSTALL',
+    },
+    category: PLUGIN_CATEGORY,
+  };
+  const existingIndex = Array.isArray(marketplace.plugins)
+    ? marketplace.plugins.findIndex((entry) => entry && entry.name === PLUGIN_NAME)
+    : -1;
+  if (!Array.isArray(marketplace.plugins)) {
+    marketplace.plugins = [nextEntry];
+  } else if (existingIndex >= 0) {
+    marketplace.plugins[existingIndex] = nextEntry;
+  } else {
+    marketplace.plugins.push(nextEntry);
+  }
+  writeJson(marketplacePath, marketplace);
+  return nextEntry;
+}
+
+function removeMarketplaceEntry(marketplacePath) {
+  if (!fs.existsSync(marketplacePath)) {
+    return;
+  }
+  const marketplace = readJson(marketplacePath);
+  if (!Array.isArray(marketplace.plugins)) {
+    return;
+  }
+  marketplace.plugins = marketplace.plugins.filter((entry) => entry && entry.name !== PLUGIN_NAME);
+  writeJson(marketplacePath, marketplace);
+}
+
+function mergeManagedHooksConfig(packageRoot, cursorHome) {
+  const hooksJsonPath = path.join(packageRoot, 'hooks.json');
+  if (!fs.existsSync(hooksJsonPath)) return;
+  const managedConfig = readJson(hooksJsonPath);
+  const managedHooks = managedConfig.hooks || {};
+  const hooksConfigPath = path.join(cursorHome, 'hooks.json');
+  const existing = fs.existsSync(hooksConfigPath)
+    ? readJson(hooksConfigPath)
+    : { version: 1, hooks: {} };
+  existing.version = existing.version || 1;
+  if (!existing.hooks || typeof existing.hooks !== 'object') {
+    existing.hooks = {};
+  }
+
+  for (const [eventName, entries] of Object.entries(managedHooks)) {
+    const existingEntries = Array.isArray(existing.hooks[eventName]) ? existing.hooks[eventName] : [];
+    const filteredEntries = existingEntries
+      .filter((entry) => {
+        const bash = String(entry.bash || entry.command || '');
+        const ps = String(entry.powershell || '');
+        return !HOOK_SCRIPT_NAMES.some((name) => bash.includes(name) || ps.includes(name));
+      });
+    existing.hooks[eventName] = [...filteredEntries, ...entries];
+  }
+
+  writeJson(hooksConfigPath, existing);
+}
+
+function removeManagedHooks(cursorHome) {
+  for (const hookName of HOOK_SCRIPT_NAMES) {
+    fs.rmSync(path.join(cursorHome, 'hooks', hookName), { force: true });
+  }
+
+  const hooksConfigPath = path.join(cursorHome, 'hooks.json');
+  if (!fs.existsSync(hooksConfigPath)) {
+    return;
+  }
+  let hooksConfig;
+  try {
+    hooksConfig = readJson(hooksConfigPath);
+  } catch {
+    return;
+  }
+  if (!hooksConfig.hooks || typeof hooksConfig.hooks !== 'object') {
+    return;
+  }
+  for (const eventName of Object.keys(hooksConfig.hooks)) {
+    const eventHooks = Array.isArray(hooksConfig.hooks[eventName]) ? hooksConfig.hooks[eventName] : [];
+    const filtered = eventHooks.filter((entry) => {
+      const bash = String(entry.bash || entry.command || '');
+      const ps = String(entry.powershell || '');
+      return !HOOK_SCRIPT_NAMES.some((name) => bash.includes(name) || ps.includes(name));
+    });
+    if (filtered.length > 0) {
+      hooksConfig.hooks[eventName] = filtered;
+    } else {
+      delete hooksConfig.hooks[eventName];
+    }
+  }
+  if (Object.keys(hooksConfig.hooks).length === 0) {
+    fs.rmSync(hooksConfigPath, { force: true });
+  } else {
+    writeJson(hooksConfigPath, hooksConfig);
+  }
+}
+
+function installCursorSurface(packageRoot, cursorHome) {
+  // Install skills
+  const sourceSkills = path.join(packageRoot, 'skills');
+  if (fs.existsSync(sourceSkills)) {
+    const targetSkills = path.join(cursorHome, 'skills');
+    fs.mkdirSync(targetSkills, { recursive: true });
+    for (const entry of fs.readdirSync(sourceSkills, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      copyRecursive(
+        path.join(sourceSkills, entry.name),
+        path.join(targetSkills, entry.name),
+      );
+    }
+  }
+
+  // Install hooks
+  const sourceHooks = path.join(packageRoot, 'hooks');
+  if (fs.existsSync(sourceHooks)) {
+    const targetHooks = path.join(cursorHome, 'hooks');
+    fs.mkdirSync(targetHooks, { recursive: true });
+    for (const scriptName of HOOK_SCRIPT_NAMES) {
+      const sourcePath = path.join(sourceHooks, scriptName);
+      if (!fs.existsSync(sourcePath)) continue;
+      const targetPath = path.join(targetHooks, scriptName);
+      copyRecursive(sourcePath, targetPath);
+      ensureExecutable(targetPath);
+    }
+  }
+
+  // Merge hooks.json config
+  mergeManagedHooksConfig(packageRoot, cursorHome);
+
+  // Install .cursorrules
+  const sourceRules = path.join(packageRoot, '.cursorrules');
+  if (fs.existsSync(sourceRules)) {
+    copyRecursive(sourceRules, path.join(cursorHome, '.cursorrules'));
+  }
+}
+
+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;
+  }
+  console.warn(`[${PLUGIN_NAME}] Note: On Windows, Cursor will use .ps1 PowerShell hooks.`);
+  console.warn(`[${PLUGIN_NAME}] Both bash (.sh) and PowerShell (.ps1) hook scripts are included.`);
+}
+
+module.exports = {
+  copyPluginBundle,
+  ensureGlobalProcessLibrary,
+  ensureMarketplaceEntry,
+  getCursorHome,
+  getHomeMarketplacePath,
+  getHomePluginRoot,
+  installCursorSurface,
+  removeManagedHooks,
+  removeMarketplaceEntry,
+  warnWindowsHooks,
+  writeJson,
+};

package/bin/install.js

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

package/bin/uninstall.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const {
+  getCursorHome,
+  getHomeMarketplacePath,
+  getHomePluginRoot,
+  removeManagedHooks,
+  removeMarketplaceEntry,
+} = require('./install-shared');
+
+function main() {
+  const cursorHome = getCursorHome();
+  const pluginRoot = getHomePluginRoot();
+  const marketplacePath = getHomeMarketplacePath();
+  let removedPlugin = false;
+
+  if (fs.existsSync(pluginRoot)) {
+    try {
+      fs.rmSync(pluginRoot, { recursive: true, force: true });
+      console.log(`[babysitter-cursor] Removed ${pluginRoot}`);
+      removedPlugin = true;
+    } catch (err) {
+      console.warn(`[babysitter-cursor] Warning: Could not remove plugin directory ${pluginRoot}: ${err.message}`);
+    }
+  }
+
+  removeMarketplaceEntry(marketplacePath);
+  removeManagedHooks(cursorHome);
+
+  if (!removedPlugin) {
+    console.log('[babysitter-cursor] Plugin directory not found, config and hooks cleaned if present.');
+    return;
+  }
+
+  console.log('[babysitter-cursor] Restart Cursor to complete uninstallation.');
+}
+
+main();

package/hooks/session-start.ps1

@@ -0,0 +1,115 @@
+# Babysitter Session Start Hook for Cursor IDE/CLI (PowerShell)
+# Ensures the babysitter SDK CLI is installed (from versions.json sdkVersion),
+# then delegates to the SDK hook handler.
+#
+# Protocol:
+#   Input:  JSON via stdin (contains session_id, cwd, etc.)
+#   Output: JSON via stdout ({} on success)
+#   Stderr: debug/log output only
+#   Exit 0: success
+#   Exit 2: block (fatal error)
+
+$ErrorActionPreference = "Stop"
+
+$PluginRoot = if ($env:CURSOR_PLUGIN_ROOT) { $env:CURSOR_PLUGIN_ROOT } else { Split-Path -Parent $PSScriptRoot }
+$StateDir = if ($env:BABYSITTER_STATE_DIR) { $env:BABYSITTER_STATE_DIR } else { Join-Path $PWD ".a5c" }
+$MarkerFile = Join-Path $PluginRoot ".babysitter-install-attempted"
+
+$env:CURSOR_PLUGIN_ROOT = $PluginRoot
+$env:BABYSITTER_STATE_DIR = $StateDir
+
+$LogDir = if ($env:BABYSITTER_LOG_DIR) { $env:BABYSITTER_LOG_DIR } else { Join-Path $PluginRoot ".a5c\logs" }
+$LogFile = Join-Path $LogDir "babysitter-session-start-hook.log"
+New-Item -ItemType Directory -Path $LogDir -Force -ErrorAction SilentlyContinue | Out-Null
+
+function Write-Blog {
+    param([string]$Message)
+    $ts = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+    Add-Content -Path $LogFile -Value "[INFO] $ts $Message" -ErrorAction SilentlyContinue
+    if (Get-Command babysitter -ErrorAction SilentlyContinue) {
+        & babysitter log --type hook --label "hook:session-start" --message $Message --source shell-hook 2>$null
+    }
+}
+
+Write-Blog "Hook script invoked"
+Write-Blog "PLUGIN_ROOT=$PluginRoot"
+Write-Blog "STATE_DIR=$StateDir"
+
+# Get required SDK version from versions.json
+$versionsFile = Join-Path $PluginRoot "versions.json"
+try {
+    $SdkVersion = (Get-Content $versionsFile -Raw | ConvertFrom-Json).sdkVersion
+    if (-not $SdkVersion) { $SdkVersion = "latest" }
+} catch {
+    $SdkVersion = "latest"
+}
+
+function Install-Sdk {
+    param([string]$TargetVersion)
+    try {
+        & npm i -g "@a5c-ai/babysitter-sdk@$TargetVersion" --loglevel=error 2>$null
+        if ($LASTEXITCODE -eq 0) {
+            Write-Blog "Installed SDK globally ($TargetVersion)"
+            return $true
+        }
+    } catch {}
+    try {
+        $prefix = Join-Path $env:USERPROFILE ".local"
+        & npm i -g "@a5c-ai/babysitter-sdk@$TargetVersion" --prefix $prefix --loglevel=error 2>$null
+        if ($LASTEXITCODE -eq 0) {
+            $env:PATH = "$prefix\bin;$env:PATH"
+            Write-Blog "Installed SDK to user prefix ($TargetVersion)"
+            return $true
+        }
+    } catch {}
+    return $false
+}
+
+# Check if babysitter CLI exists and if version matches
+$NeedsInstall = $false
+if (Get-Command babysitter -ErrorAction SilentlyContinue) {
+    $CurrentVersion = & babysitter --version 2>$null
+    if ($CurrentVersion -ne $SdkVersion) {
+        Write-Blog "SDK version mismatch: installed=$CurrentVersion, required=$SdkVersion"
+        $NeedsInstall = $true
+    } else {
+        Write-Blog "SDK version OK: $CurrentVersion"
+    }
+} else {
+    Write-Blog "SDK CLI not found, will install"
+    $NeedsInstall = $true
+}
+
+# Install/upgrade if needed (only attempt once per plugin version)
+if ($NeedsInstall -and -not (Test-Path $MarkerFile)) {
+    Install-Sdk $SdkVersion | Out-Null
+    Set-Content -Path $MarkerFile -Value $SdkVersion -ErrorAction SilentlyContinue
+}
+
+# If still not available after install attempt, try npx as last resort
+$useFallback = $false
+if (-not (Get-Command babysitter -ErrorAction SilentlyContinue)) {
+    Write-Blog "CLI not found after install, using npx fallback"
+    $useFallback = $true
+}
+
+# Capture stdin
+$InputFile = [System.IO.Path]::GetTempFileName()
+$input | Out-File -FilePath $InputFile -Encoding utf8
+
+Write-Blog "Hook input received"
+
+$stderrLog = Join-Path $LogDir "babysitter-session-start-hook-stderr.log"
+
+if ($useFallback) {
+    $Result = Get-Content $InputFile | & npx -y "@a5c-ai/babysitter-sdk@$SdkVersion" hook:run --hook-type session-start --harness cursor --plugin-root $PluginRoot --state-dir $StateDir --json 2>$stderrLog
+} else {
+    $Result = Get-Content $InputFile | & babysitter hook:run --hook-type session-start --harness cursor --plugin-root $PluginRoot --state-dir $StateDir --json 2>$stderrLog
+}
+$ExitCode = $LASTEXITCODE
+
+Write-Blog "CLI exit code=$ExitCode"
+
+Remove-Item $InputFile -Force -ErrorAction SilentlyContinue
+Write-Output $Result
+exit $ExitCode

package/hooks/session-start.sh

@@ -0,0 +1,105 @@
+#!/usr/bin/env bash
+# Babysitter Session Start Hook for Cursor IDE/CLI
+# Ensures the babysitter SDK CLI is installed (from versions.json sdkVersion),
+# then delegates to the SDK hook handler.
+#
+# Protocol:
+#   Input:  JSON via stdin (contains session_id, cwd, etc.)
+#   Output: JSON via stdout ({} on success)
+#   Stderr: debug/log output only
+#   Exit 0: success
+#   Exit 2: block (fatal error)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PLUGIN_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+STATE_DIR="${BABYSITTER_STATE_DIR:-${PWD}/.a5c}"
+LOG_DIR="${BABYSITTER_LOG_DIR:-$PLUGIN_ROOT/.a5c/logs}"
+LOG_FILE="$LOG_DIR/babysitter-session-start-hook.log"
+
+export CURSOR_PLUGIN_ROOT="${CURSOR_PLUGIN_ROOT:-${PLUGIN_ROOT}}"
+export BABYSITTER_STATE_DIR="${STATE_DIR}"
+
+mkdir -p "$LOG_DIR" 2>/dev/null
+
+blog() {
+  local msg="$1"
+  local ts
+  ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+  echo "[INFO] $ts $msg" >> "$LOG_FILE" 2>/dev/null
+  babysitter log --type hook --label "hook:session-start" --message "$msg" --source shell-hook 2>/dev/null || true
+}
+
+blog "Hook script invoked"
+blog "PLUGIN_ROOT=$PLUGIN_ROOT"
+blog "STATE_DIR=$STATE_DIR"
+
+# Get required SDK version from versions.json
+SDK_VERSION=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('${PLUGIN_ROOT}/versions.json','utf8')).sdkVersion||'latest')}catch{console.log('latest')}" 2>/dev/null || echo "latest")
+
+# Function to install/upgrade SDK
+install_sdk() {
+  local target_version="$1"
+  if npm i -g "@a5c-ai/babysitter-sdk@${target_version}" --loglevel=error 2>/dev/null; then
+    blog "Installed SDK globally (${target_version})"
+    return 0
+  else
+    if npm i -g "@a5c-ai/babysitter-sdk@${target_version}" --prefix "$HOME/.local" --loglevel=error 2>/dev/null; then
+      export PATH="$HOME/.local/bin:$PATH"
+      blog "Installed SDK to user prefix (${target_version})"
+      return 0
+    fi
+  fi
+  return 1
+}
+
+# Check if babysitter CLI exists and if version matches
+NEEDS_INSTALL=false
+if command -v babysitter &>/dev/null; then
+  CURRENT_VERSION=$(babysitter --version 2>/dev/null || echo "unknown")
+  if [ "$CURRENT_VERSION" != "$SDK_VERSION" ]; then
+    blog "SDK version mismatch: installed=${CURRENT_VERSION}, required=${SDK_VERSION}"
+    NEEDS_INSTALL=true
+  else
+    blog "SDK version OK: ${CURRENT_VERSION}"
+  fi
+else
+  blog "SDK CLI not found, will install"
+  NEEDS_INSTALL=true
+fi
+
+MARKER_FILE="${PLUGIN_ROOT}/.babysitter-install-attempted"
+
+# Install/upgrade if needed (only attempt once per plugin version)
+if [ "$NEEDS_INSTALL" = true ] && [ ! -f "$MARKER_FILE" ]; then
+  install_sdk "$SDK_VERSION"
+  echo "$SDK_VERSION" > "$MARKER_FILE" 2>/dev/null
+fi
+
+# If still not available after install attempt, try npx as last resort
+if ! command -v babysitter &>/dev/null; then
+  blog "CLI not found after install, using npx fallback"
+  babysitter() { npx -y "@a5c-ai/babysitter-sdk@${SDK_VERSION}" "$@"; }
+  export -f babysitter
+fi
+
+# Capture stdin to a temp file so the CLI receives a clean EOF
+INPUT_FILE=$(mktemp 2>/dev/null || echo "/tmp/cursor-session-start-hook-$$.json")
+cat > "$INPUT_FILE"
+
+blog "Hook input received ($(wc -c < "$INPUT_FILE") bytes)"
+
+RESULT=$(babysitter hook:run \
+  --hook-type session-start \
+  --harness cursor \
+  --plugin-root "$PLUGIN_ROOT" \
+  --state-dir "${BABYSITTER_STATE_DIR}" \
+  --json < "$INPUT_FILE" 2>"$LOG_DIR/babysitter-session-start-hook-stderr.log")
+EXIT_CODE=$?
+
+blog "CLI exit code=$EXIT_CODE"
+
+rm -f "$INPUT_FILE" 2>/dev/null
+printf '%s\n' "$RESULT"
+exit $EXIT_CODE