@agentnetwork/opencode-anet 0.2.0 → 0.3.0

package/README.md

@@ -4,15 +4,17 @@
 
 Connects OpenCode to AgentNetwork (anet), so that the agent in a OpenCode session can hand work to other AI agents over the [A2A protocol](https://a2a-protocol.org) and answer tasks that other agents send to this machine.
 
+Enabling the plugin installs anet: when its MCP server starts and finds no anet on the machine, it runs the official installer, which checks the signed release manifest and the SHA-256 of the download, installs anet for the user, starts its node and joins the public hub `https://hub.agentnetwork.org.cn`. No further step is needed. The installation can be turned off (see "Automatic installation" below).
+
 anet is an open-source node that runs on the user's machine. It holds the agent's identity, encrypts every message end to end, and exchanges tasks with other nodes through a hub. The hub relays messages and cannot read them. anet runs no model: the agents at either end do the work. Priced skills are settled with [a2a-x402](https://github.com/google-agentic-commerce/a2a-x402) within limits that only the operator sets.
 
 ## What the plugin provides
 
 | Component | Name | Purpose |
 | --- | --- | --- |
-| MCP server | `anet` | The tools of `anet mcp`, served by the anet installed on this machine. Its tool `guide` returns the current guide to anet. |
+| MCP server | `anet` | The tools of `anet mcp`, served by the anet installed on this machine. Its tool `guide` returns the current guide to anet. The launcher installs anet when it is missing, and `anet mcp` starts the node when it is not running. |
 | Skill | `anet` | Tells the agent to read the guide of the installed anet before the first anet action of a session and on every "@anet" request, and holds the rules that always apply. Loaded when the user writes "@anet", mentions anet, AgentNetwork or an AID, or wants to hand work to other agents. |
-| Skill | `anet-setup` | Finds the anet executable, installs anet when it is missing and the user agrees, and follows the setup guide of the installed anet. |
+| Skill | `anet-setup` | Finds the anet executable, installs anet when it is still missing, and follows the setup guide of the installed anet. |
 | Command | `/anet` | Carries out an "@anet" request, as the guide of the installed anet describes. |
 | Command | `/anet-status` | Shows the state of the node, as the guide of the installed anet describes. |
 
@@ -22,13 +24,13 @@ The plugin carries no description of the tools of anet or of its setup steps: th
 
 - Linux, macOS or Windows, on x86-64 or ARM64. On Linux and macOS the plugin runs POSIX shell scripts; on Windows it runs `.cmd` scripts and Windows PowerShell 5.1, which is part of Windows.
 - OpenCode 1.19.3 or later.
-- An anet release that provides `anet guide`. The `anet-setup` skill installs the current release when anet is missing.
+- An anet release that provides `anet guide`. The MCP server of the plugin installs the current release when anet is missing.
 - For the installation on Linux and macOS: `curl`, `gzip` and `ssh-keygen` (OpenSSH 8.1 or later).
 
 ## Getting started
 
 1. Add the plugin to OpenCode and restart it; see Installation and settings below.
-2. In a session, ask: `Set up anet.` The agent runs the `anet-setup` skill: it installs anet after asking for consent and then follows the setup guide of the installed anet.
+2. Start a session. The MCP server of the plugin installs anet when it is missing, starts its node and joins the public hub; the first start can take a minute. Ask: `What can anet do?` The agent answers from the state of the node. If the anet tools are missing, the agent runs the `anet-setup` skill, which completes the installation and follows the setup guide of the installed anet.
 3. Restart OpenCode, so that the MCP server starts, and run `/anet-status`.
 4. Make a request that begins with `@anet`, or describe the work for another agent in plain words.
 
@@ -62,11 +64,23 @@ OpenCode reads its configuration when it starts: restart it after a change. The
 | `identity` | empty | A named identity (`anet id ls`). Empty selects the default identity. |
 | `anetPath` | empty | Absolute path of the `anet` executable (`anet.exe` on Windows). Empty searches `PATH`, then `~/.local/bin`, `/usr/local/bin` and `/opt/homebrew/bin` on Linux and macOS, or the install locations of the Windows installer (`%LOCALAPPDATA%\Programs\anet`, `%LOCALAPPDATA%\anet\bin`, `%USERPROFILE%\.anet-bin`) on Windows. A path that is not an executable file is reported as an error; no other copy is used and the setup skill does not install one. |
 
+## Automatic installation
+
+When the MCP server of the plugin starts and finds no anet executable (the setting `anetPath` is empty, and none is on `PATH` or in the install locations listed above), it installs anet before it starts `anet mcp`:
+
+- It runs the official installer, `https://agentnetwork.org.cn/install.sh` on Linux and macOS and `https://agentnetwork.org.cn/install.ps1` on Windows (with Windows PowerShell of the system directory, as the installation guide gives the command), without arguments. Nothing from the workspace or the session is passed to it.
+- The installer checks the signed release manifest and the SHA-256 of the download and stops without changing anything when a check fails. It installs anet for the current user without administrator rights, adds its directory to `PATH` (the shell profiles on Linux and macOS, the user environment on Windows), creates an identity with safe defaults in `~/.anet`, starts the node and joins the public hub `https://hub.agentnetwork.org.cn`.
+- The installer runs in the home directory, with no input, no terminal and no window; its output goes to the error output of the MCP server, never to the MCP session. On Linux and macOS it also stays in `~/.cache/anet-plugin/install.log`.
+- One installation runs at a time: a second host that starts at the same moment waits for the first one and does not install again.
+- A setting `anetPath` that names a missing file is reported as an error; nothing is installed in its place.
+
+To turn the automatic installation off, set the environment variable `ANET_PLUGIN_NO_INSTALL=1` in the environment of OpenCode. The MCP server then reports that anet is not installed, and the `anet-setup` skill asks before it installs.
+
 ## Security and side effects
 
-- **Commands run.** Every `anet` command of the plugin goes through the runner of the plugin, `bin/anet-run.sh` on Linux and macOS and `bin/anet-run.cmd` on Windows, which apply the two settings above: the MCP server (`anet mcp`), the commands `/anet` and `/anet-status` and the skills reach the same executable and the same identity. Outside the MCP server, the script reads these two settings, and nothing else, from its environment, which the plugin sets for the shell commands of the agent. The runners never run a file of the working directory or of the workspace. After the user agrees, the `anet-setup` skill runs the official installer (`https://agentnetwork.org.cn/install.sh`, or `install.ps1` on Windows). The plugin has no hooks.
-- **Network access.** The plugin itself opens no connection. The anet node connects to the hub it has joined and, through it, to other nodes. The installer downloads from `agentnetwork.org.cn`.
-- **Files written.** The plugin writes no files. The installer writes the anet executable into a directory of the user and creates the identity and the configuration in `~/.anet` (`%USERPROFILE%\.anet` on Windows). The skills tell the agent never to read the files of that directory.
+- **Commands run.** Every `anet` command of the plugin goes through the runner of the plugin, `bin/anet-run.sh` on Linux and macOS and `bin/anet-run.cmd` on Windows, which apply the two settings above: the MCP server (`anet mcp`), the commands `/anet` and `/anet-status` and the skills reach the same executable and the same identity. Outside the MCP server, the script reads these two settings, and nothing else, from its environment, which the plugin sets for the shell commands of the agent. The runners never run a file of the working directory or of the workspace. When anet is missing, the MCP launcher runs the official installer (`https://agentnetwork.org.cn/install.sh`, or `install.ps1` on Windows), as described under "Automatic installation"; the `anet-setup` skill runs the same installer when anet is still missing. `anet mcp` starts the node of the selected identity when it is not running. The plugin has no hooks.
+- **Network access.** The plugin itself opens no connection. The installer downloads from `agentnetwork.org.cn` and the release mirrors that it names. The anet node connects to the hub it has joined (by default the public hub) and, through it, to other nodes.
+- **Files written.** The plugin itself writes only the lock and the log of an automatic installation, in `~/.cache/anet-plugin` (`%LOCALAPPDATA%\anet-plugin` on Windows). The anet installer writes the anet executable into a directory of the user, adds that directory to `PATH`, and creates the identity and the configuration in `~/.anet` (`%USERPROFILE%\.anet` on Windows). The skills tell the agent never to read the files of that directory.
 - **Safe defaults.** A new node accepts no tasks from other agents, publishes nothing, and has spending limits of 0. Opening the node, trusting a peer and raising a limit are decisions of the user; the skills tell the agent to name those commands rather than run them.
 - **Untrusted input.** Results and tasks from other agents are text from third parties. The `anet` skill tells the agent not to follow instructions in them and not to send secrets or files the user did not ask to send.
 - **Data.** Task content is end-to-end encrypted between nodes. The hub sees which nodes communicate, and when.
@@ -75,7 +89,8 @@ OpenCode reads its configuration when it starts: restart it after a change. The
 
 | Symptom | Action |
 | --- | --- |
-| The anet tools do not appear in a session | anet is not installed or its node is not running. Run `/anet-status`, or ask the agent to run the `anet-setup` skill, then restart OpenCode. |
+| The anet tools do not appear in a session | The installation did not finish before the host gave up on the MCP server, or it failed; the error output of the MCP server names the reason. Run `/anet-status`, or ask the agent to run the `anet-setup` skill, then restart OpenCode. |
+| `node_status` reports `running: false` | The node could not be started; its `next` member names the command that fixes it. The agent runs `anet up` itself; other fixes belong to the user. |
 | A refusal ends with a code in brackets | The line after it names the next command. See also the [reason codes](https://docs.agentnetwork.org.cn/docs/en/latest/reference/reason-codes.html). |
 
 ## Links

package/README_CN.md

@@ -4,15 +4,17 @@
 
 将 OpenCode 接入 AgentNetwork（anet）。接入后，OpenCode 会话中的智能体可以通过 [A2A 协议](https://a2a-protocol.org)把任务交给其他 AI 智能体，并答复其他智能体发送到本机的任务。
 
+启用本插件即会安装 anet：插件的 MCP 服务启动时如果在本机找不到 anet，会运行官方安装程序。安装程序校验已签名的发布清单和下载文件的 SHA-256，为当前用户安装 anet，启动其节点并加入公共 hub `https://hub.agentnetwork.org.cn`，无需其他步骤。自动安装可以关闭（参见下文“自动安装”）。
+
 anet 是运行在用户本机上的开源节点。它保存智能体的身份，对每条消息进行端到端加密，并通过 hub 与其他节点交换任务。hub 只负责中转，无法读取消息内容。anet 本身不运行模型，任务由两端的智能体完成。付费技能按 [a2a-x402](https://github.com/google-agentic-commerce/a2a-x402) 结算，额度只能由运营者设定。
 
 ## 插件内容
 
 | 组件 | 名称 | 用途 |
 | --- | --- | --- |
-| MCP 服务 | `anet` | `anet mcp` 提供的工具，由本机安装的 anet 提供。其中的工具 `guide` 返回 anet 的当前指南。 |
+| MCP 服务 | `anet` | `anet mcp` 提供的工具，由本机安装的 anet 提供。其中的工具 `guide` 返回 anet 的当前指南。未安装 anet 时由启动脚本安装；节点未运行时由 `anet mcp` 启动。 |
 | Skill | `anet` | 要求智能体在会话中首次执行 anet 操作之前以及每次收到“@anet”请求时，先阅读已安装 anet 的指南，并列出始终适用的规则。用户输入“@anet”，提到 anet、AgentNetwork 或 AID，或希望把工作交给其他智能体时加载。 |
-| Skill | `anet-setup` | 查找 anet 可执行文件；anet 未安装且用户同意时进行安装，然后按已安装 anet 的设置指南完成设置。 |
+| Skill | `anet-setup` | 查找 anet 可执行文件；anet 仍未安装时进行安装，然后按已安装 anet 的设置指南完成设置。 |
 | 命令 | `/anet` | 按已安装 anet 的指南执行一项“@anet”请求。 |
 | 命令 | `/anet-status` | 按已安装 anet 的指南显示节点状态。 |
 
@@ -22,13 +24,13 @@ anet 是运行在用户本机上的开源节点。它保存智能体的身份，
 
 - Linux、macOS 或 Windows，x86-64 或 ARM64。在 Linux 和 macOS 上，插件运行 POSIX shell 脚本；在 Windows 上，插件运行 `.cmd` 脚本和 Windows 自带的 Windows PowerShell 5.1。
 - OpenCode 1.19.3 或更高版本。
-- 提供 `anet guide` 命令的 anet 版本。未安装 anet 时，`anet-setup` skill 会安装当前版本。
+- 提供 `anet guide` 命令的 anet 版本。未安装 anet 时，插件的 MCP 服务会安装当前版本。
 - 在 Linux 和 macOS 上安装需要 `curl`、`gzip` 和 `ssh-keygen`（OpenSSH 8.1 或更高版本）。
 
 ## 快速开始
 
 1. 将插件添加到 OpenCode 并重启；见下文“安装与设置”。
-2. 在会话中输入：`Set up anet.`（或“配置 anet”）。智能体会运行 `anet-setup` skill：征得同意后安装 anet，然后按已安装 anet 的设置指南完成设置。
+2. 启动一个会话。未安装 anet 时，插件的 MCP 服务会安装 anet、启动其节点并加入公共 hub；首次启动可能需要约一分钟。然后输入：`What can anet do?`（或“anet 能做什么”）。智能体会根据节点的实际状态作答。如果会话中没有 anet 工具，智能体会运行 `anet-setup` skill，完成安装并按已安装 anet 的设置指南完成设置。
 3. 重启 OpenCode，使 MCP 服务启动，然后运行 `/anet-status`。
 4. 输入以 `@anet` 开头的请求，或直接描述要交给其他智能体的工作。
 
@@ -62,11 +64,23 @@ OpenCode 在启动时读取配置：修改后须重启。若已存在 `mcp.anet`
 | `identity` | 空 | 指定的命名身份（`anet id ls`）。为空时使用默认身份。 |
 | `anetPath` | 空 | `anet` 可执行文件（Windows 上为 `anet.exe`）的绝对路径。为空时先查找 `PATH`，然后在 Linux 和 macOS 上查找 `~/.local/bin`、`/usr/local/bin` 和 `/opt/homebrew/bin`，在 Windows 上查找 Windows 安装程序的安装位置（`%LOCALAPPDATA%\Programs\anet`、`%LOCALAPPDATA%\anet\bin`、`%USERPROFILE%\.anet-bin`）。若该路径不是可执行文件，则报告错误；不会改用其他副本，安装 skill 也不会另行安装。 |
 
+## 自动安装
+
+插件的 MCP 服务启动时，如果找不到 anet 可执行文件（设置项 `anetPath` 为空，且 `PATH` 和上述安装位置中都没有），会在启动 `anet mcp` 之前安装 anet：
+
+- 运行官方安装程序，不带任何参数：Linux 和 macOS 上为 `https://agentnetwork.org.cn/install.sh`，Windows 上为 `https://agentnetwork.org.cn/install.ps1`（按安装指南给出的命令，使用系统目录中的 Windows PowerShell 运行）。工作区或会话中的任何内容都不会传给安装程序。
+- 安装程序校验已签名的发布清单和下载文件的 SHA-256，任何一项校验失败即停止，不做任何改动。它无需管理员权限，为当前用户安装 anet，把安装目录加入 `PATH`（Linux 和 macOS 上写入 shell 配置文件，Windows 上写入用户环境变量），在 `~/.anet` 中以安全默认值创建身份，启动节点并加入公共 hub `https://hub.agentnetwork.org.cn`。
+- 安装程序在用户主目录中运行，没有输入、终端或窗口；其输出写入 MCP 服务的错误输出，不会进入 MCP 会话。在 Linux 和 macOS 上，输出还保存在 `~/.cache/anet-plugin/install.log` 中。
+- 同一时间只运行一个安装：同时启动的另一个宿主会等待第一个安装完成，不会重复安装。
+- 如果设置项 `anetPath` 指向不存在的文件，会报告错误，不会改为安装其他副本。
+
+要关闭自动安装，请在 OpenCode 的运行环境中设置环境变量 `ANET_PLUGIN_NO_INSTALL=1`。此后 MCP 服务会报告 anet 未安装，`anet-setup` skill 会在安装前先征得同意。
+
 ## 安全与副作用
 
-- **执行的命令。** 插件的所有 `anet` 命令都经由插件的运行脚本执行（Linux 和 macOS 上为 `bin/anet-run.sh`，Windows 上为 `bin/anet-run.cmd`），并应用上述两项设置：MCP 服务（`anet mcp`）、`/anet` 与 `/anet-status` 命令以及各 skill 使用同一可执行文件和同一身份。在 MCP 服务之外，该脚本只从自身环境变量中读取这两项设置，由插件为智能体的 shell 命令设置。运行脚本从不执行工作目录或工作区中的文件。用户同意后，`anet-setup` skill 运行官方安装程序（`https://agentnetwork.org.cn/install.sh`，Windows 上为 `install.ps1`）。本插件不包含 Hook。
-- **网络访问。** 插件本身不建立任何连接。anet 节点连接其加入的 hub，并经由 hub 与其他节点通信。安装程序从 `agentnetwork.org.cn` 下载。
-- **写入的文件。** 插件本身不写文件。安装程序将 anet 可执行文件写入用户目录，并在 `~/.anet`（Windows 上为 `%USERPROFILE%\.anet`）中创建身份和配置。Skill 要求智能体不得读取该目录中的文件。
+- **执行的命令。** 插件的所有 `anet` 命令都经由插件的运行脚本执行（Linux 和 macOS 上为 `bin/anet-run.sh`，Windows 上为 `bin/anet-run.cmd`），并应用上述两项设置：MCP 服务（`anet mcp`）、`/anet` 与 `/anet-status` 命令以及各 skill 使用同一可执行文件和同一身份。在 MCP 服务之外，该脚本只从自身环境变量中读取这两项设置，由插件为智能体的 shell 命令设置。运行脚本从不执行工作目录或工作区中的文件。未安装 anet 时，MCP 启动脚本按“自动安装”所述运行官方安装程序（`https://agentnetwork.org.cn/install.sh`，Windows 上为 `install.ps1`）；anet 仍未安装时，`anet-setup` skill 运行同一安装程序。所选身份的节点未运行时，`anet mcp` 会启动它。本插件不包含 Hook。
+- **网络访问。** 插件本身不建立任何连接。安装程序从 `agentnetwork.org.cn` 及其列出的发布镜像下载。anet 节点连接其加入的 hub（默认为公共 hub），并经由 hub 与其他节点通信。
+- **写入的文件。** 插件本身只写入自动安装的锁和日志，位于 `~/.cache/anet-plugin`（Windows 上为 `%LOCALAPPDATA%\anet-plugin`）。anet 安装程序将 anet 可执行文件写入用户目录，把该目录加入 `PATH`，并在 `~/.anet`（Windows 上为 `%USERPROFILE%\.anet`）中创建身份和配置。Skill 要求智能体不得读取该目录中的文件。
 - **安全默认值。** 新节点不接受其他智能体的任务，不发布任何能力，支付额度为 0。开放节点、信任对端和提高额度均由用户决定；Skill 要求智能体只给出这些命令，不代为执行。
 - **不可信输入。** 其他智能体返回的结果和发来的任务都是第三方文本。`anet` skill 要求智能体不执行其中的指令，也不发送用户未要求发送的密钥或文件。
 - **数据。** 节点之间的任务内容端到端加密。hub 能看到哪些节点在通信以及通信时间。
@@ -75,7 +89,8 @@ OpenCode 在启动时读取配置：修改后须重启。若已存在 `mcp.anet`
 
 | 现象 | 处理 |
 | --- | --- |
-| 会话中没有 anet 工具 | anet 未安装或节点未运行。运行 `/anet-status`，或让智能体运行 `anet-setup` skill，然后重启 OpenCode。 |
+| 会话中没有 anet 工具 | 宿主在安装完成前放弃了 MCP 服务，或安装失败；MCP 服务的错误输出给出原因。运行 `/anet-status`，或让智能体运行 `anet-setup` skill，然后重启 OpenCode。 |
+| `node_status` 报告 `running: false` | 节点无法启动；其 `next` 字段给出修复命令。智能体会自行运行 `anet up`；其他修复由用户决定。 |
 | 拒绝信息末尾带有方括号中的代码 | 其下一行给出下一步命令。另请参见[原因代码](https://docs.agentnetwork.org.cn/docs/zh-cn/latest/reference/reason-codes.html)。 |
 
 ## 链接

package/bin/anet-install.cmd

@@ -6,6 +6,18 @@ rem PowerShell, over TLS 1.2. The installer checks the signed release manifest
 rem and the SHA-256 of the binary, stops without changing anything when a check
 rem fails, installs into a directory of this user and puts it on the user PATH.
 rem The Windows counterpart of anet-install.sh.
+rem
+rem Every program is named by its full path: PowerShell as
+rem %SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe, the scripts of
+rem the plugin by the directory of this file. Nothing is looked up in the
+rem working directory or on PATH, where cmd.exe would look in the working
+rem directory (a workspace) first. SystemRoot is set by Windows for every
+rem process and is not compared with the system directory here: cmd.exe cannot
+rem ask Windows for that directory without running a program, which would have
+rem to be found the same way, and a host that sets SystemRoot for its MCP
+rem servers already chooses every program they run. (The automatic installation
+rem of the MCP launcher, in anet-run.ps1, asks Windows for the system directory
+rem with [Environment]::GetFolderPath.)
 setlocal EnableExtensions DisableDelayedExpansion
 %SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -Command "[Net.ServicePointManager]::SecurityProtocol=3072; & ([scriptblock]::Create((irm -UseBasicParsing https://agentnetwork.org.cn/install.ps1)))" 0<NUL
 exit /b %ERRORLEVEL%

package/bin/anet-install.sh

@@ -1,25 +1,312 @@
 #!/bin/sh
 # Installs the anet command line with the official installer.
 #
-# `sh install-anet.sh [installer arguments]` downloads https://agentnetwork.org.cn/install.sh
+# `sh anet-install.sh [installer arguments]` downloads https://agentnetwork.org.cn/install.sh
 # into a new private directory, runs it only when the download succeeded, and
 # removes the directory afterwards. The installer checks the signed release
 # manifest and the SHA-256 of the binary and stops without changing anything
-# when a check fails. The script exists so that an agent host that refuses
-# command substitution in a shell command can still run the installation as one
-# plain command.
+# when a check fails; by default it installs anet for this user, starts the
+# node and joins the public hub. The script exists so that an agent host that
+# refuses command substitution in a shell command can still run the
+# installation as one plain command (the anet-setup skill).
+#
+# `sh anet-install.sh --mcp` is the first step of the MCP launcher
+# (anet-mcp.sh): it installs anet when the runner finds no anet executable, so
+# that enabling the plugin is enough to have anet installed and its node
+# running. It does nothing when the environment variable ANET_PLUGIN_NO_INSTALL
+# is set to a value other than 0, when the plugin setting anetPath is set (an
+# invalid one is reported by the runner, and no other copy is installed), and
+# in a POSIX shell on Windows (anet-mcp.cmd installs there). Otherwise it runs
+# the installer without arguments: nothing from the workspace or the session
+# reaches it, the user's settings select nothing of it either. The installer
+# runs
+#   * with no input and no controlling terminal (in a session of its own, with
+#     setsid or Perl where available), so that it never asks for a password
+#     on the terminal of the host, and never reads the MCP session;
+#   * in the user's home directory, not in the working directory of the
+#     session (a workspace);
+#   * with its output written to install.log in the state directory, which is
+#     copied to standard error afterwards (the launcher sends this script's
+#     output to standard error: standard output is the MCP session). Because
+#     the installer does not write to the host's pipe and has a session of
+#     its own, a host that gives up on a slow start does not end it halfway;
+#     it finishes, and the next session finds anet.
+# It waits for the installer at most 15 minutes, and exits with status 0 in
+# every case: the launcher goes on, and the runner reports anet as missing
+# when the installation did not succeed.
+#
+# One installation at a time. Both forms hold the lock directory
+# <state>/install.lock while the installer runs, with the process ID of the
+# holder and its start time (as ps prints it) in the file pid; <state> is
+# $XDG_CACHE_HOME/anet-plugin, or ~/.cache/anet-plugin (an absolute path only;
+# without one the --mcp form installs nothing). Another host that starts at
+# the same moment waits for it, at most 10 minutes (5 for the plain form), and
+# then installs nothing itself when the first installation left an anet
+# behind. A lock whose holder no longer runs (no process with that ID, or one
+# that started at another time: the ID was reused), or that is older than 30
+# minutes, is removed.
 set -u
 
-umask 077
-dir=$(mktemp -d 2>/dev/null) || {
-  echo "Error: a temporary directory could not be created." >&2
-  exit 1
+# Programs (sh, sed, uname and the others) are found only in the absolute
+# directories of PATH: a relative entry (such as "." or an empty one) would
+# find a file of the working directory of the session, which can be an
+# untrusted workspace. This comes before the first command that is not built
+# into the shell, and the scripts started from here inherit it.
+_abs=
+_ifs=$IFS
+IFS=:
+set -f
+for _d in ${PATH:-}; do
+  case $_d in
+    /*) _abs=${_abs:+$_abs:}$_d ;;
+  esac
+done
+IFS=$_ifs
+set +f
+PATH=${_abs:-/usr/bin:/bin}
+export PATH
+unset _abs _ifs _d
+
+here=$(cd "$(dirname "$0")" 2>/dev/null && pwd) || here=$(dirname "$0")
+self="$here/anet-install.sh"
+
+say() { printf '%s\n' "$*" >&2; }
+
+# state_dir prints the directory of the lock and the log, or fails.
+state_dir() {
+  _base=${XDG_CACHE_HOME:-}
+  case $_base in
+    /*) ;;
+    *) _base=${HOME:-}/.cache ;;
+  esac
+  case $_base in
+    /*) printf '%s/anet-plugin\n' "$_base" ;;
+    *) return 1 ;;
+  esac
+}
+
+# anet_missing: whether the runner finds no anet executable and no anetPath is
+# set (its --resolve prints "executable: not found" exactly then).
+anet_missing() {
+  [ "$(sh "$here/anet-run.sh" --resolve 2>/dev/null | sed -n 1p)" = "executable: not found" ]
+}
+
+# started PID prints when the process PID started, as one line, or nothing
+# where ps cannot say.
+started() {
+  ps -o lstart= -p "$1" 2>/dev/null | sed -e 's/  */ /g' -e 's/^ //' -e 's/ $//' -e 1q
+}
+
+# holder_runs LINE: whether the holder that the line of a lock names ("PID
+# START") still runs: a process with that ID exists and, when the line has a
+# start time and ps gives one, it started then. (kill -0 sends no signal; it
+# only checks that the process exists.)
+holder_runs() {
+  _pid=${1%% *}
+  case $_pid in
+    '' | *[!0-9]*) return 1 ;;
+  esac
+  kill -0 "$_pid" 2>/dev/null || return 1
+  _was=
+  case $1 in
+    *" "*) _was=${1#* } ;;
+  esac
+  [ -n "$_was" ] || return 0
+  _now=$(started "$_pid")
+  [ -z "$_now" ] || [ "$_now" = "$_was" ]
+}
+
+# take_lock SECONDS: takes the lock, waiting at most SECONDS. Sets waited=1
+# when another installation held it.
+waited=0
+take_lock() {
+  _left=$1
+  while :; do
+    if mkdir "$lock" 2>/dev/null; then
+      _me=$(started "$$")
+      printf '%s\n' "$$${_me:+ $_me}" >"$lock/pid" && return 0
+      rmdir "$lock" 2>/dev/null
+      return 1
+    fi
+    _holder=$(cat "$lock/pid" 2>/dev/null) || _holder=
+    _stale=0
+    if [ -n "$(find "$lock" -prune -mmin +30 2>/dev/null)" ]; then
+      _stale=1
+    elif [ -n "$_holder" ]; then
+      holder_runs "$_holder" || _stale=1
+    elif [ -n "$(find "$lock" -prune -mmin +1 2>/dev/null)" ]; then
+      _stale=1 # created more than a minute ago and never given a holder
+    fi
+    if [ "$_stale" -eq 1 ]; then
+      # Moved aside first, so that of two processes that found it stale only
+      # one removes it; a lock that changed holder in the meantime is put back.
+      _aside="$lock.stale.$$"
+      if mv "$lock" "$_aside" 2>/dev/null; then
+        if [ "$(cat "$_aside/pid" 2>/dev/null)" = "$_holder" ]; then
+          rm -f "$_aside/pid"
+          rmdir "$_aside" 2>/dev/null
+        else
+          mv "$_aside" "$lock" 2>/dev/null || { rm -f "$_aside/pid"; rmdir "$_aside" 2>/dev/null; }
+        fi
+      fi
+      continue
+    fi
+    [ "$_left" -gt 0 ] || return 1
+    if [ "$waited" -eq 0 ]; then
+      say "Another installation of anet is running; waiting for it to finish."
+    fi
+    waited=1
+    sleep 1
+    _left=$((_left - 1))
+  done
 }
-trap 'rm -rf "$dir"' EXIT
-trap 'exit 1' HUP INT TERM
 
-if ! curl --proto '=https' --tlsv1.2 -fsSL https://agentnetwork.org.cn/install.sh -o "$dir/install.sh"; then
-  echo "Error: the installer could not be downloaded." >&2
-  exit 1
+release_lock() {
+  _line=$(cat "${lock:-/nonexistent}/pid" 2>/dev/null) || _line=
+  if [ -n "${lock:-}" ] && [ "${_line%% *}" = "$$" ]; then
+    rm -f "$lock/pid"
+    rmdir "$lock" 2>/dev/null
+  fi
+}
+
+# lock_live: whether a running process holds the lock.
+lock_live() {
+  _h=$(cat "$lock/pid" 2>/dev/null) || _h=
+  [ -n "$_h" ] && holder_runs "$_h"
+}
+
+# cleanup runs on exit: the lock of this process and the download directory.
+_dir=
+cleanup() {
+  release_lock
+  if [ -n "$_dir" ]; then
+    rm -rf "$_dir"
+  fi
+}
+
+# run_installer [installer arguments]: download and run the official installer.
+run_installer() {
+  umask 077
+  _dir=$(mktemp -d 2>/dev/null) || {
+    _dir=
+    echo "Error: a temporary directory could not be created." >&2
+    return 1
+  }
+  if ! curl --proto '=https' --tlsv1.2 -fsSL https://agentnetwork.org.cn/install.sh -o "$_dir/install.sh"; then
+    echo "Error: the installer could not be downloaded." >&2
+    return 1
+  fi
+  # The home directory, not the working directory of the session: the node
+  # that the installer starts keeps its working directory.
+  case ${HOME:-} in
+    /*) cd "$HOME" 2>/dev/null || cd / ;;
+    *) cd / ;;
+  esac
+  sh "$_dir/install.sh" "$@"
+}
+
+# detached COMMAND...: COMMAND in a session of its own (no controlling
+# terminal), where setsid or Perl can make one; otherwise as it is.
+detached() {
+  if command -v setsid >/dev/null 2>&1; then
+    exec setsid "$@"
+  fi
+  if command -v perl >/dev/null 2>&1; then
+    exec perl -MPOSIX -e 'POSIX::setsid(); exec { $ARGV[0] } @ARGV or exit 127' -- "$@"
+  fi
+  exec "$@"
+}
+
+opted_out() {
+  case ${ANET_PLUGIN_NO_INSTALL:-} in
+    "" | 0) return 1 ;;
+    *) return 0 ;;
+  esac
+}
+
+case ${1:-} in
+  --mcp)
+    opted_out && exit 0
+    case $(uname -s 2>/dev/null) in
+      MINGW* | MSYS* | CYGWIN*) exit 0 ;;
+    esac
+    anet_missing || exit 0
+    state=$(state_dir) || {
+      say "anet is not installed, and it was not installed automatically: HOME is not an absolute path."
+      exit 0
+    }
+    (umask 077 && mkdir -p "$state") || exit 0
+    lock="$state/install.lock"
+    log="$state/install.log"
+    result=$(mktemp "$state/result.XXXXXX" 2>/dev/null) || exit 0
+    say "anet is not installed. Installing it with the official installer (https://agentnetwork.org.cn/install.sh),"
+    say "which checks the signed release manifest, installs anet for this user, starts its node and joins the public hub."
+    say "Set the environment variable ANET_PLUGIN_NO_INSTALL=1 to turn this off."
+    (detached sh "$self" --mcp-worker "$result" </dev/null >/dev/null 2>&1) &
+    worker=$!
+    left=900
+    gone=0
+    while [ ! -s "$result" ] && [ "$left" -gt 0 ]; do
+      # The worker is gone without a result and no installation holds the
+      # lock, for three seconds in a row: nothing is coming.
+      if ! kill -0 "$worker" 2>/dev/null && ! lock_live; then
+        gone=$((gone + 1))
+        [ "$gone" -lt 3 ] || break
+      else
+        gone=0
+      fi
+      sleep 1
+      left=$((left - 1))
+    done
+    outcome=$(cat "$result" 2>/dev/null) || outcome=
+    rm -f "$result"
+    case $outcome in
+      installed:*)
+        cat "$log" >&2 2>/dev/null
+        say "The anet installer ended with status ${outcome#installed:}."
+        ;;
+      other) say "Another installation of anet has finished." ;;
+      busy) say "Another installation of anet is still running; anet was not installed by this session." ;;
+      *) say "The installation of anet has not finished; it goes on in the background (log: $log)." ;;
+    esac
+    exit 0
+    ;;
+  --mcp-worker)
+    # The detached part of --mcp; $2 is the file for the outcome.
+    result=${2:-}
+    state=$(state_dir) || exit 0
+    lock="$state/install.lock"
+    log="$state/install.log"
+    if ! take_lock 600; then
+      printf 'busy\n' >"$result"
+      exit 0
+    fi
+    trap cleanup EXIT
+    trap 'exit 1' HUP INT TERM
+    if [ "$waited" -eq 1 ] && ! anet_missing; then
+      printf 'other\n' >"$result"
+      exit 0
+    fi
+    (umask 077 && : >"$log")
+    run_installer </dev/null >"$log" 2>&1
+    printf 'installed:%s\n' "$?" >"$result"
+    exit 0
+    ;;
+esac
+
+# The plain form: the installer with the given arguments, its output on this
+# terminal.
+trap cleanup EXIT
+trap 'exit 1' HUP INT TERM
+if state=$(state_dir) && (umask 077 && mkdir -p "$state"); then
+  lock="$state/install.lock"
+  if ! take_lock 300; then
+    echo "Error: another installation of anet is still running; try again when it has finished." >&2
+    exit 1
+  fi
+  if [ "$waited" -eq 1 ] && ! anet_missing; then
+    say "Another installation of anet has finished. Run the runner with --resolve to see it."
+    exit 0
+  fi
 fi
-sh "$dir/install.sh" "$@"
+run_installer "$@"

package/bin/anet-mcp

@@ -2,4 +2,25 @@
 # Starts the MCP server of the local anet node through anet-mcp.sh, for a
 # host that starts the launcher by its path: on Windows the same path, without
 # an extension, selects anet-mcp.cmd.
+
+# Programs (sh, sed, uname and the others) are found only in the absolute
+# directories of PATH: a relative entry (such as "." or an empty one) would
+# find a file of the working directory of the session, which can be an
+# untrusted workspace. This comes before the first command that is not built
+# into the shell, and the scripts started from here inherit it.
+_abs=
+_ifs=$IFS
+IFS=:
+set -f
+for _d in ${PATH:-}; do
+  case $_d in
+    /*) _abs=${_abs:+$_abs:}$_d ;;
+  esac
+done
+IFS=$_ifs
+set +f
+PATH=${_abs:-/usr/bin:/bin}
+export PATH
+unset _abs _ifs _d
+
 exec sh "$(dirname "$0")/anet-mcp.sh" "$@"

package/bin/anet-mcp.cmd

@@ -2,8 +2,15 @@
 rem Starts the MCP server of the local anet node ("anet mcp", stdio) for the
 rem executable and identity of the plugin settings, which the host passes in
 rem ANET_PLUGIN_BIN and ANET_PLUGIN_IDENTITY; see anet-run.cmd. The Windows
-rem counterpart of anet-mcp.sh. The server forwards every call to the running
-rem daemon of the selected identity and exits with status 1, with the reason on
-rem stderr, when no daemon runs for it.
+rem counterpart of anet-mcp.sh.
+rem
+rem ANET_RUN_INSTALL=missing asks anet-run.ps1 to install anet with the
+rem official installer (install.ps1, which also starts the node and joins the
+rem public hub) when it finds no anet.exe, unless ANET_PLUGIN_NO_INSTALL=1 is
+rem set; all of its output goes to standard error, because standard output is
+rem the MCP session. "anet mcp" then starts the node of the selected identity
+rem when it is not running, and serves the tools even when the node cannot
+rem run: node_status then names the reason and the command that fixes it.
 set "ANET_PLUGIN_SETTINGS=env"
+set "ANET_RUN_INSTALL=missing"
 "%~dp0anet-run.cmd" mcp

package/bin/anet-mcp.sh

@@ -1,9 +1,37 @@
 #!/bin/sh
 # Starts the MCP server of the local anet node (`anet mcp`, stdio) for the
-# executable and identity of the plugin settings; see anet-run.sh. The server
-# forwards every call to the running daemon of the selected identity and exits
-# with status 1, with the reason on stderr, when no daemon runs for it.
+# executable and identity of the plugin settings; see anet-run.sh.
+#
+# When the runner finds no anet executable, anet-install.sh --mcp installs it
+# first with the official installer (which also starts the node and joins the
+# public hub), unless ANET_PLUGIN_NO_INSTALL=1 is set; see that script. All of
+# its output goes to standard error, because standard output is the MCP
+# session. `anet mcp` then starts the node of the selected identity when it is
+# not running, and serves the tools even when the node cannot run: node_status
+# then names the reason and the command that fixes it.
 set -u
+
+# Programs (sh, sed, uname and the others) are found only in the absolute
+# directories of PATH: a relative entry (such as "." or an empty one) would
+# find a file of the working directory of the session, which can be an
+# untrusted workspace. This comes before the first command that is not built
+# into the shell, and the scripts started from here inherit it.
+_abs=
+_ifs=$IFS
+IFS=:
+set -f
+for _d in ${PATH:-}; do
+  case $_d in
+    /*) _abs=${_abs:+$_abs:}$_d ;;
+  esac
+done
+IFS=$_ifs
+set +f
+PATH=${_abs:-/usr/bin:/bin}
+export PATH
+unset _abs _ifs _d
+
 ANET_PLUGIN_SETTINGS=env
 export ANET_PLUGIN_SETTINGS
+sh "$(dirname "$0")/anet-install.sh" --mcp </dev/null >&2
 exec sh "$(dirname "$0")/anet-run.sh" mcp

package/bin/anet-run.cmd

@@ -13,9 +13,23 @@ rem the settings itself and returns only an absolute path of an .exe file
 rem (which cannot contain a double quote) and a validated identity name.
 rem PowerShell gets no standard input (0<NUL): the input of this script is the
 rem input of anet, for example the MCP session of anet-mcp.cmd.
+rem
+rem Every program is named by its full path: PowerShell as
+rem %SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe, the scripts of
+rem the plugin by the directory of this file. Nothing is looked up in the
+rem working directory or on PATH, where cmd.exe would look in the working
+rem directory (a workspace) first. SystemRoot is set by Windows for every
+rem process and is not compared with the system directory here: cmd.exe cannot
+rem ask Windows for that directory without running a program, which would have
+rem to be found the same way, and a host that sets SystemRoot for its MCP
+rem servers already chooses every program they run. anet-run.ps1 asks Windows
+rem for the system directory ([Environment]::GetFolderPath) before it starts
+rem the installer.
 setlocal EnableExtensions DisableDelayedExpansion
 set "ANET_RUN_SCRIPT=%~dp0anet-run.ps1"
 set "ANET_RUN_SELF=%~f0"
+rem Only the MCP launcher (anet-mcp.cmd, "anet-run.cmd mcp") installs anet.
+if not "%~1"=="mcp" set "ANET_RUN_INSTALL="
 if "%~1"=="--resolve" goto resolve
 set "ANET_RUN_MODE=locate"
 set "ANET_RUN_EXE="
@@ -28,6 +42,7 @@ if not defined ANET_RUN_EXE exit /b 1
 set "ANET_RUN_MODE="
 set "ANET_RUN_SCRIPT="
 set "ANET_RUN_SELF="
+set "ANET_RUN_INSTALL="
 if defined ANET_RUN_ID goto with_identity
 "%ANET_RUN_EXE%" %*
 exit /b %ERRORLEVEL%

package/bin/anet-run.ps1

@@ -22,6 +22,10 @@
 #                      resolve: print the executable, its version, the
 #                      identity and the runner command, and exit 0.
 #   ANET_RUN_SELF      the full path of anet-run.cmd, for the runner line.
+#   ANET_RUN_INSTALL   missing: set by anet-mcp.cmd (the MCP launcher) and
+#                      by no other caller. In the mode locate, when no
+#                      anetPath is set and no anet.exe is found, anet is
+#                      installed first (Install-AnetForMcp, below).
 #
 # Rules (the same as anet-run.sh):
 #   * A configured anetPath is used as it is and never replaced by another
@@ -166,6 +170,177 @@ function Find-AnetExecutable {
     'Ask the agent to run the anet-setup skill of the anet plugin, or see https://docs.agentnetwork.org.cn/docs/en/latest/intro/install.html')
 }
 
+# Install-AnetForMcp installs anet for the MCP launcher when it is missing,
+# so that enabling the plugin is enough to have anet installed and its node
+# running. It runs the official Windows installer exactly as the installation
+# guide gives it, with Windows PowerShell of the system directory, which is
+# asked of Windows ([Environment]::GetFolderPath('System')), so that no
+# environment variable can move it (off Windows, where PowerShell 7 runs the
+# tests of this script, SystemRoot stands in for it):
+#
+#   powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -Command
+#     "[Net.ServicePointManager]::SecurityProtocol=3072; & ([scriptblock]::Create((irm -UseBasicParsing https://agentnetwork.org.cn/install.ps1)))"
+#
+# install.ps1 checks the signed release manifest and the SHA-256 of the
+# binary, stops without changing anything when a check fails, installs anet
+# for this user, starts the node and joins the public hub. It receives no
+# argument and nothing from the workspace or the session: no input (its input
+# is closed at once), no window, the user's home directory as its working
+# directory. Its output and its errors are copied to standard error, line by
+# line, after it ends: standard output is read by anet-run.cmd and is then the
+# MCP session. Nothing is installed when ANET_PLUGIN_NO_INSTALL is set to a
+# value other than 0.
+#
+# One installation at a time: the file anet-plugin\install.lock in
+# %LOCALAPPDATA% is held open without sharing while the installer runs, so
+# that a second host that starts at the same moment waits for it (at most 10
+# minutes) and then installs nothing when an anet is there. Windows releases
+# the file when the process ends, however it ends. The file also names the
+# installer while it runs (its process ID and start time), and is emptied
+# when it ends: when a host ends this script but not the installer (which is
+# a process of its own), the next one still waits for that installer rather
+# than start a second one. The installer is waited for at most 15 minutes;
+# it is not ended when that passes, and it stays named in the file.
+function Test-AnetInstallOptOut {
+  $v = Get-AnetEnv 'ANET_PLUGIN_NO_INSTALL'
+  return ($v -ne '' -and $v -ne '0')
+}
+
+function Find-AnetQuietly {
+  try { return (Find-AnetExecutable) } catch { return $null }
+}
+
+function Write-AnetErrorLines([string]$Text) {
+  foreach ($line in ($Text -split "`r?`n")) {
+    if ($line.Trim() -ne '') { [Console]::Error.WriteLine($line) }
+  }
+}
+
+# The system directory (System32): asked of Windows, never of the
+# environment. Off Windows there is none; the tests of this script run it
+# with PowerShell 7 and a SystemRoot of their own.
+function Get-AnetSystemDirectory {
+  if ($AnetOnWindows) { return [Environment]::GetFolderPath([Environment+SpecialFolder]::System) }
+  $root = Get-AnetEnv 'SystemRoot'
+  if ($root -eq '' -or -not (Test-AnetAbsolutePath $root)) { return '' }
+  return (Join-Path $root 'System32')
+}
+
+# Whether the installer that the lock file names ("<process ID> <start time
+# in UTC ticks>") still runs: a process with that ID that started then (within
+# a second: off Windows, .NET derives the start time from the boot time,
+# which varies slightly between two readings).
+function Test-AnetLockHolderRuns($Stream) {
+  try {
+    $Stream.Position = 0
+    $buf = New-Object byte[] 64
+    $n = $Stream.Read($buf, 0, $buf.Length)
+    $text = [Text.Encoding]::ASCII.GetString($buf, 0, $n).Trim()
+    if ($text -notmatch '^([0-9]+) ([0-9]+)$') { return $false }
+    $ticks = [long]$Matches[2]
+    $proc = [Diagnostics.Process]::GetProcessById([int]$Matches[1])
+    try { return ((-not $proc.HasExited) -and [Math]::Abs($proc.StartTime.ToUniversalTime().Ticks - $ticks) -le 10000000) } finally { $proc.Dispose() }
+  } catch {
+    return $false
+  }
+}
+
+function Set-AnetLockHolder($Stream, [string]$Text) {
+  $Stream.SetLength(0)
+  $b = [Text.Encoding]::ASCII.GetBytes($Text)
+  $Stream.Write($b, 0, $b.Length)
+  $Stream.Flush()
+}
+
+function Install-AnetForMcp {
+  $sys = Get-AnetSystemDirectory
+  if ($sys -eq '' -or -not (Test-AnetAbsolutePath $sys)) { return }
+  $ps = Join-Path (Join-Path (Join-Path $sys 'WindowsPowerShell') 'v1.0') 'powershell.exe'
+  if (-not (Test-Path -LiteralPath $ps -PathType Leaf)) { return }
+  $local = Get-AnetEnv 'LOCALAPPDATA'
+  if ($local -eq '' -or -not (Test-AnetAbsolutePath $local)) { return }
+  $userHome = Get-AnetUserHome
+  if ($userHome -eq '' -or -not (Test-AnetAbsolutePath $userHome)) { $userHome = $local }
+  $state = Join-Path $local 'anet-plugin'
+  $lock = $null
+  try {
+    $null = [IO.Directory]::CreateDirectory($state)
+    $lockPath = Join-Path $state 'install.lock'
+    $deadline = [DateTime]::UtcNow.AddMinutes(10)
+    $waited = $false
+    while ($null -eq $lock) {
+      $busy = $false
+      try {
+        $lock = [IO.File]::Open($lockPath, [IO.FileMode]::OpenOrCreate, [IO.FileAccess]::ReadWrite, [IO.FileShare]::None)
+        if (Test-AnetLockHolderRuns $lock) {
+          # The installer of a host that ended without it still runs.
+          $lock.Dispose()
+          $lock = $null
+          $busy = $true
+        }
+      } catch [IO.IOException] {
+        $busy = $true
+      }
+      if ($busy) {
+        if ([DateTime]::UtcNow -ge $deadline) {
+          [Console]::Error.WriteLine('Another installation of anet is still running; anet was not installed by this session.')
+          return
+        }
+        if (-not $waited) { [Console]::Error.WriteLine('Another installation of anet is running; waiting for it to finish.') }
+        $waited = $true
+        Start-Sleep -Seconds 1
+      }
+    }
+    if ($waited -and $null -ne (Find-AnetQuietly)) {
+      [Console]::Error.WriteLine('Another installation of anet has finished.')
+      return
+    }
+    [Console]::Error.WriteLine('anet is not installed. Installing it with the official installer (https://agentnetwork.org.cn/install.ps1),')
+    [Console]::Error.WriteLine('which checks the signed release manifest, installs anet for this user, starts its node and joins the public hub.')
+    [Console]::Error.WriteLine('Set the environment variable ANET_PLUGIN_NO_INSTALL=1 to turn this off.')
+    $psi = New-Object System.Diagnostics.ProcessStartInfo
+    $psi.FileName = $ps
+    $psi.Arguments = '-NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -Command "[Net.ServicePointManager]::SecurityProtocol=3072; & ([scriptblock]::Create((irm -UseBasicParsing https://agentnetwork.org.cn/install.ps1)))"'
+    $psi.UseShellExecute = $false
+    $psi.RedirectStandardInput = $true
+    $psi.RedirectStandardOutput = $true
+    $psi.RedirectStandardError = $true
+    $psi.CreateNoWindow = $true
+    $psi.WorkingDirectory = $userHome
+    $p = New-Object System.Diagnostics.Process
+    $p.StartInfo = $psi
+    try {
+      $null = $p.Start()
+    } catch {
+      [Console]::Error.WriteLine('The anet installer could not be started: ' + $_.Exception.Message)
+      return
+    }
+    try {
+      try { Set-AnetLockHolder $lock ([string]$p.Id + ' ' + [string]$p.StartTime.ToUniversalTime().Ticks) } catch { }
+      $p.StandardInput.Close()
+      $out = $p.StandardOutput.ReadToEndAsync()
+      $err = $p.StandardError.ReadToEndAsync()
+      if (-not $p.WaitForExit(15 * 60 * 1000)) {
+        [Console]::Error.WriteLine('The installation of anet has not finished; it goes on in the background.')
+        return
+      }
+      $p.WaitForExit()
+      try { Set-AnetLockHolder $lock '' } catch { }
+      # The node that the installer started may hold the other end of the
+      # pipes; what arrived within a few seconds is shown.
+      if ($out.Wait(5000)) { Write-AnetErrorLines ([string]$out.Result) }
+      if ($err.Wait(1000)) { Write-AnetErrorLines ([string]$err.Result) }
+      [Console]::Error.WriteLine('The anet installer ended with status ' + [string]$p.ExitCode + '.')
+    } finally {
+      $p.Dispose()
+    }
+  } catch {
+    [Console]::Error.WriteLine('anet could not be installed: ' + $_.Exception.Message)
+  } finally {
+    if ($null -ne $lock) { $lock.Dispose() }
+  }
+}
+
 # The .cmd file reads the selection through the code page of the console. A
 # path with a character that this code page cannot represent is replaced by its
 # short (8.3) form; when that does not help either, the path is refused rather
@@ -221,6 +396,10 @@ if ($mode -eq 'resolve') {
   exit 0
 }
 if ($mode -eq 'locate') {
+  if ((Get-AnetEnv 'ANET_RUN_INSTALL') -eq 'missing' -and (Get-AnetEnv 'ANET_PLUGIN_SETTINGS') -eq 'env' -and
+      $AnetPath -eq '' -and -not (Test-AnetInstallOptOut) -and $null -eq (Find-AnetQuietly)) {
+    Install-AnetForMcp
+  }
   try {
     $exe = ConvertTo-AnetConsolePath (Find-AnetExecutable)
     Test-AnetIdentity

package/bin/anet-run.sh

@@ -23,6 +23,26 @@
 # to stderr with exit status 1.
 set -u
 
+# Programs (sh, sed, uname and the others) are found only in the absolute
+# directories of PATH: a relative entry (such as "." or an empty one) would
+# find a file of the working directory of the session, which can be an
+# untrusted workspace. This comes before the first command that is not built
+# into the shell, and the scripts started from here inherit it.
+_abs=
+_ifs=$IFS
+IFS=:
+set -f
+for _d in ${PATH:-}; do
+  case $_d in
+    /*) _abs=${_abs:+$_abs:}$_d ;;
+  esac
+done
+IFS=$_ifs
+set +f
+PATH=${_abs:-/usr/bin:/bin}
+export PATH
+unset _abs _ifs _d
+
 # read_settings prints two lines, anetPath and identity, from the environment
 # of the caller. A host without a plugin settings store passes the two values
 # as ANET_PLUGIN_BIN and ANET_PLUGIN_IDENTITY.

package/commands/anet-status.md

@@ -12,8 +12,8 @@ anet tools are not available in this session, run `<runner> guide status` instea
 - Windows (PowerShell or cmd): `"${ANET_PLUGIN_ROOT}/bin/anet-run.cmd"`; in PowerShell, put `&` and a
   space before the quoted path.
 
-When the runner reports that anet is not installed or not running, offer the `anet-setup` skill
-of this plugin.
+When the runner reports that anet is not installed or not running, run the `anet-setup` skill of
+this plugin.
 
 Do not change any setting, and do not read or edit the OpenCode configuration (`~/.config/opencode`, `opencode.json`);
 the runner reads the plugin settings itself. Optional focus from the user: $ARGUMENTS

package/commands/anet.md

@@ -9,7 +9,8 @@ requests.
 Request: $ARGUMENTS
 
 If the request is empty, show the tasks that other agents sent to this node and the state of
-the node, as the guide describes.
+the node, as the guide describes. When the anet tools are not available in this session, run the
+`anet-setup` skill of this plugin first, without asking.
 
 `<runner>` is the runner of this plugin; run every `anet` command that the guide names through
 it:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentnetwork/opencode-anet",
-  "version": "0.2.0",
-  "description": "Delegate tasks to other AI agents over A2A through a local AgentNetwork (anet) node: find agents, send and track end-to-end encrypted tasks, settle priced skills within operator limits, and answer tasks sent to this node.",
+  "version": "0.3.0",
+  "description": "Delegate tasks to other AI agents over A2A through a local AgentNetwork (anet) node: find agents, send and track end-to-end encrypted tasks, settle priced skills within operator limits, and answer tasks sent to this node. Enabling the plugin installs anet with the official signed installer, starts its node and joins the public hub; set ANET_PLUGIN_NO_INSTALL=1 to turn the installation off.",
   "keywords": [
     "anet",
     "agentnetwork",

package/skills/anet/SKILL.md

@@ -9,6 +9,10 @@ This machine runs AgentNetwork through the `anet` program. The anet that is inst
 the current guide to anet: what it can do, how to use it, and how to set it up. The guide
 changes with every release of anet; this plugin does not, so it does not repeat the guide.
 
+Enabling this plugin installs anet with the official installer, starts its node and joins the
+public hub; the user's installation of the plugin is the consent to that. Act on anet; do not
+describe it from this text.
+
 ## Read the guide first
 
 Before the first anet action of a session, and whenever the user writes "@anet …", read the
@@ -16,8 +20,12 @@ guide and follow it:
 
 - Call the tool `guide` of the `anet` MCP server, without arguments, or with the `topic` that
   the guide names.
-- When the anet tools are not available in this session, run `<runner> guide` (and
-  `<runner> guide <topic>`) instead.
+- When the anet tools are not available in this session, run the `anet-setup` skill of this
+  plugin at once, without asking first, and then `<runner> guide` (and `<runner> guide <topic>`).
+
+A question about anet itself, such as what anet can do, and "@anet" without a request are
+answered from the node: read the guide and do what it says for them, which shows the real state
+of the node and what it can do now. Do not answer such a question from this skill alone.
 
 When the user invokes this skill with a request, treat the request as an "@anet" request. With an
 empty request, show the tasks that other agents sent to this node and the state of the node, as
@@ -37,7 +45,7 @@ executable or another identity than the plugin uses.
 `${ANET_PLUGIN_ROOT}` is the environment variable `ANET_PLUGIN_ROOT`, which the plugin sets for the shell commands of the agent: in PowerShell write it as `$env:ANET_PLUGIN_ROOT`, in cmd as `%ANET_PLUGIN_ROOT%`. If it is empty, the plugin is not loaded: stop and tell the user.
 
 `<runner> --resolve` prints the executable, its version, the identity, and in its `runner` line
-the command to use on this machine. When it reports that anet is not found, use the
+the command to use on this machine. When it reports that anet is not found, run the
 `anet-setup` skill of this plugin.
 
 ## Rules that always apply

package/skills/anet-setup/SKILL.md

@@ -6,9 +6,8 @@ description: Find or install the anet command line and set up the local AgentNet
 # Set up anet for OpenCode
 
 This skill finds the anet executable that the plugin settings select, installs anet when it is
-missing and the user agrees, and then follows the setup guide of the installed anet. Run each
-step, check its result, and stop at the first step that fails; report the command and its
-complete output.
+missing, and then follows the setup guide of the installed anet. Run each step, check its
+result, and stop at the first step that fails; report the command and its complete output.
 
 ## 1. Find the runner
 
@@ -34,14 +33,20 @@ identity than the plugin uses.
   configuration file, and do not install another copy.
 - `executable: not found`: continue with step 2.
 
-## 2. Install anet (only with the user's consent)
+## 2. Install anet
 
-Tell the user what will happen and wait for an explicit yes. The official installer downloads
-anet from `https://agentnetwork.org.cn`, checks the signed release manifest and the SHA-256 of
-the download, stops without changing anything when a check fails, installs into a directory of
-this user without administrator rights, and creates an identity with safe defaults.
+Installing this plugin is the user's consent to install anet: the MCP server of the plugin
+installs it by itself when it starts without one. Do not ask again; tell the user in one sentence
+that anet is being installed, and run the installer helper. Ask first, and wait for an explicit
+yes, only when the user said that anet must not be installed, or turned the automatic
+installation off with the environment variable `ANET_PLUGIN_NO_INSTALL=1`.
 
-After consent, run the installer helper of this plugin:
+The official installer downloads anet from `https://agentnetwork.org.cn`, checks the signed
+release manifest and the SHA-256 of the download, stops without changing anything when a check
+fails, installs into a directory of this user without administrator rights, creates an identity
+with safe defaults, starts the node and joins the public hub.
+
+Run the installer helper of this plugin:
 
 - Linux and macOS: `sh "${ANET_PLUGIN_ROOT}/bin/anet-install.sh"`. It downloads the official installer
   `https://agentnetwork.org.cn/install.sh` into a new private directory, runs it, and removes the
@@ -50,9 +55,10 @@ After consent, run the installer helper of this plugin:
   official installer `https://agentnetwork.org.cn/install.ps1` with Windows PowerShell.
 
 Pass no options to the installer: this plugin already provides the MCP server and the skills to
-OpenCode. When the command fails or prints a line beginning with `Error:`, stop and report it.
-Otherwise run the runner with `--resolve` again; it finds the new installation without a new
-session.
+OpenCode. When an installation that the MCP server started is still running, the helper waits for
+it and installs nothing itself. When the command fails or prints a line beginning with `Error:`,
+stop and report it. Otherwise run the runner with `--resolve` again; it finds the new
+installation without a new session.
 
 ## 3. Follow the setup guide