openclaw-opencode-bridge 2.0.6

package/lib/onboard.js

@@ -0,0 +1,895 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const util = require("util");
+const { exec, execSync } = require("child_process");
+const chalk = require("chalk");
+
+const execAsync = util.promisify(exec);
+const { checkAll, getInstallCmd, installDep } = require("./deps");
+const {
+  detectOS,
+  getHomeDir,
+  getWorkspace,
+  getScriptsDir,
+  installDaemon,
+  substituteTemplate,
+} = require("./platform");
+
+const CORE_CHANNELS = [
+  "telegram",
+  "discord",
+  "slack",
+  "whatsapp",
+  "signal",
+  "irc",
+];
+const PLUGIN_CHANNELS = ["matrix", "line", "mattermost", "teams"];
+
+const SESSION_NAME = "opencode-daemon";
+const CHANNELS_URL = "http://127.0.0.1:18789/channels";
+
+// Commands to register in openclaw.json customCommands
+const BRIDGE_COMMANDS = [
+  { command: "cc", description: "Send instruction to existing OpenCode session" },
+  {
+    command: "ccn",
+    description: "Create new OpenCode session and send instruction",
+  },
+  { command: "ccu", description: "Query OpenCode usage/stats" },
+  { command: "ccm", description: "List available FREE OpenCode models" },
+  { command: "ccms", description: "Set OpenCode model (number or shortcut)" },
+];
+
+// Variable names used in each script (for patching existing scripts)
+const SCRIPT_VARS = {
+  "opencode-session.sh": {
+    TMUX: "TMUX_BIN",
+    OPENCODE: "OPENCODE_BIN",
+    WORKSPACE: "WORKSPACE",
+    SESSION: "SESSION_NAME",
+  },
+  "opencode-send.sh": {
+    TMUX: "TMUX_BIN",
+    CHANNEL: "CHANNEL",
+    TARGET: "TARGET_ID",
+    SESSION: "SESSION_NAME",
+  },
+  "opencode-new-session.sh": {
+    TMUX: "TMUX_BIN",
+    OPENCODE: "OPENCODE_BIN",
+    WORKSPACE: "WORKSPACE",
+    CHANNEL: "CHANNEL",
+    TARGET: "TARGET_ID",
+    SESSION: "SESSION_NAME",
+  },
+  "opencode-stats.sh": {
+    TMUX: "TMUX_BIN",
+    OPENCODE: "OPENCODE_BIN",
+    CHANNEL: "CHANNEL",
+    TARGET: "TARGET_ID",
+    WORKSPACE: "WORKSPACE",
+  },
+  "opencode-models.sh": {
+    TMUX: "TMUX_BIN",
+    OPENCODE: "OPENCODE_BIN",
+    CHANNEL: "CHANNEL",
+    TARGET: "TARGET_ID",
+  },
+  "opencode-setmodel.sh": {
+    TMUX: "TMUX_BIN",
+    OPENCODE: "OPENCODE_BIN",
+    CHANNEL: "CHANNEL",
+    TARGET: "TARGET_ID",
+    OPENCODE_CONFIG: "OPENCODE_CONFIG",
+  },
+};
+
+// --- Utility functions ---
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function ask(rl, question, defaultVal) {
+  return new Promise((resolve) => {
+    const suffix = defaultVal ? chalk.dim(` [${defaultVal}]`) : "";
+    rl.question(`    ${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultVal || "");
+    });
+  });
+}
+
+/**
+ * Interactive list selector with arrow keys.
+ * items: [{ label, tag?, separator? }]
+ * defaultIndex: initially highlighted index
+ * Returns the selected item's label.
+ *
+ * Falls back to simple numbered list if stdin is not a TTY (piped input).
+ */
+function selectList(items, defaultIndex = 0) {
+  const { stdin, stdout } = process;
+
+  // Fallback for non-TTY (piped input, CI, etc.)
+  if (!stdin.isTTY) {
+    return new Promise((resolve) => {
+      const selectable = items.filter((i) => !i.separator);
+      for (let i = 0; i < selectable.length; i++) {
+        const marker = i === defaultIndex ? chalk.cyan.bold(">") : " ";
+        const tag = selectable[i].tag ? chalk.dim(` ${selectable[i].tag}`) : "";
+        console.log(`    ${marker} ${i + 1}. ${selectable[i].label}${tag}`);
+      }
+      console.log();
+      const chosen = selectable[defaultIndex];
+      console.log(
+        `    ${chalk.green("\u2713")} Selected: ${chalk.bold(chosen.label)}`,
+      );
+      resolve(chosen.label);
+    });
+  }
+
+  return new Promise((resolve) => {
+    const wasRaw = stdin.isRaw;
+
+    // Ensure defaultIndex points to a selectable item
+    const selectableIndices = items
+      .map((item, i) => (item.separator ? -1 : i))
+      .filter((i) => i >= 0);
+    if (!selectableIndices.includes(defaultIndex)) {
+      defaultIndex = selectableIndices[0] ?? 0;
+    }
+    let cursor = defaultIndex;
+
+    const cleanup = () => {
+      try {
+        stdin.setRawMode(wasRaw || false);
+      } catch {}
+      stdin.removeListener("data", onKey);
+      stdin.pause();
+      process.removeListener("exit", cleanup);
+    };
+
+    process.once("exit", cleanup);
+
+    function render(first) {
+      // Move cursor up to overwrite previous render (except on first draw)
+      if (!first) {
+        stdout.write(`\x1b[${items.length + 1}A`); // +1 for hint line
+      }
+
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+
+        // Separator line
+        if (item.separator) {
+          stdout.write(`\r\x1b[K    ${chalk.dim("\u2500".repeat(36))}\n`);
+          continue;
+        }
+
+        const isActive = i === cursor;
+        const pointer = isActive ? chalk.cyan.bold("\u276f") : " ";
+        const label = isActive
+          ? chalk.cyan.bold(item.label)
+          : chalk.white(item.label);
+        const tag = item.tag
+          ? isActive
+            ? chalk.cyan.dim(` ${item.tag}`)
+            : chalk.dim(` ${item.tag}`)
+          : "";
+
+        stdout.write(`\r\x1b[K    ${pointer} ${label}${tag}\n`);
+      }
+
+      // Hint line
+      stdout.write(
+        `\r\x1b[K    ${chalk.dim("\u2191\u2193 navigate   enter select")}\n`,
+      );
+    }
+
+    function moveCursor(direction) {
+      const currentPos = selectableIndices.indexOf(cursor);
+      if (currentPos < 0) return;
+
+      let nextPos = currentPos + direction;
+      if (nextPos < 0) nextPos = selectableIndices.length - 1;
+      if (nextPos >= selectableIndices.length) nextPos = 0;
+      cursor = selectableIndices[nextPos];
+    }
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+
+    render(true);
+
+    function onKey(key) {
+      // Ctrl+C
+      if (key === "\x03") {
+        cleanup();
+        process.exit(0);
+      }
+
+      // Arrow up / k
+      if (key === "\x1b[A" || key === "k") {
+        moveCursor(-1);
+        render(false);
+        return;
+      }
+
+      // Arrow down / j
+      if (key === "\x1b[B" || key === "j") {
+        moveCursor(1);
+        render(false);
+        return;
+      }
+
+      // Enter
+      if (key === "\r" || key === "\n") {
+        cleanup();
+
+        // Overwrite the hint line with the selection result
+        stdout.write(
+          `\x1b[1A\r\x1b[K    ${chalk.green("\u2713")} Selected: ${chalk.bold(items[cursor].label)}\n`,
+        );
+
+        resolve(items[cursor].label);
+        return;
+      }
+    }
+
+    stdin.on("data", onKey);
+  });
+}
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+let activeSpinner = null;
+
+function startSpinner(text) {
+  let i = 0;
+  const id = setInterval(() => {
+    process.stdout.write(
+      `\r\x1b[K    ${chalk.cyan(SPINNER_FRAMES[i % SPINNER_FRAMES.length])} ${text}`,
+    );
+    i++;
+  }, 80);
+  const spinner = {
+    _id: id,
+    stop(result) {
+      clearInterval(id);
+      activeSpinner = null;
+      process.stdout.write(`\r\x1b[K    ${chalk.green("\u2713")} ${result}\n`);
+    },
+    fail(result) {
+      clearInterval(id);
+      activeSpinner = null;
+      process.stdout.write(`\r\x1b[K    ${chalk.red("\u2717")} ${result}\n`);
+    },
+  };
+  activeSpinner = spinner;
+  return spinner;
+}
+
+function formatInstallMsg(label, dir, created, patched) {
+  const parts = [];
+  if (created > 0) parts.push(`${created} created`);
+  if (patched > 0) parts.push(`${patched} updated`);
+  return `${label.padEnd(11)} ${chalk.dim("->")} ${dir} ${chalk.dim(`(${parts.join(", ")})`)}`;
+}
+
+function getScriptVersion(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const match = content.match(/^# bridge-version:\s*(\d+)/m);
+    return match ? parseInt(match[1], 10) : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function getTemplateVersion(srcRel) {
+  const srcPath = path.join(__dirname, "..", "templates", srcRel);
+  return getScriptVersion(srcPath);
+}
+
+function copyTemplate(srcRel, destPath, vars) {
+  const srcPath = path.join(__dirname, "..", "templates", srcRel);
+  let content = fs.readFileSync(srcPath, "utf8");
+  content = substituteTemplate(content, vars);
+  const dir = path.dirname(destPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(destPath, content);
+}
+
+function patchScriptVars(filePath, varMapping, vars) {
+  let content = fs.readFileSync(filePath, "utf8");
+  let patched = 0;
+
+  for (const [scriptVar, varsKey] of Object.entries(varMapping)) {
+    const newValue = vars[varsKey];
+    if (!newValue) continue;
+
+    const escaped = newValue.replace(/["\\`$]/g, "\\$&");
+    const regex = new RegExp(`^(${scriptVar}=).*$`, "gm");
+    const updated = content.replace(regex, `$1"${escaped}"`);
+    if (updated !== content) {
+      content = updated;
+      patched++;
+    }
+  }
+
+  if (patched > 0) fs.writeFileSync(filePath, content);
+  return patched;
+}
+
+function getDateStr() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+
+function openBrowser(url) {
+  try {
+    const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+    execSync(`${cmd} "${url}"`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// --- Main onboard flow ---
+
+async function onboard() {
+  const pkg = require("../package.json");
+  console.log();
+  console.log(
+    `  ${chalk.bold("openclaw-opencode-bridge")} ${chalk.dim(`v${pkg.version}`)}`,
+  );
+  console.log(`  ${"─".repeat(40)}`);
+  console.log();
+  await sleep(300);
+
+  // ========== Step 1: Check dependencies ==========
+  console.log(
+    `  ${chalk.bold("[1/5]")} ${chalk.bold("Checking dependencies...")}`,
+  );
+  console.log();
+  await sleep(200);
+
+  const { results } = checkAll();
+  const missing = [];
+
+  for (const dep of results) {
+    await sleep(250);
+    if (dep.found) {
+      console.log(
+        `    ${chalk.green("\u2713")} ${chalk.bold(dep.name.padEnd(10))} ${chalk.dim(dep.path)}`,
+      );
+      continue;
+    }
+
+    if (!dep.autoInstall) {
+      const cmd = getInstallCmd(dep);
+      console.log(
+        `    ${chalk.red("\u2717")} ${chalk.bold(dep.name.padEnd(10))} ${chalk.red("not found")}`,
+      );
+      console.log(`      ${chalk.dim("Install:")} ${chalk.cyan(cmd)}`);
+      if (dep.url) {
+        console.log(
+          `      ${chalk.dim("Docs:")}    ${chalk.underline(dep.url)}`,
+        );
+      }
+      missing.push(dep);
+      continue;
+    }
+
+    const cmd = getInstallCmd(dep);
+    console.log(
+      `    ${chalk.red("\u2717")} ${chalk.bold(dep.name.padEnd(10))} ${chalk.red("not found")}`,
+    );
+
+    if (cmd) {
+      console.log(`    ${chalk.cyan("\u2192")} Installing: ${chalk.bold(cmd)}`);
+      console.log();
+      const binPath = installDep(dep);
+      console.log();
+
+      if (binPath) {
+        dep.path = binPath;
+        dep.found = true;
+        console.log(
+          `    ${chalk.green("\u2713")} ${chalk.bold(dep.name.padEnd(10))} ${chalk.dim(binPath)}`,
+        );
+      } else {
+        console.log(
+          `    ${chalk.red("\u2717")} ${chalk.bold(dep.name.padEnd(10))} ${chalk.red("installation failed")}`,
+        );
+        missing.push(dep);
+      }
+    } else {
+      console.log(
+        `      ${chalk.yellow("!")} No package manager found. Install manually.`,
+      );
+      missing.push(dep);
+    }
+  }
+
+  console.log();
+
+  if (missing.length > 0) {
+    const hasPrereqs = missing.some((d) => !d.autoInstall);
+    if (hasPrereqs) {
+      console.log(
+        chalk.red(
+          "  OpenClaw and OpenCode must be installed before running this tool.",
+        ),
+      );
+      console.log(
+        chalk.red("  Install them first, then run this command again."),
+      );
+    } else {
+      console.log(
+        chalk.red(
+          "  Some dependencies could not be installed. Fix them and try again.",
+        ),
+      );
+    }
+    process.exit(1);
+  }
+
+  await sleep(400);
+
+  // ========== Step 2: Detect environment ==========
+  console.log(
+    `  ${chalk.bold("[2/5]")} ${chalk.bold("Detecting environment...")}`,
+  );
+  console.log();
+
+  const homeDir = getHomeDir();
+  const workspace = getWorkspace();
+  const osName = detectOS();
+  const tmuxBin = results.find((r) => r.name === "tmux").path;
+  const opencodeBin = results.find((r) => r.name === "opencode").path;
+
+  const envItems = [
+    ["OS", `${osName} (${process.platform})`],
+    ["Workspace", workspace],
+    ["Home", homeDir],
+  ];
+
+  for (const [label, value] of envItems) {
+    await sleep(200);
+    console.log(
+      `    ${chalk.green("\u2713")} ${chalk.bold(label.padEnd(13))} ${chalk.dim(value)}`,
+    );
+  }
+
+  console.log();
+  await sleep(400);
+
+  // ========== Step 3: OpenCode config ==========
+  console.log(`  ${chalk.bold("[3/5]")} ${chalk.bold("Configuring OpenCode...")}`);
+  console.log();
+  
+  const opencodeConfigDir = path.join(homeDir, ".config", "opencode");
+  const opencodeConfigPath = path.join(opencodeConfigDir, "opencode.json");
+
+  if (!fs.existsSync(opencodeConfigDir)) {
+    fs.mkdirSync(opencodeConfigDir, { recursive: true });
+  }
+
+  let opencodeConfig = {};
+  const opencodeConfigExists = fs.existsSync(opencodeConfigPath);
+
+  if (opencodeConfigExists) {
+    try {
+      opencodeConfig = JSON.parse(fs.readFileSync(opencodeConfigPath, "utf8"));
+      console.log(`    ${chalk.green("\u2713")} Existing config found`);
+    } catch {
+      opencodeConfig = {};
+      console.log(`    ${chalk.yellow("!")} Corrupted config, creating new`);
+    }
+  }
+
+  const defaultOpencodeConfig = {
+    $schema: "https://opencode.ai/config.json",
+    permission: {
+      read: "allow",
+      grep: "allow",
+      glob: "allow",
+      list: "allow",
+      edit: "allow",
+      write: "allow",
+      bash: "allow",
+      webfetch: "allow",
+      websearch: "allow",
+      question: "allow",
+      todowrite: "allow",
+      todoread: "allow",
+      skill: "allow",
+      patch: "allow",
+      lsp: "allow",
+    },
+  };
+
+  let configUpdated = false;
+  if (!opencodeConfig.permission) {
+    opencodeConfig = { ...defaultOpencodeConfig, ...opencodeConfig };
+    configUpdated = true;
+  }
+
+  if (configUpdated || !opencodeConfigExists) {
+    fs.writeFileSync(opencodeConfigPath, JSON.stringify(opencodeConfig, null, 2));
+    console.log(`    ${chalk.green("\u2713")} Config saved: ${opencodeConfigPath}`);
+  } else {
+    console.log(`    ${chalk.green("\u2713")} Permissions already configured`);
+  }
+
+  console.log();
+  await sleep(400);
+
+  // ========== Step 4: Channel setup ==========
+  console.log(`  ${chalk.bold("[4/5]")} ${chalk.bold("Channel setup")}`);
+  console.log();
+  await sleep(200);
+
+  console.log(`    ${chalk.bold("Select a channel:")}`);
+  console.log();
+
+  const channelItems = [
+    ...CORE_CHANNELS.map((c) => ({ label: c })),
+    { separator: true },
+    ...PLUGIN_CHANNELS.map((c) => ({ label: c, tag: "plugin" })),
+  ];
+
+  const channel = await selectList(channelItems, 0);
+  console.log();
+
+  // --- Channel target ID ---
+  console.log(`    ${chalk.yellow("?")} ${chalk.bold("Your ${channel} User/Chat ID")}`);
+  console.log();
+  console.log(`      OpenCode needs to know where to send replies.`);
+  console.log();
+
+  if (channel === "telegram") {
+    console.log(`      ${chalk.cyan("1.")} Open this bot: ${chalk.underline("https://t.me/userinfobot")}`);
+    console.log(`      ${chalk.cyan("2.")} It will show your Telegram User ID`);
+    console.log(`      ${chalk.cyan("3.")} Copy and paste it below`);
+  } else {
+    console.log(
+      `      ${chalk.dim("Enter your channel/chat ID for")} ${chalk.bold(channel)}`,
+    );
+  }
+  console.log();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const targetId = await ask(rl, "Paste your user ID");
+  rl.close();
+
+  if (!targetId) {
+    console.log(chalk.red("\n  Target ID is required."));
+    process.exit(1);
+  }
+
+  console.log();
+  await sleep(300);
+
+  // ========== Step 5: Install ==========
+  console.log(`  ${chalk.bold("[5/5]")} ${chalk.bold("Installing...")}`);
+  console.log();
+
+  const scriptsDir = getScriptsDir();
+  const skillsDir = path.join(workspace, "skills");
+
+  const vars = {
+    CHANNEL: channel,
+    TARGET_ID: targetId,
+    WORKSPACE: workspace,
+    TMUX_BIN: tmuxBin,
+    OPENCODE_BIN: opencodeBin,
+    HOME_DIR: homeDir,
+    SESSION_NAME: SESSION_NAME,
+    SCRIPTS_DIR: scriptsDir,
+    OPENCODE_CONFIG: path.join(homeDir, ".config", "opencode", "opencode.json"),
+  };
+
+  // --- 4a. Scripts ---
+  const spinner1 = startSpinner("Installing scripts...");
+  await sleep(400);
+
+  const scriptFiles = Object.keys(SCRIPT_VARS);
+  let scriptsCreated = 0;
+  let scriptsPatched = 0;
+
+  for (const file of scriptFiles) {
+    const dest = path.join(scriptsDir, file);
+    const tplRel = path.join("scripts", file);
+
+    if (fs.existsSync(dest)) {
+      const installedVer = getScriptVersion(dest);
+      const templateVer = getTemplateVersion(tplRel);
+
+      if (installedVer < templateVer) {
+        // Structure changed — replace with new template
+        copyTemplate(tplRel, dest, vars);
+        fs.chmodSync(dest, 0o755);
+        scriptsCreated++;
+      } else {
+        // Same version — patch variables only
+        const varMapping = SCRIPT_VARS[file];
+        if (varMapping) {
+          patchScriptVars(dest, varMapping, vars);
+          scriptsPatched++;
+        }
+      }
+    } else {
+      copyTemplate(tplRel, dest, vars);
+      fs.chmodSync(dest, 0o755);
+      scriptsCreated++;
+    }
+  }
+
+  spinner1.stop(
+    formatInstallMsg("Scripts", scriptsDir, scriptsCreated, scriptsPatched),
+  );
+
+  await sleep(300);
+
+  // --- 4b. Plugin (prefix detection + LLM suppression) ---
+  const spinner2a = startSpinner("Installing plugin...");
+  await sleep(400);
+
+  const pluginDir = path.join(homeDir, ".openclaw", "plugins", "opencode-bridge");
+  const pluginFiles = ["openclaw.plugin.json", "package.json", "index.ts"];
+  let pluginCreated = 0;
+  let pluginPatched = 0;
+
+  fs.mkdirSync(pluginDir, { recursive: true });
+
+  for (const file of pluginFiles) {
+    const dest = path.join(pluginDir, file);
+    const existed = fs.existsSync(dest);
+
+    const srcPath = path.join(__dirname, "..", "plugin", file);
+    fs.writeFileSync(dest, fs.readFileSync(srcPath, "utf8"));
+
+    if (existed) pluginPatched++;
+    else pluginCreated++;
+  }
+
+  // Write plugin config + clean legacy commands in openclaw.json (single read/write)
+  const openclawConfigPath = path.join(homeDir, ".openclaw", "openclaw.json");
+  try {
+    const config = JSON.parse(fs.readFileSync(openclawConfigPath, "utf8"));
+    if (!config.plugins) config.plugins = {};
+
+    // Register plugin load path
+    if (!config.plugins.load) config.plugins.load = {};
+    if (!Array.isArray(config.plugins.load.paths))
+      config.plugins.load.paths = [];
+    if (!config.plugins.load.paths.includes(pluginDir)) {
+      config.plugins.load.paths.push(pluginDir);
+    }
+
+    // Explicitly allow plugin to avoid auto-load warnings
+    if (!Array.isArray(config.plugins.allow)) config.plugins.allow = [];
+    if (!config.plugins.allow.includes("opencode-bridge")) {
+      config.plugins.allow.push("opencode-bridge");
+    }
+
+    // Plugin entry config
+    if (!config.plugins.entries) config.plugins.entries = {};
+    config.plugins.entries["opencode-bridge"] = {
+      enabled: true,
+      config: {
+        scriptsDir: scriptsDir,
+        channel: channel,
+        targetId: targetId,
+      },
+    };
+
+    // Install record
+    if (!config.plugins.installs) config.plugins.installs = {};
+    config.plugins.installs["opencode-bridge"] = {
+      source: "path",
+      sourcePath: pluginDir,
+      installPath: pluginDir,
+      version: pkg.version,
+      installedAt: new Date().toISOString(),
+    };
+
+    // Register customCommands so OpenClaw passes them to the plugin
+    if (!config.channels) config.channels = {};
+    if (!config.channels[channel]) config.channels[channel] = {};
+    if (!Array.isArray(config.channels[channel].customCommands)) {
+      config.channels[channel].customCommands = [];
+    }
+    const cmds = config.channels[channel].customCommands;
+    for (const bc of BRIDGE_COMMANDS) {
+      const idx = cmds.findIndex((c) => c.command === bc.command);
+      if (idx >= 0) cmds[idx].description = bc.description;
+      else cmds.push({ command: bc.command, description: bc.description });
+    }
+
+    fs.writeFileSync(
+      openclawConfigPath,
+      `${JSON.stringify(config, null, 2)}\n`,
+    );
+  } catch {
+    console.log(
+      `    ${chalk.yellow("!")} Could not write openclaw.json — plugin may need manual config`,
+    );
+  }
+
+  // Remove legacy workspace hook if present
+  const legacyHookDir = path.join(workspace, "hooks", "opencode-bridge");
+  if (fs.existsSync(legacyHookDir)) {
+    fs.rmSync(legacyHookDir, { recursive: true, force: true });
+  }
+
+  spinner2a.stop(
+    formatInstallMsg("Plugin", pluginDir, pluginCreated, pluginPatched),
+  );
+
+  await sleep(300);
+
+  // --- 4c. Remove legacy skills (replaced by hook) ---
+  const skillNames = BRIDGE_COMMANDS.map((c) => c.command);
+  let skillsToRemove = [];
+
+  for (const skill of skillNames) {
+    const skillFile = path.join(skillsDir, skill, "SKILL.md");
+    if (fs.existsSync(skillFile)) {
+      skillsToRemove.push(skill);
+    }
+  }
+
+  if (skillsToRemove.length > 0) {
+    const spinner2 = startSpinner("Cleaning legacy skills...");
+    await sleep(400);
+    let skillsRemoved = 0;
+    for (const skill of skillsToRemove) {
+      const skillFile = path.join(skillsDir, skill, "SKILL.md");
+      const skillDir = path.join(skillsDir, skill);
+      fs.unlinkSync(skillFile);
+      try {
+        fs.rmdirSync(skillDir);
+      } catch {}
+      skillsRemoved++;
+    }
+    spinner2.stop(
+      `Skills      ${chalk.dim("->")} ${skillsRemoved} legacy skills removed ${chalk.dim("(replaced by hook)")}`,
+    );
+    await sleep(300);
+  }
+
+  // --- 4d. Global AGENTS.md for OpenCode ---
+  const spinner3 = startSpinner("Installing AGENTS.md...");
+  await sleep(400);
+
+  const opencodeAgentsDir = path.join(homeDir, ".config", "opencode");
+  const opencodeAgentsDest = path.join(opencodeAgentsDir, "AGENTS.md");
+
+  if (!fs.existsSync(opencodeAgentsDir)) {
+    fs.mkdirSync(opencodeAgentsDir, { recursive: true });
+  }
+
+  if (fs.existsSync(opencodeAgentsDest)) {
+    const dateStr = getDateStr();
+    let backupPath = path.join(opencodeAgentsDir, `AGENTS.${dateStr}.md`);
+    let suffix = 1;
+    while (fs.existsSync(backupPath)) {
+      backupPath = path.join(opencodeAgentsDir, `AGENTS.${dateStr}-${suffix}.md`);
+      suffix++;
+    }
+    fs.renameSync(opencodeAgentsDest, backupPath);
+    spinner3.stop(
+      `AGENTS.md    ${chalk.dim("->")} existing backed up as ${chalk.yellow(path.basename(backupPath))}`,
+    );
+
+    await sleep(200);
+    const spinner3b = startSpinner("Writing new AGENTS.md...");
+    await sleep(300);
+    copyTemplate(path.join("workspace", "OPENCODE.md"), opencodeAgentsDest, vars);
+    spinner3b.stop(`AGENTS.md    ${chalk.dim("->")} ${opencodeAgentsDest}`);
+  } else {
+    copyTemplate(path.join("workspace", "OPENCODE.md"), opencodeAgentsDest, vars);
+    spinner3.stop(`AGENTS.md    ${chalk.dim("->")} ${opencodeAgentsDest}`);
+  }
+
+  await sleep(300);
+
+  // --- 4e. Daemon ---
+
+  const spinner4 = startSpinner("Registering daemon...");
+  await sleep(500);
+
+  const sessionScript = path.join(scriptsDir, "opencode-session.sh");
+  const daemonOk = installDaemon(sessionScript);
+  if (daemonOk) {
+    const daemonType =
+      process.platform === "darwin" ? "LaunchAgent" : "systemd";
+    spinner4.stop(
+      `Daemon      ${chalk.dim("->")} ${daemonType} registered ${chalk.dim("(30s interval)")}`,
+    );
+  } else {
+    spinner4.fail(`Daemon      ${chalk.dim("->")} manual setup required`);
+  }
+
+  await sleep(300);
+
+  // --- 4f. Restart OpenClaw Gateway ---
+  const spinner5 = startSpinner("Restarting OpenClaw Gateway...");
+  await sleep(300);
+
+  let restarted = false;
+  let restartError = "";
+  try {
+    await execAsync("openclaw gateway restart", { timeout: 15000 });
+    restarted = true;
+  } catch (e) {
+    restartError = e.stderr?.trim() || e.message;
+  }
+
+  if (restarted) {
+    spinner5.stop(
+      `Gateway     ${chalk.dim("->")} restarted ${chalk.dim("(skills loaded)")}`,
+    );
+  } else {
+    spinner5.fail(
+      `Gateway     ${chalk.dim("->")} could not restart ${restartError ? chalk.dim(`(${restartError})`) : ""}`,
+    );
+  }
+
+  // ========== Done ==========
+  console.log();
+  await sleep(300);
+  console.log(`  ${chalk.green.bold("\u2705 Setup complete!")}`);
+  console.log();
+
+  if (!restarted) {
+    console.log(`  ${chalk.bold.yellow("Action required:")}`);
+    console.log(`    Restart OpenClaw to load the new skills:`);
+    console.log(
+      `    ${chalk.cyan("/restart")}                from your ${chalk.bold(channel)}`,
+    );
+    console.log(`    ${chalk.cyan("openclaw gateway restart")}  from terminal`);
+    console.log();
+  }
+
+  console.log(`  ${chalk.bold("Quick test:")}`);
+  console.log(
+    `    Send ${chalk.cyan.bold("@cc hello")} from your ${chalk.bold(channel)}`,
+  );
+  console.log();
+  console.log(`  ${chalk.bold("Commands:")}`);
+  console.log(`    ${chalk.cyan("@cc message")}   Send to existing session`);
+  console.log(
+    `    ${chalk.cyan("@ccn message")}  Create new session and send`,
+  );
+  console.log(`    ${chalk.cyan("@ccu")}          Check usage/stats`);
+  console.log(`    ${chalk.cyan("@ccm")}          List available models`);
+  console.log(`    ${chalk.cyan("@ccms <num>")}    Set model (use @ccm first)`);
+  console.log();
+  console.log(
+    `  ${chalk.dim("Prefix @cc and /cc are both supported. Quotes are optional.")}`,
+  );
+  console.log();
+}
+
+process.on("exit", () => {
+  if (activeSpinner) {
+    clearInterval(activeSpinner._id);
+    activeSpinner = null;
+  }
+});
+
+module.exports = { onboard, BRIDGE_COMMANDS, SCRIPT_VARS };