@a5c-ai/babysitter-opencode 0.1.1-staging.0dc03363

package/bin/install-shared.cjs

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Shared installation utilities for babysitter-opencode plugin.
+ *
+ * Handles plugin bundle copying, OpenCode config registration,
+ * marketplace entry management, and process library bootstrapping.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PLUGIN_NAME = 'babysitter';
+
+const PLUGIN_BUNDLE_ENTRIES = [
+  'plugin.json',
+  'versions.json',
+  'hooks',
+  'skills',
+  'commands',
+];
+
+const HOOK_SCRIPT_NAMES = [
+  'session-created.js',
+  'session-idle.js',
+  'shell-env.js',
+  'tool-execute-before.js',
+  'tool-execute-after.js',
+];
+
+const DEFAULT_MARKETPLACE = {
+  name: 'local-plugins',
+  interface: {
+    displayName: 'Local Plugins',
+  },
+  plugins: [],
+};
+
+// ---------------------------------------------------------------------------
+// Path helpers
+// ---------------------------------------------------------------------------
+
+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');
+}
+
+/**
+ * Resolve the OpenCode config root.
+ * OpenCode uses `.opencode/` in the workspace directory by default.
+ * Respect OPENCODE_HOME env var if set.
+ */
+function getOpenCodeHome(workspace) {
+  if (process.env.OPENCODE_HOME) return path.resolve(process.env.OPENCODE_HOME);
+  return path.join(workspace || process.cwd(), '.opencode');
+}
+
+function getHomePluginRoot(workspace) {
+  if (process.env.BABYSITTER_OPENCODE_PLUGIN_DIR) {
+    return path.resolve(process.env.BABYSITTER_OPENCODE_PLUGIN_DIR, PLUGIN_NAME);
+  }
+  return path.join(getOpenCodeHome(workspace), 'plugins', PLUGIN_NAME);
+}
+
+function getHomeMarketplacePath(workspace) {
+  if (process.env.BABYSITTER_OPENCODE_MARKETPLACE_PATH) {
+    return path.resolve(process.env.BABYSITTER_OPENCODE_MARKETPLACE_PATH);
+  }
+  return path.join(getUserHome(), '.agents', 'plugins', 'marketplace.json');
+}
+
+// ---------------------------------------------------------------------------
+// File utilities
+// ---------------------------------------------------------------------------
+
+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 readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, value) {
+  writeFileIfChanged(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+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;
+  }
+
+  // Strip 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;
+    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);
+}
+
+// ---------------------------------------------------------------------------
+// Plugin bundle
+// ---------------------------------------------------------------------------
+
+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));
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// OpenCode index.js entry point generation
+// ---------------------------------------------------------------------------
+
+function writeIndexJs(pluginRoot) {
+  const indexContent = `#!/usr/bin/env node
+/**
+ * Babysitter plugin entry point for OpenCode.
+ *
+ * OpenCode discovers plugins by looking for JS/TS modules in
+ * .opencode/plugins/. This file registers the babysitter hooks
+ * with the OpenCode plugin system.
+ */
+
+"use strict";
+
+const path = require("path");
+
+const PLUGIN_DIR = __dirname;
+
+module.exports = {
+  name: "babysitter",
+  version: require(path.join(PLUGIN_DIR, "plugin.json")).version,
+
+  hooks: {
+    "session.created": require(path.join(PLUGIN_DIR, "hooks", "session-created.js")),
+    "session.idle": require(path.join(PLUGIN_DIR, "hooks", "session-idle.js")),
+    "shell.env": require(path.join(PLUGIN_DIR, "hooks", "shell-env.js")),
+    "tool.execute.before": require(path.join(PLUGIN_DIR, "hooks", "tool-execute-before.js")),
+    "tool.execute.after": require(path.join(PLUGIN_DIR, "hooks", "tool-execute-after.js")),
+  },
+};
+`;
+  fs.writeFileSync(path.join(pluginRoot, 'index.js'), indexContent, 'utf8');
+}
+
+// ---------------------------------------------------------------------------
+// OpenCode hooks.json config registration
+// ---------------------------------------------------------------------------
+
+function mergeHooksConfig(packageRoot, openCodeHome) {
+  const hooksJsonPath = path.join(packageRoot, 'hooks', 'hooks.json');
+  if (!fs.existsSync(hooksJsonPath)) return;
+  const managedConfig = readJson(hooksJsonPath);
+  const managedHooks = managedConfig.hooks || {};
+  const hooksConfigPath = path.join(openCodeHome, '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 script = String(entry.script || entry.command || entry.bash || '');
+      return !HOOK_SCRIPT_NAMES.some((name) => script.includes(name));
+    });
+    existing.hooks[eventName] = [...filteredEntries, ...entries];
+  }
+
+  writeJson(hooksConfigPath, existing);
+}
+
+function removeManagedHooks(openCodeHome) {
+  const hooksConfigPath = path.join(openCodeHome, '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 script = String(entry.script || entry.command || entry.bash || '');
+      return !HOOK_SCRIPT_NAMES.some((name) => script.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);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Marketplace
+// ---------------------------------------------------------------------------
+
+function normalizeMarketplaceName(name) {
+  const raw = String(name || '').trim();
+  const sanitized = raw
+    .replace(/[^A-Za-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return sanitized || DEFAULT_MARKETPLACE.name;
+}
+
+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 ensureMarketplaceEntry(marketplacePath, pluginSourcePath) {
+  const marketplace = fs.existsSync(marketplacePath)
+    ? readJson(marketplacePath)
+    : { ...DEFAULT_MARKETPLACE, plugins: [] };
+  marketplace.name = normalizeMarketplaceName(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: 'Coding',
+  };
+  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);
+}
+
+// ---------------------------------------------------------------------------
+// Babysitter SDK CLI helpers
+// ---------------------------------------------------------------------------
+
+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 },
+    ),
+  );
+}
+
+// ---------------------------------------------------------------------------
+// OpenCode surface installation
+// ---------------------------------------------------------------------------
+
+function installOpenCodeSurface(packageRoot, openCodeHome) {
+  // Copy skills into .opencode/skills/
+  const sourceSkills = path.join(packageRoot, 'skills');
+  if (fs.existsSync(sourceSkills)) {
+    const targetSkills = path.join(openCodeHome, '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),
+      );
+    }
+  }
+
+  // Merge hooks config
+  mergeHooksConfig(packageRoot, openCodeHome);
+}
+
+module.exports = {
+  copyPluginBundle,
+  copyRecursive,
+  ensureGlobalProcessLibrary,
+  ensureMarketplaceEntry,
+  getHomeMarketplacePath,
+  getHomePluginRoot,
+  getOpenCodeHome,
+  installOpenCodeSurface,
+  removeManagedHooks,
+  removeMarketplaceEntry,
+  writeIndexJs,
+  writeJson,
+};

package/bin/install.cjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Babysitter OpenCode Plugin Installer
+ *
+ * Copies the babysitter plugin bundle into the OpenCode plugins directory:
+ *   <workspace>/.opencode/plugins/babysitter/
+ *
+ * Registers hooks in OpenCode config, creates the index.js entry point
+ * for plugin discovery, and bootstraps the global process library.
+ *
+ * Usage:
+ *   node install.cjs                     # Install into cwd workspace
+ *   node install.cjs --workspace /path   # Install into specified workspace
+ *   node install.cjs --global            # Global install (user home)
+ */
+
+const path = require('path');
+const {
+  copyPluginBundle,
+  ensureGlobalProcessLibrary,
+  ensureMarketplaceEntry,
+  getHomeMarketplacePath,
+  getHomePluginRoot,
+  getOpenCodeHome,
+  installOpenCodeSurface,
+  writeIndexJs,
+} = require('./install-shared.cjs');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function parseArgs(argv) {
+  let workspace = process.env.OPENCODE_WORKSPACE || process.cwd();
+  for (let i = 2; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--workspace') {
+      const next = argv[i + 1];
+      workspace = next && !next.startsWith('-') ? path.resolve(argv[++i]) : process.cwd();
+      continue;
+    }
+    if (arg === '--global') {
+      workspace = null;
+      continue;
+    }
+    throw new Error(`unknown argument: ${arg}`);
+  }
+  return { workspace };
+}
+
+function main() {
+  const { workspace } = parseArgs(process.argv);
+  const openCodeHome = getOpenCodeHome(workspace);
+  const pluginRoot = getHomePluginRoot(workspace);
+  const marketplacePath = getHomeMarketplacePath(workspace);
+
+  console.log(`[babysitter] Installing OpenCode plugin to ${pluginRoot}`);
+
+  try {
+    // 1. Copy plugin bundle
+    copyPluginBundle(PACKAGE_ROOT, pluginRoot);
+    console.log('[babysitter]   Copied plugin bundle');
+
+    // 2. Write index.js entry point for OpenCode plugin discovery
+    writeIndexJs(pluginRoot);
+    console.log('[babysitter]   Created index.js entry point');
+
+    // 3. Register in marketplace
+    ensureMarketplaceEntry(marketplacePath, pluginRoot);
+    console.log(`[babysitter]   Marketplace: ${marketplacePath}`);
+
+    // 4. Install OpenCode surfaces (skills, hooks config)
+    installOpenCodeSurface(PACKAGE_ROOT, openCodeHome);
+    console.log('[babysitter]   Installed hooks and skills');
+
+    // 5. Bootstrap global process library
+    try {
+      const active = ensureGlobalProcessLibrary(PACKAGE_ROOT);
+      console.log(`[babysitter]   Process library: ${active.binding?.dir || '(default)'}`);
+      if (active.defaultSpec?.cloneDir) {
+        console.log(`[babysitter]   Process library clone: ${active.defaultSpec.cloneDir}`);
+      }
+      console.log(`[babysitter]   Process library state: ${active.stateFile}`);
+    } catch (err) {
+      console.warn(`[babysitter]   Warning: Could not bootstrap process library: ${err.message}`);
+      console.warn('[babysitter]   Run "babysitter process-library:clone" manually if needed.');
+    }
+
+    console.log('[babysitter] Installation complete!');
+    console.log('[babysitter] Restart OpenCode to pick up the installed plugin.');
+  } catch (err) {
+    console.error(`[babysitter] Failed to install plugin: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/bin/install.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Babysitter OpenCode Plugin Installer
+ *
+ * Copies plugin files into the OpenCode plugins directory:
+ *   .opencode/plugins/babysitter/
+ *
+ * OpenCode discovers plugins as JS/TS modules in .opencode/plugins/.
+ * This installer creates the necessary directory structure and copies
+ * hook scripts, skills, and an index.js entry point.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const PLUGIN_ROOT = path.resolve(__dirname, "..");
+const WORKSPACE = process.env.OPENCODE_WORKSPACE || process.cwd();
+const TARGET_DIR = path.join(WORKSPACE, ".opencode", "plugins", "babysitter");
+
+function copyRecursive(src, dest) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+  } else {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+  }
+}
+
+function main() {
+  console.log(`Installing babysitter plugin for OpenCode...`);
+  console.log(`  Source: ${PLUGIN_ROOT}`);
+  console.log(`  Target: ${TARGET_DIR}`);
+
+  // Create target directory
+  fs.mkdirSync(TARGET_DIR, { recursive: true });
+
+  // Copy hooks
+  const hooksDir = path.join(PLUGIN_ROOT, "hooks");
+  if (fs.existsSync(hooksDir)) {
+    copyRecursive(hooksDir, path.join(TARGET_DIR, "hooks"));
+    console.log("  Copied hooks/");
+  }
+
+  // Copy skills
+  const skillsDir = path.join(PLUGIN_ROOT, "skills");
+  if (fs.existsSync(skillsDir)) {
+    copyRecursive(skillsDir, path.join(TARGET_DIR, "skills"));
+    console.log("  Copied skills/");
+  }
+
+  // Copy commands
+  const commandsDir = path.join(PLUGIN_ROOT, "commands");
+  if (fs.existsSync(commandsDir)) {
+    copyRecursive(commandsDir, path.join(TARGET_DIR, "commands"));
+    console.log("  Copied commands/");
+  }
+
+  // Copy plugin.json and versions.json
+  for (const file of ["plugin.json", "versions.json"]) {
+    const src = path.join(PLUGIN_ROOT, file);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(TARGET_DIR, file));
+      console.log(`  Copied ${file}`);
+    }
+  }
+
+  // Create index.js entry point for OpenCode plugin discovery
+  const indexContent = `#!/usr/bin/env node
+/**
+ * Babysitter plugin entry point for OpenCode.
+ *
+ * OpenCode discovers plugins by looking for JS/TS modules in
+ * .opencode/plugins/. This file registers the babysitter hooks
+ * with the OpenCode plugin system.
+ */
+
+"use strict";
+
+const path = require("path");
+
+const PLUGIN_DIR = __dirname;
+
+module.exports = {
+  name: "babysitter",
+  version: require(path.join(PLUGIN_DIR, "plugin.json")).version,
+
+  hooks: {
+    "session.created": require(path.join(PLUGIN_DIR, "hooks", "session-created.js")),
+    "session.idle": require(path.join(PLUGIN_DIR, "hooks", "session-idle.js")),
+    "shell.env": require(path.join(PLUGIN_DIR, "hooks", "shell-env.js")),
+    "tool.execute.before": require(path.join(PLUGIN_DIR, "hooks", "tool-execute-before.js")),
+    "tool.execute.after": require(path.join(PLUGIN_DIR, "hooks", "tool-execute-after.js")),
+  },
+};
+`;
+
+  fs.writeFileSync(path.join(TARGET_DIR, "index.js"), indexContent);
+  console.log("  Created index.js");
+
+  console.log(`\nBabysitter plugin installed to ${TARGET_DIR}`);
+  console.log("Restart OpenCode to activate the plugin.");
+}
+
+main();

package/bin/uninstall.cjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Babysitter OpenCode Plugin Uninstaller
+ *
+ * Removes the babysitter plugin from the OpenCode plugins directory
+ * and cleans up hooks config and marketplace entries.
+ *
+ * Usage:
+ *   node uninstall.cjs                     # Uninstall from cwd workspace
+ *   node uninstall.cjs --workspace /path   # Uninstall from specified workspace
+ *   node uninstall.cjs --global            # Global uninstall
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {
+  getHomeMarketplacePath,
+  getHomePluginRoot,
+  getOpenCodeHome,
+  removeManagedHooks,
+  removeMarketplaceEntry,
+} = require('./install-shared.cjs');
+
+function parseArgs(argv) {
+  let workspace = process.env.OPENCODE_WORKSPACE || process.cwd();
+  for (let i = 2; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--workspace') {
+      const next = argv[i + 1];
+      workspace = next && !next.startsWith('-') ? path.resolve(argv[++i]) : process.cwd();
+      continue;
+    }
+    if (arg === '--global') {
+      workspace = null;
+      continue;
+    }
+    throw new Error(`unknown argument: ${arg}`);
+  }
+  return { workspace };
+}
+
+function main() {
+  const { workspace } = parseArgs(process.argv);
+  const openCodeHome = getOpenCodeHome(workspace);
+  const pluginRoot = getHomePluginRoot(workspace);
+  const marketplacePath = getHomeMarketplacePath(workspace);
+  let removedPlugin = false;
+
+  console.log(`[babysitter] Uninstalling OpenCode plugin from ${pluginRoot}`);
+
+  // 1. Remove plugin directory
+  if (fs.existsSync(pluginRoot)) {
+    try {
+      fs.rmSync(pluginRoot, { recursive: true, force: true });
+      console.log(`[babysitter]   Removed ${pluginRoot}`);
+      removedPlugin = true;
+    } catch (err) {
+      console.warn(`[babysitter]   Warning: Could not remove plugin directory: ${err.message}`);
+    }
+  }
+
+  // 2. Remove marketplace entry
+  removeMarketplaceEntry(marketplacePath);
+  console.log('[babysitter]   Cleaned marketplace entry');
+
+  // 3. Remove managed hooks from OpenCode config
+  removeManagedHooks(openCodeHome);
+  console.log('[babysitter]   Cleaned hooks config');
+
+  // 4. Clean up empty parent directories
+  const pluginsDir = path.dirname(pluginRoot);
+  try {
+    const remaining = fs.readdirSync(pluginsDir);
+    if (remaining.length === 0) {
+      fs.rmdirSync(pluginsDir);
+      console.log('[babysitter]   Removed empty plugins/ directory');
+    }
+  } catch { /* best-effort */ }
+
+  if (!removedPlugin) {
+    console.log('[babysitter] Plugin directory not found; config and hooks cleaned if present.');
+    return;
+  }
+
+  console.log('[babysitter] Uninstallation complete. Restart OpenCode to finish removal.');
+}
+
+main();