superacli 1.1.4 → 1.1.6

package/plugins/browser-use/scripts/post-install.js

@@ -0,0 +1,146 @@
+const path = require("path")
+const { addProvider, syncCatalog } = require("../../../cli/skills-catalog")
+const { setMcpServer, listMcpServers, upsertCommand } = require("../../../cli/config")
+const { discoverMcpTools } = require("../../../cli/mcp-discovery")
+
+const PLUGIN_NAME = "browser-use"
+const MCP_SERVER_NAME = "browser-use"
+const NAMESPACE = "browseruse"
+const SKILLS_ROOT = path.resolve(__dirname, "..", "skills")
+
+const DEFAULT_SERVER = {
+  command: "npx",
+  args: [
+    "-y",
+    "mcp-remote",
+    "https://api.browser-use.com/mcp",
+    "--header",
+    "X-Browser-Use-API-Key: ${BROWSER_USE_API_KEY}"
+  ],
+  env: {
+    BROWSER_USE_API_KEY: "${BROWSER_USE_API_KEY}"
+  },
+  timeout_ms: 180000
+}
+
+const KNOWN_TOOLS = [
+  "browser_task",
+  "list_browser_profiles",
+  "monitor_task",
+  "list_skills",
+  "get_cookies",
+  "execute_skill"
+]
+
+function uniqueStrings(values) {
+  const seen = new Set()
+  const out = []
+  for (const value of values || []) {
+    if (typeof value !== "string" || !value) continue
+    if (seen.has(value)) continue
+    seen.add(value)
+    out.push(value)
+  }
+  return out
+}
+
+function actionFromToolName(toolName) {
+  return String(toolName || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "tool"
+}
+
+function buildToolCommand(toolName) {
+  return {
+    namespace: NAMESPACE,
+    resource: "tool",
+    action: actionFromToolName(toolName),
+    description: `Browser Use MCP tool '${toolName}'`,
+    adapter: "mcp",
+    adapterConfig: {
+      server: MCP_SERVER_NAME,
+      tool: toolName,
+      timeout_ms: 180000
+    },
+    args: []
+  }
+}
+
+async function ensureMcpServer() {
+  const servers = await listMcpServers()
+  const existing = (servers || []).find(s => s && s.name === MCP_SERVER_NAME)
+  if (existing) return { server: existing, created: false }
+  await setMcpServer(MCP_SERVER_NAME, DEFAULT_SERVER)
+  return {
+    server: { name: MCP_SERVER_NAME, ...DEFAULT_SERVER },
+    created: true
+  }
+}
+
+async function discoverToolNames(server) {
+  const discovered = await discoverMcpTools(server)
+  const names = discovered.map(t => t && t.name).filter(Boolean)
+  return uniqueStrings(names)
+}
+
+async function run() {
+  const warnings = []
+  const { server, created } = await ensureMcpServer()
+
+  let toolNames = []
+  try {
+    toolNames = await discoverToolNames(server)
+  } catch (err) {
+    warnings.push(`Tool discovery failed: ${err.message}`)
+  }
+
+  if (toolNames.length === 0) {
+    toolNames = KNOWN_TOOLS.slice()
+    warnings.push("Using fallback Browser Use tool bindings; run `supercli mcp tools --mcp-server browser-use` after setting BROWSER_USE_API_KEY")
+  }
+
+  const commands = uniqueStrings(toolNames).map(buildToolCommand)
+
+  for (const cmd of commands) {
+    await upsertCommand(cmd)
+  }
+
+  addProvider({
+    name: PLUGIN_NAME,
+    type: "local_fs",
+    roots: [SKILLS_ROOT],
+    enabled: true
+  })
+
+  const index = syncCatalog()
+  return {
+    plugin: PLUGIN_NAME,
+    mcp_server: MCP_SERVER_NAME,
+    server_created: created,
+    discovered_tools: toolNames.length,
+    bound_commands: commands.length,
+    warnings,
+    provider: PLUGIN_NAME,
+    synced_skills: Array.isArray(index.skills) ? index.skills.length : 0
+  }
+}
+
+if (require.main === module) {
+  run()
+    .then((result) => {
+      process.stdout.write(JSON.stringify(result))
+    })
+    .catch((err) => {
+      process.stderr.write(err.message)
+      process.exit(1)
+    })
+}
+
+module.exports = {
+  run,
+  actionFromToolName,
+  buildToolCommand,
+  DEFAULT_SERVER,
+  KNOWN_TOOLS
+}

package/plugins/browser-use/scripts/post-uninstall.js

@@ -0,0 +1,28 @@
+const { removeProvider, syncCatalog } = require("../../../cli/skills-catalog")
+const { removeCommandsByNamespace } = require("../../../cli/config")
+
+async function run() {
+  const removedCommands = await removeCommandsByNamespace("browseruse")
+  const removedProvider = removeProvider("browser-use")
+  const index = syncCatalog()
+  return {
+    plugin: "browser-use",
+    removed_provider: removedProvider,
+    removed_commands: removedCommands,
+    synced_skills: Array.isArray(index.skills) ? index.skills.length : 0,
+    note: "MCP server 'browser-use' was not removed automatically. Run: supercli mcp remove browser-use"
+  }
+}
+
+if (require.main === module) {
+  run()
+    .then((result) => {
+      process.stdout.write(JSON.stringify(result))
+    })
+    .catch((err) => {
+      process.stderr.write(err.message)
+      process.exit(1)
+    })
+}
+
+module.exports = { run }

package/plugins/browser-use/skills/quickstart/SKILL.md

@@ -0,0 +1,47 @@
+---
+skill_name: browser-use.quickstart
+description: Agent workflow to install, configure, and run Browser Use MCP tools quickly via SuperCLI.
+tags: browser-use,mcp,automation,agents
+---
+
+# Browser Use Quickstart
+
+Use this when you need browser automation through Browser Use MCP.
+
+## 1) Ensure API key is available
+
+```bash
+export BROWSER_USE_API_KEY=<your_key>
+```
+
+## 2) Install plugin
+
+```bash
+supercli plugins learn browser-use
+supercli plugins install browser-use --json
+```
+
+This auto-registers the `browser-use` MCP server and binds direct commands under `browseruse.tool.*`.
+
+## 3) Verify health and discover tools
+
+```bash
+supercli mcp doctor --mcp-server browser-use --json
+supercli mcp tools --mcp-server browser-use --json
+```
+
+## 4) Call tools directly
+
+```bash
+supercli mcp call --mcp-server browser-use --tool list_skills --input-json '{}' --timeout-ms 180000 --json
+supercli mcp call --mcp-server browser-use --tool browser_task --input-json '{"task":"Search Google for the latest iPhone reviews and summarize the top 3 results"}' --timeout-ms 180000 --json
+```
+
+For long-running tasks, use `monitor_task` with the returned `task_id`.
+
+## 5) Use bound tool commands (faster)
+
+```bash
+supercli browseruse tool list-skills --json
+supercli browseruse tool browser-task --task "Open example.com and summarize the home page" --json
+```

package/plugins/monty/README.md

@@ -0,0 +1,49 @@
+# Monty Plugin for SuperCLI
+
+Hybrid plugin for the [Monty](https://github.com/pydantic/monty) sandboxed Python interpreter.
+
+## Overview
+
+Monty is a minimal, secure Python interpreter written in Rust, designed for AI agents to run untrusted code safely. This plugin provides a Node.js wrapper for the `@pydantic/monty` package and indexes the upstream agent documentation into the SuperCLI skills catalog.
+
+## Features
+
+- **Sandboxed Execution**: Runs Python code without access to the host filesystem, network, or environment.
+- **Dependency Management**: Controlled setup of the `@pydantic/monty` binary.
+- **Skills Indexing**: Teaches agents about Monty's capabilities by indexing remote `README.md` and `CLAUDE.md`.
+- **Hybrid Support**: Combines local CLI wrappers with remote documentation.
+
+## Installation
+
+1. Install the plugin:
+   ```bash
+   supercli plugins install ./plugins/monty
+   ```
+2. Setup the Monty dependency:
+   ```bash
+   supercli monty cli setup
+   ```
+
+## Usage
+
+### Run Python Code
+
+```bash
+supercli monty python run "1 + 2"
+```
+
+### Run with Inputs
+
+```bash
+supercli monty python run "x + y" --inputs '{"x": 10, "y": 20}'
+```
+
+### Version and Status
+
+```bash
+supercli monty cli version
+```
+
+## Security
+
+Monty executes code in a strict sandbox. The only way to interact with the host is through explicit external function calls (not yet exposed via this generic CLI wrapper).

package/plugins/monty/plugin.json

@@ -0,0 +1,69 @@
+{
+  "name": "monty",
+  "version": "0.1.1",
+  "description": "Hybrid Monty plugin: sandboxed Python via @pydantic/monty and remote agent skills",
+  "source": "https://github.com/pydantic/monty",
+  "checks": [
+    { "type": "binary", "name": "node" },
+    { "type": "binary", "name": "npm" }
+  ],
+  "post_install": {
+    "script": "scripts/post-install.js",
+    "runtime": "node",
+    "timeout_ms": 15000
+  },
+  "post_uninstall": {
+    "script": "scripts/post-uninstall.js",
+    "runtime": "node",
+    "timeout_ms": 15000
+  },
+  "commands": [
+    {
+      "namespace": "monty",
+      "resource": "cli",
+      "action": "setup",
+      "description": "Install @pydantic/monty dependency globally",
+      "adapter": "process",
+      "adapterConfig": {
+        "command": "node",
+        "baseArgs": ["scripts/setup-monty.js"],
+        "parseJson": false,
+        "timeout_ms": 60000
+      },
+      "args": []
+    },
+    {
+      "namespace": "monty",
+      "resource": "cli",
+      "action": "version",
+      "description": "Show monty plugin version and dependency status",
+      "adapter": "process",
+      "adapterConfig": {
+        "command": "node",
+        "baseArgs": ["scripts/run-python.js", "--version"],
+        "parseJson": true,
+        "timeout_ms": 15000
+      },
+      "args": []
+    },
+    {
+      "namespace": "monty",
+      "resource": "python",
+      "action": "run",
+      "description": "Run sandboxed Python code via Monty",
+      "adapter": "process",
+      "adapterConfig": {
+        "command": "node",
+        "baseArgs": ["scripts/run-python.js"],
+        "positionalArgs": ["code"],
+        "parseJson": true,
+        "timeout_ms": 15000
+      },
+      "args": [
+        { "name": "code", "type": "string", "required": true },
+        { "name": "inputs", "type": "string", "required": false },
+        { "name": "typeCheck", "type": "boolean", "required": false }
+      ]
+    }
+  ]
+}

package/plugins/monty/scripts/post-install.js

@@ -0,0 +1,73 @@
+const { addProvider, syncCatalog } = require("../../../cli/skills-catalog")
+
+const OWNER = "intranefr"
+const REPO = "monty"
+const REF = "main"
+const SOURCE_REPO = `https://github.com/${OWNER}/${REPO}`
+const RAW_BASE_URL = `https://raw.githubusercontent.com/${OWNER}/${REPO}/${REF}`
+
+const CATALOG_FILES = [
+  {
+    id: "root.skill",
+    name: "Monty Agent Skill",
+    path: "CLAUDE.md",
+    description: "Core guidance for working with the Monty sandboxed Python interpreter, including VM architecture, security mandates, and SuperCLI agentic patterns.",
+    tags: ["agents", "python", "sandbox", "security", "supercli"]
+  },
+  {
+    id: "root.usage",
+    name: "Monty Usage Guide",
+    path: "docs/usage-guide.md",
+    description: "Comprehensive guide for developers on installing, configuring, and using Monty in Python and JavaScript environments.",
+    tags: ["usage", "guide", "python", "javascript", "examples"]
+  },
+  {
+    id: "root.readme",
+    name: "Monty Overview",
+    path: "README.md",
+    description: "General overview of Monty's goals, performance, and language support.",
+    tags: ["overview", "python", "interpreter"]
+  }
+]
+
+function buildRemoteEntries() {
+  return CATALOG_FILES.map(file => ({
+    ...file,
+    source_url: `${RAW_BASE_URL}/${file.path}`
+  }))
+}
+
+function run() {
+  const entries = buildRemoteEntries()
+  addProvider({
+    name: "monty",
+    type: "remote_static",
+    enabled: true,
+    source_repo: SOURCE_REPO,
+    ref: REF,
+    entries
+  })
+
+  const index = syncCatalog()
+  return {
+    provider: "monty",
+    entries: entries.length,
+    synced_skills: Array.isArray(index.skills) ? index.skills.length : 0
+  }
+}
+
+if (require.main === module) {
+  try {
+    const result = run()
+    process.stdout.write(JSON.stringify(result))
+  } catch (err) {
+    process.stderr.write(err.message)
+    process.exit(1)
+  }
+}
+
+module.exports = {
+  CATALOG_FILES,
+  buildRemoteEntries,
+  run
+}

package/plugins/monty/scripts/post-uninstall.js

@@ -0,0 +1,23 @@
+const { removeProvider, syncCatalog } = require("../../../cli/skills-catalog")
+
+function run() {
+  const removed = removeProvider("monty")
+  const index = syncCatalog()
+  return {
+    provider: "monty",
+    removed,
+    synced_skills: Array.isArray(index.skills) ? index.skills.length : 0
+  }
+}
+
+if (require.main === module) {
+  try {
+    const result = run()
+    process.stdout.write(JSON.stringify(result))
+  } catch (err) {
+    process.stderr.write(err.message)
+    process.exit(1)
+  }
+}
+
+module.exports = { run }

package/plugins/monty/scripts/run-python.js

@@ -0,0 +1,140 @@
+const { spawnSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+function getGlobalNodeModules() {
+  const result = spawnSync("npm", ["root", "-g"], { encoding: "utf-8" });
+  if (result.status === 0 && result.stdout) {
+    return result.stdout.trim();
+  }
+  return null;
+}
+
+function resolveMonty() {
+  if (process.env.MOCK_MISSING_MONTY === "1") return null;
+  try {
+    return require("@pydantic/monty");
+  } catch (e) {
+    const globalRoot = getGlobalNodeModules();
+    if (globalRoot) {
+      const globalMontyPath = path.join(globalRoot, "@pydantic", "monty");
+      if (fs.existsSync(globalMontyPath)) {
+        try {
+          return require(globalMontyPath);
+        } catch (inner) {
+          // ignore
+        }
+      }
+    }
+  }
+  return null;
+}
+
+function run() {
+  const args = process.argv.slice(2);
+  const isVersion = args.includes("--version");
+
+  const MontyPkg = resolveMonty();
+
+  if (!MontyPkg) {
+    console.error(
+      JSON.stringify({
+        error: {
+          code: 85,
+          type: "invalid_argument",
+          message:
+            "Dependency @pydantic/monty not found. Please run the setup command first.",
+          recoverable: true,
+          suggestions: ["Run: supercli monty cli setup"],
+        },
+      })
+    );
+    process.exit(1);
+  }
+
+  if (isVersion) {
+    const pkgPath = require.resolve("@pydantic/monty", {
+      paths: [process.cwd(), getGlobalNodeModules()].filter(Boolean),
+    });
+    const pkgJson = JSON.parse(
+      fs.readFileSync(path.join(path.dirname(pkgPath), "package.json"), "utf-8")
+    );
+    console.log(
+      JSON.stringify({
+        plugin_version: "0.1.0",
+        monty_version: pkgJson.version,
+        status: "ready",
+        location: pkgPath,
+      })
+    );
+    return;
+  }
+
+  // Find the code argument
+  // In our plugin.json, code is the first positional arg
+  // Flags like --inputs or --typeCheck will be passed as well
+  let code = null;
+  let inputs = {};
+  let typeCheck = false;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--inputs") {
+      try {
+        inputs = JSON.parse(args[++i]);
+      } catch (e) {
+        console.error(
+          JSON.stringify({ error: { message: "Invalid JSON for --inputs" } })
+        );
+        process.exit(1);
+      }
+    } else if (args[i] === "--typeCheck") {
+      typeCheck = true;
+    } else if (!args[i].startsWith("--") && code === null) {
+      code = args[i];
+    }
+  }
+
+  if (!code) {
+    console.error(
+      JSON.stringify({ error: { message: "No Python code provided" } })
+    );
+    process.exit(1);
+  }
+
+  try {
+    const { Monty } = MontyPkg;
+    const inputNames = Object.keys(inputs);
+    const m = new Monty(code, { inputs: inputNames, typeCheck });
+    const runOptions = {};
+    if (inputNames.length > 0) {
+      runOptions.inputs = inputs;
+    }
+    const result = m.run(runOptions);
+
+    console.log(
+      JSON.stringify({
+        ok: true,
+        result: result,
+      })
+    );
+  } catch (error) {
+    const errorInfo = {
+      ok: false,
+      error_type: error.constructor.name,
+      message: error.message,
+    };
+
+    if (typeof error.traceback === "function") {
+      errorInfo.traceback = error.traceback();
+    }
+    if (typeof error.displayDiagnostics === "function") {
+      errorInfo.diagnostics = error.displayDiagnostics();
+    }
+
+    console.log(JSON.stringify(errorInfo));
+  }
+}
+
+if (require.main === module) {
+  run();
+}

package/plugins/monty/scripts/setup-monty.js

@@ -0,0 +1,27 @@
+const { spawnSync } = require("child_process")
+
+function run() {
+  console.log("Installing @pydantic/monty globally...")
+  const result = spawnSync("npm", ["install", "-g", "@pydantic/monty"], {
+    encoding: "utf-8",
+    stdio: "inherit"
+  })
+
+  if (result.error) {
+    console.error(`Error starting npm: ${result.error.message}`)
+    process.exit(1)
+  }
+
+  if (result.status !== 0) {
+    console.error(`npm install failed with exit code ${result.status}`)
+    console.log("\nIf you see permission errors, you may need to run this command with sudo or fix your npm global permissions.")
+    process.exit(result.status)
+  }
+
+  console.log("\nSuccessfully installed @pydantic/monty globally.")
+  console.log("You can now run Python code with: supercli monty python run \"code\"")
+}
+
+if (require.main === module) {
+  run()
+}

package/plugins/plugins.json

@@ -280,6 +280,15 @@
         "manifest_path": "plugins/clix/plugin.json"
       }
     },
+    {
+      "name": "monty",
+      "description": "Hybrid Monty plugin with remote docs indexing and sandboxed Python execution",
+      "tags": ["monty", "python", "sandbox", "skills", "agents"],
+      "source": {
+        "type": "bundled",
+        "manifest_path": "plugins/monty/plugin.json"
+      }
+    },
     {
       "name": "cline",
       "description": "Cline CLI plugin with rich non-interactive task wrappers and passthrough",
@@ -327,6 +336,16 @@
         "manifest_path": "plugins/visual-explainer/plugin.json"
       }
     },
+    {
+      "name": "browser-use",
+      "description": "Hybrid Browser Use plugin: auto MCP setup, dynamic tool bindings, and local usage skills",
+      "tags": ["browser-use", "mcp", "browser", "automation", "agents", "skills"],
+      "has_learn": true,
+      "source": {
+        "type": "bundled",
+        "manifest_path": "plugins/browser-use/plugin.json"
+      }
+    },
     {
       "name": "superpowers",
       "description": "Agentic skills framework for software development methodology from obra/superpowers",
@@ -353,6 +372,16 @@
         "type": "bundled",
         "manifest_path": "plugins/openfang/plugin.json"
       }
+    },
+    {
+      "name": "resend",
+      "description": "Resend CLI plugin for official email sending, domain management, API keys, and audience contacts",
+      "tags": ["resend", "email", "api", "domains", "passthrough"],
+      "has_learn": true,
+      "source": {
+        "type": "bundled",
+        "manifest_path": "plugins/resend/plugin.json"
+      }
     }
   ]
 }