@miphamai/cli 0.85.5 → 0.85.7

package/src/i18n-core/locales/zh-CN.json

@@ -42,129 +42,11 @@
     "dismiss": "关闭",
     "terminalName": "Mipham Code"
   },
-  "web": {
-    "hero": {
-      "title": "Mipham Code",
-      "subtitle": "多模型开源智能编程终端。为追求性能、速度和灵活性的开发者而打造。",
-      "company": "由 One Mipham Corporation 驱动 | 北京华安麦逄科技有限公司",
-      "domains": "国际站: mipham.ai  |  中国大陆: onemipham.com",
-      "cta_start": "快速开始",
-      "cta_docs": "文档"
-    },
-    "features": {
-      "title": "为什么选择 Mipham Code？",
-      "multi_model": {
-        "title": "多模型支持",
-        "desc": "通过统一接口连接 Claude、GPT、DeepSeek、Qwen、Kimi 等。使用 Ctrl+P 实时切换模型。"
-      },
-      "slash_commands": {
-        "title": "85 个 Slash 命令",
-        "desc": "完全对标 Claude Code：/commit、/pr、/simplify、/lint、/loop init、/browse-plugins — 全部 85 个命令，零学习成本。"
-      },
-      "plugins": {
-        "title": "插件市场",
-        "desc": "从 npm 或本地路径安装插件。探索社区插件，包括 NotebookLM MCP 集成。"
-      },
-      "loopkit": {
-        "title": "LoopKit Vault",
-        "desc": "/loop init 初始化完整的项目结构：.mipham/ 配置、钩子、代理、9 领域技能、.mcp.json 等。"
-      },
-      "mcp": {
-        "title": "MCP 协议",
-        "desc": "完整的 Model Context Protocol 支持，基于 stdio 传输。连接 NotebookLM、文件系统、GitHub 和自定义 MCP 服务器。"
-      },
-      "secure": {
-        "title": "开源核心 · 安全可靠",
-        "desc": "Apache 2.0 许可证。TLS 1.3、AES-256-GCM 加密，全面的权限系统。开箱即用的企业级安全。"
-      }
-    },
-    "models": {
-      "title": "支持的模型",
-      "status_active": "已上线",
-      "status_upcoming": "即将推出"
-    },
-    "install_section": {
-      "title": "秒级安装",
-      "subtitle": "四种安装方式 — 选择适合你的平台。",
-      "npm_recommended": "npm（推荐）",
-      "curl_label": "curl（macOS / Linux）",
-      "powershell_label": "PowerShell（Windows）",
-      "label_international": "International · 国际站",
-      "label_china": "中国大陆 · China mainland",
-      "requirements": "需要 Bun 1.2+ 或 Node.js 22+。支持 macOS、Linux、Windows。",
-      "full_guide": "完整安装指南"
-    },
-    "footer": {
-      "copyright": "© {year} One Mipham Corporation。保留所有权利。",
-      "docs": "文档",
-      "dashboard": "控制台",
-      "github": "GitHub"
-    },
-    "install_page": {
-      "title": "安装指南",
-      "current_version": "当前版本：",
-      "choose_platform": "选择适合你的平台和安装方式。",
-      "all_methods_same": "所有方式安装的是同一个 Mipham Code。",
-      "prerequisites": "前置要求",
-      "prereq_bun": "Bun 1.2+（推荐）或 Node.js 22+",
-      "prereq_os": "macOS、Linux 或 Windows（PowerShell）",
-      "prereq_api_key": "至少一个 AI 提供商的 API 密钥（如 Anthropic、OpenAI）",
-      "npm_title": "1. npm 安装（推荐）",
-      "npm_desc": "适用于所有平台 — macOS、Linux、Windows。",
-      "curl_title": "2. curl 安装（macOS / Linux）",
-      "powershell_title": "3. PowerShell 安装（Windows）",
-      "direct_download": "4. 直接下载",
-      "table_platform": "平台",
-      "table_download": "下载",
-      "platform_mac_arm": "macOS（Apple Silicon）",
-      "platform_mac_intel": "macOS（Intel）",
-      "platform_linux": "Linux（x64）",
-      "platform_windows": "Windows（x64）",
-      "verify_title": "验证安装",
-      "start_title": "启动 Mipham Code",
-      "first_launch": "首次启动时，交互式设置向导（/setup）将引导你完成提供商配置、模型选择、技能安装和权限设置。",
-      "api_keys_title": "设置 API 密钥",
-      "api_keys_desc": "将提供商的 API 密钥导出为环境变量：",
-      "international": "International · 国际站",
-      "china_mainland": "中国大陆 · China mainland"
-    },
-    "docs": {
-      "title": "文档",
-      "quick_start": "快速开始",
-      "configuration": "配置",
-      "commands": "命令",
-      "help": "显示帮助",
-      "model": "显示当前模型",
-      "switch": "切换模型",
-      "clear": "清除对话",
-      "exit": "退出 Mipham Code"
-    },
-    "dashboard": {
-      "title": "控制台",
-      "coming_soon": "即将推出",
-      "description": "Mipham Code 控制台将展示你的使用分析 — 会话历史、Token 消耗、最常用的模型和工具以及技能活动。我们正在开发中。",
-      "sessions": "会话",
-      "sessions_desc": "会话历史与统计",
-      "tokens": "Token",
-      "tokens_desc": "各提供商用量",
-      "skills": "技能",
-      "skills_desc": "活跃技能分析"
-    },
-    "not_found": {
-      "code": "404",
-      "title": "页面未找到",
-      "description": "你要找的页面不存在。",
-      "back": "返回 Mipham Code"
-    },
-    "error": {
-      "title": "出了点问题",
-      "fallback_message": "发生了意外错误。",
-      "try_again": "重试"
-    }
-  },
   "greeting": "你好 {name}",
   "commands": {
-    "clear": { "confirmed": "✓ 对话已清除，上下文已重置。" },
+    "clear": {
+      "confirmed": "✓ 对话已清除，上下文已重置。"
+    },
     "compact": {
       "confirmed": "✓ 上下文已压缩。",
       "tokens": "Tokens: {before} → {after} (节省 {saved}%)"
@@ -304,7 +186,6 @@
     },
     "task_list": {
       "title": "── 后台任务 ──",
-      "detected": "在此会话中检测到 {count} 次任务操作。\n\n使用 Task 工具（action \"create\" / \"update\" / \"list\"）管理结构化任务跟踪。",
       "no_tasks": "尚未跟踪任何任务。使用 Task 工具的 action \"create\"、\"update\" 或 \"list\" 管理结构化任务。",
       "reference": "快速参考:",
       "legacy_hint": "输入 /todos 使用旧版任务界面。"
@@ -333,7 +214,9 @@
       "not_found_content": "未找到名为 \"{name}\" 的会话。\n\n不带参数运行 /resume 列出所有已保存的会话。",
       "found_content": "名称:      {name}\n消息数:  {messages}\n提供商:  {provider} / {model}\n更新时间:   {updated}\n\n要接着此会话继续，请另起进程运行:\n  mipham --resume \"{target}\""
     },
-    "help": { "title": "── Mipham Code 帮助 ──" },
+    "help": {
+      "title": "── Mipham Code 帮助 ──"
+    },
     "lang": {
       "current": "当前语言: {locale}",
       "set": "语言已设置为 {locale}。重启 Mipham Code 生效。"
@@ -433,6 +316,8 @@
       "update_failed": "✗ 更新失败: {reason}{rolledBack}\n  手动尝试: {command}\n  配置备份位于: {path}",
       "rolled_back": "\n  已恢复原安装 —— mipham 仍可使用。",
       "no_rollback": "\n  ⚠ 原安装未能恢复 —— 请按下方命令手动重装。",
+      "install_untouched": "\n  原安装未被改动 —— mipham 仍可使用。",
+      "install_unknown": "\n  ⚠ 无法定位全局安装路径 —— 无法判断原安装是否完好。",
       "unverified": "⚠ 已安装，但无法验证新版本: {reason}"
     },
     "no_plan": {
@@ -849,9 +734,15 @@
       "finished": "已完成",
       "status_label": "代理"
     },
-    "system": { "role_label": "系统" },
-    "assistant": { "role_label": "Mipham Code" },
-    "user": { "role_label": "用户" },
+    "system": {
+      "role_label": "系统"
+    },
+    "assistant": {
+      "role_label": "Mipham Code"
+    },
+    "user": {
+      "role_label": "用户"
+    },
     "input": {
       "placeholder": "输入消息（Esc 清空）..."
     },
@@ -976,22 +867,70 @@
     }
   },
   "tools": {
-    "bash": { "name": "Bash", "description": "执行 Shell 命令" },
-    "read": { "name": "Read", "description": "从文件系统读取文件" },
-    "write": { "name": "Write", "description": "写入内容到文件" },
-    "edit": { "name": "Edit", "description": "通过字符串替换编辑文件" },
-    "glob": { "name": "Glob", "description": "查找匹配模式的文件" },
-    "grep": { "name": "Grep", "description": "使用正则表达式搜索文件内容" },
-    "web_fetch": { "name": "WebFetch", "description": "获取 URL 并解析内容" },
-    "web_search": { "name": "WebSearch", "description": "搜索网页" },
-    "agent": { "name": "Agent", "description": "启动子代理执行复杂任务" },
-    "task": { "name": "Task", "description": "创建和跟踪任务" },
-    "skill": { "name": "Skill", "description": "调用命名技能" },
-    "memory": { "name": "Memory", "description": "读写持久记忆" },
-    "workflow": { "name": "Workflow", "description": "执行多代理工作流" },
-    "plan": { "name": "Plan", "description": "进入计划模式进行结构化思考" },
-    "config": { "name": "Config", "description": "查看和修改配置" },
-    "mcp": { "name": "MCP", "description": "管理 MCP 服务器连接" }
+    "bash": {
+      "name": "Bash",
+      "description": "执行 Shell 命令"
+    },
+    "read": {
+      "name": "Read",
+      "description": "从文件系统读取文件"
+    },
+    "write": {
+      "name": "Write",
+      "description": "写入内容到文件"
+    },
+    "edit": {
+      "name": "Edit",
+      "description": "通过字符串替换编辑文件"
+    },
+    "glob": {
+      "name": "Glob",
+      "description": "查找匹配模式的文件"
+    },
+    "grep": {
+      "name": "Grep",
+      "description": "使用正则表达式搜索文件内容"
+    },
+    "web_fetch": {
+      "name": "WebFetch",
+      "description": "获取 URL 并解析内容"
+    },
+    "web_search": {
+      "name": "WebSearch",
+      "description": "搜索网页"
+    },
+    "agent": {
+      "name": "Agent",
+      "description": "启动子代理执行复杂任务"
+    },
+    "task": {
+      "name": "Task",
+      "description": "创建和跟踪任务"
+    },
+    "skill": {
+      "name": "Skill",
+      "description": "调用命名技能"
+    },
+    "memory": {
+      "name": "Memory",
+      "description": "读写持久记忆"
+    },
+    "workflow": {
+      "name": "Workflow",
+      "description": "执行多代理工作流"
+    },
+    "plan": {
+      "name": "Plan",
+      "description": "进入计划模式进行结构化思考"
+    },
+    "config": {
+      "name": "Config",
+      "description": "查看和修改配置"
+    },
+    "mcp": {
+      "name": "MCP",
+      "description": "管理 MCP 服务器连接"
+    }
   },
   "errors": {
     "tool_denied_deny_rule": "工具 \"{name}\" 被拒绝规则（\"{pattern}\"）阻止。拒绝规则优先于权限模式 — 请改用其他方式，或移除该规则：/permissions remove \"{pattern}\"",

package/src/providers/anthropic.ts

@@ -132,6 +132,9 @@ export class AnthropicProvider implements ProviderInstance {
         'anthropic-beta': 'prompt-caching-2024-07-31',
       },
       body: JSON.stringify(body),
+      // Same as `openai-compat`: without this the caller's signal never reaches
+      // the transport, and every per-call cancellation budget is decorative.
+      signal: req.signal,
     })
 
     if (!response.ok) {
@@ -153,162 +156,173 @@ export class AnthropicProvider implements ProviderInstance {
     // passes aren't mistaken for a stalled connection.
     const STREAM_READ_TIMEOUT_MS = streamIdleTimeoutMs(req.effort)
 
-    while (true) {
-      let readResult: Awaited<ReturnType<typeof reader.read>>
-      let idleTimer: ReturnType<typeof setTimeout> | undefined
-      try {
-        readResult = await Promise.race([
-          reader.read(),
-          new Promise<never>((_, reject) => {
-            idleTimer = setTimeout(
-              () =>
-                reject(
-                  new Error(
-                    `Stream read timeout — no data for ${Math.round(STREAM_READ_TIMEOUT_MS / 1000)}s`,
-                  ),
-                ),
-              STREAM_READ_TIMEOUT_MS,
-            )
-          }),
-        ])
-      } catch (err) {
-        yield { type: 'error', error: `Stream stalled: ${String(err)}` }
-        return
-      } finally {
-        if (idleTimer) clearTimeout(idleTimer)
-      }
-      const { done, value } = readResult
-      if (done) break
-
-      buffer += decoder.decode(value, { stream: true })
-      const lines = buffer.split('\n')
-      buffer = lines.pop() || ''
-
-      for (const line of lines) {
-        const trimmed = line.trim()
-        if (!trimmed || !trimmed.startsWith('data: ')) continue
-        const data = trimmed.slice(6)
-
+    // The read loop and the trailing stop share one reader, and that reader owns
+    // the connection. `engine.ts` breaks out of this generator on the ordinary
+    // `stop` chunk, and a sub-agent throws mid-stream on abort — both call
+    // `.return()`, which unwinds through here. Without this, a turn that ends
+    // normally (or is abandoned) leaves the body unread and uncancelled, so the
+    // socket can't be reused. `cancel()` on an already-errored stream rejects, and
+    // on a closed one is a no-op — the catch covers the first.
+    try {
+      while (true) {
+        let readResult: Awaited<ReturnType<typeof reader.read>>
+        let idleTimer: ReturnType<typeof setTimeout> | undefined
         try {
-          const event = JSON.parse(data) as AnthropicSSEEvent
-
-          switch (event.type) {
-            case 'content_block_start': {
-              const cb = event.content_block
-              if (!cb) continue
-
-              if (cb.type === 'tool_use') {
-                currentToolName = cb.name || ''
-                currentToolId = cb.id || ''
-                accumulatedToolInput = ''
+          readResult = await Promise.race([
+            reader.read(),
+            new Promise<never>((_, reject) => {
+              idleTimer = setTimeout(
+                () =>
+                  reject(
+                    new Error(
+                      `Stream read timeout — no data for ${Math.round(STREAM_READ_TIMEOUT_MS / 1000)}s`,
+                    ),
+                  ),
+                STREAM_READ_TIMEOUT_MS,
+              )
+            }),
+          ])
+        } catch (err) {
+          yield { type: 'error', error: `Stream stalled: ${String(err)}` }
+          return
+        } finally {
+          if (idleTimer) clearTimeout(idleTimer)
+        }
+        const { done, value } = readResult
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split('\n')
+        buffer = lines.pop() || ''
+
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (!trimmed || !trimmed.startsWith('data: ')) continue
+          const data = trimmed.slice(6)
+
+          try {
+            const event = JSON.parse(data) as AnthropicSSEEvent
+
+            switch (event.type) {
+              case 'content_block_start': {
+                const cb = event.content_block
+                if (!cb) continue
+
+                if (cb.type === 'tool_use') {
+                  currentToolName = cb.name || ''
+                  currentToolId = cb.id || ''
+                  accumulatedToolInput = ''
+                }
+                break
               }
-              break
-            }
 
-            case 'content_block_delta': {
-              const delta = event.delta
-              if (!delta) continue
+              case 'content_block_delta': {
+                const delta = event.delta
+                if (!delta) continue
 
-              if (delta.type === 'text_delta' && delta.text) {
-                yield { type: 'text', content: delta.text }
-              }
+                if (delta.type === 'text_delta' && delta.text) {
+                  yield { type: 'text', content: delta.text }
+                }
 
-              if (delta.type === 'thinking_delta' && delta.text) {
-                yield { type: 'thinking', thinking: delta.text }
-              }
+                if (delta.type === 'thinking_delta' && delta.text) {
+                  yield { type: 'thinking', thinking: delta.text }
+                }
 
-              if (delta.type === 'input_json_delta' && delta.partial_json) {
-                accumulatedToolInput += delta.partial_json
+                if (delta.type === 'input_json_delta' && delta.partial_json) {
+                  accumulatedToolInput += delta.partial_json
+                }
+                break
               }
-              break
-            }
 
-            case 'content_block_stop': {
-              // 此刻还无从得知本轮是否被截断 —— `stop_reason` 要到后面的
-              // `message_delta` 才到（见下方同名分支）。所以被截断的 `tool_use`
-              // 在这里已经发出去了；openai-compat 那条路上「截断即丢弃未完成的
-              // tool_call」的处置，这里结构上做不到（它的 finish_reason 与
-              // tool_calls 落在同一个响应体里）。**这是有意的不对称，不是漏做**：
-              // 要在这里丢弃，就得把 `tool_use` 缓冲到 `message_stop` 再发 ——
-              // 那是一次行为变更，不属本次范围。
-              if (currentToolId && currentToolName && accumulatedToolInput) {
-                // A replayed block carries the id it was first sent with, so the
-                // id is what tells a second call apart from the same call twice.
-                if (!emittedToolIds.has(currentToolId)) {
-                  emittedToolIds.add(currentToolId)
-
-                  let parsedInput: Record<string, unknown> = {}
-                  try {
-                    parsedInput = JSON.parse(accumulatedToolInput)
-                  } catch {
-                    parsedInput = { _raw: accumulatedToolInput }
-                  }
-
-                  yield {
-                    type: 'tool_use',
-                    toolUse: {
+              case 'content_block_stop': {
+                // 此刻还无从得知本轮是否被截断 —— `stop_reason` 要到后面的
+                // `message_delta` 才到（见下方同名分支）。所以被截断的 `tool_use`
+                // 在这里已经发出去了；openai-compat 那条路上「截断即丢弃未完成的
+                // tool_call」的处置，这里结构上做不到（它的 finish_reason 与
+                // tool_calls 落在同一个响应体里）。**这是有意的不对称，不是漏做**：
+                // 要在这里丢弃，就得把 `tool_use` 缓冲到 `message_stop` 再发 ——
+                // 那是一次行为变更，不属本次范围。
+                if (currentToolId && currentToolName && accumulatedToolInput) {
+                  // A replayed block carries the id it was first sent with, so the
+                  // id is what tells a second call apart from the same call twice.
+                  if (!emittedToolIds.has(currentToolId)) {
+                    emittedToolIds.add(currentToolId)
+
+                    let parsedInput: Record<string, unknown> = {}
+                    try {
+                      parsedInput = JSON.parse(accumulatedToolInput)
+                    } catch {
+                      parsedInput = { _raw: accumulatedToolInput }
+                    }
+
+                    yield {
                       type: 'tool_use',
-                      id: currentToolId,
-                      name: currentToolName,
-                      input: parsedInput,
-                    },
+                      toolUse: {
+                        type: 'tool_use',
+                        id: currentToolId,
+                        name: currentToolName,
+                        input: parsedInput,
+                      },
+                    }
                   }
-                }
 
-                // Reset accumulator
-                currentToolName = ''
-                currentToolId = ''
-                accumulatedToolInput = ''
+                  // Reset accumulator
+                  currentToolName = ''
+                  currentToolId = ''
+                  accumulatedToolInput = ''
+                }
+                break
               }
-              break
-            }
 
-            case 'message_delta': {
-              // Capture token usage for accurate cost tracking
-              if (event.usage) {
-                yield {
-                  type: 'usage',
-                  inputTokens: event.usage.input_tokens,
-                  outputTokens: event.usage.output_tokens,
+              case 'message_delta': {
+                // Capture token usage for accurate cost tracking
+                if (event.usage) {
+                  yield {
+                    type: 'usage',
+                    inputTokens: event.usage.input_tokens,
+                    outputTokens: event.usage.output_tokens,
+                  }
                 }
+                // Contains stop_reason; also handles late input_json_delta
+                if (event.delta?.type === 'input_json_delta' && event.delta.partial_json) {
+                  accumulatedToolInput += event.delta.partial_json
+                }
+                // `max_tokens` means the turn hit the output ceiling. Without this the
+                // truncation is indistinguishable from `end_turn`: both arrive here and
+                // the terminal stop below looks the same either way.
+                const stopReason = event.delta?.stop_reason
+                if (stopReason === 'max_tokens') {
+                  truncated = true
+                }
+                break
               }
-              // Contains stop_reason; also handles late input_json_delta
-              if (event.delta?.type === 'input_json_delta' && event.delta.partial_json) {
-                accumulatedToolInput += event.delta.partial_json
-              }
-              // `max_tokens` means the turn hit the output ceiling. Without this the
-              // truncation is indistinguishable from `end_turn`: both arrive here and
-              // the terminal stop below looks the same either way.
-              const stopReason = event.delta?.stop_reason
-              if (stopReason === 'max_tokens') {
-                truncated = true
-              }
-              break
-            }
 
-            case 'message_stop': {
-              sawTerminalEvent = true
-              yield truncated ? { type: 'stop', truncated: true } : { type: 'stop' }
-              return
-            }
+              case 'message_stop': {
+                sawTerminalEvent = true
+                yield truncated ? { type: 'stop', truncated: true } : { type: 'stop' }
+                return
+              }
 
-            case 'error': {
-              yield { type: 'error', error: event.error?.message || 'Unknown Anthropic error' }
-              return
+              case 'error': {
+                yield { type: 'error', error: event.error?.message || 'Unknown Anthropic error' }
+                return
+              }
             }
+          } catch {
+            // Skip unparseable SSE events
           }
-        } catch {
-          // Skip unparseable SSE events
         }
       }
-    }
 
-    // The stream ran out without `message_stop`. Whatever stopped it, the turn is
-    // incomplete — and this is the only place that knows, because a cleanly
-    // closed connection and a finished response are otherwise the same stream.
-    if (!sawTerminalEvent) truncated = true
+      // The stream ran out without `message_stop`. Whatever stopped it, the turn is
+      // incomplete — and this is the only place that knows, because a cleanly
+      // closed connection and a finished response are otherwise the same stream.
+      if (!sawTerminalEvent) truncated = true
 
-    yield truncated ? { type: 'stop', truncated: true } : { type: 'stop' }
+      yield truncated ? { type: 'stop', truncated: true } : { type: 'stop' }
+    } finally {
+      await reader.cancel().catch(() => {})
+    }
   }
 
   async listModels(): Promise<ModelInfo[]> {

package/src/providers/fetch-utils.ts

@@ -96,7 +96,13 @@ export async function fetchWithRetry(
       timedOut = true
       controller.abort()
     }, timeout)
-    const signal = init.signal ? anySignal([init.signal, controller.signal]) : controller.signal
+    // `AbortSignal.any` (node ≥22 / bun ≥1.2, both in `engines`) instead of a
+    // hand-rolled combiner: it keeps a *weak* reference to the source signals, so
+    // the combination stays live for the reader without pinning the caller's
+    // signal — which is what the hand-rolled version had to trade away.
+    const signal = init.signal
+      ? AbortSignal.any([init.signal, controller.signal])
+      : controller.signal
 
     try {
       const response = await fetch(url, { ...init, signal })
@@ -123,14 +129,11 @@ export async function fetchWithRetry(
       await sleep(baseDelay * Math.pow(2, attempt))
     } finally {
       clearTimeout(timer)
-      // Clean up combined signal if we created one
-      if (init.signal) {
-        try {
-          controller.abort()
-        } catch {
-          /* best effort */
-        }
-      }
+      // Nothing to release: the combination is natively managed. Do NOT abort
+      // anything here — `fetch` holds that signal and the caller reads the body
+      // *after* we return, so aborting it at this point errored every response at
+      // the headers (measured on Node: the next read throws AbortError; Bun
+      // happens to tolerate it, which is why a Bun-only run never showed this).
     }
   }
 
@@ -163,23 +166,3 @@ export function streamIdleTimeoutMs(effort?: string): number {
   const multiplier = effort ? (EFFORT_TIMEOUT_MULTIPLIER[effort] ?? 1) : 1
   return STREAM_IDLE_TIMEOUT_BASE_MS * multiplier
 }
-
-/**
- * Combine multiple AbortSignals into one — any signal aborting
- * triggers the combined signal.
- */
-function anySignal(signals: AbortSignal[]): AbortSignal {
-  const controller = new AbortController()
-  const onAbort = () => {
-    controller.abort()
-    for (const s of signals) s.removeEventListener('abort', onAbort)
-  }
-  for (const s of signals) {
-    if (s.aborted) {
-      controller.abort()
-      return controller.signal
-    }
-    s.addEventListener('abort', onAbort)
-  }
-  return controller.signal
-}