open-computer-use 0.1.18 → 0.1.20

package/README.md

@@ -62,7 +62,7 @@ open-computer-use install-codex-plugin
 
 ## Notes
 
-- Version: `0.1.18`
+- Version: `0.1.20`
 - Platform: macOS 14+
 - Architectures: `arm64` and `x64` via a universal app bundle
 - The host terminal or app still needs macOS `Accessibility` and `Screen Recording` permissions

package/dist/Open Computer Use.app/Contents/Info.plist

@@ -21,7 +21,7 @@
   <key>CFBundlePackageType</key>
   <string>APPL</string>
   <key>CFBundleShortVersionString</key>
-  <string>0.1.18</string>
+  <string>0.1.20</string>
   <key>CFBundleVersion</key>
   <string>1</string>
   <key>LSMinimumSystemVersion</key>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-computer-use",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Prebuilt macOS Computer Use MCP server. After install, run open-computer-use doctor.",
   "license": "MIT",
   "homepage": "https://github.com/iFurySt/open-codex-computer-use",
@@ -46,6 +46,7 @@
     "plugins/open-computer-use/assets/",
     "plugins/open-computer-use/scripts/",
     "scripts/install-claude-mcp.sh",
+    "scripts/install-config-helper.mjs",
     "scripts/install-codex-mcp.sh",
     "scripts/install-codex-plugin.sh",
     "scripts/postinstall.mjs",

package/plugins/open-computer-use/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "open-computer-use",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Open-source macOS Computer Use MCP server packaged as a Codex plugin.",
   "author": {
     "name": "Leo",

package/scripts/install-claude-mcp.sh

@@ -2,6 +2,8 @@
 
 set -euo pipefail
 
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+config_helper="${script_dir}/install-config-helper.mjs"
 claude_config_path="${CLAUDE_CONFIG_PATH:-${HOME}/.claude.json}"
 project_root="$(pwd -P)"
 server_name="open-computer-use"
@@ -30,71 +32,4 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-python3 - "${claude_config_path}" "${project_root}" "${server_name}" "${command_name}" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-config_path = Path(sys.argv[1])
-project_root = sys.argv[2]
-server_name = sys.argv[3]
-command_name = sys.argv[4]
-desired_entry = {
-    "type": "stdio",
-    "command": command_name,
-    "args": ["mcp"],
-}
-legacy_server_name = "open-codex-computer-use"
-
-if config_path.exists():
-    try:
-        raw = config_path.read_text()
-        data = json.loads(raw) if raw.strip() else {}
-    except json.JSONDecodeError as exc:
-        print(f"Existing Claude config is not valid JSON: {exc}", file=sys.stderr)
-        sys.exit(1)
-else:
-    data = {}
-
-if not isinstance(data, dict):
-    print("Existing Claude config root is not a JSON object; refusing to modify it.", file=sys.stderr)
-    sys.exit(1)
-
-projects = data.setdefault("projects", {})
-if not isinstance(projects, dict):
-    print('Existing Claude config has non-object "projects"; refusing to modify it.', file=sys.stderr)
-    sys.exit(1)
-
-project_entry = projects.setdefault(project_root, {})
-if not isinstance(project_entry, dict):
-    print(f'Existing Claude project entry for {project_root} is not an object; refusing to modify it.', file=sys.stderr)
-    sys.exit(1)
-
-mcp_servers = project_entry.setdefault("mcpServers", {})
-if not isinstance(mcp_servers, dict):
-    print(f'Existing Claude project MCP config for {project_root} is not an object; refusing to modify it.', file=sys.stderr)
-    sys.exit(1)
-
-target = mcp_servers.get(server_name)
-legacy = mcp_servers.get(legacy_server_name)
-
-target_matches = target == desired_entry
-legacy_matches = legacy == desired_entry
-
-if target_matches and not legacy_matches:
-    print(f'Claude MCP server "{server_name}" is already installed for {project_root} in {config_path}.')
-    sys.exit(0)
-
-mcp_servers[server_name] = desired_entry
-
-if legacy_matches:
-    del mcp_servers[legacy_server_name]
-
-config_path.parent.mkdir(parents=True, exist_ok=True)
-config_path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n")
-
-if target_matches and legacy_matches:
-    print(f'Claude MCP server "{server_name}" was already installed for {project_root}; removed legacy alias "{legacy_server_name}" from {config_path}.')
-else:
-    print(f'Installed Claude MCP server "{server_name}" for {project_root} into {config_path}.')
-PY
+node "${config_helper}" claude-mcp "${claude_config_path}" "${project_root}" "${server_name}" "${command_name}"

package/scripts/install-codex-mcp.sh

@@ -2,6 +2,8 @@
 
 set -euo pipefail
 
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+config_helper="${script_dir}/install-config-helper.mjs"
 codex_home="${CODEX_HOME:-${HOME}/.codex}"
 config_path="${codex_home}/config.toml"
 server_name="open-computer-use"
@@ -32,88 +34,4 @@ done
 
 mkdir -p "${codex_home}"
 
-python3 - "${config_path}" "${server_name}" "${command_name}" <<'PY'
-import json
-import re
-import sys
-from pathlib import Path
-
-try:
-    import tomllib
-except ModuleNotFoundError as exc:
-    print(f"python3 with tomllib is required: {exc}", file=sys.stderr)
-    sys.exit(1)
-
-
-def section_pattern(header: str) -> re.Pattern[str]:
-    return re.compile(rf'(?ms)^\[{re.escape(header)}\]\n.*?(?=^\[|\Z)')
-
-
-def remove_section(text: str, header: str) -> str:
-    return section_pattern(header).sub("", text)
-
-
-def upsert_section(text: str, header: str, body: str) -> str:
-    section = f'[{header}]\n{body.rstrip()}\n'
-    pattern = section_pattern(header)
-    if pattern.search(text):
-        return pattern.sub(section, text, count=1)
-
-    if text and not text.endswith("\n"):
-        text += "\n"
-    if text and not text.endswith("\n\n"):
-        text += "\n"
-    return text + section
-
-
-config_path = Path(sys.argv[1])
-server_name = sys.argv[2]
-command_name = sys.argv[3]
-desired_args = ["mcp"]
-legacy_server_name = "open-codex-computer-use"
-
-text = config_path.read_text() if config_path.exists() else ""
-
-try:
-    parsed = tomllib.loads(text) if text.strip() else {}
-except tomllib.TOMLDecodeError as exc:
-    print(f"Existing Codex config is not valid TOML: {exc}", file=sys.stderr)
-    sys.exit(1)
-
-mcp_servers = parsed.get("mcp_servers")
-if mcp_servers is not None and not isinstance(mcp_servers, dict):
-    print('Existing Codex config has non-table "mcp_servers"; refusing to modify it.', file=sys.stderr)
-    sys.exit(1)
-
-target = (mcp_servers or {}).get(server_name)
-legacy = (mcp_servers or {}).get(legacy_server_name)
-
-target_matches = (
-    isinstance(target, dict)
-    and target.get("command") == command_name
-    and target.get("args") == desired_args
-)
-legacy_matches = (
-    isinstance(legacy, dict)
-    and legacy.get("command") == command_name
-    and legacy.get("args") == desired_args
-)
-
-if target_matches and not legacy_matches:
-    print(f'Codex MCP server "{server_name}" is already installed in {config_path}.')
-    sys.exit(0)
-
-body = f'command = {json.dumps(command_name)}\nargs = {json.dumps(desired_args)}'
-text = upsert_section(text, f'mcp_servers."{server_name}"', body)
-
-if legacy_matches:
-    text = remove_section(text, f'mcp_servers."{legacy_server_name}"')
-
-text = re.sub(r"\n{3,}", "\n\n", text).rstrip() + "\n"
-config_path.write_text(text)
-
-if target_matches and legacy_matches:
-    print(f'Codex MCP server "{server_name}" was already installed; removed legacy alias "{legacy_server_name}" from {config_path}.')
-else:
-    print(f'Installed Codex MCP server "{server_name}" into {config_path}.')
-PY
+node "${config_helper}" codex-mcp "${config_path}" "${server_name}" "${command_name}"

package/scripts/install-codex-plugin.sh

@@ -3,6 +3,7 @@
 set -euo pipefail
 
 repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+config_helper="${repo_root}/scripts/install-config-helper.mjs"
 codex_home="${CODEX_HOME:-${HOME}/.codex}"
 config_path="${codex_home}/config.toml"
 marketplace_name="open-computer-use-local"
@@ -84,17 +85,7 @@ if [[ -z "${app_bundle}" || ! -x "${app_binary}" ]]; then
   exit 1
 fi
 
-plugin_version="$(
-  python3 - "${plugin_manifest}" <<'PY'
-import json
-import sys
-
-with open(sys.argv[1], "r", encoding="utf-8") as fh:
-    manifest = json.load(fh)
-
-print(manifest["version"])
-PY
-)"
+plugin_version="$(node "${config_helper}" codex-plugin-version "${plugin_manifest}")"
 
 if [[ -z "${plugin_version}" ]]; then
   echo "Failed to read plugin version from ${plugin_manifest}" >&2
@@ -108,64 +99,9 @@ mkdir -p "${codex_home}" "${plugin_cache_root}"
 rm -rf "${plugin_install_root}"
 mkdir -p "${plugin_install_root}"
 
-rsync -a "${plugin_source_root}/" "${plugin_install_root}/"
-rsync -a "${app_bundle}" "${plugin_install_root}/"
-
-python3 - "${config_path}" "${repo_root}" "${marketplace_name}" "${plugin_name}" <<'PY'
-import json
-import re
-import sys
-from pathlib import Path
-
-
-def section_pattern(header: str) -> re.Pattern[str]:
-    return re.compile(rf'(?ms)^\[{re.escape(header)}\]\n.*?(?=^\[|\Z)')
-
-
-def remove_section(text: str, header: str) -> str:
-    return section_pattern(header).sub("", text)
-
-
-def upsert_section(text: str, header: str, body: str) -> str:
-    section = f'[{header}]\n{body.rstrip()}\n'
-    pattern = section_pattern(header)
-    if pattern.search(text):
-        return pattern.sub(section, text, count=1)
-
-    if text and not text.endswith("\n"):
-        text += "\n"
-    if text and not text.endswith("\n\n"):
-        text += "\n"
-    return text + section
-
-
-config_path = Path(sys.argv[1])
-repo_root = Path(sys.argv[2]).resolve()
-marketplace_name = sys.argv[3]
-plugin_name = sys.argv[4]
-
-text = config_path.read_text() if config_path.exists() else ""
-
-for header in (
-    'mcp_servers."open-codex-computer-use"',
-    'mcp_servers."open-computer-use"',
-):
-    text = remove_section(text, header)
-
-text = upsert_section(
-    text,
-    f"marketplaces.{marketplace_name}",
-    f'source_type = "local"\nsource = {json.dumps(str(repo_root))}',
-)
-text = upsert_section(
-    text,
-    f'plugins."{plugin_name}@{marketplace_name}"',
-    "enabled = true",
-)
+node "${config_helper}" copy-into-dir "${plugin_install_root}" "${plugin_source_root}" "${app_bundle}"
 
-text = re.sub(r"\n{3,}", "\n\n", text).rstrip() + "\n"
-config_path.write_text(text)
-PY
+node "${config_helper}" codex-plugin-config "${config_path}" "${repo_root}" "${marketplace_name}" "${plugin_name}"
 
 echo "Installed ${plugin_name}@${marketplace_name}"
 echo "Marketplace source: ${repo_root}"

package/scripts/install-config-helper.mjs

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+function usage() {
+  process.stdout.write(`Usage:
+  node ./scripts/install-config-helper.mjs claude-mcp <config-path> <project-root> <server-name> <command-name>
+  node ./scripts/install-config-helper.mjs codex-mcp <config-path> <server-name> <command-name>
+  node ./scripts/install-config-helper.mjs codex-plugin-version <plugin-manifest-path>
+  node ./scripts/install-config-helper.mjs codex-plugin-config <config-path> <repo-root> <marketplace-name> <plugin-name>
+  node ./scripts/install-config-helper.mjs copy-into-dir <target-dir> <source-path> [<source-path> ...]
+`);
+}
+
+function readTextIfExists(filePath) {
+  if (!existsSync(filePath)) {
+    return "";
+  }
+  return readFileSync(filePath, "utf8");
+}
+
+function ensureParentDir(filePath) {
+  mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+
+function trimTrailingBlankLines(lines) {
+  let end = lines.length;
+  while (end > 0 && lines[end - 1].trim() === "") {
+    end -= 1;
+  }
+  return lines.slice(0, end);
+}
+
+function canonicalSectionBody(bodyLines) {
+  const lines = [...bodyLines];
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines.shift();
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  return lines.join("\n");
+}
+
+function splitTomlSections(text) {
+  const normalized = normalizeNewlines(text);
+  if (normalized.length === 0) {
+    return { preambleLines: [], sections: [] };
+  }
+
+  const lines = normalized.split("\n");
+  const preambleLines = [];
+  const sections = [];
+  let currentHeader = null;
+  let currentBodyLines = [];
+
+  for (const line of lines) {
+    const headerMatch = line.match(/^\[([^\]]+)\]\s*$/);
+    if (headerMatch) {
+      if (currentHeader === null) {
+        preambleLines.push(...currentBodyLines);
+      } else {
+        sections.push({ header: currentHeader, bodyLines: currentBodyLines });
+      }
+      currentHeader = headerMatch[1];
+      currentBodyLines = [];
+      continue;
+    }
+    currentBodyLines.push(line);
+  }
+
+  if (currentHeader === null) {
+    preambleLines.push(...currentBodyLines);
+  } else {
+    sections.push({ header: currentHeader, bodyLines: currentBodyLines });
+  }
+
+  return { preambleLines, sections };
+}
+
+function renderTomlDocument(document) {
+  const chunks = [];
+  const preamble = trimTrailingBlankLines(document.preambleLines);
+  if (preamble.length > 0) {
+    chunks.push(preamble.join("\n"));
+  }
+
+  for (const section of document.sections) {
+    const bodyLines = trimTrailingBlankLines(section.bodyLines);
+    if (bodyLines.length > 0) {
+      chunks.push(`[${section.header}]\n${bodyLines.join("\n")}`);
+    } else {
+      chunks.push(`[${section.header}]`);
+    }
+  }
+
+  return chunks.length > 0 ? `${chunks.join("\n\n")}\n` : "";
+}
+
+function ensureUniqueManagedHeaders(document, headers, configPath) {
+  for (const header of headers) {
+    const count = document.sections.filter((section) => section.header === header).length;
+    if (count > 1) {
+      fail(`Existing Codex config has duplicate section [${header}] in ${configPath}; refusing to modify it.`);
+    }
+  }
+}
+
+function applyTomlSectionUpdates(text, updates, configPath) {
+  const document = splitTomlSections(text);
+  const managedHeaders = [
+    ...updates.removeHeaders,
+    ...updates.upserts.map((entry) => entry.header),
+  ];
+  ensureUniqueManagedHeaders(document, managedHeaders, configPath);
+
+  const upsertMap = new Map(
+    updates.upserts.map((entry) => [
+      entry.header,
+      {
+        header: entry.header,
+        bodyLines: normalizeNewlines(entry.body).split("\n"),
+      },
+    ]),
+  );
+  const removeSet = new Set(updates.removeHeaders);
+  const nextSections = [];
+  const insertedHeaders = new Set();
+
+  for (const section of document.sections) {
+    if (removeSet.has(section.header)) {
+      continue;
+    }
+    if (upsertMap.has(section.header)) {
+      nextSections.push(upsertMap.get(section.header));
+      insertedHeaders.add(section.header);
+      continue;
+    }
+    nextSections.push(section);
+  }
+
+  for (const entry of updates.upserts) {
+    if (!insertedHeaders.has(entry.header)) {
+      nextSections.push(upsertMap.get(entry.header));
+    }
+  }
+
+  return renderTomlDocument({
+    preambleLines: document.preambleLines,
+    sections: nextSections,
+  });
+}
+
+function installClaudeMcp(configPath, projectRoot, serverName, commandName) {
+  const desiredEntry = {
+    type: "stdio",
+    command: commandName,
+    args: ["mcp"],
+  };
+  const legacyServerName = "open-codex-computer-use";
+
+  const raw = readTextIfExists(configPath);
+  let data;
+
+  if (raw.trim().length === 0) {
+    data = {};
+  } else {
+    try {
+      data = JSON.parse(raw);
+    } catch (error) {
+      fail(`Existing Claude config is not valid JSON: ${error.message}`);
+    }
+  }
+
+  if (data === null || Array.isArray(data) || typeof data !== "object") {
+    fail("Existing Claude config root is not a JSON object; refusing to modify it.");
+  }
+
+  const projects = data.projects ?? {};
+  if (projects === null || Array.isArray(projects) || typeof projects !== "object") {
+    fail('Existing Claude config has non-object "projects"; refusing to modify it.');
+  }
+  data.projects = projects;
+
+  const projectEntry = projects[projectRoot] ?? {};
+  if (projectEntry === null || Array.isArray(projectEntry) || typeof projectEntry !== "object") {
+    fail(`Existing Claude project entry for ${projectRoot} is not an object; refusing to modify it.`);
+  }
+  projects[projectRoot] = projectEntry;
+
+  const mcpServers = projectEntry.mcpServers ?? {};
+  if (mcpServers === null || Array.isArray(mcpServers) || typeof mcpServers !== "object") {
+    fail(`Existing Claude project MCP config for ${projectRoot} is not an object; refusing to modify it.`);
+  }
+  projectEntry.mcpServers = mcpServers;
+
+  const target = mcpServers[serverName];
+  const legacy = mcpServers[legacyServerName];
+  const targetMatches = JSON.stringify(target) === JSON.stringify(desiredEntry);
+  const legacyMatches = JSON.stringify(legacy) === JSON.stringify(desiredEntry);
+
+  if (targetMatches && !legacyMatches) {
+    process.stdout.write(`Claude MCP server "${serverName}" is already installed for ${projectRoot} in ${configPath}.\n`);
+    return;
+  }
+
+  mcpServers[serverName] = desiredEntry;
+  if (legacyMatches) {
+    delete mcpServers[legacyServerName];
+  }
+
+  ensureParentDir(configPath);
+  writeFileSync(configPath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+
+  if (targetMatches && legacyMatches) {
+    process.stdout.write(`Claude MCP server "${serverName}" was already installed for ${projectRoot}; removed legacy alias "${legacyServerName}" from ${configPath}.\n`);
+  } else {
+    process.stdout.write(`Installed Claude MCP server "${serverName}" for ${projectRoot} into ${configPath}.\n`);
+  }
+}
+
+function installCodexMcp(configPath, serverName, commandName) {
+  const desiredBody = `command = ${JSON.stringify(commandName)}\nargs = ["mcp"]`;
+  const targetHeader = `mcp_servers."${serverName}"`;
+  const legacyServerName = "open-codex-computer-use";
+  const legacyHeader = `mcp_servers."${legacyServerName}"`;
+  const text = readTextIfExists(configPath);
+  const document = splitTomlSections(text);
+
+  ensureUniqueManagedHeaders(document, [targetHeader, legacyHeader], configPath);
+
+  const targetSection = document.sections.find((section) => section.header === targetHeader);
+  const legacySection = document.sections.find((section) => section.header === legacyHeader);
+  const desiredCanonical = canonicalSectionBody(desiredBody.split("\n"));
+  const targetMatches = targetSection ? canonicalSectionBody(targetSection.bodyLines) === desiredCanonical : false;
+  const legacyMatches = legacySection ? canonicalSectionBody(legacySection.bodyLines) === desiredCanonical : false;
+
+  if (targetMatches && !legacyMatches) {
+    process.stdout.write(`Codex MCP server "${serverName}" is already installed in ${configPath}.\n`);
+    return;
+  }
+
+  const nextText = applyTomlSectionUpdates(
+    text,
+    {
+      removeHeaders: [legacyHeader],
+      upserts: [{ header: targetHeader, body: desiredBody }],
+    },
+    configPath,
+  );
+
+  ensureParentDir(configPath);
+  writeFileSync(configPath, nextText, "utf8");
+
+  if (targetMatches && legacyMatches) {
+    process.stdout.write(`Codex MCP server "${serverName}" was already installed; removed legacy alias "${legacyServerName}" from ${configPath}.\n`);
+  } else {
+    process.stdout.write(`Installed Codex MCP server "${serverName}" into ${configPath}.\n`);
+  }
+}
+
+function printCodexPluginVersion(pluginManifestPath) {
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(pluginManifestPath, "utf8"));
+  } catch (error) {
+    fail(`Failed to read plugin manifest ${pluginManifestPath}: ${error.message}`);
+  }
+
+  if (!manifest || typeof manifest.version !== "string" || manifest.version.length === 0) {
+    fail(`Plugin manifest ${pluginManifestPath} does not contain a valid string "version".`);
+  }
+
+  process.stdout.write(`${manifest.version}\n`);
+}
+
+function installCodexPluginConfig(configPath, repoRoot, marketplaceName, pluginName) {
+  const text = readTextIfExists(configPath);
+  const repoRootPath = path.resolve(repoRoot);
+  const nextText = applyTomlSectionUpdates(
+    text,
+    {
+      removeHeaders: [
+        'mcp_servers."open-codex-computer-use"',
+        'mcp_servers."open-computer-use"',
+      ],
+      upserts: [
+        {
+          header: `marketplaces.${marketplaceName}`,
+          body: `source_type = "local"\nsource = ${JSON.stringify(repoRootPath)}`,
+        },
+        {
+          header: `plugins."${pluginName}@${marketplaceName}"`,
+          body: "enabled = true",
+        },
+      ],
+    },
+    configPath,
+  );
+
+  ensureParentDir(configPath);
+  writeFileSync(configPath, nextText, "utf8");
+}
+
+function copyIntoDir(targetDir, sourcePaths) {
+  if (sourcePaths.length === 0) {
+    fail("copy-into-dir requires at least one source path.");
+  }
+
+  mkdirSync(targetDir, { recursive: true });
+
+  for (const sourcePath of sourcePaths) {
+    if (!existsSync(sourcePath)) {
+      fail(`Source path does not exist: ${sourcePath}`);
+    }
+
+    const destinationPath = path.join(targetDir, path.basename(sourcePath));
+    rmSync(destinationPath, { recursive: true, force: true });
+    cpSync(sourcePath, destinationPath, { recursive: true });
+  }
+}
+
+function main(argv) {
+  const [command, ...args] = argv;
+  switch (command) {
+    case "claude-mcp":
+      if (args.length !== 4) {
+        usage();
+        process.exit(1);
+      }
+      installClaudeMcp(...args);
+      return;
+    case "codex-mcp":
+      if (args.length !== 3) {
+        usage();
+        process.exit(1);
+      }
+      installCodexMcp(...args);
+      return;
+    case "codex-plugin-version":
+      if (args.length !== 1) {
+        usage();
+        process.exit(1);
+      }
+      printCodexPluginVersion(args[0]);
+      return;
+    case "codex-plugin-config":
+      if (args.length !== 4) {
+        usage();
+        process.exit(1);
+      }
+      installCodexPluginConfig(...args);
+      return;
+    case "copy-into-dir":
+      if (args.length < 2) {
+        usage();
+        process.exit(1);
+      }
+      copyIntoDir(args[0], args.slice(1));
+      return;
+    default:
+      usage();
+      process.exit(1);
+  }
+}
+
+main(process.argv.slice(2));

package/scripts/postinstall.mjs

@@ -11,7 +11,7 @@ const mcpConfig = {
 };
 const lines = [
   "",
-  "Installed open-computer-use@0.1.18.",
+  "Installed open-computer-use@0.1.20.",
   "Package: https://www.npmjs.com/package/open-computer-use",
   "Commands: open-computer-use, open-computer-use-mcp, open-codex-computer-use-mcp",
   "",