opendevbrowser 0.0.10

package/dist/cli/index.js

@@ -0,0 +1,802 @@
+#!/usr/bin/env node
+import {
+  extractExtension,
+  generateSecureToken
+} from "../chunk-R5VUZEUU.js";
+
+// src/cli/args.ts
+var SHORT_FLAGS = {
+  "-g": "--global",
+  "-l": "--local",
+  "-u": "--update",
+  "-h": "--help",
+  "-v": "--version",
+  "-f": "--full"
+};
+function expandShortFlags(args) {
+  return args.map((arg) => SHORT_FLAGS[arg] ?? arg);
+}
+function parseSkillsMode(args) {
+  if (args.includes("--no-skills")) {
+    return "none";
+  }
+  if (args.includes("--skills-local")) {
+    return "local";
+  }
+  if (args.includes("--skills-global")) {
+    return "global";
+  }
+  return "global";
+}
+function parseArgs(argv) {
+  const args = expandShortFlags(argv.slice(2));
+  const skillsMode = parseSkillsMode(args);
+  const fullInstall = args.includes("--full");
+  if (args.includes("--help") || args.includes("-h")) {
+    return { command: "help", withConfig: false, noPrompt: false, skillsMode, fullInstall };
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    return { command: "version", withConfig: false, noPrompt: false, skillsMode, fullInstall };
+  }
+  if (args.includes("--update")) {
+    const mode2 = args.includes("--global") ? "global" : args.includes("--local") ? "local" : void 0;
+    return { command: "update", mode: mode2, withConfig: false, noPrompt: false, skillsMode, fullInstall };
+  }
+  if (args.includes("--uninstall")) {
+    const mode2 = args.includes("--global") ? "global" : args.includes("--local") ? "local" : void 0;
+    const noPrompt2 = args.includes("--no-prompt");
+    return { command: "uninstall", mode: mode2, withConfig: false, noPrompt: noPrompt2, skillsMode, fullInstall };
+  }
+  const withConfig = args.includes("--with-config") || fullInstall;
+  const noPrompt = args.includes("--no-prompt");
+  let mode;
+  if (args.includes("--global")) {
+    mode = "global";
+  } else if (args.includes("--local")) {
+    mode = "local";
+  } else if (noPrompt) {
+    mode = "global";
+  }
+  const validFlags = /* @__PURE__ */ new Set([
+    "--global",
+    "--local",
+    "--update",
+    "--uninstall",
+    "--help",
+    "--version",
+    "--with-config",
+    "--no-prompt",
+    "--full",
+    "--skills-global",
+    "--skills-local",
+    "--no-skills"
+  ]);
+  for (const arg of args) {
+    if (arg.startsWith("--") && !validFlags.has(arg)) {
+      throw new Error(`Unknown flag: ${arg}`);
+    }
+    if (arg.startsWith("-") && !arg.startsWith("--") && !SHORT_FLAGS[arg]) {
+      throw new Error(`Unknown flag: ${arg}`);
+    }
+  }
+  return { command: "install", mode, withConfig, noPrompt, skillsMode, fullInstall };
+}
+function getHelpText() {
+  return `
+OpenDevBrowser CLI - Install and manage the OpenDevBrowser plugin
+
+USAGE:
+  npx opendevbrowser [options]
+
+COMMANDS:
+  (default)        Install the plugin (interactive if no mode specified)
+  --update, -u     Clear cached plugin to trigger reinstall
+  --uninstall      Remove plugin from config
+  --help, -h       Show this help message
+  --version, -v    Show version
+
+INSTALL OPTIONS:
+  --global, -g     Install to ~/.config/opencode/opencode.json
+  --local, -l      Install to ./opencode.json (project-local)
+  --with-config    Also create opendevbrowser.jsonc with defaults
+  --full, -f       Create config and pre-extract extension assets
+  --no-prompt      Skip prompts, use defaults (global install)
+  --skills-global  Install bundled skills to ~/.config/opencode/skill (default)
+  --skills-local   Install bundled skills to ./.opencode/skill
+  --no-skills      Skip installing bundled skills
+
+EXAMPLES:
+  npx opendevbrowser              # Interactive install
+  npx opendevbrowser --global     # Global install
+  npx opendevbrowser --local      # Project install
+  npx opendevbrowser --full       # Install + config + extension assets
+  npx opendevbrowser -g --with-config  # Global + config file
+  npx opendevbrowser --skills-local   # Install skills locally
+  npx opendevbrowser --no-skills      # Skip skill installation
+  npx opendevbrowser --update     # Update plugin
+  npx opendevbrowser --uninstall --global  # Remove from global config
+`.trim();
+}
+
+// src/cli/installers/global.ts
+import * as fs4 from "fs";
+
+// src/cli/utils/config.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os from "os";
+import { parse as parseJsonc, modify, applyEdits } from "jsonc-parser";
+
+// src/utils/fs.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+function writeFileAtomic(filePath, content, options = {}) {
+  const { encoding = "utf-8", mode } = options;
+  const dir = path.dirname(filePath);
+  const hash = crypto.randomBytes(8).toString("hex");
+  const tempPath = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${hash}.tmp`);
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const writeOptions = { encoding };
+    if (mode !== void 0) {
+      writeOptions.mode = mode;
+    }
+    fs.writeFileSync(tempPath, content, writeOptions);
+    fs.renameSync(tempPath, filePath);
+  } catch (error) {
+    try {
+      if (fs.existsSync(tempPath)) {
+        fs.unlinkSync(tempPath);
+      }
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// src/cli/utils/config.ts
+var PLUGIN_NAME = "opendevbrowser";
+var SCHEMA_URL = "https://opencode.ai/config.json";
+function getGlobalConfigPath() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR || path2.join(os.homedir(), ".config", "opencode");
+  return path2.join(configDir, "opencode.json");
+}
+function getLocalConfigPath() {
+  return path2.join(process.cwd(), "opencode.json");
+}
+function ensureDir(dirPath) {
+  if (!fs2.existsSync(dirPath)) {
+    fs2.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function readConfig(configPath) {
+  if (!fs2.existsSync(configPath)) {
+    return { content: "", config: {} };
+  }
+  const content = fs2.readFileSync(configPath, "utf-8");
+  const errors = [];
+  const parsed = parseJsonc(content, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    const firstError = errors[0];
+    throw new Error(`Invalid JSONC at ${configPath}: parse error at offset ${firstError?.offset ?? 0}`);
+  }
+  return { content, config: parsed ?? {} };
+}
+function hasPlugin(config, pluginName = PLUGIN_NAME) {
+  return config.plugin?.includes(pluginName) ?? false;
+}
+function createConfigWithPlugin(pluginName = PLUGIN_NAME) {
+  return {
+    $schema: SCHEMA_URL,
+    plugin: [pluginName]
+  };
+}
+function updateConfigContent(content, pluginName = PLUGIN_NAME) {
+  if (!content.trim()) {
+    return JSON.stringify(createConfigWithPlugin(pluginName), null, 2) + "\n";
+  }
+  const parsed = parseJsonc(content, [], { allowTrailingComma: true }) ?? {};
+  if (parsed.plugin?.includes(pluginName)) {
+    return content;
+  }
+  let result = content;
+  if (!parsed.$schema) {
+    const edits2 = modify(result, ["$schema"], SCHEMA_URL, { formattingOptions: { tabSize: 2, insertSpaces: true } });
+    result = applyEdits(result, edits2);
+  }
+  const newPlugins = parsed.plugin ? [...parsed.plugin, pluginName] : [pluginName];
+  const edits = modify(result, ["plugin"], newPlugins, { formattingOptions: { tabSize: 2, insertSpaces: true } });
+  result = applyEdits(result, edits);
+  return result;
+}
+function removePluginFromContent(content, pluginName = PLUGIN_NAME) {
+  if (!content.trim()) {
+    return content;
+  }
+  const parsed = parseJsonc(content, [], { allowTrailingComma: true }) ?? {};
+  if (!parsed.plugin?.includes(pluginName)) {
+    return content;
+  }
+  const newPlugins = parsed.plugin.filter((p) => p !== pluginName);
+  const edits = modify(content, ["plugin"], newPlugins.length > 0 ? newPlugins : void 0, {
+    formattingOptions: { tabSize: 2, insertSpaces: true }
+  });
+  return applyEdits(content, edits);
+}
+
+// src/cli/templates/config.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
+function buildConfigTemplate(token) {
+  return `{
+  // OpenDevBrowser Plugin Configuration
+  // See: https://github.com/anthropics/opendevbrowser#configuration
+
+  "headless": false,
+  "profile": "default",
+  "persistProfile": true,
+
+  "snapshot": {
+    "maxChars": 16000,
+    "maxNodes": 1000
+  },
+
+  "export": {
+    "maxNodes": 1000,
+    "inlineStyles": true
+  },
+
+  "devtools": {
+    "showFullUrls": false,
+    "showFullConsole": false
+  },
+
+  "security": {
+    "allowRawCDP": false,
+    "allowNonLocalCdp": false,
+    "allowUnsafeExport": false
+  },
+
+  "skillPaths": [],
+  "skills": {
+    "nudge": {
+      "enabled": true,
+      "keywords": ["login", "form", "extract"],
+      "maxAgeMs": 60000
+    }
+  },
+
+  "continuity": {
+    "enabled": true,
+    "filePath": "opendevbrowser_continuity.md",
+    "nudge": {
+      "enabled": true,
+      "keywords": [
+        "plan",
+        "multi-step",
+        "multi step",
+        "long-running",
+        "long running",
+        "refactor",
+        "migration",
+        "rollout",
+        "release",
+        "upgrade",
+        "investigate",
+        "follow-up",
+        "continue"
+      ],
+      "maxAgeMs": 60000
+    }
+  },
+
+  "relayPort": 8787,
+  "relayToken": "${token}",
+
+  "flags": [],
+
+  "checkForUpdates": false
+}
+`;
+}
+function getPluginConfigPath(mode) {
+  if (mode === "global") {
+    const configDir = process.env.OPENCODE_CONFIG_DIR || path3.join(os2.homedir(), ".config", "opencode");
+    return path3.join(configDir, "opendevbrowser.jsonc");
+  }
+  return path3.join(process.cwd(), "opendevbrowser.jsonc");
+}
+function createPluginConfig(mode) {
+  const configPath = getPluginConfigPath(mode);
+  if (fs3.existsSync(configPath)) {
+    return { created: false, path: configPath };
+  }
+  const dir = path3.dirname(configPath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  const token = generateSecureToken();
+  writeFileAtomic(configPath, buildConfigTemplate(token));
+  return { created: true, path: configPath };
+}
+
+// src/cli/installers/global.ts
+function installGlobal(withConfig = false) {
+  const configPath = getGlobalConfigPath();
+  try {
+    const { content, config } = readConfig(configPath);
+    if (hasPlugin(config)) {
+      return {
+        success: true,
+        message: `opendevbrowser is already installed in ${configPath}`,
+        configPath,
+        created: false,
+        alreadyInstalled: true
+      };
+    }
+    const newContent = updateConfigContent(content, "opendevbrowser");
+    ensureDir(configPath.replace(/[/\\][^/\\]+$/, ""));
+    fs4.writeFileSync(configPath, newContent, "utf-8");
+    if (withConfig) {
+      createPluginConfig("global");
+    }
+    return {
+      success: true,
+      message: `Added opendevbrowser to ${configPath}`,
+      configPath,
+      created: content.trim() === "",
+      alreadyInstalled: false
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Failed to install globally: ${message}`,
+      configPath,
+      created: false,
+      alreadyInstalled: false
+    };
+  }
+}
+
+// src/cli/installers/local.ts
+import * as fs5 from "fs";
+function installLocal(withConfig = false) {
+  const configPath = getLocalConfigPath();
+  try {
+    const { content, config } = readConfig(configPath);
+    if (hasPlugin(config)) {
+      return {
+        success: true,
+        message: `opendevbrowser is already installed in ${configPath}`,
+        configPath,
+        created: false,
+        alreadyInstalled: true
+      };
+    }
+    const newContent = updateConfigContent(content, "opendevbrowser");
+    fs5.writeFileSync(configPath, newContent, "utf-8");
+    if (withConfig) {
+      createPluginConfig("local");
+    }
+    return {
+      success: true,
+      message: `Added opendevbrowser to ${configPath}`,
+      configPath,
+      created: content.trim() === "",
+      alreadyInstalled: false
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Failed to install locally: ${message}`,
+      configPath,
+      created: false,
+      alreadyInstalled: false
+    };
+  }
+}
+
+// src/cli/installers/skills.ts
+import * as fs7 from "fs";
+import * as path5 from "path";
+
+// src/cli/utils/skills.ts
+import * as fs6 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "opendevbrowser";
+var SKILL_DIR_NAME = "skill";
+var cachedPackageRoot = null;
+function findPackageRoot(startDir) {
+  let current = startDir;
+  while (true) {
+    const pkgPath = path4.join(current, "package.json");
+    if (fs6.existsSync(pkgPath)) {
+      try {
+        const parsed = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+        if (parsed.name === PACKAGE_NAME) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  throw new Error("Unable to locate opendevbrowser package root for skill installation.");
+}
+function getPackageRoot() {
+  if (cachedPackageRoot) return cachedPackageRoot;
+  const moduleDir = path4.dirname(fileURLToPath(import.meta.url));
+  cachedPackageRoot = findPackageRoot(moduleDir);
+  return cachedPackageRoot;
+}
+function getBundledSkillsDir() {
+  const skillsDir = path4.join(getPackageRoot(), "skills");
+  if (!fs6.existsSync(skillsDir)) {
+    throw new Error(`Bundled skills directory not found at ${skillsDir}`);
+  }
+  return skillsDir;
+}
+function getGlobalSkillDir() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR || path4.join(os3.homedir(), ".config", "opencode");
+  return path4.join(configDir, SKILL_DIR_NAME);
+}
+function getLocalSkillDir() {
+  return path4.join(process.cwd(), ".opencode", SKILL_DIR_NAME);
+}
+
+// src/cli/installers/skills.ts
+function installSkills(mode) {
+  const targetDir = mode === "global" ? getGlobalSkillDir() : getLocalSkillDir();
+  const installed = [];
+  const skipped = [];
+  try {
+    const sourceDir = getBundledSkillsDir();
+    const entries = fs7.readdirSync(sourceDir, { withFileTypes: true });
+    ensureDir(targetDir);
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillName = entry.name;
+      const sourcePath = path5.join(sourceDir, skillName);
+      const targetPath = path5.join(targetDir, skillName);
+      if (fs7.existsSync(targetPath)) {
+        skipped.push(skillName);
+        continue;
+      }
+      fs7.cpSync(sourcePath, targetPath, { recursive: true });
+      installed.push(skillName);
+    }
+    const summary = `Skills ${mode} install: ${installed.length} installed${skipped.length ? `, ${skipped.length} skipped` : ""} (${targetDir})`;
+    return {
+      success: true,
+      message: summary,
+      targetDir,
+      installed,
+      skipped
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Failed to install skills (${mode}): ${message}`,
+      targetDir,
+      installed,
+      skipped
+    };
+  }
+}
+
+// src/cli/commands/update.ts
+import * as fs8 from "fs";
+import * as path6 from "path";
+import * as os4 from "os";
+var PLUGIN_NAME2 = "opendevbrowser";
+function getCacheDir() {
+  return process.env.OPENCODE_CACHE_DIR || path6.join(os4.homedir(), ".cache", "opencode");
+}
+function rmdir(dirPath) {
+  const cacheDir = getCacheDir();
+  const resolvedCache = path6.resolve(cacheDir);
+  const resolvedPath = path6.resolve(dirPath);
+  if (!resolvedPath.startsWith(resolvedCache + path6.sep) || resolvedPath === resolvedCache) {
+    throw new Error(`Security: refusing to delete path outside cache directory: ${dirPath}`);
+  }
+  if (fs8.existsSync(dirPath)) {
+    fs8.rmSync(dirPath, { recursive: true, force: true });
+  }
+}
+function runUpdate() {
+  const cacheDir = getCacheDir();
+  const nodeModulesDir = path6.join(cacheDir, "node_modules");
+  const pluginCacheDir = path6.join(nodeModulesDir, PLUGIN_NAME2);
+  try {
+    if (!fs8.existsSync(pluginCacheDir)) {
+      if (fs8.existsSync(nodeModulesDir)) {
+        rmdir(nodeModulesDir);
+        return {
+          success: true,
+          message: "Cleared OpenCode plugin cache. The latest version will be installed on next run.",
+          cleared: true
+        };
+      }
+      return {
+        success: true,
+        message: "No cached plugin found. OpenCode will install the latest version on next run.",
+        cleared: false
+      };
+    }
+    rmdir(pluginCacheDir);
+    return {
+      success: true,
+      message: "Cache cleared. OpenCode will install the latest version on next run.",
+      cleared: true
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Failed to clear cache: ${message}`,
+      cleared: false
+    };
+  }
+}
+
+// src/cli/commands/uninstall.ts
+import * as fs9 from "fs";
+import * as path7 from "path";
+import * as os5 from "os";
+function getPluginConfigPath2(mode) {
+  if (mode === "global") {
+    const configDir = process.env.OPENCODE_CONFIG_DIR || path7.join(os5.homedir(), ".config", "opencode");
+    return path7.join(configDir, "opendevbrowser.jsonc");
+  }
+  return path7.join(process.cwd(), "opendevbrowser.jsonc");
+}
+function removePluginConfigFile(mode) {
+  const configPath = getPluginConfigPath2(mode);
+  if (fs9.existsSync(configPath)) {
+    fs9.unlinkSync(configPath);
+    return true;
+  }
+  return false;
+}
+function runUninstall(mode, deleteConfigFile = false) {
+  const configPath = mode === "global" ? getGlobalConfigPath() : getLocalConfigPath();
+  try {
+    const { content, config } = readConfig(configPath);
+    if (!hasPlugin(config)) {
+      return {
+        success: true,
+        message: `opendevbrowser is not installed in ${configPath}`,
+        configPath,
+        removed: false,
+        configFileDeleted: false
+      };
+    }
+    const newContent = removePluginFromContent(content, "opendevbrowser");
+    fs9.writeFileSync(configPath, newContent, "utf-8");
+    let configFileDeleted = false;
+    if (deleteConfigFile) {
+      configFileDeleted = removePluginConfigFile(mode);
+    }
+    return {
+      success: true,
+      message: `Removed opendevbrowser from ${configPath}`,
+      configPath,
+      removed: true,
+      configFileDeleted
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Failed to uninstall: ${message}`,
+      configPath,
+      removed: false,
+      configFileDeleted: false
+    };
+  }
+}
+function findInstalledConfigs() {
+  let global = false;
+  let local = false;
+  try {
+    const { config: globalConfig } = readConfig(getGlobalConfigPath());
+    global = hasPlugin(globalConfig);
+  } catch {
+  }
+  try {
+    const { config: localConfig } = readConfig(getLocalConfigPath());
+    local = hasPlugin(localConfig);
+  } catch {
+  }
+  return { global, local };
+}
+
+// src/cli/index.ts
+var VERSION = "0.1.0";
+async function promptInstallMode() {
+  if (!process.stdin.isTTY) {
+    console.log("Non-interactive mode detected. Using global install.");
+    return "global";
+  }
+  return new Promise((resolve2) => {
+    console.log("\nWhere would you like to install opendevbrowser?\n");
+    console.log("  1. Global (~/.config/opencode/opencode.json)");
+    console.log("  2. Local (./opencode.json in this project)\n");
+    process.stdout.write("Enter choice [1]: ");
+    process.stdin.setEncoding("utf8");
+    let resolved = false;
+    let timeoutId = null;
+    const cleanup = () => {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+    process.stdin.once("data", (data) => {
+      cleanup();
+      if (resolved) return;
+      resolved = true;
+      const input = data.toString().trim();
+      if (input === "2") {
+        resolve2("local");
+      } else {
+        resolve2("global");
+      }
+    });
+    process.stdin.once("close", () => {
+      cleanup();
+      if (resolved) return;
+      resolved = true;
+      resolve2("global");
+    });
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      if (resolved) return;
+      resolved = true;
+      console.log("\nTimeout - using global install.");
+      resolve2("global");
+    }, 3e4);
+  });
+}
+async function promptUninstallMode() {
+  const installed = findInstalledConfigs();
+  if (!installed.global && !installed.local) {
+    console.log("opendevbrowser is not installed in any config.");
+    return null;
+  }
+  if (installed.global && !installed.local) {
+    return "global";
+  }
+  if (!installed.global && installed.local) {
+    return "local";
+  }
+  if (!process.stdin.isTTY) {
+    console.log("Plugin found in both global and local configs. Use --global or --local flag.");
+    return null;
+  }
+  return new Promise((resolve2) => {
+    console.log("\nopendevbrowser is installed in multiple locations:\n");
+    console.log("  1. Global (~/.config/opencode/opencode.json)");
+    console.log("  2. Local (./opencode.json)");
+    console.log("  3. Cancel\n");
+    process.stdout.write("Which to uninstall? [3]: ");
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (data) => {
+      const input = data.toString().trim();
+      if (input === "1") {
+        resolve2("global");
+      } else if (input === "2") {
+        resolve2("local");
+      } else {
+        resolve2(null);
+      }
+    });
+    process.stdin.once("close", () => {
+      resolve2(null);
+    });
+  });
+}
+async function main() {
+  try {
+    const args = parseArgs(process.argv);
+    switch (args.command) {
+      case "help":
+        console.log(getHelpText());
+        process.exit(0);
+        break;
+      case "version":
+        console.log(`opendevbrowser v${VERSION}`);
+        process.exit(0);
+        break;
+      case "update": {
+        const result = runUpdate();
+        console.log(result.message);
+        process.exit(result.success ? 0 : 1);
+        break;
+      }
+      case "uninstall": {
+        let mode = args.mode;
+        if (!mode && !args.noPrompt) {
+          mode = await promptUninstallMode() ?? void 0;
+          if (!mode) {
+            console.log("Uninstall cancelled.");
+            process.exit(0);
+          }
+        }
+        if (!mode) {
+          console.error("Error: Please specify --global or --local for uninstall.");
+          process.exit(1);
+        }
+        const result = runUninstall(mode);
+        console.log(result.message);
+        process.exit(result.success ? 0 : 1);
+        break;
+      }
+      case "install":
+      default: {
+        let mode = args.mode;
+        if (!mode) {
+          mode = await promptInstallMode();
+        }
+        const result = mode === "global" ? installGlobal(args.withConfig) : installLocal(args.withConfig);
+        console.log(result.message);
+        if (args.skillsMode === "none") {
+          console.log("Skill installation skipped (--no-skills).");
+        } else if (result.success) {
+          const skillsResult = installSkills(args.skillsMode);
+          if (skillsResult.success) {
+            console.log(skillsResult.message);
+          } else {
+            console.warn(skillsResult.message);
+          }
+        } else {
+          console.warn("Skill installation skipped because plugin install failed.");
+        }
+        if (args.fullInstall && result.success) {
+          try {
+            const extensionPath = extractExtension();
+            if (extensionPath) {
+              console.log(`Extension assets extracted to ${extensionPath}`);
+            } else {
+              console.warn("Extension assets not found; skipping extraction.");
+            }
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Extension pre-extraction failed: ${message}`);
+          }
+        }
+        if (result.success && !result.alreadyInstalled) {
+          console.log("\nNext steps:");
+          console.log("  1. Start or restart OpenCode");
+          console.log("  2. Use opendevbrowser_status to verify the plugin is loaded");
+          console.log("\nFor help: npx opendevbrowser --help");
+        }
+        process.exit(result.success ? 0 : 1);
+        break;
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    console.error("\nFor help: npx opendevbrowser --help");
+    process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error("Unexpected error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map