@justsilver/opencode-providers 0.2.1 → 0.3.1

package/CHANGELOG.md

@@ -7,6 +7,35 @@
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-10-07
+
+### Fixed
+
+- **`/connect-providers` 强制刷新后列表不更新**：`doRefresh` 刷新成功只调了
+  `ctx.data.location.integration.invalidate()`，而 `invalidate` 仅删除 sync 标记、**不会重新拉取**，`list()`
+  读到的仍是旧的客户端缓存（此时服务端其实已注册新供应商）→ 重开的弹窗还是旧列表。
+  改用与其它操作一致的 `reloadIntegrations()`（`invalidate` + `await sync`），刷新后重开的列表与服务端
+  `/api/integration` 一致。证据：`packages/client/src/solid/data.ts` 的 `locationResource`
+  （`list` 读 store、`sync` 才 `sync.run` 拉取、`invalidate` 只 `sync.invalidate`）
+- **`/connect-providers` 刷新进度模态看不到**：`refreshWithProgress` 用 `void` 打开 `dialog.alert` 后
+  在 `finally` 里立即 `clear()`，刷新一返回就把模态抹掉（快则一帧都看不到）。改为刷新期间不再自行 `clear`：
+  列表路径由重开的列表弹窗顶替模态，空态路径（无后续弹窗）显式 `clear`，模态在整个刷新期间保持可见
+
+## [0.3.0] - 2026-10-07
+
+### Added
+
+- `/connect-providers` 账号管理支持**重命名**（`ctrl+r`，弹窗预填当前名称）与**删除**（`ctrl+d`，二次确认后删除）；
+  删除最后一个账号时提示 `Disconnected <name>` 并关闭弹窗（该供应商随之从 `/models` 消失）。
+  动作触发后**留在弹窗**并原地刷新（与内置 `/connect` 一致）；选中已激活账号不再重复调用 activate
+- 强制刷新改为**阻塞式进度模态**（`dialog.alert`，刷新结束自动 `clear`）：刷新期间输入被模态捕获、无法重复触发；
+  `forceRefresh` 增加**单飞**（并发调用共用同一次刷新）
+
+### Changed
+
+- **移除安装脚本**：不再提供 `install.sh` / `install.ps1` / `uninstall.sh` / `uninstall.ps1`，本插件**只通过 npm 包分发**；
+  本地开发改为在 `plugins` 里指向工作树的**绝对路径目录**（opencode 按「本地目录插件」加载，改完自动热重载）
+
 ## [0.2.1] - 2026-10-07
 
 ### Fixed
@@ -121,7 +150,9 @@
 - 插件源码从 `.opencode/plugins/opencode-providers/` 移到 `plugin/opencode-providers/`：仓库自身不再是插件发现根，避免在仓库里跑 opencode 时与全局安装的同 id 副本相撞（`Duplicate plugin ID` → 面板里一条 `failed`）
 - 安装后**通常无需重启**（插件目录被文件监视热重载），不再要求 `opencode service restart`
 
-[Unreleased]: https://github.com/Just-Silver/opencode-providers/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/Just-Silver/opencode-providers/compare/v0.3.1...HEAD
+[0.3.1]: https://github.com/Just-Silver/opencode-providers/releases/tag/v0.3.1
+[0.3.0]: https://github.com/Just-Silver/opencode-providers/releases/tag/v0.3.0
 [0.1.0]: https://github.com/Just-Silver/opencode-providers/releases/tag/v0.1.0
 [0.1.0-beta.2]: https://github.com/Just-Silver/opencode-providers/releases/tag/v0.1.0-beta.2
 [0.1.0-beta.1]: https://github.com/Just-Silver/opencode-providers/releases/tag/v0.1.0-beta.1

package/README.md

@@ -7,14 +7,15 @@
 registry/index.json              ← manifest：schemaVersion / revision / providers[]（CLI 自动维护）
 registry/providers/<id>/          ← 每家：provider.json（供应商参数）+ models.json（该家模型）
 registry/models/<lab>/<model>.json ← 顶层共享模型（多家用 base 引用）
-plugin/opencode-providers/       ← 插件源码（安装时整目录复制到 ~/.config/opencode/plugins/）
+plugin/opencode-providers/       ← 插件源码（npm 包的 server / tui 入口所在）
 ├── index.ts                     ← server 入口：拉注册表 → 注册 integration/provider/models
 ├── tui.ts                       ← TUI 入口：注册 /connect-providers 命令（不写 JSX，见下）
 ├── registry/                    ← 纯逻辑：schema 校验 / 元数据映射 / 拉取缓存
 └── view/                        ← /connect-providers 交互
 ```
 
-> 源码**故意不放在 `.opencode/plugins/` 下**：那样在本仓库里跑 opencode 时，仓库副本会和全局安装副本撞同一个插件 id，
+> 源码**故意不放在 `.opencode/plugins/` 下**：opencode 会自动发现该目录下的插件，
+> 那样在本仓库里跑 opencode 时就会和 npm/全局那份撞同一个插件 id，
 > 被 supervisor 判为 `Duplicate plugin ID: opencode-providers`，在 `/plugins` 面板里显示成一条 `failed`（实际加载的是另一条，功能正常）。
 
 ## 为什么需要它
@@ -25,8 +26,7 @@ OpenCode 的供应商清单来自 models.dev 目录，**目录里没有的供应
 
 ## 安装
 
-### 方式 A：npm 包（推荐）
-
+本插件**只通过 npm 包分发**（走 opencode 的 `plugins` 配置或 `opencode plugin add`），没有安装脚本。
 在 `opencode.json(c)` 里写一行（不需要手写 provider/模型）：
 
 ```jsonc
@@ -58,35 +58,24 @@ OpenCode 的供应商清单来自 models.dev 目录，**目录里没有的供应
   }
   ```
 
-### 方式 B：安装脚本（零依赖备用路径）
+装完**通常无需重启**（插件被文件监视，覆盖后自动热重载）；必要时 `opencode service restart`。
+卸载：`opencode plugin remove @justsilver/opencode-providers`（或把 `plugins` 里那一行删掉）。
 
-```bash
-# Linux / macOS
-./install.sh
-```
+### 本地开发：直接跑工作树
 
-```powershell
-# Windows
-.\install.ps1
-```
+不想先发版也能让 opencode 加载**当前工作树**——`plugins` 里给一个**绝对路径目录**即可
+（opencode 对绝对路径按「本地目录插件」处理；该目录需含 `index.ts` 与 `tui.ts`）：
 
-脚本把 `plugin/opencode-providers/` 整目录装到：
-
-```
-~/.config/opencode/plugins/opencode-providers/        # $XDG_CONFIG_HOME 优先
+```jsonc
+{
+  "plugins": [
+    { "package": "E:/Code/Projects/Agent/opencode-providers/plugin/opencode-providers" }
+  ]
+}
 ```
 
-装完**通常无需重启**（插件目录被文件监视，覆盖后自动热重载）；必要时 `opencode service restart`。
-卸载：`./uninstall.sh` / `.\uninstall.ps1`。
-
-开发时把**工作树**（含未提交改动）直接部署到全局插件目录：
-
-```bash
-bash install.sh --local
-```
-```powershell
-pwsh -NoProfile -File .\install.ps1 -Local
-```
+这样改完源码会被文件监视热重载，无需发布、也无需 `npm install`。
+（它和 npm 包**同 id**，别同时留着两条，否则 `/plugins` 面板会出现一条 `failed`。）
 
 ## 使用
 
@@ -187,7 +176,7 @@ registry/
 - **不做参数推断**：注册表写什么就是什么，插件不会去猜 `limit`/`cost`。
 - **不调供应商 API**：不访问 `/v1/models`，也就没有运行期的额外网络与失败面。
 - **不声明 `env` 认证**：本插件只走 `/connect`-式交互；opencode 的 env 是静默旁路且不在 `/connect` 里展示。
-- 账号重命名/删除请用内置 `/connect`（同一个 integration，同一个凭据表）。
+- 不改注册表来源时**不需要** `opencode.json` 里的 `providers` 声明（那是另一条路线）。
 
 ## 开发
 
@@ -231,9 +220,9 @@ push tag `vX.Y.Z-beta.n`（或 Actions → Release → Run workflow 勾 `publish
 
 | 现象 | 原因 / 处理 |
 |---|---|
-| `/plugins` 面板里本插件有**一条 `failed`** | 同一插件 id 被发现两次（例：脚本装到 `~/.config/opencode/plugins/` + 又在 `opencode.json` 里配了 npm 包，或某个项目的 `.opencode/plugins/` 里也有一份）。supervisor 保留首个、把后来者标成 `failed`，错误信息是 `Duplicate plugin ID: opencode-providers`。删掉多余的那份即可 |
+| `/plugins` 面板里本插件有**一条 `failed`** | 同一插件 id 被发现两次（例：`opencode.json` 里配了 npm 包，某个项目的 `.opencode/plugins/` 里又放了一份；或本地绝对路径与 npm 包同时留着）。supervisor 保留首个、把后来者标成 `failed`，错误信息是 `Duplicate plugin ID: opencode-providers`。删掉多余的那份即可 |
 | `/connect-providers` 说没有可用供应商 | 注册表没加载成功。看 server 日志里的 `[opencode-providers]`，并确认 `/api/plugin` 里自己那条 `state.status` 是 `active` |
 | `/models` 里看不到新供应商 | 正常：`activation: "auto"`，在 `/connect-providers` 里存过 key 之后才会出现 |
-| 改了插件代码没生效 | 覆盖的是**全局**那份（`~/.config/opencode/plugins/opencode-providers/`）。开发时用 `install.ps1 -Local` / `install.sh --local` 把工作树复制过去 |
+| 改了插件代码没生效 | 改的是**工作树**，但 opencode 加载的是 npm 缓存里那份（`~/.cache/opencode/npm/@justsilver/opencode-providers@…/`）。开发时改用上面的「本地开发：直接跑工作树」把 `plugins` 指到工作树目录 |
 
 验证命令见上面的「开发」小节。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justsilver/opencode-providers",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "type": "module",
   "description": "Register providers missing from the models.dev catalog in OpenCode V2 from a self-hosted registry — no opencode.json needed",
   "license": "MIT",

package/plugin/opencode-providers/view/connect.ts

@@ -2,13 +2,16 @@
  * `/connect-providers` flow.
  *
  * Mirrors the built-in `/connect` interaction for the providers this plugin
- * registers: pick a provider, then either add an account (paste an API key) or
- * activate one that already exists. Everything goes through the normal server
- * API, so credentials land in opencode's own store.
+ * registers: pick a provider, then either add an account (paste an API key),
+ * activate one that already exists, rename it, or delete it. Everything goes
+ * through the normal server API, so credentials land in opencode's own store.
  *
- * Out of scope on purpose (use the built-in `/connect` for these): renaming and
- * deleting accounts. Renaming needs a bound footer action; deletion needs a
- * confirm binding. Both are cosmetic actions on the same records.
+ * Why this looks a bit different from the built-in dialog: the plugin API
+ * (`ctx.ui.dialog.select`) is a one-shot, non-reactive wrapper. Options are
+ * frozen when the prompt opens and actions cannot be hidden or disabled, so we
+ * cannot mutate a row in place the way the core `DialogIntegration` does. This
+ * flow instead re-opens the account manager after every mutation to show fresh
+ * state, and uses `dialog.confirm` for the delete confirmation.
  */
 
 import type { IntegrationInfo } from "@opencode/client"
@@ -18,52 +21,87 @@ import { registryRpc } from "../rpc.ts"
 
 type Context = Plugin.Context
 type Connection = IntegrationInfo["connections"][number]
+type CredentialConnection = Extract<Connection, { type: "credential" }>
 
 const INTEGRATION_SOURCE = "opencode-providers"
 const ADD_ACCOUNT = "\u0000add-account"
 
 export async function connectProviders(ctx: Context): Promise<void> {
-  const integrations = ownIntegrations(ctx).toSorted((a, b) => a.name.localeCompare(b.name))
+  while (true) {
+    const integrations = ownIntegrations(ctx).toSorted((a, b) => a.name.localeCompare(b.name))
 
-  if (integrations.length === 0) {
-    // Nothing to connect yet — offer the refresh here rather than making the user
-    // restart the service and wait out the 6h TTL.
-    const confirmed = await ctx.ui.dialog.confirm({
+    if (integrations.length === 0) {
+      // Nothing to connect yet — offer the refresh here rather than making the user
+      // restart the service and wait out the 6h TTL.
+      const confirmed = await ctx.ui.dialog.confirm({
+        title: "Connect providers",
+        message:
+          "No providers from the registry are available. Force a refresh to re-fetch the registry, then run /connect-providers again.",
+        label: { confirm: "Force refresh" },
+      })
+      if (confirmed) {
+        const ok = await refreshWithProgress(ctx)
+        // No dialog follows this branch, so close the refresh modal ourselves.
+        ctx.ui.dialog.clear()
+        if (ok) {
+          ctx.ui.toast.show({
+            variant: "info",
+            message: "Reloaded. Run /connect-providers again to connect a provider.",
+          })
+        }
+      }
+      return
+    }
+
+    let refreshRequested = false
+    const selected = await ctx.ui.dialog.select<string>({
       title: "Connect providers",
-      message:
-        "No providers from the registry are available. Force a refresh to re-fetch the registry, then run /connect-providers again.",
-      label: { confirm: "Force refresh" },
+      options: integrations.map((integration) => ({
+        title: integration.name,
+        value: integration.id,
+        footer: footer(integration),
+      })),
+      actions: [
+        {
+          title: "Force refresh",
+          bind: "ctrl+r",
+          selection: "none",
+          onTrigger: () => {
+            refreshRequested = true
+            ctx.ui.dialog.clear()
+          },
+        },
+      ],
     })
-    if (confirmed) {
-      if (await forceRefresh(ctx)) {
-        ctx.ui.toast.show({ variant: "info", message: "Reloaded. Run /connect-providers again to connect a provider." })
-      }
+
+    // The dialog is static, so a triggered action only records intent and closes
+    // the prompt; the work (and the re-open with fresh data) happens out here.
+    if (refreshRequested) {
+      await refreshWithProgress(ctx)
+      continue
     }
-    return
-  }
+    if (selected === undefined) return
 
-  const selected = await ctx.ui.dialog.select<string>({
-    title: "Connect providers",
-    options: integrations.map((integration) => ({
-      title: integration.name,
-      value: integration.id,
-      footer: footer(integration),
-    })),
-    actions: [
-      {
-        title: "Force refresh",
-        bind: "ctrl+r",
-        selection: "none",
-        onTrigger: () => void forceRefresh(ctx),
-      },
-    ],
-  })
-  if (selected === undefined) return
+    const integration = integrations.find((item) => item.id === selected)
+    if (integration === undefined) return
 
-  const integration = integrations.find((item) => item.id === selected)
-  if (integration === undefined) return
+    await openProvider(ctx, integration)
+    return
+  }
+}
 
-  await openProvider(ctx, integration)
+/**
+ * Show the "Refreshing registry…" modal and force a refresh.
+ *
+ * The modal is intentionally **not** cleared here: clearing it the moment the
+ * refresh resolves raced the renderer and turned it into a sub-frame flash the
+ * user never sees. The caller closes it explicitly (the empty state, which opens
+ * no follow-up dialog) or lets the reopened dialog replace it (the list state),
+ * so it stays up for the whole refresh.
+ */
+async function refreshWithProgress(ctx: Context): Promise<boolean> {
+  void ctx.ui.dialog.alert({ title: "Connect providers", message: "Refreshing registry…" })
+  return forceRefresh(ctx)
 }
 
 /**
@@ -71,8 +109,23 @@ export async function connectProviders(ctx: Context): Promise<void> {
  * provider list. Returns whether it succeeded. A failure only surfaces as an
  * error toast: the previously registered providers stay usable, so nothing is
  * invalidated.
+ *
+ * Single-flight: concurrent callers share one refresh. The blocking modal makes
+ * a second trigger hard to reach, but the command palette is `mode: "global"`
+ * and can still re-enter this flow, so the guard keeps network work idempotent.
  */
-export async function forceRefresh(ctx: Context): Promise<boolean> {
+let refreshInFlight: Promise<boolean> | undefined
+
+export function forceRefresh(ctx: Context): Promise<boolean> {
+  if (refreshInFlight) return refreshInFlight
+  const pending = doRefresh(ctx).finally(() => {
+    if (refreshInFlight === pending) refreshInFlight = undefined
+  })
+  refreshInFlight = pending
+  return pending
+}
+
+async function doRefresh(ctx: Context): Promise<boolean> {
   try {
     const result = await ctx.client.rpc(registryRpc).refresh({})
     if (!result.ok) {
@@ -80,7 +133,10 @@ export async function forceRefresh(ctx: Context): Promise<boolean> {
       ctx.ui.toast.show({ variant: "error", message: `Registry refresh failed: ${detail}` })
       return false
     }
-    ctx.data.location.integration.invalidate(ctx.location)
+    // `invalidate` alone only drops the sync marker — it does not refetch, so
+    // `list()` would keep returning the stale integrations. `reloadIntegrations`
+    // also awaits the sync, so the reopened list shows the freshly registered set.
+    await reloadIntegrations(ctx)
     ctx.ui.toast.show({
       variant: "success",
       message: `Registry refreshed: ${result.providers ?? 0} providers, ${result.models ?? 0} models`,
@@ -92,45 +148,141 @@ export async function forceRefresh(ctx: Context): Promise<boolean> {
   }
 }
 
+/**
+ * Account manager. Loops so mutations (add / activate / rename / delete) land on
+ * a freshly re-read account list while the prompt stays open, matching the
+ * built-in behaviour. Returns when the user backs out.
+ */
 async function openProvider(ctx: Context, integration: IntegrationInfo): Promise<void> {
-  const credentials = credentialConnections(integration)
-  const active = credentials[0]
+  while (true) {
+    const current = integrationByID(ctx, integration.id) ?? integration
+    const credentials = credentialConnections(current)
+    const active = credentials[0]
 
-  if (credentials.length === 0) {
-    await connectKey(ctx, integration)
-    return
+    if (credentials.length === 0) {
+      await connectKey(ctx, current)
+      return
+    }
+
+    let rename: string | undefined
+    let remove: string | undefined
+    const choice = await ctx.ui.dialog.select<string>({
+      title: current.name,
+      current: active?.id,
+      options: [
+        {
+          title: "Add account",
+          value: ADD_ACCOUNT,
+          description: "Paste another API key; it becomes the active account",
+        },
+        ...credentials.toSorted((a, b) => a.label.localeCompare(b.label)).map((credential) => ({
+          title: credential.label,
+          value: credential.id,
+          category: "Accounts",
+          footer: credential.id === active?.id ? "active" : undefined,
+        })),
+      ],
+      actions: [
+        {
+          title: "rename",
+          bind: "ctrl+r",
+          selection: "required",
+          onTrigger: (value) => {
+            // Actions cannot be hidden while "Add account" is focused, so guard here.
+            if (value === ADD_ACCOUNT) return
+            rename = value
+            ctx.ui.dialog.clear()
+          },
+        },
+        {
+          title: "delete",
+          bind: "ctrl+d",
+          selection: "required",
+          onTrigger: (value) => {
+            if (value === ADD_ACCOUNT) return
+            remove = value
+            ctx.ui.dialog.clear()
+          },
+        },
+      ],
+    })
+
+    if (rename !== undefined) {
+      await renameAccount(ctx, current, rename)
+      continue
+    }
+    if (remove !== undefined) {
+      if (await deleteAccount(ctx, current, remove)) return
+      continue
+    }
+
+    if (choice === undefined) return
+
+    if (choice === ADD_ACCOUNT) {
+      await connectKey(ctx, current)
+      continue
+    }
+
+    if (choice === active?.id) continue
+    const credential = credentials.find((item) => item.id === choice)
+    try {
+      await ctx.client.credential.activate({ credentialID: choice })
+      await reloadIntegrations(ctx)
+      ctx.ui.toast.show({ variant: "success", message: `Activated ${credential?.label ?? choice}` })
+    } catch (error) {
+      ctx.ui.toast.show({ variant: "error", message: message(error) })
+    }
   }
+}
 
-  const choice = await ctx.ui.dialog.select<string>({
-    title: integration.name,
-    current: active?.id,
-    options: [
-      {
-        title: "Add account",
-        value: ADD_ACCOUNT,
-        description: "Paste another API key; it becomes the active account",
-      },
-      ...credentials.toSorted((a, b) => a.label.localeCompare(b.label)).map((credential) => ({
-        title: credential.label,
-        value: credential.id,
-        category: "Accounts",
-        footer: credential.id === active?.id ? "active" : undefined,
-      })),
-    ],
+async function renameAccount(ctx: Context, integration: IntegrationInfo, credentialID: string): Promise<void> {
+  const credential = credentialConnections(integration).find((item) => item.id === credentialID)
+  if (credential === undefined) return
+
+  const value = await ctx.ui.dialog.prompt({
+    title: "Rename account",
+    placeholder: "Account name",
+    value: credential.label,
   })
-  if (choice === undefined) return
+  if (value === undefined) return
 
-  if (choice === ADD_ACCOUNT) {
-    await connectKey(ctx, integration)
-    return
+  const label = value.trim()
+  if (label === "" || label === credential.label) return
+
+  try {
+    await ctx.client.credential.update({ credentialID, label })
+    await reloadIntegrations(ctx)
+    ctx.ui.toast.show({ variant: "success", message: `Renamed to ${label}` })
+  } catch (error) {
+    ctx.ui.toast.show({ variant: "error", message: message(error) })
   }
+}
+
+/** Returns whether the manager should close (the last account was removed). */
+async function deleteAccount(ctx: Context, integration: IntegrationInfo, credentialID: string): Promise<boolean> {
+  const credentials = credentialConnections(integration)
+  const credential = credentials.find((item) => item.id === credentialID)
+  if (credential === undefined) return false
 
-  const credential = credentials.find((item) => item.id === choice)
+  const confirmed = await ctx.ui.dialog.confirm({
+    title: "Delete account",
+    message: `Delete "${credential.label}" from ${integration.name}?`,
+    label: { confirm: "Delete", cancel: "Cancel" },
+  })
+  if (confirmed !== true) return false
+
+  const last = credentials.length === 1
   try {
-    await ctx.client.credential.activate({ credentialID: choice })
-    ctx.ui.toast.show({ variant: "success", message: `Activated ${credential?.label ?? choice}` })
+    await ctx.client.credential.remove({ credentialID })
+    await reloadIntegrations(ctx)
+    if (last) {
+      ctx.ui.toast.show({ variant: "success", message: `Disconnected ${integration.name}` })
+      return true
+    }
+    return false
   } catch (error) {
     ctx.ui.toast.show({ variant: "error", message: message(error) })
+    return false
   }
 }
 
@@ -147,22 +299,36 @@ async function connectKey(ctx: Context, integration: IntegrationInfo): Promise<v
 
   try {
     await ctx.client.integration.connect.key({ integrationID: integration.id, key: key.trim() })
-    ctx.data.location.integration.invalidate(ctx.location)
+    await reloadIntegrations(ctx)
     ctx.ui.toast.show({ variant: "success", message: `${integration.name} connected` })
   } catch (error) {
     ctx.ui.toast.show({ variant: "error", message: message(error) })
   }
 }
 
+/** Drop the cached integration list and re-read it so the loop sees fresh accounts. */
+async function reloadIntegrations(ctx: Context): Promise<void> {
+  ctx.data.location.integration.invalidate(ctx.location)
+  try {
+    await ctx.data.location.integration.sync(ctx.location)
+  } catch {
+    // A failed sync still leaves `list()` readable; the next action retries.
+  }
+}
+
 function ownIntegrations(ctx: Context): IntegrationInfo[] {
   return (ctx.data.location.integration.list(ctx.location) ?? []).filter(
     (integration) => integration.metadata?.source === INTEGRATION_SOURCE,
   )
 }
 
-function credentialConnections(integration: IntegrationInfo): Array<Extract<Connection, { type: "credential" }>> {
+function integrationByID(ctx: Context, id: string): IntegrationInfo | undefined {
+  return ownIntegrations(ctx).find((integration) => integration.id === id)
+}
+
+function credentialConnections(integration: IntegrationInfo): CredentialConnection[] {
   return integration.connections.filter(
-    (connection): connection is Extract<Connection, { type: "credential" }> => connection.type === "credential",
+    (connection): connection is CredentialConnection => connection.type === "credential",
   )
 }