@songtonyli/dsh-cli 0.1.8 → 0.1.10

package/README.md

@@ -26,7 +26,7 @@ workspace and no build step. Native packages that ship one build per platform
 ripgrep, the PTY backend's addons, sharp, koffi, and the Landlock launcher — are
 ordinary optional dependencies, so npm resolves the right one for your machine.
 
-Requires Node `^22.19.0 || >=24.0.0`. Version 0.1.8; `dsh --version`
+Requires Node `^22.19.0 || >=24.0.0`. Version 0.1.10; `dsh --version`
 also reports the harness build the package was assembled from.
 
 ## License

package/bin/dsh.mjs

@@ -18,7 +18,7 @@ const argv = process.argv.slice(2)
 // version this package publishes. Reporting only one of the two would make an
 // ordinary `npm install @songtonyli/dsh-cli@x` look like it installed something else.
 if (argv.length === 1 && (argv[0] === '--version' || argv[0] === '-V')) {
-  console.log('@songtonyli/dsh-cli 0.1.8 (deepseek-harness 0.1.6-alpha.1)')
+  console.log('@songtonyli/dsh-cli 0.1.10 (deepseek-harness 0.1.6-alpha.1)')
   process.exit(0)
 }
 

package/node_modules/@deepseek-ai/dsh-api-authorization-controller/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/api/authorization-controller/README.md
-README.md: bdf227b45a0f31adc8ceb7c0d2cf8e5002c487a6
-README.zh.md: b65b8ce1840395b89b5feb36083b96650cb122da
+README.md: 6020b15cee27504168035a1c35876fe41be09771
+README.zh.md: 54ef3a48613ca189e6809f83303fdc946dfd7fd1

package/node_modules/@deepseek-ai/dsh-api-authorization-controller/README.md

@@ -50,7 +50,7 @@ This package takes no configuration.
 
 ### Running one attempt
 
-`begin(request, signal)` is a stream. Each item is one frame: a `notice` carrying what the human must do and any page or code it refers to, a `prompt` carrying a question and the id an answer names, a `prompt-withdrawn` for a question the flow retired, and a final `settled` frame carrying `authorized` or `cancelled`. The attempt starts when the carrier pulls the first frame and ends when the stream does; closing the stream withdraws it. `cancel(key)` withdraws it from a call that no longer holds the stream, which is what a Cancel button on a re-rendered page uses.
+`begin(request, signal)` is a stream. Each item is one frame: a `notice` carrying what the human must do, any page or code it refers to, and whether a desktop surface should hand that page to the default browser, a `prompt` carrying a question and the id an answer names, a `prompt-withdrawn` for a question the flow retired, and a final `settled` frame carrying `authorized` or `cancelled`. The attempt starts when the carrier pulls the first frame and ends when the stream does; closing the stream withdraws it. `cancel(key)` withdraws it from a call that no longer holds the stream, which is what a Cancel button on a re-rendered page uses.
 
 A question is answered by a second call naming the frame's `promptId`: `answer(key, promptId, value)` with the typed text or the chosen option's id, or `decline(key, promptId)` when the human says no, which settles the attempt as `cancelled`. Only the attempt's own prompts can be answered, so a stale id is refused rather than silently applied to a newer attempt.
 

package/node_modules/@deepseek-ai/dsh-api-authorization-controller/README.zh.md

@@ -50,7 +50,7 @@ kind: "package-reference"
 
 ### 运行一次尝试
 
-`begin(request, signal)` 是一条流。每一项都是一个帧：`notice` 携带人需要做的事以及它涉及的页面或验证码，`prompt` 携带一个提问以及回答时要指明的 id，`prompt-withdrawn` 对应 flow 撤回的提问，最后的 `settled` 帧携带 `authorized` 或 `cancelled`。尝试在载体拉取第一帧时开始，随流结束而结束；关闭该流即撤回它。`cancel(key)` 用于已不再持有该流的调用撤回它，这正是重新渲染后的页面上「取消」按钮所用的方式。
+`begin(request, signal)` 是一条流。每一项都是一个帧：`notice` 携带人需要做的事、它涉及的页面或验证码，以及桌面界面是否应把该页面交给默认浏览器，`prompt` 携带一个提问以及回答时要指明的 id，`prompt-withdrawn` 对应 flow 撤回的提问，最后的 `settled` 帧携带 `authorized` 或 `cancelled`。尝试在载体拉取第一帧时开始，随流结束而结束；关闭该流即撤回它。`cancel(key)` 用于已不再持有该流的调用撤回它，这正是重新渲染后的页面上「取消」按钮所用的方式。
 
 回答提问要用第二次调用并指明该帧的 `promptId`：`answer(key, promptId, value)` 传入输入的文本或所选项的 id，或在人拒绝时用 `decline(key, promptId)`，后者会让尝试以 `cancelled` 结算。只有该尝试自己的提问可以被回答，因此过期的 id 会被拒绝，而不会被悄悄用在更新的尝试上。
 

package/node_modules/@deepseek-ai/dsh-api-authorization-controller/lib/index.js

@@ -398,6 +398,7 @@ let AuthorizationController = (() => {
 							type: "notice",
 							message: notice.message,
 							...notice.url === void 0 ? {} : { url: notice.url },
+							...notice.openInBrowser === void 0 ? {} : { openInBrowser: notice.openInBrowser },
 							...notice.code === void 0 ? {} : { code: notice.code }
 						});
 					},

package/node_modules/@deepseek-ai/dsh-api-authorization-controller/lib/typert.host.js

@@ -19,6 +19,7 @@ const _deepseek_ai_dsh_api_authorization_controller_authorization_begin_result$s
   'type': z.literal("notice").readonly(),
   'message': z.string().readonly(),
   'url': z.string().readonly().optional(),
+  'openInBrowser': z.literal(true).readonly().optional(),
   'code': z.string().readonly().optional(),
 }), z.object({
   'type': z.literal("prompt").readonly(),
@@ -318,7 +319,7 @@ export const TYPERT = {
           },
           {
             "name": "AuthorizationNoticeFrame",
-            "declaration": "export interface AuthorizationNoticeFrame {\n    readonly type: 'notice';\n    readonly message: string;\n    readonly url?: string;\n    readonly code?: string;\n}"
+            "declaration": "export interface AuthorizationNoticeFrame {\n    readonly type: 'notice';\n    readonly message: string;\n    readonly url?: string;\n    readonly openInBrowser?: true;\n    readonly code?: string;\n}"
           },
           {
             "name": "AuthorizationPromptFrame",

package/node_modules/@deepseek-ai/dsh-api-authorization-controller/lib/typert.remote-client.js

@@ -19,6 +19,7 @@ const _deepseek_ai_dsh_api_authorization_controller_authorization_begin_result$s
   'type': z.literal("notice").readonly(),
   'message': z.string().readonly(),
   'url': z.string().readonly().optional(),
+  'openInBrowser': z.literal(true).readonly().optional(),
   'code': z.string().readonly().optional(),
 }), z.object({
   'type': z.literal("prompt").readonly(),

package/node_modules/@deepseek-ai/dsh-api-authorization-controller/lib/types/index.js

@@ -315,6 +315,7 @@ let AuthorizationController = (() => {
                             type: 'notice',
                             message: notice.message,
                             ...notice.url === undefined ? {} : { url: notice.url },
+                            ...notice.openInBrowser === undefined ? {} : { openInBrowser: notice.openInBrowser },
                             ...notice.code === undefined ? {} : { code: notice.code },
                         });
                     },

package/node_modules/@deepseek-ai/dsh-api-remotes/lib/client.js

@@ -4540,6 +4540,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				"type": literal("notice").readonly(),
 				"message": string().readonly(),
 				"url": string().readonly().optional(),
+				"openInBrowser": literal(true).readonly().optional(),
 				"code": string().readonly().optional()
 			}),
 			object({

package/node_modules/@deepseek-ai/dsh-authorization/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/credentials/authorization/README.md
-README.md: 9b4f4e895bc94c0a34a1cee2d6bf28d7663decea
-README.zh.md: 44c354fef1cb2bd9261483cb4048858a7f70bd31
+README.md: 6368d6c0e8abe14b4166250bef82a06ce2ddf425
+README.zh.md: f1b4d92c9eb6519323d95778bd2e4e53249c1e9c

package/node_modules/@deepseek-ai/dsh-authorization/README.md

@@ -107,7 +107,7 @@ One attempt per key at a time. `begin()` validates the key and method, refuses a
 
 ### The interaction vocabulary
 
-A notice is one-way and never carries a secret: a message, optionally the page the human must open and the code they must enter there. A prompt is a question the flow cannot answer for itself — `text`, `secret`, or `select` — where `secret` differs from `text` only in presentation. A prompt carries its own signal so a flow that races a typed code against a browser callback can withdraw the losing question while the attempt continues; the request's signal withdraws the whole attempt instead. The vocabulary is deliberately smaller than any one provider's: it describes what a surface must render, so a surface that renders one flow renders all of them.
+A notice is one-way and never carries a secret: a message, optionally the page the human must open and the code they must enter there, and whether a desktop surface should hand that page to the default browser (`openInBrowser`, set for an authorization destination rather than an informational link; the printed URL always remains the fallback). A prompt is a question the flow cannot answer for itself — `text`, `secret`, or `select` — where `secret` differs from `text` only in presentation. A prompt carries its own signal so a flow that races a typed code against a browser callback can withdraw the losing question while the attempt continues; the request's signal withdraws the whole attempt instead. The vocabulary is deliberately smaller than any one provider's: it describes what a surface must render, so a surface that renders one flow renders all of them.
 
 ### Commit confirmation
 

package/node_modules/@deepseek-ai/dsh-authorization/README.zh.md

@@ -107,7 +107,7 @@ flow 声明它写入的凭据记录、面向用户的标签以及它提供的登
 
 ### 交互词汇
 
-notice 是单向的，且从不携带机密：一条消息，以及可选的「人需要打开的页面」与「需要在该页面输入的码」。prompt 是 flow 无法自行回答的问题——`text`、`secret` 或 `select`——其中 `secret` 与 `text` 的差别仅在呈现方式。prompt 自带 signal，使得让手输码与浏览器回调赛跑的 flow 可以在尝试继续的同时撤下落败的那个问题；撤销整次尝试则用请求的 signal。这套词汇刻意小于任何单个提供方的词汇：它描述的是界面必须渲染什么，因此能渲染一个 flow 的界面就能渲染全部 flow。
+notice 是单向的，且从不携带机密：一条消息，可选的「人需要打开的页面」与「需要在该页面输入的码」，以及桌面界面是否应把该页面交给默认浏览器（`openInBrowser`，仅为授权目标页设置而非信息链接；打印出的 URL 始终保留为后备）。prompt 是 flow 无法自行回答的问题——`text`、`secret` 或 `select`——其中 `secret` 与 `text` 的差别仅在呈现方式。prompt 自带 signal，使得让手输码与浏览器回调赛跑的 flow 可以在尝试继续的同时撤下落败的那个问题；撤销整次尝试则用请求的 signal。这套词汇刻意小于任何单个提供方的词汇：它描述的是界面必须渲染什么，因此能渲染一个 flow 的界面就能渲染全部 flow。
 
 ### 提交确认
 

package/node_modules/@deepseek-ai/dsh-client-ui-settings-signin/lib/client.js

@@ -228,6 +228,7 @@ window.__ModuleLoader__.load({
 								directions: [...attempt.directions, {
 									message: frame.message,
 									...frame.url === void 0 ? {} : { url: frame.url },
+									...frame.openInBrowser === void 0 ? {} : { openInBrowser: frame.openInBrowser },
 									...frame.code === void 0 ? {} : { code: frame.code }
 								}]
 							};

package/node_modules/@deepseek-ai/dsh-client-ui-sidebar/lib/client.js

@@ -100,7 +100,7 @@ window.__ModuleLoader__.load({
 		const SCROLLBAR_LINGER_MS = 2e3;
 		/** Format complete-build metadata for the local brand badge. */
 		function localBuildVersion() {
-			return `0.1.6-alpha.1-0fd6c65-dirty`;
+			return `0.1.6-alpha.1-057f07b-dirty`;
 		}
 		/** Each panel row subscribes only to its own selection state. */
 		function PanelRow({ id, label, wide, usePanelInfo, selectPanel, renderSlot }) {

package/node_modules/@deepseek-ai/dsh-llm-pi-ai/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/llm/llm-pi-ai/README.md
-README.md: a49281b5ddc63c1fe4ce628857ff6f267dc498cd
-README.zh.md: 78aed7db98e217691351f49f3f8ee41e74177e17
+README.md: e8b9b1e7aea345a70aaeb7667572ead879d7fcb6
+README.zh.md: 3ad4572a7a0ea57f9bffbb4fce3a5136ab7eecc8

package/node_modules/@deepseek-ai/dsh-llm-pi-ai/README.md

@@ -90,7 +90,7 @@ The generated [configuration catalog](../../../docs/config-catalog.md#deepseek-a
 
 ### Sign in to a provider
 
-A provider pi-ai ships a login for can be signed into through the harness authorization seam: the flow offers OAuth or an interactive key prompt (a key is typed into pi-ai's own login prompt, not into the settings form), and the resulting credential is stored in the harness credential store at `llm-pi-ai/<provider id>`. The stored sign-in authenticates its route beneath any `apiKeyEnv` override and refreshes itself under the store's cross-process lock; signing out deletes the stored record. A hand-declared route key outside the record grammar — a lowercase hyphenated identifier — cannot be signed into, because a record write for it refuses with `LlmError('UNSTORABLE_PROVIDER_ID')`; such a route authenticates through `apiKeyEnv` or ambient provider settings instead.
+A provider pi-ai ships a login for can be signed into through the harness authorization seam: the flow offers OAuth or an interactive key prompt (a key is typed into pi-ai's own login prompt, not into the settings form), and the resulting credential is stored in the harness credential store at `llm-pi-ai/<provider id>`. Signing in never activates a route: a dormant catalog provider still needs its profile under `providers.<id>` (an empty `{}` takes the installed defaults), and each surface owns how an authorization page reaches the browser — the Web Models page renders the link, while the terminal hands marked pages to the default browser. The stored sign-in authenticates its route beneath any `apiKeyEnv` override and refreshes itself under the store's cross-process lock; signing out deletes the stored record. A hand-declared route key outside the record grammar — a lowercase hyphenated identifier — cannot be signed into, because a record write for it refuses with `LlmError('UNSTORABLE_PROVIDER_ID')`; such a route authenticates through `apiKeyEnv` or ambient provider settings instead.
 
 ### Resolve the model catalog
 

package/node_modules/@deepseek-ai/dsh-llm-pi-ai/README.zh.md

@@ -90,7 +90,7 @@ kind: "package-reference"
 
 ### 登录提供方
 
-pi-ai 提供登录的提供方可以通过 harness 授权 seam 登录：流程提供 OAuth 或交互式密钥提示（密钥键入 pi-ai 自己的登录提示，而非设置表单），得到的凭据存储在 harness 凭据存储的 `llm-pi-ai/<provider id>` 记录中。存储的登录在其路由的 `apiKeyEnv` 覆盖之下完成认证，并在存储的跨进程锁下自行刷新；退出登录即删除存储记录。落在记录文法之外——小写连字符标识符——的手工声明路由键无法登录，因为对它的记录写入会以 `LlmError('UNSTORABLE_PROVIDER_ID')` 拒绝；这类路由改用 `apiKeyEnv` 或提供方 ambient 设置认证。
+pi-ai 提供登录的提供方可以通过 harness 授权 seam 登录：流程提供 OAuth 或交互式密钥提示（密钥键入 pi-ai 自己的登录提示，而非设置表单），得到的凭据存储在 harness 凭据存储的 `llm-pi-ai/<provider id>` 记录中。登录不会激活路由：休眠的 catalog 提供方仍需要 `providers.<id>` 下的 profile（空的 `{}` 取已安装默认值），且各界面自行决定授权页面如何到达浏览器——Web 的 Models 页面渲染链接，终端则把被标记的页面交给默认浏览器。存储的登录在其路由的 `apiKeyEnv` 覆盖之下完成认证，并在存储的跨进程锁下自行刷新；退出登录即删除存储记录。落在记录文法之外——小写连字符标识符——的手工声明路由键无法登录，因为对它的记录写入会以 `LlmError('UNSTORABLE_PROVIDER_ID')` 拒绝；这类路由改用 `apiKeyEnv` 或提供方 ambient 设置认证。
 
 ### 解析模型目录
 

package/node_modules/@deepseek-ai/dsh-llm-pi-ai/lib/index.js

@@ -2379,13 +2379,15 @@ function relay(event, session) {
 		case "auth_url":
 			session.notify({
 				message: event.instructions ?? "Open this page to continue signing in.",
-				url: event.url
+				url: event.url,
+				openInBrowser: true
 			});
 			return;
 		case "device_code":
 			session.notify({
 				message: "Enter this code on the verification page to finish signing in.",
 				url: event.verificationUri,
+				openInBrowser: true,
 				code: event.userCode
 			});
 			return;

package/node_modules/@deepseek-ai/dsh-native-command/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/util/native-command/README.md
-README.md: 10b60266403f6a479a286cccd369ee2e52dd3aa6
-README.zh.md: e8f2adda57ee257983a06bb2798c852cab20bf6a
+README.md: 9dae51fc0c605e9c0ac6d04a0c768897ce04fc9f
+README.zh.md: 92a1885e51dc12c51ef3a6d127bf0e7d3dc3391c

package/node_modules/@deepseek-ai/dsh-native-command/README.md

@@ -1,5 +1,5 @@
 ---
-description: "Host-native command and path-opening utilities with shell-free execution, cancellation, desktop detection, and WSL path handoff."
+description: "Host-native command, path-opening, and default-browser URL handoff utilities with shell-free execution, cancellation, desktop detection, and credential scrubbing."
 kind: "package-library"
 ---
 
@@ -9,7 +9,7 @@ English | [中文](README.zh.md)
 
 ## Summary
 
-`dsh-native-command` runs host executables without a shell and opens Host filesystem paths through the desktop. The command runner captures utf8 output, propagates cancellation, and hides transient Windows consoles. The path opener supports default-application and text-editor intents, browser-renderable documents, WSL translation, and desktop availability checks. It is a library, not a plugin: no `ctx`, no state, no events.
+`dsh-native-command` runs host executables without a shell, opens Host filesystem paths through the desktop, and hands HTTP(S) URLs to the default browser. The command runner captures utf8 output, propagates cancellation, and hides transient Windows consoles. The path opener supports default-application and text-editor intents, browser-renderable documents, WSL translation, and desktop availability checks. The URL opener keeps Harness credentials out of the browser's environment. It is a library, not a plugin: no `ctx`, no state, no events.
 
 ## Table of Contents
 
@@ -49,6 +49,10 @@ The `NativeCommandRunner` type is the injectable command boundary for host integ
 
 `revealNativePath(path, signal)` selects the file in Finder or Explorer, including WSL path translation, and opens its parent directory through `xdg-open` on desktop Linux. `nativeFileManager()` identifies that action for Host-derived UI labels; desktop availability remains a separate `canOpenNativePath()` check. Callers must authorize the absolute file path before invoking either operation. Platform dispatch is covered by injected-runner tests; native desktop verification belongs to the corresponding platform. Explorer receives an encoded file URI as a separate argument. Its exit code 1 is accepted as a delegated handoff; cancellation, missing executables, and other exit codes still reject. This acknowledgement does not prove that a desktop window selected the file.
 
+### Opening a URL in the default browser
+
+`openNativeUrl(url)` hands one HTTP(S) URL to the operating system's default browser and rejects every other protocol before spawning. The URL travels through a short-lived Node helper running the maintained `open` package with a scrubbed environment, so Harness credentials such as API keys and the Harness home never reach a newly launched browser process; on Windows the helper stays alive until PowerShell has accepted the handoff. The returned promise settles when the operating-system launcher exits, not when the browser window closes; a launch failure rejects with the helper's first stderr line, so the caller can fall back to showing the URL. This is the URL counterpart of the filesystem path opener — do not pass a URL to `openNativePath`, which treats its argument as a filesystem path.
+
 -----
 
 <a id="understand-the-implementation"></a>
@@ -66,6 +70,7 @@ The command runner is a thin wrapper over Node's `execFile`. The path opener sel
 | [`src/index.ts`](src/index.ts) | Public command-runner and path-opener exports |
 | [`src/runner.ts`](src/runner.ts) | Shell-free `execFile` adapter |
 | [`src/path-opener.ts`](src/path-opener.ts) | Desktop detection, open intents, browser preference, and WSL translation |
+| [`src/url-opener.ts`](src/url-opener.ts) | Credential-scrubbed default-browser handoff for HTTP(S) URLs |
 | — | No runtime invariant companion is published; each run is one stateless child-process round trip with no owned event stream or mutable runtime data; behavior is enforced by unit tests. |
 
 ### What execFile gives the runner

package/node_modules/@deepseek-ai/dsh-native-command/README.zh.md

@@ -1,5 +1,5 @@
 ---
-description: "宿主原生命令与路径打开工具，提供无 shell 执行、取消、桌面探测与 WSL 路径交接。"
+description: "宿主原生命令、路径打开与默认浏览器 URL 交接工具，提供无 shell 执行、取消、桌面探测与凭据擦除。"
 kind: "package-library"
 ---
 
@@ -9,7 +9,7 @@ kind: "package-library"
 
 ## 概述
 
-`dsh-native-command` 无需 shell 即可运行 Host 可执行文件，并通过桌面打开 Host 文件系统路径。命令运行器捕获 utf8 输出、传播取消，并隐藏 Windows 瞬时控制台。路径打开器支持默认应用与文本编辑器意图、浏览器可渲染文档、WSL 转换与桌面可用性检查。它是库而非插件：没有 `ctx`、无状态、不发事件。
+`dsh-native-command` 无需 shell 即可运行 Host 可执行文件、通过桌面打开 Host 文件系统路径，并把 HTTP(S) URL 交给默认浏览器。命令运行器捕获 utf8 输出、传播取消，并隐藏 Windows 瞬时控制台。路径打开器支持默认应用与文本编辑器意图、浏览器可渲染文档、WSL 转换与桌面可用性检查。URL 打开器让 Harness 凭据不进入浏览器的环境。它是库而非插件：没有 `ctx`、无状态、不发事件。
 
 ## 目录
 
@@ -49,6 +49,10 @@ const { stdout, stderr } = await runNativeCommand('osascript', ['-e', script], s
 
 `revealNativePath(path, signal)` 在 Finder 或文件资源管理器中选中文件，包含 WSL 路径转换；在桌面 Linux 上通过 `xdg-open` 打开上层目录。`nativeFileManager()` 标识该操作，供 UI 根据 Host 选择文案；桌面是否可用仍由独立的 `canOpenNativePath()` 检查决定。调用方必须先授权绝对文件路径，再执行操作。平台分派由注入运行器的测试覆盖；原生桌面验证由对应平台负责。 Explorer 接收独立参数中的编码文件 URI。退出码 1 按已转交请求处理；取消、找不到可执行文件和其他退出码仍然报错。该确认不能证明桌面窗口已选中文件。
 
+### 在默认浏览器中打开 URL
+
+`openNativeUrl(url)` 把一个 HTTP(S) URL 交给操作系统的默认浏览器，并在启动任何进程前拒绝其他协议。URL 经由一个短生命周期的 Node 辅助进程传递，该进程运行受维护的 `open` 包且使用擦除后的环境，因此 API 密钥与 Harness 主目录等 Harness 凭据不会进入新启动的浏览器进程；在 Windows 上辅助进程会存活到 PowerShell 接受交接为止。返回的 promise 在操作系统启动器退出时结算，而不是在浏览器窗口关闭时；启动失败会以辅助进程 stderr 的首行拒绝，调用方因此可以回退到展示 URL。这是与文件系统路径打开器对应的 URL 能力——不要把 URL 传给 `openNativePath`，后者把参数当作文件系统路径处理。
+
 -----
 
 <a id="understand-the-implementation"></a>
@@ -66,6 +70,7 @@ const { stdout, stderr } = await runNativeCommand('osascript', ['-e', script], s
 | [`src/index.ts`](src/index.ts) | 命令运行器与路径打开器的公共导出 |
 | [`src/runner.ts`](src/runner.ts) | 无 shell 的 `execFile` 适配器 |
 | [`src/path-opener.ts`](src/path-opener.ts) | 桌面探测、打开意图、浏览器偏好与 WSL 转换 |
+| [`src/url-opener.ts`](src/url-opener.ts) | 面向 HTTP(S) URL 的凭据擦除默认浏览器交接 |
 | — | 不发布运行时不变式伴生入口；每次运行都是一次无状态的子进程往返，不拥有事件流或可变运行时数据；相关行为由单元测试保障。 |
 
 ### execFile 给了运行器什么

package/node_modules/@deepseek-ai/dsh-native-command/lib/index.js

@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
+import { scrubbedParentEnv } from "@deepseek-ai/dsh-subprocess";
 import { release } from "node:os";
 import { dirname, extname } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -35,6 +36,96 @@ const runNativeCommand = (command, args, signal) => new Promise((resolve, reject
 	});
 });
 //#endregion
+//#region lib/types/url-opener.js
+/**
+* Default-browser handoff for HTTP(S) URLs through a credential-scrubbed helper.
+* @module @deepseek-ai/dsh-native-command/url-opener
+*/
+const BROWSER_OPENER_MODULE = import.meta.resolve("open");
+const BROWSER_OPENER_PROGRAM = `
+try {
+  const { default: open } = await import(${JSON.stringify(BROWSER_OPENER_MODULE)})
+  const launcher = await open(process.argv[1])
+  if (process.platform === 'win32') {
+    // open resolves at PowerShell spawn; keep it referenced until that launcher hands the URL to Windows.
+    const code = launcher.exitCode ?? await new Promise((resolve, reject) => {
+      function onError(error) {
+        launcher.off('close', onClose)
+        reject(error)
+      }
+      function onClose(code) {
+        launcher.off('error', onError)
+        resolve(code)
+      }
+      launcher.ref()
+      launcher.once('error', onError)
+      launcher.once('close', onClose)
+    })
+    if (code !== 0) throw new Error('browser operating-system launcher exited with code ' + String(code))
+  }
+  process.exitCode = 0
+} catch (error) {
+  console.error(error)
+  process.exitCode = 1
+}
+`;
+/** Start the maintained platform opener without forwarding Harness credentials. */
+function spawnBrowserLauncher(url) {
+	return spawn(process.execPath, [
+		"--input-type=module",
+		"--eval",
+		BROWSER_OPENER_PROGRAM,
+		"--",
+		url
+	], {
+		env: scrubbedParentEnv(),
+		stdio: [
+			"ignore",
+			"inherit",
+			"pipe"
+		]
+	});
+}
+/**
+* Hand an HTTP(S) URL to the operating system's default browser.
+*
+* The promise settles after the short-lived operating-system launcher exits,
+* not after the browser window closes. Browser-launch failures reject with the
+* helper's first stderr line when available. The helper receives a scrubbed
+* environment so Harness credentials do not reach the browser process.
+* @param url - absolute HTTP(S) URL to open.
+* @returns once the operating-system launcher has accepted the URL.
+*/
+async function openNativeUrl(url) {
+	const protocol = new URL(url).protocol;
+	if (protocol !== "http:" && protocol !== "https:") throw new Error(`native URL opener supports only HTTP(S), not ${protocol}`);
+	const launcher = spawnBrowserLauncher(url);
+	let launcherStderr = "";
+	launcher.stderr?.setEncoding("utf8");
+	launcher.stderr?.on("data", (chunk) => {
+		launcherStderr += chunk;
+	});
+	await new Promise((resolve, reject) => {
+		function onError(error) {
+			launcher.off("close", onClose);
+			reject(error);
+		}
+		function onClose(code) {
+			launcher.off("error", onError);
+			if (code !== 0) {
+				const firstLine = launcherStderr.trim().split(/\r?\n/u)[0];
+				const reason = firstLine === void 0 || firstLine === "" ? `browser launcher exited with code ${String(code)}` : firstLine.replace(/^(?:[A-Za-z]*Error):\s*/u, "");
+				reject(new Error(reason));
+				return;
+			}
+			if (launcherStderr !== "") process.stderr.write(launcherStderr);
+			resolve();
+		}
+		launcher.once("error", onError);
+		launcher.once("close", onClose);
+	});
+}
+//#endregion
 //#region lib/types/path-opener.js
 /**
 * Cross-platform native path and text-document openers for Host UI
@@ -241,4 +332,4 @@ async function revealNativePath(path, signal, internals = {}) {
 	throw new Error(`native file manager is unsupported on ${platform}`);
 }
 //#endregion
-export { canOpenNativePath, nativeFileManager, openNativePath, openNativeTextFile, revealNativePath, runNativeCommand };
+export { canOpenNativePath, nativeFileManager, openNativePath, openNativeTextFile, openNativeUrl, revealNativePath, runNativeCommand };

package/node_modules/@deepseek-ai/dsh-native-command/package.json

@@ -26,6 +26,10 @@
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",
+  "dependencies": {
+    "@deepseek-ai/dsh-subprocess": "0.1.6-alpha.1",
+    "open": "^11.0.0"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "4.0.2"
   },

package/node_modules/@deepseek-ai/dsh-tool-cordis/lib/index.js

@@ -6320,11 +6320,11 @@ const TYPE_API = [
 	},
 	{
 		name: "AuthorizationNotice",
-		declaration: "export interface AuthorizationNotice {\n    message: string;\n    url?: string;\n    code?: string;\n}"
+		declaration: "export interface AuthorizationNotice {\n    message: string;\n    url?: string;\n    openInBrowser?: true;\n    code?: string;\n}"
 	},
 	{
 		name: "AuthorizationNoticeFrame",
-		declaration: "export interface AuthorizationNoticeFrame {\n    readonly type: 'notice';\n    readonly message: string;\n    readonly url?: string;\n    readonly code?: string;\n}"
+		declaration: "export interface AuthorizationNoticeFrame {\n    readonly type: 'notice';\n    readonly message: string;\n    readonly url?: string;\n    readonly openInBrowser?: true;\n    readonly code?: string;\n}"
 	},
 	{
 		name: "AuthorizationOutcome",

package/node_modules/@deepseek-ai/dsh-tui-app/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/bundle/tui-app/README.md
-README.md: a74c0b8642192cd2b44abd939c3d8082e935991a
-README.zh.md: 3b9ba69a63d5461e85fab40b80f21502aaf8558a
+README.md: 1176042ca87a4a439e65818c9333b9004ea3519e
+README.zh.md: a2d0e296e2e1e5aaf7e3568727fd57e30c2e538b

package/node_modules/@deepseek-ai/dsh-tui-app/README.md

@@ -9,7 +9,7 @@ English | [中文](README.zh.md)
 
 ## Summary
 
-`dsh-tui-app` is the terminal surface of dsh: `dsh tui` starts a multi-turn session in the terminal you are already in, with no browser and no server. Replies stream as you watch, tool calls become foldable cards, approvals and `ask_user_question` questions appear above the input, `@` completes paths and sessions, `/attach` adds images and files, and `/`-commands share the Web registry. Sessions persist: `/sessions`, `/new`, and `/fork` switch between them, `/export` writes the browser's ZIP, and `--resume` continues one later. It runs the same model, tools, and safety defaults as `dsh web`, one session at a time.
+`dsh-tui-app` is the terminal surface of dsh: `dsh tui` starts a multi-turn session in the terminal you are already in, with no browser-hosted application and no server. Replies stream as you watch, tool calls become foldable cards, approvals and `ask_user_question` questions appear above the input, `@` completes paths and sessions, `/attach` adds images and files, and `/`-commands share the Web registry. Sessions persist: `/sessions`, `/new`, and `/fork` switch between them, `/export` writes the browser's ZIP, and `--resume` continues one later. It runs the same model, tools, and safety defaults as `dsh web`, one session at a time.
 
 ## Table of Contents
 
@@ -33,6 +33,7 @@ Start a session, type, and read the answer in place. `dsh tui` is an alias of `d
 dsh tui                                   # new session, wait for input
 dsh tui "explain this repository"         # new session with a first prompt
 dsh tui --resume <session-id>             # continue an earlier session
+dsh tui --no-open                         # print sign-in URLs without opening a browser
 ```
 
 On quit the app prints `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>` on stderr for the session bound at that moment. A resumed session redraws its persisted history before accepting input; inside the terminal, `/sessions` opens a picker over every persisted root session, `/new` starts a fresh one, and `/fork` copies the current session up to its last completed turn into a new one, the same cut the browser's fork takes. Switching releases the previous Agent and redraws the transcript of the next.
@@ -82,6 +83,10 @@ Typing `/` at the start of the editor completes the terminal's own commands and
 
 Every other `/name` line goes to the shared command registry, so `/compact`, `/permission`, `/goal`, and plugin commands work as they do in the browser.
 
+### Subscription sign-in
+
+`/login` stores a subscription credential but does not activate a dormant model route. Configure the catalog route first, then use its full credential key; for example, run `/settings llm-pi-ai providers.openai-codex {}` and then `/login llm-pi-ai/openai-codex`. A marked authorization page opens in the local default browser while its URL remains in the transcript as a fallback. SSH launches, hosts without a desktop, `--no-open`, and opener failures leave the manual URL and device-code paths available instead.
+
 ### Prompts from the agent
 
 An approval request draws `Allow <tool>?` with the asker's reason, the logged call the request names (the same rows as its tool card, so a shell command reads before it runs), and two rows, allow once or reject; `Esc` rejects and `Ctrl+C` cancels the request. An `ask_user_question` question renders its `detail` as Markdown above its options plus a free-text row; multi-select toggles rows with `Space` and confirms through `Done`. A plan review (the `plan-review` intent `exit_plan_mode` sets) draws the plan as Markdown with Approve, Decline, and Discuss rows, where Discuss returns the request to the composer as the browser's card does. Prompts queue and show one at a time, and an aborted request withdraws its prompt.
@@ -97,8 +102,9 @@ An approval request draws `Allow <tool>?` with the asker's reason, the logged ca
 | `prompt` | none | A first prompt submitted when the terminal is up |
 | `resume` | none | A persisted session id to continue instead of starting a new one |
 | `toolPreviewLines` | `8` | Collapsed tool-card body rows before `Ctrl+O` expands them |
+| `openBrowser` | `true` | Hand marked authorization pages to the local default browser |
 
-`prompt` and `resume` come from the command line through the startup provider; the generated [configuration catalog](../../../docs/config-catalog.md#deepseek-aidsh-tui-app) is the exhaustive source for every accepted field.
+`prompt`, `resume`, and `openBrowser` come from the command line through the startup provider; the generated [configuration catalog](../../../docs/config-catalog.md#deepseek-aidsh-tui-app) is the exhaustive source for every accepted field.
 
 -----
 
@@ -112,7 +118,7 @@ The runner is a direct driver over the core API carrier, like `dsh-headless`, th
 
 ### Run flow
 
-The runner awaits the complete application (`ctx.get('loader')?.await()`) and builds a session host over the core registry with three operations: `create` makes one fresh persisted Agent with the shared [`agentDefaultModel`](../../core/agent-default-model/README.md) selection, `resume` reads the persisted log in pages through a read handle of `ctx.sessionPersistence` and resumes the Agent through the registry, and `fork` observes the source through `ctx.sessionQuery`, cuts after the chosen (by default the last) `turn/end` up to the next `turn/start`, and creates a seeded Agent with `parentSession` and `isSeeded` metadata. Every operation installs a `ModelSelectionRef` in the Agent's scoped setup so `/model` changes the next request. The terminal application starts on the session `--resume` or a fresh `create` yields, subscribes to `session/event`, `agent/assistant-stream`, and `agent/status`, answers the `approval/request` and `user-questions/request` waterfalls for the bound Agent only, and switches sessions by binding the next one and disposing the previous handle; while the host opens the next session the editor refuses input, and a quit during that wait releases the session that arrives afterwards. Quitting cancels any running turn, waits for quiescence, flushes the bound Session, disposes its handle, and requests exit 0; a driver failure writes `dsh: <message>` to stderr and requests exit 1. Shift+Tab cycles the bound model's adapter-owned reasoning efforts, wrapping through the provider default, and `/login` starts `authorization.begin` with only subscription methods (every method except a key-collecting `api-key` login).
+The runner awaits the complete application (`ctx.get('loader')?.await()`) and builds a session host over the core registry with three operations: `create` makes one fresh persisted Agent with the shared [`agentDefaultModel`](../../core/agent-default-model/README.md) selection, `resume` reads the persisted log in pages through a read handle of `ctx.sessionPersistence` and resumes the Agent through the registry, and `fork` observes the source through `ctx.sessionQuery`, cuts after the chosen (by default the last) `turn/end` up to the next `turn/start`, and creates a seeded Agent with `parentSession` and `isSeeded` metadata. Every operation installs a `ModelSelectionRef` in the Agent's scoped setup so `/model` changes the next request. The terminal application starts on the session `--resume` or a fresh `create` yields, subscribes to `session/event`, `agent/assistant-stream`, and `agent/status`, answers the `approval/request` and `user-questions/request` waterfalls for the bound Agent only, and switches sessions by binding the next one and disposing the previous handle; while the host opens the next session the editor refuses input, and a quit during that wait releases the session that arrives afterwards. Quitting cancels any running turn, waits for quiescence, flushes the bound Session, disposes its handle, and requests exit 0; a driver failure writes `dsh: <message>` to stderr and requests exit 1. Shift+Tab cycles the bound model's adapter-owned reasoning efforts, wrapping through the provider default, and `/login` starts `authorization.begin` with only subscription methods (every method except a key-collecting `api-key` login). A notice the flow marks with `openInBrowser` is handed to the default browser through `dsh-native-command`'s credential-scrubbed helper while the URL stays printed; the handoff is suppressed when `openBrowser` is false, the launch came through SSH, or the host has no desktop, and an opener failure becomes a notice beside the URL rather than a sign-in failure.
 
 ### Rendering model
 
@@ -127,7 +133,7 @@ The patch rides over `dsh-base`: it sets the coding persona prefix and cwd suffi
 | File | Role |
 |---|---|
 | [`src/index.ts`](src/index.ts) | The `tui-app` plugin: the session host (create, resume, fork), history read, quit flow, exit mapping |
-| [`src/startup.ts`](src/startup.ts) | The `tui-app-startup` provider: prompt positional, `--resume`, and `--help` |
+| [`src/startup.ts`](src/startup.ts) | The `tui-app-startup` provider: prompt positional, `--resume`, `--no-open`, and `--help` |
 | [`src/app.ts`](src/app.ts) | The terminal application: layout, keys, commands, session binding, seams, log and stream folding |
 | [`src/sessions.ts`](src/sessions.ts) | The `/sessions` list over the query engine and its picker rows |
 | [`src/attach.ts`](src/attach.ts) | `/attach`: local files into image or file blocks through the attachment store |

package/node_modules/@deepseek-ai/dsh-tui-app/README.zh.md

@@ -9,7 +9,7 @@ kind: "package-bundle"
 
 ## 概述
 
-`dsh-tui-app` 是 dsh 的终端表层：`dsh tui` 在你当前所在的终端里启动一个多轮会话，没有浏览器、没有服务器。回复实时流式显示，工具调用变成可折叠的卡片，审批与 `ask_user_question` 的问题出现在输入框上方，`@` 补全路径与会话，`/attach` 加入图片与文件，`/` 命令与 Web 共用注册表。会话持久化：`/sessions`、`/new` 与 `/fork` 在会话间切换，`/export` 写出浏览器的 ZIP，`--resume` 稍后继续。它运行与 `dsh web` 相同的模型、工具与安全默认值，同一时间一个会话。
+`dsh-tui-app` 是 dsh 的终端表层：`dsh tui` 在你当前所在的终端里启动一个多轮会话，没有浏览器托管的应用、也没有服务器。回复实时流式显示，工具调用变成可折叠的卡片，审批与 `ask_user_question` 的问题出现在输入框上方，`@` 补全路径与会话，`/attach` 加入图片与文件，`/` 命令与 Web 共用注册表。会话持久化：`/sessions`、`/new` 与 `/fork` 在会话间切换，`/export` 写出浏览器的 ZIP，`--resume` 稍后继续。它运行与 `dsh web` 相同的模型、工具与安全默认值，同一时间一个会话。
 
 ## 目录
 
@@ -33,6 +33,7 @@ kind: "package-bundle"
 dsh tui                                   # new session, wait for input
 dsh tui "explain this repository"         # new session with a first prompt
 dsh tui --resume <session-id>             # continue an earlier session
+dsh tui --no-open                         # print sign-in URLs without opening a browser
 ```
 
 退出时应用在 stderr 为当时绑定的会话打印 `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>`。恢复的会话会在接受输入前先重绘其持久化历史；在终端内，`/sessions` 打开覆盖所有持久化根会话的选择器，`/new` 开始一个新会话，`/fork` 把当前会话复制到其最后一个完成轮次并作为新会话，切割点与浏览器的 fork 相同。切换会释放先前的 Agent 并重绘下一个会话的对话记录。
@@ -82,6 +83,10 @@ dsh tui --resume <session-id>             # continue an earlier session
 
 其他每条 `/name` 行都交给共享命令注册表，因此 `/compact`、`/permission`、`/goal` 与插件命令的行为和浏览器中一致。
 
+### 订阅登录
+
+`/login` 只存储订阅凭据，不会激活休眠的模型路由。先配置 catalog 路由，再使用完整的凭据键；例如先运行 `/settings llm-pi-ai providers.openai-codex {}`，再运行 `/login llm-pi-ai/openai-codex`。被标记的授权页面会在本地默认浏览器中打开，其 URL 同时保留在对话记录中作为后备。SSH 启动、无桌面的宿主、`--no-open` 以及打开器失败时，手动 URL 与设备码路径仍然可用。
+
 ### 来自 agent 的提示
 
 审批请求绘制 `Allow <tool>?`、请求方的理由、请求所指的已记录调用（与其工具卡片相同的行，因此 shell 命令在运行前可读）以及两行选项：允许一次或拒绝；`Esc` 拒绝，`Ctrl+C` 取消该请求。`ask_user_question` 的问题把其 `detail` 渲染为 Markdown，置于选项与一行自由文本之上；多选用 `Space` 切换各行并通过 `Done` 确认。计划评审（`exit_plan_mode` 设置的 `plan-review` 意图）把计划绘制为 Markdown，并提供 Approve、Decline 与 Discuss 行，其中 Discuss 像浏览器卡片一样把请求交回编辑器。提示排队、一次只显示一个，被中止的请求会撤回其提示。
@@ -97,8 +102,9 @@ dsh tui --resume <session-id>             # continue an earlier session
 | `prompt` | 无 | 终端就绪后提交的首个提示 |
 | `resume` | 无 | 要继续的持久化会话 id，而不是新建会话 |
 | `toolPreviewLines` | `8` | `Ctrl+O` 展开前折叠的工具卡片正文行数 |
+| `openBrowser` | `true` | 把被标记的授权页面交给本地默认浏览器 |
 
-`prompt` 与 `resume` 经启动提供方来自命令行；生成的[配置目录](../../../docs/config-catalog.zh.md#deepseek-aidsh-tui-app)是所有可接受字段的完整来源。
+`prompt`、`resume` 与 `openBrowser` 经启动提供方来自命令行；生成的[配置目录](../../../docs/config-catalog.zh.md#deepseek-aidsh-tui-app)是所有可接受字段的完整来源。
 
 -----
 
@@ -112,7 +118,7 @@ runner 与 `dsh-headless` 一样是核心 API 载体之上的直接驱动器，
 
 ### 运行流程
 
-runner 等待完整应用就绪（`ctx.get('loader')?.await()`），并在核心注册表之上构建含三个操作的会话宿主：`create` 用共享的 [`agentDefaultModel`](../../core/agent-default-model/README.zh.md) 选择创建一个全新的持久化 Agent，`resume` 通过 `ctx.sessionPersistence` 的只读句柄分页读取持久化日志并经注册表恢复 Agent，`fork` 通过 `ctx.sessionQuery` 观察源会话、在所选（默认最后一个）`turn/end` 之后直到下一个 `turn/start` 处切割，并创建带 `parentSession` 与 `isSeeded` 元数据的种子 Agent。每个操作都在 Agent 的作用域 setup 中安装 `ModelSelectionRef`，因此 `/model` 会改变下一次请求。终端应用从 `--resume` 或一次新的 `create` 产生的会话开始，订阅 `session/event`、`agent/assistant-stream` 与 `agent/status`，只为绑定的 Agent 应答 `approval/request` 与 `user-questions/request` waterfall，并通过绑定下一个会话、dispose 先前句柄来切换会话；宿主打开下一个会话期间编辑器拒绝输入，等待期间退出会释放随后到达的会话。退出时取消任何进行中的轮次、等待完全停稳、flush 绑定的会话、dispose 其句柄并请求以 0 退出；驱动器失败会向 stderr 写入 `dsh: <message>` 并请求以 1 退出。Shift+Tab 循环切换绑定模型的适配器自有推理强度，并在提供方默认值处回绕；`/login` 只带着订阅方法（除收集密钥的 `api-key` 登录外的每一种方法）启动 `authorization.begin`。
+runner 等待完整应用就绪（`ctx.get('loader')?.await()`），并在核心注册表之上构建含三个操作的会话宿主：`create` 用共享的 [`agentDefaultModel`](../../core/agent-default-model/README.zh.md) 选择创建一个全新的持久化 Agent，`resume` 通过 `ctx.sessionPersistence` 的只读句柄分页读取持久化日志并经注册表恢复 Agent，`fork` 通过 `ctx.sessionQuery` 观察源会话、在所选（默认最后一个）`turn/end` 之后直到下一个 `turn/start` 处切割，并创建带 `parentSession` 与 `isSeeded` 元数据的种子 Agent。每个操作都在 Agent 的作用域 setup 中安装 `ModelSelectionRef`，因此 `/model` 会改变下一次请求。终端应用从 `--resume` 或一次新的 `create` 产生的会话开始，订阅 `session/event`、`agent/assistant-stream` 与 `agent/status`，只为绑定的 Agent 应答 `approval/request` 与 `user-questions/request` waterfall，并通过绑定下一个会话、dispose 先前句柄来切换会话；宿主打开下一个会话期间编辑器拒绝输入，等待期间退出会释放随后到达的会话。退出时取消任何进行中的轮次、等待完全停稳、flush 绑定的会话、dispose 其句柄并请求以 0 退出；驱动器失败会向 stderr 写入 `dsh: <message>` 并请求以 1 退出。Shift+Tab 循环切换绑定模型的适配器自有推理强度，并在提供方默认值处回绕；`/login` 只带着订阅方法（除收集密钥的 `api-key` 登录外的每一种方法）启动 `authorization.begin`。flow 用 `openInBrowser` 标记的 notice 会经 `dsh-native-command` 的凭据擦除辅助进程交给默认浏览器，URL 同时保持打印；当 `openBrowser` 为 false、启动经过 SSH 或宿主没有桌面时抑制该交接，打开器失败则成为 URL 旁的一条通知，而非登录失败。
 
 ### 渲染模型
 
@@ -127,7 +133,7 @@ runner 等待完整应用就绪（`ctx.get('loader')?.await()`），并在核心
 | 文件 | 职责 |
 |---|---|
 | [`src/index.ts`](src/index.ts) | `tui-app` 插件：会话宿主（创建、恢复、fork）、历史读取、退出流程、退出码映射 |
-| [`src/startup.ts`](src/startup.ts) | `tui-app-startup` 提供方：提示位置参数、`--resume` 与 `--help` |
+| [`src/startup.ts`](src/startup.ts) | `tui-app-startup` 提供方：提示位置参数、`--resume`、`--no-open` 与 `--help` |
 | [`src/app.ts`](src/app.ts) | 终端应用：布局、按键、命令、会话绑定、接缝、日志与流的折叠 |
 | [`src/sessions.ts`](src/sessions.ts) | 基于查询引擎的 `/sessions` 列表及其选择器行 |
 | [`src/attach.ts`](src/attach.ts) | `/attach`：本地文件经附件存储成为图片或文件块 |

package/node_modules/@deepseek-ai/dsh-tui-app/cordis.patch.yml

@@ -1,8 +1,8 @@
 # The dsh-tui-app bundle patch: the interactive terminal surface directly over
 # dsh-base. It mounts no Host, HTTP server, Web runtime, or browser plugin. An
 # ordinary provider plugin injects `cmdlineArgs`, parses the optional prompt
-# positional and `--resume` (`dsh --profile tui [prompt...]`) plus this app's
-# --help, then the terminal runner creates or resumes one Agent through the
+# positional, `--resume`, and `--no-open` (`dsh --profile tui [prompt...]`)
+# plus this app's --help, then the terminal runner creates or resumes one Agent through the
 # core registry and drives it from the terminal until the user quits.
 
 - id: system-prompt
@@ -56,4 +56,5 @@
       config:
         prompt: !!js ctx.tuiStartup.prompt
         resume: !!js ctx.tuiStartup.resume
+        openBrowser: !!js ctx.tuiStartup.openBrowser
         toolPreviewLines: 8

package/node_modules/@deepseek-ai/dsh-tui-app/lib/index.js

@@ -3,9 +3,12 @@ import { Container, Editor, Input, Loader, Markdown, ProcessTerminal, SelectList
 import z from "@deepseek-ai/schemastery";
 import { brandString } from "@deepseek-ai/dsh-brand";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
+import { launchEnvironmentOf, launchedThroughSsh } from "@deepseek-ai/dsh-launch-environment";
+import { canOpenNativePath, openNativeUrl } from "@deepseek-ai/dsh-native-command";
 import { SessionLogOffset } from "@deepseek-ai/dsh-session";
+import "@deepseek-ai/cordis";
+import { HarnessError, ReasoningEffortId, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { activeAtToken, formatFileMention } from "@deepseek-ai/dsh-file-reference";
-import { ReasoningEffortId, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { formatSessionReferenceMention } from "@deepseek-ai/dsh-session-reference";
 import { assertNever } from "@deepseek-ai/dsh-util-values";
 import { readFile } from "node:fs/promises";
@@ -16,6 +19,31 @@ import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { DEFAULT_SESSION_LOG_COMPRESSION_LEVEL, flushLiveSessionLog, readSessionLogText, sessionLogExportDeps, sessionLogZipFilename, streamSessionLogZip } from "@deepseek-ai/dsh-session-log-export";
 import { planReviewOptions } from "@deepseek-ai/dsh-user-questions";
+//#region ../../credentials/authorization/src/index.ts
+/** Stable error taxonomy for authorization failures. */
+var AuthorizationError = class extends HarnessError {
+	constructor(message, code, options) {
+		super(message, code, options);
+		this.name = "AuthorizationError";
+	}
+};
+/**
+* The rejection an {@link AuthorizationInteraction.prompt} uses to say the
+* human declined — dismissed the question, chose not to answer — rather than
+* that the surface broke. An attempt whose flow fails after a prompt was
+* declined settles as `cancelled`, the same outcome as a withdrawn signal,
+* because the human saying no is a refusal, not a breakage. Only a human's
+* "no" may reject with this class: a prompt withdrawn by its own `signal` (a
+* flow retiring the losing question of a race) must reject with something
+* else, or a later genuine failure would be misread as a decline.
+*/
+var AuthorizationDeclinedError = class extends AuthorizationError {
+	constructor(message = "the authorization prompt was declined") {
+		super(message, "DECLINED");
+		this.name = "AuthorizationDeclinedError";
+	}
+};
+//#endregion
 //#region lib/types/attach.js
 /**
 * `/attach`: read a local file and admit it into the attachment store as the
@@ -927,6 +955,59 @@ function editorCompletion(sources) {
 		}
 	};
 }
+/** What the provider-default row is called. */
+const PROVIDER_DEFAULT_LABEL = "Provider default";
+/** The `/effort` argument that restores the provider default. */
+const DEFAULT_ARGUMENT = "default";
+/**
+* The display name of one effort.
+* @param reasoning - what the model declares.
+* @param effort - the selected effort, or undefined for the provider default.
+* @returns the declared name, the raw id when the model no longer declares it, or the provider-default label.
+*/
+function effortName(reasoning, effort) {
+	if (effort === void 0) return PROVIDER_DEFAULT_LABEL;
+	return reasoning.efforts.find((candidate) => candidate.id === effort)?.name ?? effort;
+}
+/**
+* Picker rows for one model: the provider default above the adapter's own order.
+* @param reasoning - what the model declares.
+* @returns the rows, provider default first.
+*/
+function effortItems(reasoning) {
+	const resolved = reasoning.defaultEffort === void 0 ? void 0 : `resolves to ${effortName(reasoning, reasoning.defaultEffort)}`;
+	return [{
+		value: "",
+		label: PROVIDER_DEFAULT_LABEL,
+		...resolved === void 0 ? {} : { description: resolved }
+	}, ...reasoning.efforts.map((effort) => ({
+		value: effort.id,
+		label: effort.name,
+		...effort.description === void 0 ? {} : { description: effort.description }
+	}))];
+}
+/**
+* The dim row under the picker heading.
+* @param reasoning - what the model declares.
+* @param effort - the effort in force, or undefined for the provider default.
+* @returns one row naming the effort in force and the keys that change it.
+*/
+function effortHint(reasoning, effort) {
+	return `current: ${effortName(reasoning, effort)} · Esc keeps it · Shift+Tab cycles`;
+}
+/**
+* The effort a typed `/effort` argument names. A declared id wins over the
+* `default` keyword, so an adapter may own that id.
+* @param reasoning - what the model declares.
+* @param typed - the argument, matched against declared ids without case.
+* @returns the declared effort, undefined for the provider default, or null when the model declares no such effort.
+*/
+function matchEffort(reasoning, typed) {
+	const wanted = typed.toLowerCase();
+	const declared = reasoning.efforts.find((effort) => effort.id.toLowerCase() === wanted);
+	if (declared !== void 0) return declared.id;
+	return wanted === DEFAULT_ARGUMENT ? void 0 : null;
+}
 //#endregion
 //#region lib/types/export.js
 /**
@@ -1034,6 +1115,13 @@ var ListPrompt = class {
 	settle(value) {
 		this.settlement.settle(value);
 	}
+	/**
+	* Open the list on one row instead of the first.
+	* @param index - the row to highlight.
+	*/
+	highlight(index) {
+		this.list.setSelectedIndex(index);
+	}
 	handleInput(data) {
 		this.list.handleInput(data);
 	}
@@ -1074,10 +1162,17 @@ var ApprovalPrompt = class extends ListPrompt {
 		this.settle("cancelled");
 	}
 };
+/** Marks the row a picker opened on, so it stays visible after the highlight moves. */
+const CURRENT_MARK = " ✓";
 /** A generic list picker (models, sessions); Escape settles undefined. */
 var PickPrompt = class extends ListPrompt {
-	constructor(palette, title, items) {
-		super(palette, `${palette.accent("?")} ${palette.bold(title)}`, [], [...items], (item) => item, () => void 0);
+	constructor(palette, title, items, options = {}) {
+		const inForce = items.findIndex((item) => item.value === options.current);
+		super(palette, `${palette.accent("?")} ${palette.bold(title)}`, options.body ?? [], items.map((item, index) => index === inForce ? {
+			...item,
+			label: `${item.label}${CURRENT_MARK}`
+		} : { ...item }), (row) => items.find((item) => item.value === row.value), () => void 0);
+		if (inForce > 0) this.highlight(inForce);
 	}
 	withdraw() {
 		this.settle(void 0);
@@ -1549,6 +1644,10 @@ const LOCAL_COMMANDS = [
 		name: "model",
 		description: "Pick the model and reasoning effort for the next request (/model provider/model, /model save)"
 	},
+	{
+		name: "effort",
+		description: "Pick the current model's reasoning effort for the next request (/effort <id>, /effort default)"
+	},
 	{
 		name: "sessions",
 		description: "Switch to another session"
@@ -2041,6 +2140,9 @@ var TuiApp = class {
 			case "model":
 				await this.chooseModel(argument);
 				return;
+			case "effort":
+				await this.chooseCurrentEffort(argument);
+				return;
 			case "sessions":
 				await this.chooseSession();
 				return;
@@ -2167,7 +2269,8 @@ var TuiApp = class {
 				this.notice("no models are available from the composed providers", "error");
 				return;
 			}
-			const picked = await this.modals.run(new PickPrompt(this.deps.palette, "Model for the next request", items));
+			const current = this.currentSelection();
+			const picked = await this.modals.run(new PickPrompt(this.deps.palette, "Model for the next request", items, { current: `${current.provider}/${current.model}` }));
 			if (picked === void 0) return;
 			const slash = picked.value.indexOf("/");
 			next = {
@@ -2185,68 +2288,135 @@ var TuiApp = class {
 		this.refreshFooter();
 	}
 	/**
-	* Offer the model's reasoning efforts when it declares more than one.
+	* Offer the model's reasoning efforts when it declares more than one. The
+	* picker opens on the effort already in force for that exact model.
+	* @param model - the model the user picked.
 	* @returns the chosen effort, undefined for the provider default, or null when dismissed or the model is unknown.
 	*/
 	async chooseEffort(model) {
-		const llm = this.deps.ctx.get("llm");
-		if (llm === void 0) return void 0;
-		let efforts;
-		try {
-			efforts = (await llm.resolveModelInfo(model.provider, model.model)).reasoning?.efforts ?? [];
-		} catch (error) {
-			this.notice(`${model.provider}/${model.model}: ${describeFailure(error)}`, "error");
+		const lookup = await this.lookupEfforts(model);
+		if (this.stopped) return null;
+		if (lookup.kind === "failed") {
+			this.notice(lookup.message, "error");
 			return null;
 		}
-		if (efforts.length < 2) return void 0;
-		const items = [{
-			value: "",
-			label: "provider default"
-		}, ...efforts.map((effort) => ({
-			value: effort.id,
-			label: effort.name,
-			...effort.description === void 0 ? {} : { description: effort.description }
-		}))];
-		const picked = await this.modals.run(new PickPrompt(this.deps.palette, `Reasoning effort for ${model.model}`, items));
+		if (lookup.kind !== "ready") return void 0;
+		const current = this.currentSelection();
+		const sameModel = current.provider === model.provider && current.model === model.model;
+		const picked = await this.modals.run(new PickPrompt(this.deps.palette, `Reasoning effort · ${model.provider}/${model.model}`, effortItems(lookup.reasoning), {
+			body: ["Esc cancels the model change"],
+			current: (sameModel ? current.reasoningEffort : void 0) ?? ""
+		}));
 		if (picked === void 0) return null;
 		return picked.value === "" ? void 0 : ReasoningEffortId(picked.value);
 	}
 	/**
+	* Choose the bound model's reasoning effort for the next request: an empty
+	* argument opens the picker on the effort in force, `default` restores the
+	* provider default, and anything else names a declared effort.
+	* @param argument - a declared effort id, `default`, or empty.
+	*/
+	async chooseCurrentEffort(argument) {
+		const current = this.currentSelection();
+		const lookup = await this.lookupEfforts(current);
+		if (this.stopped) return;
+		if (lookup.kind !== "ready") {
+			this.reportEffortLookup(lookup, current);
+			return;
+		}
+		const { reasoning } = lookup;
+		if (argument !== "") {
+			const matched = matchEffort(reasoning, argument);
+			if (matched === null) {
+				const declared = reasoning.efforts.map((effort) => effort.id).join(", ");
+				this.notice(`${current.provider}/${current.model} has no effort "${argument}" (${declared}, default)`, "error");
+				return;
+			}
+			this.applyEffort(current, matched);
+			return;
+		}
+		const picked = await this.modals.run(new PickPrompt(this.deps.palette, `Reasoning effort · ${current.provider}/${current.model}`, effortItems(reasoning), {
+			body: [effortHint(reasoning, current.reasoningEffort)],
+			current: current.reasoningEffort ?? ""
+		}));
+		if (picked === void 0) return;
+		this.applyEffort(current, picked.value === "" ? void 0 : ReasoningEffortId(picked.value));
+	}
+	/**
 	* Advance the bound selection to the next reasoning effort, wrapping through
 	* the provider default. A model with fewer than two efforts has nothing to cycle.
 	*/
 	async cycleEffort() {
 		if (this.stopped || this.modals.isActive()) return;
 		const current = this.currentSelection();
-		const llm = this.deps.ctx.get("llm");
-		if (llm === void 0) {
-			this.notice("no model catalog is composed", "error");
+		const lookup = await this.lookupEfforts(current);
+		if (this.stopped) return;
+		if (lookup.kind !== "ready") {
+			this.reportEffortLookup(lookup, current);
 			return;
 		}
-		let efforts;
+		const steps = [void 0, ...lookup.reasoning.efforts.map((effort) => effort.id)];
+		const index = steps.findIndex((step) => step === current.reasoningEffort);
+		this.applyEffort(current, steps[index === -1 ? 1 : (index + 1) % steps.length]);
+	}
+	/**
+	* Read what one model declares about reasoning effort.
+	* @param model - the model to resolve.
+	* @returns the declared efforts, or why the terminal has none to offer.
+	*/
+	async lookupEfforts(model) {
+		const llm = this.deps.ctx.get("llm");
+		if (llm === void 0) return { kind: "no-catalog" };
+		let reasoning;
 		try {
-			efforts = (await llm.resolveModelInfo(current.provider, current.model)).reasoning?.efforts ?? [];
+			reasoning = (await llm.resolveModelInfo(model.provider, model.model)).reasoning;
 		} catch (error) {
-			this.notice(`${current.provider}/${current.model}: ${describeFailure(error)}`, "error");
-			return;
+			return {
+				kind: "failed",
+				message: `${model.provider}/${model.model}: ${describeFailure(error)}`
+			};
 		}
-		if (this.stopped) return;
-		if (efforts.length < 2) {
-			this.notice(`${current.provider}/${current.model} has no selectable reasoning efforts`);
-			return;
+		if (reasoning === void 0 || reasoning.efforts.length < 2) return { kind: "no-efforts" };
+		return {
+			kind: "ready",
+			reasoning
+		};
+	}
+	/**
+	* Print why a model offers no effort to choose.
+	* @param lookup - a lookup that resolved no efforts.
+	* @param model - the model it was read for.
+	*/
+	reportEffortLookup(lookup, model) {
+		switch (lookup.kind) {
+			case "no-catalog":
+				this.notice("no model catalog is composed", "error");
+				return;
+			case "failed":
+				this.notice(lookup.message, "error");
+				return;
+			case "no-efforts":
+				this.notice(`${model.provider}/${model.model} has no selectable reasoning efforts`);
+				return;
+			/* v8 ignore next -- closed-union exhaustiveness guard */
+			default: assertNever(lookup, "effort lookup");
 		}
-		const steps = [void 0, ...efforts.map((effort) => effort.id)];
-		const index = steps.findIndex((step) => step === current.reasoningEffort);
-		const next = steps[index === -1 ? 1 : (index + 1) % steps.length];
-		this.bound.selection.current = next === void 0 ? {
-			provider: current.provider,
-			model: current.model
+	}
+	/**
+	* Install one reasoning effort on the bound selection for the next request.
+	* @param model - the provider and model the effort belongs to.
+	* @param effort - the chosen effort, or undefined for the provider default.
+	*/
+	applyEffort(model, effort) {
+		this.bound.selection.current = effort === void 0 ? {
+			provider: model.provider,
+			model: model.model
 		} : {
-			provider: current.provider,
-			model: current.model,
-			reasoningEffort: next
+			provider: model.provider,
+			model: model.model,
+			reasoningEffort: effort
 		};
-		this.notice(next === void 0 ? "effort: provider default from the next request" : `effort ${next} from the next request`, "success");
+		this.notice(effort === void 0 ? "effort: provider default from the next request" : `effort ${effort} from the next request`, "success");
 		this.refreshFooter();
 	}
 	async modelItems() {
@@ -2407,6 +2577,9 @@ var TuiApp = class {
 						if (notice.url !== void 0) parts.push(notice.url);
 						if (notice.code !== void 0) parts.push(`code: ${notice.code}`);
 						this.notice(parts.join(" "));
+						if (notice.url !== void 0 && notice.openInBrowser === true && this.deps.openUrl !== void 0) this.deps.openUrl(notice.url).catch((error) => {
+							this.notice(`could not open sign-in page: ${describeFailure(error)}`, "error");
+						});
 					},
 					prompt: (prompt) => this.answerAuthorizationPrompt(prompt)
 				}
@@ -2423,7 +2596,7 @@ var TuiApp = class {
 				label: option.label,
 				...option.description === void 0 ? {} : { description: option.description }
 			}))), prompt.signal);
-			if (picked === void 0) throw new Error("the sign-in prompt was dismissed");
+			if (picked === void 0) throw new AuthorizationDeclinedError("the sign-in prompt was dismissed");
 			return picked.value;
 		}
 		const answer = await this.modals.run(new QuestionPrompt(this.deps.palette, {
@@ -2431,7 +2604,7 @@ var TuiApp = class {
 			question: prompt.message,
 			...prompt.placeholder === void 0 ? {} : { detail: prompt.placeholder }
 		}), prompt.signal);
-		if (answer?.custom === void 0) throw new Error("the sign-in prompt was dismissed");
+		if (answer?.custom === void 0) throw new AuthorizationDeclinedError("the sign-in prompt was dismissed");
 		return answer.custom;
 	}
 	async exportSession(argument) {
@@ -2674,7 +2847,8 @@ const inject = [
 const Config = z.object({
 	prompt: z.string(),
 	resume: z.string(),
-	toolPreviewLines: z.natural().min(1).default(8)
+	toolPreviewLines: z.natural().min(1).default(8),
+	openBrowser: z.boolean().default(true)
 });
 /** The process-bound pieces of the host; tests substitute a fake terminal and captured streams. */
 const internals = {
@@ -2685,7 +2859,9 @@ const internals = {
 		process.stdin.unref();
 	},
 	stderr: process.stderr,
-	color: colorEnabled(process.env, process.stdout.isTTY)
+	color: colorEnabled(process.env, process.stdout.isTTY),
+	canOpenUrl: () => canOpenNativePath(),
+	openUrl: openNativeUrl
 };
 /** Events read per page when a persisted session is resumed, through the storage handle before the Agent takes the log over. */
 const HISTORY_PAGE = 256;
@@ -2834,14 +3010,17 @@ async function run(ctx, config, host) {
 	if (core === void 0) return;
 	const cwd = process.cwd();
 	const sessions = sessionHost(ctx, core, cwd);
+	const initial = config.resume === void 0 ? await sessions.create() : await sessions.resume(brandString(config.resume));
+	const openUrl = config.openBrowser && host.canOpenUrl() && !launchedThroughSsh(launchEnvironmentOf(ctx)) ? (url) => host.openUrl(url) : void 0;
 	new TuiApp({
 		ctx,
 		host: sessions,
-		initial: config.resume === void 0 ? await sessions.create() : await sessions.resume(brandString(config.resume)),
+		initial,
 		terminal: host.createTerminal(),
 		palette: createPalette(host.color),
 		toolPreviewLines: config.toolPreviewLines,
 		cwd,
+		...openUrl === void 0 ? {} : { openUrl },
 		releaseInput: () => {
 			host.releaseInput();
 		},
@@ -2873,6 +3052,8 @@ function apply(ctx, config) {
 		releaseInput: internals.releaseInput,
 		stderr: internals.stderr,
 		color: internals.color,
+		canOpenUrl: internals.canOpenUrl,
+		openUrl: internals.openUrl,
 		exit
 	};
 	run(ctx, config, host).catch((error) => {

package/node_modules/@deepseek-ai/dsh-tui-app/lib/startup.js

@@ -19,7 +19,7 @@ const TUI_STARTUP_SERVICE = "tuiStartup";
 * @returns a fresh program, so one process can parse more than once (tests).
 */
 function tuiCommand() {
-	return new Command().name("dsh --profile tui").description("Talk to the agent in this terminal: streamed replies, tool cards, approvals, and slash commands.").helpOption("-h, --help", "show this help").option("--resume <session-id>", "continue a persisted session instead of starting a new one").argument("[prompt...]", "an optional first prompt; multiple words are joined by spaces").addHelpText("after", `
+	return new Command().name("dsh --profile tui").description("Talk to the agent in this terminal: streamed replies, tool cards, approvals, and slash commands.").helpOption("-h, --help", "show this help").option("--resume <session-id>", "continue a persisted session instead of starting a new one").option("--no-open", "print sign-in URLs instead of opening the default browser").argument("[prompt...]", "an optional first prompt; multiple words are joined by spaces").addHelpText("after", `
 Examples:
   dsh --profile tui                          start a new session and wait for input
   dsh --profile tui "explain this repo"      start with a first prompt
@@ -43,7 +43,8 @@ function apply(ctx) {
 		if (options.resume !== void 0 && options.resume.trim() === "") program.error("error: --resume needs a session id");
 		ctx.provide(TUI_STARTUP_SERVICE, {
 			prompt: prompt === "" ? void 0 : prompt,
-			resume: options.resume
+			resume: options.resume,
+			openBrowser: options.open
 		});
 	});
 	parseCmdline(ctx, program);

package/node_modules/@deepseek-ai/dsh-tui-app/package.json

@@ -44,6 +44,8 @@
     "@deepseek-ai/dsh-file-reference": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-file-reference-local": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-host-plugin-inventory": "0.1.6-alpha.1",
+    "@deepseek-ai/dsh-launch-environment": "0.1.6-alpha.1",
+    "@deepseek-ai/dsh-native-command": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-session-log-export": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-session-reference": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-session-stats": "0.1.6-alpha.1",

package/node_modules/@deepseek-ai/dsh-web-app/lib/index.js

@@ -1,5 +1,4 @@
 import { createRequire } from "node:module";
-import { spawn } from "node:child_process";
 import { dirname, join } from "node:path";
 import { networkInterfaces } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -7,7 +6,7 @@ import z from "@deepseek-ai/schemastery";
 import { addHarnessSourceSection, auditStartupEntries } from "@deepseek-ai/dsh-app-boot";
 import * as FrontendStatic from "@deepseek-ai/dsh-host-frontend-static";
 import { launchEnvironmentOf, launchedThroughSsh } from "@deepseek-ai/dsh-launch-environment";
-import { scrubbedParentEnv } from "@deepseek-ai/dsh-subprocess";
+import { openNativeUrl } from "@deepseek-ai/dsh-native-command";
 //#region lib/types/index.js
 /**
 * @deepseek-ai/dsh-web-app — the browser-surface bundle's runtime glue plugin
@@ -41,35 +40,6 @@ const DSH_WEB_URL = "DSH_WEB_URL";
 const LOOPBACK_HOST = "127.0.0.1";
 /** The webserver schema's all-interfaces bind literal. */
 const ALL_INTERFACES_HOST = "0.0.0.0";
-const BROWSER_OPENER_MODULE = import.meta.resolve("open");
-const BROWSER_OPENER_PROGRAM = `
-try {
-  const { default: open } = await import(${JSON.stringify(BROWSER_OPENER_MODULE)})
-  const launcher = await open(process.argv[1])
-  if (process.platform === 'win32') {
-    // open resolves at PowerShell spawn; keep it referenced until that launcher hands the URL to Windows.
-    const code = launcher.exitCode ?? await new Promise((resolve, reject) => {
-      function onError(error) {
-        launcher.off('close', onClose)
-        reject(error)
-      }
-      function onClose(code) {
-        launcher.off('error', onError)
-        resolve(code)
-      }
-      launcher.ref()
-      launcher.once('error', onError)
-      launcher.once('close', onClose)
-    })
-    if (code !== 0) throw new Error('browser operating-system launcher exited with code ' + String(code))
-  }
-  process.exitCode = 0
-} catch (error) {
-  // The parent turns this exit into the manual-URL warning.
-  console.error(error)
-  process.exitCode = 1
-}
-`;
 /**
 * Resolve one LAN-trust snapshot from the active server bind.
 *
@@ -113,55 +83,10 @@ function resolveDistIndex() {
 		throw new Error("web-app: @deepseek-ai/dsh-web-frontend is not resolvable from this composition");
 	}
 }
-/** Start the maintained platform opener without forwarding Harness credentials. */
-function spawnBrowserLauncher(url) {
-	return spawn(process.execPath, [
-		"--input-type=module",
-		"--eval",
-		BROWSER_OPENER_PROGRAM,
-		"--",
-		url
-	], {
-		env: scrubbedParentEnv(),
-		stdio: [
-			"ignore",
-			"inherit",
-			"pipe"
-		]
-	});
-}
-/** Hand one URL to the operating system's default browser. */
-async function openBrowser(url) {
-	const launcher = spawnBrowserLauncher(url);
-	let launcherStderr = "";
-	launcher.stderr?.setEncoding("utf8");
-	launcher.stderr?.on("data", (chunk) => {
-		launcherStderr += chunk;
-	});
-	await new Promise((resolve, reject) => {
-		function onError(error) {
-			launcher.off("close", onClose);
-			reject(error);
-		}
-		function onClose(code) {
-			launcher.off("error", onError);
-			if (code !== 0) {
-				const firstLine = launcherStderr.trim().split(/\r?\n/u)[0];
-				const reason = firstLine === void 0 || firstLine === "" ? `browser launcher exited with code ${String(code)}` : firstLine.replace(/^(?:[A-Za-z]*Error):\s*/u, "");
-				reject(new Error(reason));
-				return;
-			}
-			if (launcherStderr !== "") process.stderr.write(launcherStderr);
-			resolve();
-		}
-		launcher.once("error", onError);
-		launcher.once("close", onClose);
-	});
-}
 /** Test hooks for the built dist and native browser handoff; production never mutates them. */
 const internals = {
 	resolveDistIndex,
-	openBrowser
+	openBrowser: openNativeUrl
 };
 /**
 * Mount the Web runtime: dist serving, surface prompt, the bash runtime

package/node_modules/@deepseek-ai/dsh-web-app/package.json

@@ -110,17 +110,16 @@
     "@deepseek-ai/dsh-host-webserver": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-launch-environment": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-message-feedback": "0.1.6-alpha.1",
+    "@deepseek-ai/dsh-native-command": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-session-log-export": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-session-reference": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-session-stats": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-session-turn-outline": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-subprocess": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-tool-subagent": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-web-frontend": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-workspace": "0.1.6-alpha.1",
     "@deepseek-ai/schemastery": "3.18.2",
     "commander": "^15.0.0",
-    "open": "^11.0.0",
     "@deepseek-ai/dsh-api-terminal-controller": "0.1.6-alpha.1",
     "@deepseek-ai/dsh-client-ui-sidebar-terminal": "0.1.6-alpha.1"
   },

package/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v22.
 
 ### Additional Details
- * Last updated: Wed, 09 Sep 2026 18:05:03 GMT
+ * Last updated: Tue, 15 Sep 2026 20:33:28 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@types/node",
-  "version": "22.20.2",
+  "version": "22.20.3",
   "description": "TypeScript definitions for node",
   "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
   "license": "MIT",
@@ -139,6 +139,6 @@
     "undici-types": "~6.21.0"
   },
   "peerDependencies": {},
-  "typesPublisherContentHash": "8e6b0ce9d1f2dc282d7964257456bcffbdd45115e795462dde19073b17676daa",
+  "typesPublisherContentHash": "96f0a72c6119022091f6102f750c1a5d1b46ea12c877c15cd9614b20c51cdbc0",
   "typeScriptVersion": "5.6"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@songtonyli/dsh-cli",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "The dsh terminal agent: an interactive TUI over the DeepSeek Harness, with its whole Node runtime bundled in one install.",
   "license": "MIT",
   "type": "module",
@@ -341,7 +341,7 @@
     "@smithy/util-utf8": "2.3.0",
     "@stablelib/base64": "1.0.1",
     "@standard-schema/spec": "1.1.0",
-    "@types/node": "22.20.2",
+    "@types/node": "22.20.3",
     "@types/retry": "0.12.0",
     "@vscode/ripgrep": "1.18.0",
     "@xterm/addon-serialize": "0.14.0",