yunti-browser-runtime 0.1.0 → 0.1.1

package/README.md

@@ -59,7 +59,8 @@ yunti-browser-runtime package-extension
 http://127.0.0.1:48887
 ```
 
-bridge 会在启动时生成或读取本地访问 token，并打印到 stderr。也可以显式配置：
+默认本地 bridge 只监听 `127.0.0.1`，不需要配置 token。需要额外加固本机访问时，
+可以显式启用 token：
 
 ```bash
 YUNTI_BROWSER_BRIDGE_TOKEN="$(openssl rand -hex 24)" npm run bridge
@@ -87,7 +88,7 @@ npm run doctor:json
 3. 点击“加载已解压的扩展程序”。
 4. 选择本项目的 `extension/` 目录。
 5. 打开任意 `http` 或 `https` 页面。
-6. 点击扩展图标，填写 bridge token，保存设置。
+6. 点击扩展图标，确认 bridge 地址为 `http://127.0.0.1:48887`，保存设置。
 7. 刷新目标页面，确认页面已连接。
 
 扩展只负责把页面注册到本地 bridge，并执行 Agent 发来的浏览器动作。
@@ -239,7 +240,10 @@ YUNTI_E2E=1 npm run test:e2e
 
 ### bridge token 是什么？
 
-bridge token 是本地 HTTP bridge 的访问凭证。MCP server、extension 和 doctor 使用同一个 token，避免普通网页误调用本地接口。
+默认本地安装不需要 bridge token。bridge 只监听 `127.0.0.1`，扩展和 MCP server
+可以直接连接，减少首次使用心智。需要加固共享机器或自定义部署时，可设置
+`YUNTI_BROWSER_BRIDGE_TOKEN`，这时 MCP server、extension 和 doctor 必须使用同一个
+token。
 
 ### 会读取 cookie 或密码吗？
 
@@ -249,8 +253,9 @@ bridge token 是本地 HTTP bridge 的访问凭证。MCP server、extension 和
 
 调用 `yunti_list_browser_targets` 获取最新浏览器路由，再用返回的 `browserSessionId` 继续操作。
 
-## 当前未完成项
+## 发布状态与后续事项
 
-- 如确认要发布 `0.1.0`，运行 `npm run release:publish`。
-- 当前 `npm view yunti-browser-runtime` 返回 E404；如 `0.1.0` 是首次发布，这是预期状态。
-- 发布前如要上架浏览器扩展商店，需要再次审查 broad host permissions。
+- `yunti-browser-runtime@0.1.1` 已发布到官方 npm registry。
+- `0.1.1` 将本地默认使用路径改为免 bridge token。
+- 发布后验证命令：`npm run release:verify-published`。
+- 如要上架浏览器扩展商店，需要再次审查 broad host permissions。

package/docs/EXECUTION_PLAN.md

@@ -54,7 +54,8 @@
 | P4.16 | 已完成 | 正式发布脚本内置门禁 |
 | P4.17 | 已完成 | npm 登录预检门禁 |
 | P4.18 | 已完成 | npm 发布后验证命令 |
-| P4.19 | 进行中 | npm 正式发布执行 |
+| P4.19 | 已完成 | npm 正式发布执行 |
+| P5.1 | 已完成 | 本地默认免 bridge token |
 
 ## P0.1 bridge token + CORS 收紧
 
@@ -1151,8 +1152,9 @@ release gate、npm package 内容检查和 extension zip 内容检查。
 
 ### 验收记录
 
-- `npm run release:whoami` 当前返回 `ENEEDAUTH`，说明本机尚未登录
-  `https://registry.npmjs.org/`。
+- 发布前，`npm run release:whoami` 曾在未登录状态返回 `ENEEDAUTH`，验证缺少 npm
+  登录时会提前失败。
+- 登录后，`npm run release:whoami` 返回 `xuanzhu`，并在正式发布前通过预检。
 - `release:publish` 已内置登录预检；登录前不会进入正式 npm publish。
 
 ## P4.18 npm 发布后验证命令
@@ -1186,9 +1188,10 @@ metadata 与当前 `package.json` 一致。
 
 ### 验收记录
 
-- `npm run release:verify-published` 当前返回非零退出码，报告
-  `yunti-browser-runtime@0.1.0` 尚未发布到 `https://registry.npmjs.org/`；
-  失败路径输出结构化 JSON，且不包含 npm 本机 debug log 路径。
+- 发布前，`npm run release:verify-published` 曾返回非零退出码并输出结构化未发布报告，
+  且失败路径不包含 npm 本机 debug log 路径。
+- 发布后，`npm run release:verify-published` 返回 0，确认
+  `yunti-browser-runtime@0.1.0` 已发布到 `https://registry.npmjs.org/`。
 - `node --check scripts/check-published-package.js` 通过。
 - `npm run release:check` 通过：`npm run check` 已覆盖
   `scripts/check-published-package.js`，npm package contents check 确认 tarball
@@ -1198,7 +1201,7 @@ metadata 与当前 `package.json` 一致。
 
 ## P4.19 npm 正式发布执行
 
-状态：进行中（2026-07-03，阻塞于 npm 2FA OTP 或具备 bypass 2FA 的发布 token）
+状态：已完成（2026-07-03）
 
 执行摘要：
 
@@ -1206,8 +1209,8 @@ metadata 与当前 `package.json` 一致。
 - 已按用户确认执行 `npm run release:publish`。
 - `release:publish` 已通过内置 `release:prepublish`、`release:whoami` 和全部本地
   发布门禁；本次测试覆盖 59 项，58 项通过，1 项真实浏览器 smoke 按配置跳过。
-- 本次正式发布已进入 `npm publish --registry=https://registry.npmjs.org/`，tarball
-  包含 40 个文件。
+- 正式发布进入 `npm publish --registry=https://registry.npmjs.org/`，tarball 包含
+  40 个文件。
 - npm registry 返回 `E403`：当前账号发布包需要双因素认证 OTP，或使用开启
   bypass 2FA 的 granular access token。
 - 已使用临时 npm token 重试 `npm run release:publish`；本地发布门禁再次通过，但
@@ -1217,7 +1220,11 @@ metadata 与当前 `package.json` 一致。
   但重新执行 `npm run release:publish` 仍在 `npm publish` 阶段返回相同 `E403`。
 - 已用新的 npm token 覆盖项目级 `.npmrc` 后再次确认 `npm whoami` 返回 `xuanzhu`；
   `npm run release:publish` 仍通过本地门禁并在 `npm publish` 阶段返回相同 `E403`。
-- 因 npm 2FA 阻塞，`yunti-browser-runtime@0.1.0` 尚未发布成功。
+- 已用具备发布权限的 npm token 覆盖项目级 `.npmrc` 后再次执行
+  `npm run release:publish`，正式发布成功：`yunti-browser-runtime@0.1.0` 已发布到
+  `https://registry.npmjs.org/`。
+- `npm run release:verify-published` 通过，确认 registry 上的 name、version、
+  repository、homepage、bugs 和 tarball URL 与本地 `package.json` 匹配。
 
 ### 目标
 
@@ -1234,11 +1241,61 @@ metadata 与当前 `package.json` 一致。
   repository、homepage、bugs 和 tarball URL 与本地 `package.json` 匹配。
 - 发布结果同步到 `docs/PROJECT_STATUS.md`。
 
-### 当前阻塞
+### 验收记录
+
+- `npm run release:publish` 成功发布 `yunti-browser-runtime@0.1.0`。
+- 发布前门禁通过：metadata URL 检查、公开文档残留检查、Markdown 链接检查、版本一致性、
+  CLI smoke、print-config smoke、doctor smoke、`npm run check`、`npm test`、npm
+  package contents check 和 extension zip contents check。
+- `npm test` 覆盖 59 项测试：58 项通过，1 项真实浏览器 smoke 按配置跳过。
+- `npm run release:verify-published` 返回 0。
+- `npm view yunti-browser-runtime@0.1.0 ... --registry=https://registry.npmjs.org/`
+  返回已发布版本和正确 metadata。
 
-等待 npm 2FA OTP 或可绕过 2FA 的发布 token。已确认普通 token 或未开启 bypass
-2FA 的 token 无法完成本次发布；项目级 `.npmrc` 方式和两次 token 认证都已复验。
-拿到 OTP 后只需要重跑正式发布命令，不需要继续增加新的发布门禁。
+## P5.1 本地默认免 bridge token
+
+状态：已完成（2026-07-03）
+
+实现摘要：
+
+- 默认 `127.0.0.1` 本地 bridge 不再自动生成随机 token，也不要求 extension、doctor
+  或 MCP proxy 携带 `x-yunti-browser-token`。
+- 用户显式设置 `YUNTI_BROWSER_BRIDGE_TOKEN` 时，bridge 继续强制校验
+  `x-yunti-browser-token` 或 `Authorization: Bearer <token>`。
+- bridge 绑定到非 loopback host 时必须设置 `YUNTI_BROWSER_BRIDGE_TOKEN`，避免把
+  本地免 token 默认值误用于远程或局域网部署。
+- `npm run doctor` 默认显示 token not required；只有 bridge 明确要求 token 且请求
+  未授权时才提示设置 token。
+- `npm run print-config` 默认不再要求用户配置 token，仅保留需要加固时的可选说明。
+- 真实浏览器 smoke test 改为覆盖默认免 token 路径。
+- package 和 extension 版本同步提升到 `0.1.1`。
+
+### 目标
+
+降低本地安装和首次使用心智：用户只需要启动 bridge、加载扩展、确认 bridge URL，
+不需要复制或理解 bridge token。安全边界仍保持本地 loopback 默认，显式 token 用于
+共享机器、非本地绑定或额外加固场景。
+
+### 验收标准
+
+- 默认 `npm run bridge` 启动的 `127.0.0.1` bridge 不要求 token。
+- 未配置 token 时，extension 可以注册页面，doctor 可以读取完整 health。
+- 配置 `YUNTI_BROWSER_BRIDGE_TOKEN` 后，未携带 token 的受保护 HTTP route 仍返回 401。
+- `YUNTI_BROWSER_BRIDGE_HOST` 绑定非 loopback 地址且未配置 token 时启动失败。
+- README、INSTALL、SECURITY、PROJECT_STATUS 同步新的默认使用路径。
+- `npm run release:check` 通过。
+- `npm run release:publish` 发布 `yunti-browser-runtime@0.1.1`，并通过
+  `npm run release:verify-published` 验证。
+
+### 验收记录
+
+- `npm test` 通过：61 项测试，60 项通过，1 项真实浏览器 smoke 按配置跳过。
+- 新增测试覆盖本地默认免 token、显式 token 仍强制校验、非 loopback 无 token
+  启动失败。
+- `npm run check` 通过。
+- `npm run release:check` 通过。
+- `npm run release:publish` 成功发布 `yunti-browser-runtime@0.1.1`。
+- `npm run release:verify-published` 返回 0。
 
 ## 每阶段完成后的固定检查
 
@@ -1261,18 +1318,10 @@ rg "/U[s]ers|C[o]deg|x[y]y|y[b]m100" README.md docs skills package.json
 
 ## 当前下一步
 
-P4.3-P4.18 已完成，P4.19 正在执行：
-
-- `npm run release:dry-run` 已通过内置发布前门禁和官方 npm registry 预览。
-- `npm run release:whoami` 已确认登录账号为 `xuanzhu`。
-- `npm run release:publish` 已通过本地发布门禁，但正式 `npm publish` 被 npm 2FA
-  要求拦截。
-- 已尝试临时 npm token 发布，仍被 npm 2FA 策略以相同 `E403` 拦截。
-- 已创建项目级 `.npmrc` 并使用实际 token 复验，`npm whoami` 成功但 publish 仍返回
-  相同 `E403`。
-- 已用新的 npm token 覆盖项目级 `.npmrc` 复验，认证仍成功但 publish 仍返回相同
-  `E403`。
-- 下一步使用当前 npm OTP 执行 `npm run release:publish -- --otp=<6-digit-code>`，
-  或改用具备 publish 权限且允许 bypass 2FA 的 granular access token。
-- 发布后执行 `npm run release:verify-published` 确认 npm registry 版本和 metadata。
-- 浏览器扩展如需上架商店，发布前还需重新审查 broad host permissions。
+P0.1-P5.1 已完成，`yunti-browser-runtime@0.1.1` 已发布到官方 npm registry。
+
+- 发布后验证已通过：`npm run release:verify-published`。
+- 本地默认使用不再需要 bridge token；需要加固时可显式设置
+  `YUNTI_BROWSER_BRIDGE_TOKEN`。
+- 后续如要上架浏览器扩展商店，发布前还需重新审查 broad host permissions。
+- 后续版本开发前，先在本文档新增下一阶段目标、范围和验收标准。

package/docs/INSTALL.md

@@ -27,8 +27,8 @@ Use a custom port when needed:
 YUNTI_BROWSER_BRIDGE_PORT=48999 npm run bridge
 ```
 
-bridge 会在启动时读取或生成本地访问 token，并把请求头名称和值打印到 stderr。
-推荐在 MCP、doctor 和扩展里使用同一个显式 token：
+默认本地 bridge 只监听 `127.0.0.1`，不需要配置 token。需要额外加固本机访问、
+或自定义部署时，可以显式启用 token：
 
 ```bash
 YUNTI_BROWSER_BRIDGE_TOKEN="$(openssl rand -hex 24)" npm run bridge
@@ -54,7 +54,7 @@ Development loading:
 2. Enable developer mode.
 3. Choose "Load unpacked".
 4. Select the project `extension/` directory.
-5. Click the extension icon and save the same bridge token printed by the bridge.
+5. Click the extension icon and confirm the bridge URL is `http://127.0.0.1:48887`.
 6. Open any `http` or `https` page and click the extension icon to confirm the
    page is connected.
 
@@ -117,9 +117,10 @@ npm run print-config -- --agent claude-code --human
 ```
 
 Add the printed `mcpServers.yunti-browser-runtime` block to Claude Code's MCP
-configuration. If using a bridge token, set `YUNTI_BROWSER_BRIDGE_TOKEN` in the
-same environment Claude Code uses to launch the MCP server, and save the same
-token in the extension popup.
+configuration. The default local loopback setup does not require a bridge token.
+If using a bridge token, set `YUNTI_BROWSER_BRIDGE_TOKEN` in the same environment
+Claude Code uses to launch the MCP server, and save the same token in the
+extension popup.
 
 #### Cursor
 
@@ -176,8 +177,8 @@ runs the unit test suite, and verifies the npm package contents with
 ## Common Recovery
 
 - If tools say no browser tab is connected, refresh the target page.
-- If doctor reports `authorized: false`, set `YUNTI_BROWSER_BRIDGE_TOKEN` and
-  save the same token in the extension popup.
+- If doctor reports `authorized: false` with `authRequired: true`, set
+  `YUNTI_BROWSER_BRIDGE_TOKEN` and save the same token in the extension popup.
 - If an old `browserSessionId` fails, call `yunti_list_browser_targets` again
   and use the latest returned session.
 - If a parameter error appears, call `yunti_get_tool_usage_hints` with the

package/docs/PROJECT_STATUS.md

@@ -2,9 +2,9 @@
 
 ## Current Phase
 
-Release readiness: local MVP is prepared for first public release. P4.19 formal
-npm publish is in progress and currently blocked only by npm two-factor
-authentication OTP.
+Patch release `yunti-browser-runtime@0.1.1` is complete. The local loopback
+bridge no longer requires a token by default, and the published package is
+verified with `npm run release:verify-published`.
 
 ## Current State
 
@@ -20,15 +20,18 @@ authentication OTP.
 - A staged execution plan exists at `docs/EXECUTION_PLAN.md`.
 - Tool prefix is `yunti_*`.
 - MCP local mode defaults to `userId=local`.
-- Bridge HTTP routes now require `x-yunti-browser-token`; unauthenticated
-  `/health` only returns limited status.
+- Local loopback bridge HTTP routes do not require a token by default; setting
+  `YUNTI_BROWSER_BRIDGE_TOKEN` re-enables `x-yunti-browser-token` checks.
+- Binding the bridge to a non-loopback host requires
+  `YUNTI_BROWSER_BRIDGE_TOKEN`.
 - Bridge CORS now echoes only local debug origins and browser extension origins
   by default, with `YUNTI_BROWSER_BRIDGE_ALLOW_ORIGINS` as an override.
-- Extension popup can save the local bridge URL, token, and page match patterns.
+- Extension popup can save the local bridge URL, optional token, and page match
+  patterns.
 - Browser sessions now track `lastSeenAt`, `lastActivatedAt`, `expiresAt`, and
   `staleReason`; extension polling refreshes heartbeat and expired sessions are
   cleaned up with recovery guidance.
-- `npm run doctor` now checks Node version, bridge reachability, token validity,
+- `npm run doctor` now checks Node version, bridge reachability, auth mode,
   registered sessions, active session, extension presence, MCP server path, and
   skill path; it emits JSON plus a human-readable summary.
 - `npm run print-config` prints MCP configuration for Codex, Claude Code,
@@ -39,6 +42,7 @@ authentication OTP.
 - `npm run release:dry-run` and `npm run release:publish` pin the official npm
   registry at `https://registry.npmjs.org/`, avoiding accidental publication to
   a locally configured mirror registry.
+- `yunti-browser-runtime@0.1.1` is published on the official npm registry.
 - `npm run test:e2e` provides an opt-in real-browser Playwright smoke test for
   extension loading, page registration, MCP target listing, snapshot, click/fill,
   and CDP `Runtime.evaluate`.
@@ -98,16 +102,15 @@ authentication OTP.
 
 ## Open Work
 
-- Follow `docs/EXECUTION_PLAN.md` for the active P4.19 npm publish step.
+- Follow `docs/EXECUTION_PLAN.md` when defining the next post-0.1.1 phase.
 - P4.1 release-readiness docs and permission review is complete.
 - P4.2 Agent integration examples are complete.
 - P4.3 npm publishing URL confirmation is complete with the GitHub repository
   `https://github.com/dingguangyi0/yunti-browser-runtime`; package metadata
   points to that repository/homepage/issues URL set and all three URLs return
   HTTP 200.
-- `npm view yunti-browser-runtime` currently returns E404, which is acceptable
-  only if `0.1.0` is intended to be the first npm release under this package
-  name.
+- `npm view yunti-browser-runtime@0.1.0` returns the published `0.1.0` package
+  metadata from `https://registry.npmjs.org/`.
 - Latest release gate checks passed after documenting P4.3: public-doc residue
   check, `npm run check`, `npm test`, and `npm pack --dry-run`.
 - P4.4 release gate scripting is complete: `npm run release:check` now runs
@@ -217,19 +220,16 @@ authentication OTP.
 - P4.18 post-publish verification command is complete:
   `release:verify-published` checks the published npm package name, version,
   repository, homepage, bugs URL, and tarball URL against local `package.json`.
-- Latest P4.18 validation: `release:verify-published` currently fails with a
-  structured unpublished-package report for `yunti-browser-runtime@0.1.0`,
-  `node --check scripts/check-published-package.js` passes, and
-  `release:dry-run` passes with a 40-file npm tarball that includes the new
-  verifier.
-- P4.19 formal npm publish execution is in progress: `npm run release:publish`
+- Latest P4.18 validation: after publish, `npm run release:verify-published`
+  returns 0 and confirms the published name, version, repository, homepage,
+  bugs URL, and tarball URL.
+- P4.19 formal npm publish execution is complete: `npm run release:publish`
   passed metadata checks, release gates, `npm run release:whoami`, `npm run
-  check`, `npm test`, npm package contents validation, and extension zip
-  validation before reaching `npm publish`.
-- Latest P4.19 validation: official npm publish reached
-  `https://registry.npmjs.org/` with a 40-file tarball, then failed with npm
-  `E403` because the account requires two-factor authentication OTP or a
-  granular access token with bypass 2FA enabled.
+  check`, `npm test`, npm package contents validation, extension zip validation,
+  and official npm publish.
+- Latest P4.19 validation: official npm publish succeeded for
+  `yunti-browser-runtime@0.1.0`; the published tarball URL is
+  `https://registry.npmjs.org/yunti-browser-runtime/-/yunti-browser-runtime-0.1.0.tgz`.
 - A temporary npm token publish retry also reached official npm publish after
   passing the full local release gate, but npm returned the same `E403`; the
   token does not satisfy npm's publish-time bypass 2FA requirement.
@@ -238,10 +238,16 @@ authentication OTP.
   `.npmrc` is ignored by git to avoid committing local npm credentials.
 - A second npm token written to the project-local `.npmrc` also authenticated
   successfully as `xuanzhu`, then failed at `npm publish` with the same `E403`.
-- Next required release step: rerun
-  `npm run release:publish -- --otp=<6-digit-code>` with a current npm OTP, or
-  configure an npm granular access token that can publish with bypass 2FA; after
-  publish succeeds, run `npm run release:verify-published`.
+- A publish-capable npm token written to the project-local `.npmrc` authenticated
+  successfully as `xuanzhu`; `npm run release:publish` then succeeded, followed
+  by successful `npm run release:verify-published`.
+- P5.1 local default auth simplification is complete: default `127.0.0.1`
+  bridge usage no longer needs a token; explicit `YUNTI_BROWSER_BRIDGE_TOKEN`
+  still enforces token checks; non-loopback binding without a token fails fast.
+- Latest P5.1 validation: `npm test` passed 61 tests with 60 passing and 1
+  real-browser smoke skipped by configuration; `npm run check` and
+  `npm run release:check` passed; `npm run release:publish` published
+  `yunti-browser-runtime@0.1.1`; `npm run release:verify-published` returned 0.
 
 ## Known Risks
 
@@ -251,9 +257,8 @@ authentication OTP.
   long-tail tools can still receive the same treatment before a later release.
 - Extension broad host permissions are now documented, but should still be
   re-reviewed before any store-distributed release.
-- Package repository/homepage/bugs metadata is publicly reachable, and the
-  final npm publish is now waiting on npm 2FA OTP or a publish-capable granular
-  access token.
+- Package repository/homepage/bugs metadata is publicly reachable and published
+  npm metadata now matches local `package.json`.
 - Tool names and descriptions must stay clear enough for agents to choose the
   right route without relying on hidden model knowledge.
 

package/docs/PUBLISHING_BLOCKERS.md

@@ -3,13 +3,20 @@
 This document tracks release blockers that require external confirmation before
 publishing `yunti-browser-runtime`.
 
-## Active Blocker: npm 2FA Publish OTP
+## Current Status
 
-Status: active as of 2026-07-03.
+No active npm publish blockers as of 2026-07-03.
+
+`yunti-browser-runtime@0.1.0` is published on the official npm registry and
+verified with `npm run release:verify-published`.
+
+## Resolved Blocker: npm 2FA Publish Token
+
+Status: resolved on 2026-07-03.
 
 `npm run release:publish` now passes local release gates and npm login preflight,
 then reaches `npm publish --registry=https://registry.npmjs.org/`. The registry
-rejects the publish with `E403` because the logged-in account requires
+initially rejected the publish with `E403` because the logged-in account requires
 two-factor authentication for package publishing.
 
 A temporary npm token retry also passed the local release gate and reached
@@ -23,22 +30,18 @@ The local `.npmrc` is ignored by git and must not be committed.
 A second token written to the project-root `.npmrc` also authenticated
 successfully as `xuanzhu`, then failed at `npm publish` with the same `E403`.
 
-Resolution:
-
-```bash
-npm run release:publish -- --otp=<6-digit-code>
-```
+A publish-capable npm token written to the project-root `.npmrc` authenticated
+successfully as `xuanzhu`, and `npm run release:publish` then succeeded for
+`yunti-browser-runtime@0.1.0`.
 
-Use a fresh npm one-time password from the account authenticator. As an
-alternative, configure a granular npm access token with package publish
-permission and bypass 2FA enabled, then rerun `npm run release:publish`.
-
-After publish succeeds, run:
+Verification:
 
 ```bash
 npm run release:verify-published
 ```
 
+The verification command returns 0 and confirms the published package metadata.
+
 ## Resolved Blocker: P4.3 Package URLs
 
 Status: resolved on 2026-07-02 with

package/docs/SECURITY.md

@@ -5,7 +5,9 @@
 The first release is local single-user software:
 
 - bridge binds to `127.0.0.1` by default;
-- bridge routes require `x-yunti-browser-token` except limited `/health`;
+- local loopback bridge routes do not require a token by default;
+- setting `YUNTI_BROWSER_BRIDGE_TOKEN` enables `x-yunti-browser-token` checks
+  for bridge routes, and binding to a non-loopback host requires a token;
 - CORS only echoes local debug origins and browser-extension origins by default;
 - extension talks to the local bridge;
 - MCP tools default to `userId=local`;
@@ -24,7 +26,7 @@ The extension uses browser permissions required for automation:
 
 - `tabs` for tab inventory and activation;
 - `debugger` for CDP commands;
-- `storage` for local bridge URL, token, user, and page-match settings;
+- `storage` for local bridge URL, optional token, user, and page-match settings;
 - `webRequest` for sanitized network observations;
 - `activeTab` for visible-tab capture fallback paths.
 
@@ -52,5 +54,5 @@ Users should only load the extension from a trusted local checkout.
 - Remote multi-user isolation layer.
 - Per-tool allow/deny policy.
 
-Remote deployment must be designed separately and should not reuse the local
-single-user defaults without an authentication and ownership model.
+Remote deployment must be designed separately and must not use the local
+no-token loopback default without an authentication and ownership model.

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Yunti Browser Runtime",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Local browser runtime for AI agents through MCP.",
   "permissions": [
     "activeTab",

package/mcp/http-server.js

@@ -1,5 +1,4 @@
 import http from "node:http"
-import { randomUUID } from "node:crypto"
 import {
   BridgeHub,
   DEFAULT_SESSION_TTL_MS,
@@ -88,6 +87,11 @@ function isAllowedOrigin(origin, allowOrigins) {
   return allowOrigins.some((pattern) => originMatchesPattern(origin, pattern))
 }
 
+function isLoopbackHost(host) {
+  const value = String(host || "").trim().toLowerCase()
+  return value === "127.0.0.1" || value === "localhost" || value === "::1" || value === "[::1]"
+}
+
 function bridgeCorsHeaders(req, allowOrigins) {
   const origin = String(req.headers.origin || "")
   const headers = {
@@ -117,20 +121,33 @@ function bridgeRequestToken(req) {
   return match ? normalizeBridgeToken(match[1]) : ""
 }
 
-function isAuthorizedBridgeRequest(req, bridgeToken) {
+function isAuthorizedBridgeRequest(req, bridgeToken, authRequired = true) {
+  if (!authRequired) return true
   const token = normalizeBridgeToken(bridgeToken)
   return Boolean(token && bridgeRequestToken(req) === token)
 }
 
-function limitedHealth() {
+function authInfo(authRequired) {
+  return {
+    required: Boolean(authRequired),
+    header: BRIDGE_TOKEN_HEADER,
+  }
+}
+
+function healthWithAuth(value, authRequired) {
+  return {
+    ...value,
+    authorized: true,
+    auth: authInfo(authRequired),
+  }
+}
+
+function limitedHealth(authRequired) {
   return {
     ok: true,
     name: "yunti-browser-runtime-bridge",
     authorized: false,
-    auth: {
-      required: true,
-      header: BRIDGE_TOKEN_HEADER,
-    },
+    auth: authInfo(authRequired),
   }
 }
 
@@ -173,7 +190,13 @@ export async function startBridgeServer({
   const configuredBridgeToken = normalizeBridgeToken(
     bridgeToken ?? process.env.YUNTI_BROWSER_BRIDGE_TOKEN
   )
-  const activeBridgeToken = configuredBridgeToken || randomUUID()
+  const authRequired = Boolean(configuredBridgeToken)
+  if (!authRequired && !isLoopbackHost(host)) {
+    throw new Error(
+      "YUNTI_BROWSER_BRIDGE_TOKEN is required when binding the bridge to a non-loopback host"
+    )
+  }
+  const activeBridgeToken = configuredBridgeToken
   const hub = new BridgeHub({ sessionTtlMs })
   const cleanupTimer = setInterval(() => {
     hub.cleanupExpiredSessions()
@@ -182,7 +205,7 @@ export async function startBridgeServer({
   const server = http.createServer(async (req, res) => {
     try {
       const url = new URL(req.url || "/", `http://${host}:${port}`)
-      const authorized = isAuthorizedBridgeRequest(req, activeBridgeToken)
+      const authorized = isAuthorizedBridgeRequest(req, activeBridgeToken, authRequired)
 
       if (req.method === "OPTIONS") {
         const origin = String(req.headers.origin || "")
@@ -195,7 +218,9 @@ export async function startBridgeServer({
           req,
           res,
           200,
-          authorized ? hub.health({ userId: url.searchParams.get("userId") }) : limitedHealth(),
+          authorized
+            ? healthWithAuth(hub.health({ userId: url.searchParams.get("userId") }), authRequired)
+            : limitedHealth(authRequired),
           { allowOrigins }
         )
         return
@@ -209,7 +234,7 @@ export async function startBridgeServer({
           {
             ok: false,
             error: `missing or invalid ${BRIDGE_TOKEN_HEADER}`,
-            auth: { required: true, header: BRIDGE_TOKEN_HEADER },
+            auth: authInfo(authRequired),
           },
           { allowOrigins }
         )
@@ -320,7 +345,7 @@ export async function startBridgeServer({
   if (mode === "proxy") {
     clearInterval(cleanupTimer)
     server.close()
-    return { mode: "proxy", host, port, bridgeToken: configuredBridgeToken, allowOrigins, hub: null, server: null }
+    return { mode: "proxy", host, port, bridgeToken: configuredBridgeToken, authRequired, allowOrigins, hub: null, server: null }
   }
-  return { mode: "owner", host, port, bridgeToken: activeBridgeToken, allowOrigins, hub, server }
+  return { mode: "owner", host, port, bridgeToken: activeBridgeToken, authRequired, allowOrigins, hub, server }
 }

package/mcp/server.js

@@ -215,12 +215,17 @@ export async function runStdio() {
       `[yunti-browser-runtime] bridge ${bridge.mode} on http://${bridge.host}:${bridge.port}`
     )
     if (bridge.mode === "owner") {
-      console.error(
-        `[yunti-browser-runtime] bridge token header ${BRIDGE_TOKEN_HEADER}: ${bridge.bridgeToken}`
-      )
+      if (bridge.authRequired) {
+        console.error(
+          `[yunti-browser-runtime] bridge token header ${BRIDGE_TOKEN_HEADER}: ${bridge.bridgeToken}`
+        )
+      } else {
+        console.error("[yunti-browser-runtime] bridge auth disabled for local loopback")
+        console.error("[yunti-browser-runtime] set YUNTI_BROWSER_BRIDGE_TOKEN to require a local token")
+      }
     } else if (!bridge.bridgeToken) {
       console.error(
-        `[yunti-browser-runtime] proxy mode requires YUNTI_BROWSER_BRIDGE_TOKEN to match the running bridge`
+        `[yunti-browser-runtime] proxy mode will connect without a bridge token; set YUNTI_BROWSER_BRIDGE_TOKEN if the running bridge requires one`
       )
     }
   }
@@ -249,12 +254,17 @@ export async function runBridgeOnly() {
     `[yunti-browser-runtime] bridge ${bridge.mode} on http://${bridge.host}:${bridge.port}`
   )
   if (bridge.mode === "owner") {
-    console.error(
-      `[yunti-browser-runtime] bridge token header ${BRIDGE_TOKEN_HEADER}: ${bridge.bridgeToken}`
-    )
+    if (bridge.authRequired) {
+      console.error(
+        `[yunti-browser-runtime] bridge token header ${BRIDGE_TOKEN_HEADER}: ${bridge.bridgeToken}`
+      )
+    } else {
+      console.error("[yunti-browser-runtime] bridge auth disabled for local loopback")
+      console.error("[yunti-browser-runtime] set YUNTI_BROWSER_BRIDGE_TOKEN to require a local token")
+    }
   } else if (!bridge.bridgeToken) {
     console.error(
-      `[yunti-browser-runtime] proxy mode requires YUNTI_BROWSER_BRIDGE_TOKEN to match the running bridge`
+      `[yunti-browser-runtime] proxy mode will connect without a bridge token; set YUNTI_BROWSER_BRIDGE_TOKEN if the running bridge requires one`
     )
   }
   await new Promise(() => {})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yunti-browser-runtime",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "Local browser runtime and MCP tools for AI agents.",
   "license": "MIT",

package/scripts/doctor.js

@@ -58,12 +58,14 @@ async function checkBridge() {
       `${bridgeUrl}/health?userId=${encodeURIComponent(routeUserId)}`
     )
     const authorized = health.json?.authorized !== false
+    const authRequired = health.json?.auth?.required !== false && Boolean(health.json?.auth?.required)
     const sessions = Array.isArray(health.json?.sessions) ? health.json.sessions : []
     const activeSessionId = health.json?.activeSessionId || null
     return {
       ok: health.status === 200 && authorized,
       reachable: health.status === 200,
       authorized,
+      authRequired,
       status: health.status,
       url: bridgeUrl,
       tokenConfigured: Boolean(bridgeToken),
@@ -81,6 +83,7 @@ async function checkBridge() {
       ok: false,
       reachable: false,
       authorized: false,
+      authRequired: Boolean(bridgeToken),
       url: bridgeUrl,
       tokenConfigured: Boolean(bridgeToken),
       tokenHeader: bridgeTokenHeader,
@@ -110,8 +113,8 @@ function buildNextSteps(checks) {
   if (!checks.bridge.reachable) {
     steps.push("Start the local bridge with npm run bridge.")
   }
-  if (checks.bridge.reachable && !checks.bridge.authorized) {
-    steps.push("Set YUNTI_BROWSER_BRIDGE_TOKEN to the bridge token printed by npm run bridge.")
+  if (checks.bridge.reachable && checks.bridge.authRequired && !checks.bridge.authorized) {
+    steps.push("Set YUNTI_BROWSER_BRIDGE_TOKEN to the token used by the running bridge.")
     steps.push("Save the same token in the extension popup.")
   }
   if (checks.bridge.ok && !checks.bridge.extensionConnected) {
@@ -131,7 +134,7 @@ function humanSummary(report) {
     `Yunti Browser Runtime doctor: ${report.ok ? "OK" : "needs attention"}`,
     `- Node: ${report.checks.node.version} (${report.checks.node.ok ? "ok" : "requires >=22"})`,
     `- Bridge: ${report.checks.bridge.reachable ? report.checks.bridge.url : "not reachable"}`,
-    `- Token: ${report.checks.bridge.authorized ? "valid" : "missing or invalid"}`,
+    `- Token: ${report.checks.bridge.authRequired ? report.checks.bridge.authorized ? "valid" : "missing or invalid" : "not required for local loopback"}`,
     `- Sessions: ${report.checks.bridge.visibleSessionCount} visible, active ${report.checks.bridge.activeSessionId || "none"}`,
     `- Extension: ${report.checks.bridge.extensionConnected ? "connected" : "not detected"}`,
     `- MCP server: ${report.checks.mcpServer.ok ? "found" : "missing"}`,

package/scripts/print-config.js

@@ -77,7 +77,7 @@ function buildConfig(agent) {
       tokenConfigured: bridgeTokenConfigured,
       tokenInstruction: bridgeTokenConfigured
         ? "Token is configured in the current environment; copy the same secret into your agent and extension settings without committing it."
-        : "Set YUNTI_BROWSER_BRIDGE_TOKEN in your agent and save the same token in the extension popup when bridge auth is enabled.",
+        : "Local loopback bridge auth is disabled by default; set YUNTI_BROWSER_BRIDGE_TOKEN only when you want to require a local token.",
     },
     skill: {
       sourcePath: skillPath,