@frontendxlab/opencode-computer-use 0.1.0

package/docs/llms-full.txt

@@ -0,0 +1,146 @@
+OpenCode Computer Use - full documentation summary
+Canonical site: https://opencode-computer-use.pages.dev/
+Repository: https://github.com/rashidtvmr/opencode-computer-use
+License: MIT
+
+1. What it is
+OpenCode Computer Use is a dual-generation OpenCode plugin that provides a
+Codex-style Computer Use session. Instead of exposing many low-level desktop
+MCP tools, it exposes one persistent JavaScript surface through a local MCP
+server named cua_repl. The model receives two tools only: js (evaluate
+JavaScript in the persistent session) and js_reset (discard bindings and
+start a clean session). App bindings and variables survive across model
+turns. Native desktop calls are made by the underlying open-source
+open-computer-use runtime (optional dependency open-computer-use@0.3.5),
+kept separate from the Codex-style session adapter. The adapter is adapted
+from the MIT-licensed iFurySt/open-codex-computer-use project; see
+THIRD_PARTY_NOTICES.md in the repository.
+
+2. Architecture (three layers)
+- OpenCode plugin: loads the local package and registers cua_repl without
+  exposing raw desktop tools.
+- cua_repl MCP server: persistent JavaScript evaluation, output bounds,
+  request validation, and worker isolation so a timed-out loop cannot wedge
+  the server.
+- Native runtime: open-computer-use runs as a separate child process. OS
+  accessibility, screen capture, and input permissions are enforced there.
+The JavaScript VM is a capability guard, not a complete security boundary.
+
+3. Model workflow
+The js tool accepts code (required JavaScript source), timeout_ms (optional,
+capped at 300 seconds), and title (optional short action title).
+Typical first call:
+  var apps = await cua.listApps({ emit: false });
+  var app = await cua.getApp(apps[0].id);
+  await app.getAXState();
+Typical action and verification:
+  var save = await app.click(12);
+  await app.getAXState();
+State and action rules: read getAXState() or getAXStateAndScreenshot()
+before acting on a new layout; element indexes belong to the most recent
+state and must be re-derived after navigation, dialogs, scroll, resize, or
+rerender; prefer element indexes and semantic actions over coordinates; use
+coordinates only when no useful accessibility data exists; batch
+deterministic actions with the next state read in one js call; never replay
+a mutating action after a timeout or transport failure, observe again and
+decide anew; js_reset discards JavaScript bindings only, not native app
+state.
+
+4. API
+- cua.getState(options?): list current desktop apps with bounded output.
+- cua.listApps(options?): structured app records without emitting by
+  default.
+- cua.getApp(nameOrPid): bind an app and emit initial accessibility state.
+- app.getAXState(options?): fresh semantic accessibility tree.
+- app.getScreenshot(options?): local image bytes, optionally emitted.
+- app.getAXStateAndScreenshot(options?): combined state and image read.
+- app.click(target, options?): element index first, bounded coordinate when
+  necessary.
+- app.scroll(elementIndex, direction, pages?)
+- app.drag([fromX, fromY], [toX, toY])
+- app.typeText(text)
+- app.pressKey(key)
+- app.setValue(elementIndex, value)
+- app.performSecondaryAction(elementIndex, action)
+- nodeRepl.write(value): extra bounded text output.
+- nodeRepl.emitImage(bytesOrDataUrl): bounded local image output.
+
+5. Options
+backend (default auto: auto, native, or custom); command (required for
+custom: fixed native MCP executable plus argv, no shell syntax); serverName
+(default cua_repl); override (default false); timeoutMs (default 30000);
+disabled (default false); maxTextChars (default 200000); maxImageBytes
+(default 2097152); allowGlobalPointerFallbacks (default false, off because
+it moves the real pointer and changes focus; enable only for an explicit
+desktop automation test where that input is intended). The proxy also reads
+matching OPENCODE_COMPUTER_USE_* environment variables. Custom commands
+must implement the native MCP operations used by cua: initialize,
+tools/list, tools/call, and notifications.
+
+6. Install
+Published package:
+  npm install @frontendxlab/opencode-computer-use
+OpenCode 1 (opencode.json or opencode.jsonc, plugin list):
+  { "$schema": "https://opencode.ai/config.json",
+    "plugin": [["@frontendxlab/opencode-computer-use", { "backend": "auto" }]] }
+OpenCode2 V2 (plugins shape):
+  { "$schema": "https://opencode.ai/config.json",
+    "plugins": [{ "package": "@frontendxlab/opencode-computer-use",
+      "options": { "backend": "auto" } }] }
+A local checkout can be used by replacing the package name with its absolute
+path. Do not configure the same package both as an explicit plugin and through
+automatic plugin discovery. If Node is not on PATH, set OPENCODE_NODE to an
+absolute Node executable. Verify with: opencode mcp list.
+
+7. Requirements and OS support
+Requirements: Node.js 18 or newer; OpenCode 1.18.29 or newer (V1) or
+OpenCode2 V2; a signed-in graphical desktop session; macOS Accessibility
+and Screen Recording permissions; Linux AT-SPI plus required input and
+capture services; Windows UI Automation in the interactive desktop session.
+The plugin cannot control lock screens, login screens, UAC secure desktops,
+or other OS-owned consent surfaces, and does not bypass permissions.
+Packaged native targets: darwin-arm64, darwin-x64, linux-arm64, linux-x64,
+win32-arm64, win32-x64. Validation status: Linux x64 read-only discovery,
+app listing, MCP registration, and persistent session passed local smoke
+tests; one Ubuntu/GNOME Wayland session exposed a Chrome pseudo-window with
+no actionable AT-SPI children and synthetic input did not change it (the
+adapter reports the native result honestly); macOS and Windows have not
+been live-tested in this environment and need on-host permission and
+desktop validation.
+
+8. Safety
+High-privilege desktop-control surface. The js tool is marked conservatively
+as mutating. Keep OpenCode approval prompts enabled for consequential
+actions (sending, deleting, purchasing, uploading, changing permissions).
+Do not expose the session to an untrusted model or run it unattended
+against password managers, banking, administrator, or other high-value
+applications. Screenshots, accessibility trees, and typed values can contain
+sensitive data and should stay local. Read SECURITY.md before high-risk
+use. Manual read-only checks before acting:
+  open-computer-use doctor
+  open-computer-use list-apps
+
+9. Troubleshooting (from the docs page)
+- cua_repl not listed: check the active generation config, restart the TUI,
+  run opencode mcp list, avoid double registration.
+- Node not found: set OPENCODE_NODE or fix server PATH.
+- Empty app list: run open-computer-use list-apps in the same graphical
+  session; confirm the app runs and desktop accessibility is available.
+- Screenshots unavailable: OS compositor or permission gap; bounded
+  accessibility text may still work.
+- Linux input returns success but nothing changes: session type or missing
+  runtime prerequisite; observe again before retrying mutating actions.
+- Global pointer fallback rejected: expected safety gate.
+
+10. WebMCP preview
+The documentation page includes a progressive, read-only WebMCP enhancement
+based on the current document.modelContext.registerTool draft. It registers
+search_docs, get_install_config, and get_api_reference only when the browser
+supports the API and the tools Permissions Policy. It does not expose desktop
+control, shell, network mutation, or credentials. WebMCP is experimental and
+should not be treated as stable browser support.
+
+11. Development
+npm install; npm test; npm run lint. Adapter tests use a fake native MCP
+server and need no real desktop. Live desktop validation must run
+separately per OS.

package/docs/llms.txt

@@ -0,0 +1,30 @@
+# OpenCode Computer Use
+
+> A dual-generation OpenCode plugin that exposes a Codex-style persistent JavaScript session (cua_repl) for local desktop control. The model sees two tools, js and js_reset, backed by the open-source open-computer-use native runtime. OS permissions remain enforced.
+
+## Docs
+
+- [Documentation home](https://opencode-computer-use.pages.dev/)
+- [Install](https://opencode-computer-use.pages.dev/#install)
+- [First run](https://opencode-computer-use.pages.dev/#first-run)
+- [API surface](https://opencode-computer-use.pages.dev/#api)
+- [OS support](https://opencode-computer-use.pages.dev/#os)
+- [WebMCP preview](https://opencode-computer-use.pages.dev/#webmcp)
+- [Security](https://opencode-computer-use.pages.dev/#security)
+- [FAQ](https://opencode-computer-use.pages.dev/#faq)
+
+## Repo
+
+- [Source](https://github.com/rashidtvmr/opencode-computer-use)
+- [README](https://github.com/rashidtvmr/opencode-computer-use/blob/main/README.md)
+- [Issues](https://github.com/rashidtvmr/opencode-computer-use/issues)
+
+## Key facts
+
+- MCP server name: cua_repl. Model-facing tools: js (persistent evaluation) and js_reset (clean session).
+- Async cua API: listApps, getApp, getState, getAXState, getScreenshot, getAXStateAndScreenshot, click, scroll, drag, typeText, pressKey, setValue, performSecondaryAction. Output helpers: nodeRepl.write, nodeRepl.emitImage.
+- WebMCP preview: the docs page registers only read-only search_docs, get_install_config, and get_api_reference tools when document.modelContext is available. It is progressive enhancement, not stable browser support.
+- No arbitrary shell escape. No run_shell in the model-facing API. Restricted VM blocks require, process, fetch, filesystem, dynamic import, and code generation.
+- Published package: @frontendxlab/opencode-computer-use.
+- Requirements: Node.js 18 or newer, OpenCode 1.18.29 or newer (V1) or OpenCode2 V2, plus a signed-in graphical desktop session with OS accessibility and capture permissions.
+- Native runtimes packaged for darwin-arm64, darwin-x64, linux-arm64, linux-x64, win32-arm64, win32-x64. Live smoke tests passed on Linux x64 only; macOS and Windows need on-host validation.

package/docs/robots.txt

@@ -0,0 +1,7 @@
+# robots.txt for https://opencode-computer-use.pages.dev/
+# Static Cloudflare Pages documentation site. No secrets or tracking.
+
+User-agent: *
+Allow: /
+
+Sitemap: https://opencode-computer-use.pages.dev/sitemap.xml

package/docs/site.webmanifest

@@ -0,0 +1,10 @@
+{
+  "name": "OpenCode Computer Use",
+  "short_name": "Computer Use",
+  "description": "Install and use OpenCode Computer Use, a Codex-style cua_repl plugin for OpenCode and OpenCode2.",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "background_color": "#0a0a0a",
+  "theme_color": "#0a0a0a"
+}

package/docs/sitemap.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://opencode-computer-use.pages.dev/</loc>
+    <lastmod>2026-09-25</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>1.0</priority>
+  </url>
+</urlset>

package/docs/webmcp.js

@@ -0,0 +1,135 @@
+(function () {
+  "use strict";
+
+  var state = { enabled: false, tools: [], preview: true };
+  if (typeof window !== "undefined") window.__opencodeComputerUseWebMCP = state;
+  if (typeof document === "undefined" || typeof document.querySelectorAll !== "function") return;
+
+  var modelContext = null;
+  try {
+    modelContext = document.modelContext;
+  } catch (_) {
+    return;
+  }
+  if (!modelContext || typeof modelContext.registerTool !== "function") return;
+
+  function plainText(element, limit) {
+    var text = String(element && element.textContent || "")
+      .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "")
+      .replace(/[ \t]+/g, " ")
+      .replace(/\n\s*\n+/g, "\n\n")
+      .trim();
+    return text.slice(0, limit);
+  }
+
+  function result(value) {
+    return String(value).slice(0, 8000);
+  }
+
+  function queryValue(value, fallback) {
+    return typeof value === "string" ? value.trim() : fallback;
+  }
+
+  function searchDocs(args) {
+    var query = queryValue(args && args.query, "");
+    if (!query || query.length > 200) return "Invalid query. Provide 1 to 200 characters.";
+    var needle = query.toLowerCase();
+    var sections = document.querySelectorAll("#content [data-section]");
+    var matches = [];
+    for (var index = 0; index < sections.length; index += 1) {
+      var section = sections[index];
+      var heading = section.querySelector("h2, h3");
+      var text = plainText(section, 12000);
+      var position = text.toLowerCase().indexOf(needle);
+      if (position === -1) continue;
+      var start = Math.max(0, position - 200);
+      var end = Math.min(text.length, position + query.length + 600);
+      matches.push((heading ? heading.textContent.trim() + "\n" : "") + text.slice(start, end));
+      if (matches.join("\n\n").length >= 8000) break;
+    }
+    return result(matches.length ? matches.join("\n\n") : "No documentation matches found for: " + query);
+  }
+
+  function getInstallConfig(args) {
+    var generation = args && args.generation;
+    if (generation !== "v1" && generation !== "v2") return "Invalid generation. Use v1 or v2.";
+    var block = document.getElementById(generation === "v1" ? "config-v1" : "config-v2");
+    return block ? result(plainText(block, 4000)) : "Install configuration is unavailable on this page.";
+  }
+
+  function getApiReference(args) {
+    var requested = queryValue(args && args.name, "").toLowerCase();
+    if (!requested || requested.length > 100) return "Invalid name. Provide 1 to 100 characters.";
+    var entries = document.querySelectorAll("#api .cards li");
+    for (var index = 0; index < entries.length; index += 1) {
+      var label = entries[index].querySelector("strong");
+      if (!label) continue;
+      var documented = String(label.textContent || "").trim().toLowerCase();
+      var method = documented.split(".").pop();
+      if (documented === requested || documented.endsWith("." + requested) || (requested.indexOf(".") === -1 && method === requested)) {
+        return result(plainText(entries[index], 2000));
+      }
+    }
+    return "No API entry found for: " + requested;
+  }
+
+  var tools = [
+    {
+      name: "search_docs",
+      title: "Search documentation",
+      description: "Search this documentation page and return bounded matching excerpts.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", minLength: 1, maxLength: 200, description: "Text to find in the documentation." }
+        },
+        required: ["query"],
+        additionalProperties: false
+      },
+      annotations: { readOnlyHint: true, untrustedContentHint: true, consequentialHint: false, debugging: false },
+      execute: searchDocs
+    },
+    {
+      name: "get_install_config",
+      title: "Get installation configuration",
+      description: "Return the documented OpenCode installation configuration for one generation.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          generation: { type: "string", enum: ["v1", "v2"], description: "OpenCode configuration generation." }
+        },
+        required: ["generation"],
+        additionalProperties: false
+      },
+      annotations: { readOnlyHint: true, untrustedContentHint: true, consequentialHint: false, debugging: false },
+      execute: getInstallConfig
+    },
+    {
+      name: "get_api_reference",
+      title: "Get API reference",
+      description: "Return one documented CUA API entry by method name.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", minLength: 1, maxLength: 100, description: "Method name, with or without its cua or app prefix." }
+        },
+        required: ["name"],
+        additionalProperties: false
+      },
+      annotations: { readOnlyHint: true, untrustedContentHint: true, consequentialHint: false, debugging: false },
+      execute: getApiReference
+    }
+  ];
+
+  Promise.all(tools.map(function (tool) {
+    return Promise.resolve().then(function () {
+      return modelContext.registerTool(tool);
+    }).then(function () {
+      state.tools.push(tool.name);
+    }).catch(function () {
+      // Experimental registration failures must not affect normal documentation.
+    });
+  })).then(function () {
+    state.enabled = state.tools.length > 0;
+  });
+}());

package/index.js

@@ -0,0 +1,78 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+import { normalizeOptions, optionsToEnvironment } from "./lib/options.js";
+
+const packageRoot = dirname(fileURLToPath(import.meta.url));
+const proxyPath = join(packageRoot, "bin", "opencode-computer-use-repl.js");
+
+function proxyCommand() {
+  return [process.env.OPENCODE_NODE || "node", proxyPath];
+}
+
+function baseServerConfig(options) {
+  return {
+    type: "local",
+    command: proxyCommand(),
+    cwd: packageRoot,
+    environment: optionsToEnvironment(options),
+  };
+}
+
+function v1ServerConfig(options) {
+  return {
+    ...baseServerConfig(options),
+    enabled: !options.disabled,
+  };
+}
+
+function v2ServerConfig(options) {
+  return {
+    ...baseServerConfig(options),
+    disabled: options.disabled,
+  };
+}
+
+function shouldReplace(existing, options) {
+  return options.override || !existing;
+}
+
+async function setup(ctx) {
+  const options = normalizeOptions(ctx.options);
+  if (!ctx.mcp?.transform) {
+    throw new Error("This OpenCode2 runtime does not expose ctx.mcp.transform");
+  }
+  const registration = await ctx.mcp.transform((editor) => {
+    const existing = editor.get(options.serverName);
+    if (shouldReplace(existing, options)) {
+      editor.set(options.serverName, v2ServerConfig(options));
+    }
+  });
+  return async () => {
+    await registration?.dispose?.();
+  };
+}
+
+async function server(_input, inputOptions) {
+  const options = normalizeOptions(inputOptions);
+  return {
+    config: async (config) => {
+      if (!config.mcp || typeof config.mcp !== "object" || Array.isArray(config.mcp)) {
+        config.mcp = {};
+      }
+      const existing = config.mcp[options.serverName];
+      if (shouldReplace(existing, options)) {
+        config.mcp[options.serverName] = v1ServerConfig(options);
+      }
+    },
+  };
+}
+
+const plugin = {
+  id: "opencode-computer-use",
+  setup,
+  server,
+};
+
+export const ComputerUsePlugin = server;
+export default plugin;

package/lib/backend.js

@@ -0,0 +1,190 @@
+import { constants, accessSync, existsSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { delimiter, dirname, join } from "node:path";
+import process from "node:process";
+import { normalizeOptions, optionsFromEnvironment } from "./options.js";
+
+const require = createRequire(import.meta.url);
+
+const PLATFORM_PATHS = {
+  "darwin-arm64": ["dist", "Open Computer Use.app", "Contents", "MacOS", "OpenComputerUse"],
+  "darwin-x64": ["dist", "Open Computer Use.app", "Contents", "MacOS", "OpenComputerUse"],
+  "linux-arm64": ["dist", "linux", "arm64", "open-computer-use"],
+  "linux-x64": ["dist", "linux", "amd64", "open-computer-use"],
+  "win32-arm64": ["dist", "windows", "arm64", "open-computer-use.exe"],
+  "win32-x64": ["dist", "windows", "amd64", "open-computer-use.exe"],
+};
+
+function isExecutable(path) {
+  try {
+    accessSync(path, constants.X_OK);
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function commandOnPath(name, environment = process.env) {
+  const pathValue = environment.PATH;
+  if (!pathValue) return undefined;
+  const extensions =
+    process.platform === "win32"
+      ? (environment.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";")
+      : [""];
+  for (const directory of pathValue.split(delimiter)) {
+    if (!directory) continue;
+    for (const extension of extensions) {
+      const candidate = join(directory, `${name}${extension}`);
+      if (isExecutable(candidate)) return candidate;
+    }
+  }
+  return undefined;
+}
+
+function packageRoot() {
+  try {
+    return dirname(require.resolve("open-computer-use/package.json"));
+  } catch {
+    try {
+      let current = dirname(require.resolve("open-computer-use"));
+      while (current !== dirname(current)) {
+        if (existsSync(join(current, "package.json"))) return current;
+        current = dirname(current);
+      }
+    } catch {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+function nativeCommand(environment) {
+  const override = environment.OPEN_COMPUTER_USE_NATIVE_COMMAND;
+  if (override) {
+    const args = environment.OPEN_COMPUTER_USE_NATIVE_ARGS
+      ? JSON.parse(environment.OPEN_COMPUTER_USE_NATIVE_ARGS)
+      : ["mcp"];
+    if (!Array.isArray(args) || args.some((value) => typeof value !== "string")) {
+      throw new Error("OPEN_COMPUTER_USE_NATIVE_ARGS must be a JSON string array");
+    }
+    return {
+      name: "open-computer-use",
+      source: "OPEN_COMPUTER_USE_NATIVE_COMMAND",
+      command: override,
+      args,
+      platform: process.platform,
+      arch: process.arch,
+    };
+  }
+
+  const root = packageRoot();
+  const relative = PLATFORM_PATHS[`${process.platform}-${process.arch}`];
+  if (root && relative) {
+    const executable = join(root, ...relative);
+    if (isExecutable(executable)) {
+      return {
+        name: "open-computer-use",
+        source: "open-computer-use",
+        command: executable,
+        args: ["mcp"],
+        platform: process.platform,
+        arch: process.arch,
+      };
+    }
+  }
+
+  const fromPath = commandOnPath("open-computer-use", environment);
+  if (fromPath) {
+    return {
+      name: "open-computer-use",
+      source: "PATH:open-computer-use",
+      command: fromPath,
+      args: ["mcp"],
+      platform: process.platform,
+      arch: process.arch,
+    };
+  }
+
+  throw new Error(
+    "Open Computer Use native runtime is not installed. Install open-computer-use or set OPEN_COMPUTER_USE_NATIVE_COMMAND.",
+  );
+}
+
+export function resolveBackend(input = {}, environment = process.env) {
+  const fromEnvironment = optionsFromEnvironment(environment);
+  const options = normalizeOptions({
+    ...fromEnvironment,
+    ...input,
+    command: input.command ?? fromEnvironment.command,
+  });
+
+  if (options.backend === "custom") {
+    const [command, ...args] = options.command;
+    return {
+      name: "custom",
+      source: "options.command",
+      command,
+      args,
+      platform: process.platform,
+      arch: process.arch,
+    };
+  }
+  return nativeCommand(environment);
+}
+
+export function backendEnvironment(environment = process.env) {
+  const allowed = new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "LANG",
+    "LANGUAGE",
+    "LC_ALL",
+    "LC_CTYPE",
+    "TERM",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "DISPLAY",
+    "WAYLAND_DISPLAY",
+    "XAUTHORITY",
+    "DBUS_SESSION_BUS_ADDRESS",
+    "XDG_RUNTIME_DIR",
+    "XDG_CURRENT_DESKTOP",
+    "XDG_SESSION_TYPE",
+    "XDG_SESSION_DESKTOP",
+    "XDG_DATA_DIRS",
+    "XDG_CONFIG_HOME",
+    "XDG_CACHE_HOME",
+    "XDG_STATE_HOME",
+    "APPDATA",
+    "LOCALAPPDATA",
+    "USERPROFILE",
+    "ProgramData",
+    "SystemRoot",
+    "SYSTEMROOT",
+    "windir",
+    "ComSpec",
+    "PATHEXT",
+    "RUST_LOG",
+    "OPEN_COMPUTER_USE_ACTION_READ_BACK",
+    "OPEN_COMPUTER_USE_ALLOW_GLOBAL_POINTER_FALLBACKS",
+    "OPEN_COMPUTER_USE_WINDOWS_ALLOW_APP_LAUNCH",
+    "OPEN_COMPUTER_USE_WINDOWS_ALLOW_FOCUS_ACTIONS",
+    "OPEN_COMPUTER_USE_WINDOWS_ALLOW_UIA_TEXT_FALLBACK",
+    "OPEN_COMPUTER_USE_IMAGE_CAPTURE_TIMEOUT",
+    "OPEN_COMPUTER_USE_IMAGE_MAX_BYTES",
+    "OPEN_COMPUTER_USE_IMAGE_MAX_DIMENSION",
+    "OPEN_COMPUTER_USE_IMAGE_MIN_SCALE",
+    "COMPUTER_USE_LINUX_COSMIC_HELPER",
+    "COMPUTER_USE_LINUX_SCREENSHOT_BACKEND",
+  ]);
+
+  return Object.fromEntries(
+    Object.entries(environment).filter(
+      ([key, value]) => allowed.has(key) && typeof value === "string",
+    ),
+  );
+}