dsh-jira-tasks 1.0.4 → 1.0.6

package/README.en.md

@@ -4,12 +4,14 @@
 
 [中文](README.md) · **English**
 
-Shows the current JIRA project's **open / reopened** issues **assigned to the current user** below the DSH composer input. The JIRA base URL and token are read from credentials; the project key and JQL are **configured per workspace** and persisted.
+Shows the current JIRA project's **open / reopened** issues **assigned to the current user** below the DSH composer input. The JIRA base URL and token are configured in **Settings → Plugins → JIRA** (`JIRA_BASE_URL` / `JIRA_API_TOKEN` act as fallback); the project key and JQL are **configured per workspace** and persisted.
 
 ## Features
 
 - 📋 Panel shown below the composer in both new and active sessions (aligned with the input width in new sessions)
 - 👤 Defaults to the current user (`assignee = currentUser()`) with status `开启 / 重新开启` (Open / Reopened)
+- ⚙️ **Settings → Plugins → JIRA** edits the base URL and access token (the token is written to the credential store and never sent back to the browser)
+- 🟢 The card auto-probes the connection and shows a status light: green = usable, red = unusable, grey = unconfigured; **Test connection** verifies unsaved drafts immediately
 - ⚙️ Project key and JQL are saved per workspace; unconfigured workspaces show "unconfigured"
 - 🔄 Auto-query on every new session, with a one-click refresh (⟳)
 - 🔗 Click an issue to open its JIRA detail in a new tab
@@ -48,7 +50,22 @@ In a DSH session, use the Cordis tools: `cordis_define` (`kind: new`, `idPrefix:
 
 ### 1. JIRA base URL and token
 
-Write to `$DSH_HOME/.credentials.yaml` (recommended, hot-reloaded), or export environment variables before launching DSH:
+Open **Settings → Plugins → Plugin configuration → JIRA** and fill in:
+
+- **JIRA base URL**: e.g. `http://jira.example.com/` (stored in the user settings document and read back by the form)
+- **Access token / PAT**: written to the credential store (`$DSH_HOME/.credentials.yaml`); the browser only ever sees "configured", never the token itself
+
+Leaving the token blank on save keeps the existing one; clearing the address on save removes the override and falls back to the environment. Auth is auto-detected: tokens containing `:` use Basic, otherwise Bearer (JIRA PAT).
+
+#### Connection test
+
+The card's footer carries a status light and a **Test connection** button:
+
+- Opening the card **auto-probes** once (against JIRA `/rest/api/2/myself`), and saving re-probes
+- **Green** = address and token work (the current user is shown); **red** = unusable (JIRA's reason, e.g. 401, is shown); **grey** = address or token not configured
+- **Test connection** probes what is currently in the fields, saved or not, so you can check before saving
+
+Environment variables / credentials still work as a **fallback** (used when the settings card is empty), hot-reloaded without a restart:
 
 ```yaml
 JIRA_BASE_URL: "http://jira.example.com/"
@@ -57,7 +74,6 @@ JIRA_API_TOKEN: "<PAT or user:token>"
 
 - Base URL aliases: `JIRA_BASE_URL` / `JIRA_URL`
 - Token aliases: `JIRA_API_TOKEN` / `JIRA_TOKEN`
-- Auth is auto-detected: tokens containing `:` use Basic, otherwise Bearer (JIRA PAT)
 
 ### 2. Project key and JQL (per workspace)
 
@@ -86,7 +102,8 @@ dsh plugin --profile web remove dsh-jira-tasks
 
 | Message | Fix |
 |---|---|
-| JIRA_BASE_URL not configured | Credentials missing — see "Configuration 1" above |
+| JIRA base URL not configured | Address missing — see "Configuration 1" above |
+| JIRA token not configured | Token missing — see "Configuration 1" above |
 | 401 … | Invalid token or wrong auth scheme; verify with `curl -H "Authorization: Bearer <token>" <base>/rest/api/2/myself` |
 | Cannot parse JIRA response | Network / proxy issue, curl produced no output |
 </details>
@@ -107,15 +124,16 @@ dsh plugin --profile web remove dsh-jira-tasks
 ┌─────────── Browser (Client) ───────────┐      ┌──────────── Host ──────────────┐
 │ conversation.composer.dock (active)        │      │ webServer route /jira/api/search │
 │ conversation.input.dock (new, order:99)    │      │   ↓                            │
-│   ↓ on mount/refresh fetch POST            │      │ credentials.resolve(JIRA_*)     │
-│ render: list / error / unconfigured        │      │ subprocess.spawn(curl …)        │
-│ localStorage per-workspace config          │      │   ↓ stdout JSON                 │
+│   ↓ on mount/refresh fetch POST            │      │ settings.get("jira-tasks")      │
+│ render: list / error / unconfigured        │      │ credentials.resolve(JIRA_*)     │
+│ localStorage per-workspace key/JQL         │      │ subprocess.spawn(curl …)        │
+│ settings.plugin.item (Settings card)       │      │   ↓ stdout JSON                 │
 └────────────────────────────────────────────┘      │ parse issues → {ok,issues}      │
                                                     └────────────────────────────────┘
 ```
 
-- **Host**: registers a `webServer` route `POST /jira/api/search`; credentials resolved via the `credentials` service (env / `$DSH_HOME/.credentials.yaml`, hot-reloaded); queries run through `subprocess` spawning `curl` directly, with the auth header passed via stdin (`--config -`) so the token never appears in argv.
-- **Client**: a standard `window.__ModuleLoader__.load({ id, factory })` web bundle; registers `conversation.composer.dock` (active sessions) and `conversation.input.dock` (new sessions, flex `order: 99` below the input, aligned width).
+- **Host**: registers the `jira-tasks` settings namespace (`baseUrl`, readable) and a `webServer` route `POST /jira/api/search`; the address comes from the settings document, the token from the `credentials` service (Settings card / env / `$DSH_HOME/.credentials.yaml`, hot-reloaded); queries run through `subprocess` spawning `curl` directly, with the auth header passed via stdin (`--config -`) so the token never appears in argv.
+- **Client**: a standard `window.__ModuleLoader__.load({ id, factory })` web bundle; registers `conversation.composer.dock` (active sessions) and `conversation.input.dock` (new sessions, flex `order: 99` below the input, aligned width), plus `settings.plugin.item` (`key: "jira-tasks"`) for the Settings card — the address is written through `settingsScope` and the token through `remote.credentials`.
 - **Why not the `shell` service**: `shell` wraps commands with `sandbox-exec`, which is broken on some macOS versions (`sandbox_apply: Operation not permitted`); `subprocess` is the raw process seam without this issue.
 - **New-session display**: the DSH shell does not render `composer.dock` during the hero (blank session) phase, so the plugin also registers `input.dock` and de-duplicates by "session has messages".
 
@@ -126,7 +144,7 @@ dsh plugin --profile web remove dsh-jira-tasks
 | Persistence | Lost on restart | Survives restart |
 | Client→Host | `host.call` / `harness.handle` | `webServer` route + `fetch` |
 | Client bundle | Injected per session | `/plugins/dsh-jira-tasks/client.js` |
-| Config / credentials | Same `localStorage` key, same `.credentials.yaml` | Identical |
+| Config / credentials | Env / `.credentials.yaml` only (no Settings card) | Settings card + same `.credentials.yaml` fallback |
 </details>
 
 ## License

package/README.md

@@ -4,7 +4,7 @@
 
 **中文** · [English](README.en.md)
 
-在 DSH 会话**输入框下方**展示当前 JIRA 项目**指派给当前用户**的「开启 / 重新开启」任务列表。JIRA 地址与令牌从凭据读取；项目 Key 与 JQL **按工作区配置**并持久化。
+在 DSH 会话**输入框下方**展示当前 JIRA 项目**指派给当前用户**的「开启 / 重新开启」任务列表。JIRA 地址与令牌在**设置 → 插件 → JIRA** 中配置（`JIRA_BASE_URL` / `JIRA_API_TOKEN` 作为回退）；项目 Key 与 JQL **按工作区配置**并持久化。
 
 ## 功能
 
@@ -14,14 +14,18 @@
 <img width="1972" height="746" alt="image" src="https://github.com/user-attachments/assets/9f543e04-a5ad-4b86-85c8-baa2de26f44e" />
 
 - 👤 默认仅显示当前用户（`assignee = currentUser()`）的「开启 / 重新开启」任务
+- ⚙️ **设置 → 插件 → JIRA** 配置 JIRA 地址与访问令牌（令牌写入凭据存储，不回传前端）
+- 🟢 设置卡片自动探测连接并显示状态灯：绿=可用、红=不可用、灰=未配置；点「测试连接」可用**未保存的草稿值**即时验证
 - ⚙️ 项目 Key 与 JQL 按工作区保存；未配置的工作区显示"未配置"
 - 🔄 打开新会话自动查询，面板内支持一键刷新（⟳）
+- 🧭 点击标题可**收起 / 展开**面板；标题徽标显示查询命中的任务总数（列表最多展示 50 条，按更新时间倒序）
+- 🏷️ 每条任务附状态徽章（按状态分类着色：新建 / 进行中 / 其他）、优先级与类型标签
 - 🔗 任务可点击，在新标签页打开 JIRA 详情
 - 🎨 颜色使用 DSH 主题令牌，浅色 / 深色主题自适应
 
 ## 安装
 
-包已发布到 npm：
+包已发布到公共 npm（`dsh-jira-tasks`）；仓库的发布工作流同时把同一版本发布到 GitHub Packages（作用域包名 `@liu3734/dsh-jira-tasks`）。从 npm 安装（推荐）：
 
 ```bash
 dsh plugin --profile web add dsh-jira-tasks
@@ -29,6 +33,8 @@ dsh plugin --profile web add dsh-jira-tasks
 
 **重启 DSH** 后生效。
 
+> 若改用 GitHub Packages 源：先在 profile 的 `.npmrc` 配置 `@liu3734:registry=https://npm.pkg.github.com/` 及读取令牌，再执行 `dsh plugin --profile web add @liu3734/dsh-jira-tasks`。
+
 <details>
 <summary>手动安装（不使用 npm）</summary>
 
@@ -52,7 +58,22 @@ dsh plugin --profile web add dsh-jira-tasks
 
 ### 1. JIRA 地址与令牌
 
-写入 `$DSH_HOME/.credentials.yaml`（推荐，热加载无需重启），或启动 DSH 前导出环境变量：
+打开 **设置 → 插件 → 插件配置 → JIRA**，填写：
+
+- **JIRA 地址**：如 `http://jira.example.com/`（存入用户设置文档，可在界面回读）
+- **访问令牌 / PAT**：写入凭据存储（`$DSH_HOME/.credentials.yaml`），前端只显示"已配置"，不回传令牌本身
+
+留空并保存会保持已有令牌不变；地址留空并保存则清除设置项，回退到环境变量。认证自动识别：令牌含 `:` 用 Basic，否则用 Bearer（JIRA PAT）。
+
+#### 连接测试
+
+卡片底部有连接状态灯与 **测试连接** 按钮：
+
+- 打开卡片时会**自动探测**一次（请求 JIRA `/rest/api/2/myself`），保存后也会自动重测
+- **绿** = 地址与令牌可用（并显示当前登录用户）；**红** = 不可用（显示 JIRA 返回的原因，如 401 认证失败）；**灰** = 地址或令牌未配置
+- 点 **测试连接** 会用**当前输入框里的内容**（未保存也可）立即测试，方便改完再存
+
+以下环境变量 / 凭据仍作为**回退**（设置页未配置时生效，兼容旧部署），热加载无需重启：
 
 ```yaml
 JIRA_BASE_URL: "http://jira.example.com/"
@@ -61,7 +82,6 @@ JIRA_API_TOKEN: "<PAT 或 user:token>"
 
 - 地址别名：`JIRA_BASE_URL` / `JIRA_URL`
 - 令牌别名：`JIRA_API_TOKEN` / `JIRA_TOKEN`
-- 认证自动识别：令牌含 `:` 用 Basic，否则用 Bearer（JIRA PAT）
 
 ### 2. 项目 Key 与 JQL（按工作区）
 
@@ -88,11 +108,15 @@ dsh plugin --profile web remove dsh-jira-tasks
 <details>
 <summary>面板显示「查询失败」</summary>
 
+面板中的提示位于「查询失败：」之后，与下列文案对应：
+
 | 提示 | 处理 |
 |---|---|
-| 未配置环境变量 JIRA_BASE_URL | 凭据未写入，见上文「配置 1」 |
+| 未设置项目 Key | 面板未配置项目，点标题右侧 ⚙ 填写项目 Key |
+| 未配置 JIRA 地址（设置 → 插件 → JIRA，或环境变量 JIRA_BASE_URL） | 地址未写入，见上文「配置 1」 |
+| 未配置 JIRA 令牌（设置 → 插件 → JIRA，或环境变量 JIRA_API_TOKEN） | 令牌未写入，见上文「配置 1」 |
 | 401 … | 令牌无效或认证方式不对；先 `curl -H "Authorization: Bearer <token>" <base>/rest/api/2/myself` 验证 |
-| 无法解析 JIRA 响应 | 网络 / 代理问题，curl 无输出 |
+| 无法解析 JIRA 响应：… | 网络 / 代理问题，curl 无输出 |
 </details>
 
 <details>
@@ -108,20 +132,21 @@ dsh plugin --profile web remove dsh-jira-tasks
 <summary>点击展开</summary>
 
 ```
-┌─────────── 浏览器（Client） ───────────┐      ┌──────────── Host ──────────────┐
-│ conversation.composer.dock（活跃会话）      │      │ webServer 路由 /jira/api/search │
-│ conversation.input.dock（新会话, order:99）│      │   ↓                            │
-│   ↓ 挂载时/刷新时 fetch POST               │      │ credentials.resolve(JIRA_*)     │
-│ 渲染：任务列表 / 错误 / 未配置               │      │ subprocess.spawn(curl …)        │
-│ localStorage 按工作区存取配置                │      │   ↓ stdout JSON                 │
-└────────────────────────────────────────────┘      │ 解析 issues → 返回 {ok,issues}  │
-                                                    └────────────────────────────────┘
+┌────────────────────────────────────────┐   ┌────────────────────────────────────┐
+│ conversation.composer.dock（活跃会话）  │   │ webServer 路由 /jira/api/search     │
+│ conversation.input.dock（新会话）       │   │ ↓                                   │
+│   面板 hero 布局（flex order:99）       │   │ settings.get("jira-tasks").baseUrl   │
+│   ↓ 挂载 / 刷新时 fetch POST            │   │ credentials.resolve(JIRA_API_TOKEN) │
+│ 渲染：任务列表 / 错误 / 未配置          │   │ subprocess.spawn(curl …)            │
+│ localStorage 按工作区存取项目 Key/JQL   │   │ ↓ stdout JSON                       │
+│ settings.plugin.item（设置页卡片）      │   │ 解析 issues → 返回 {ok,issues}      │
+└────────────────────────────────────────┘   └────────────────────────────────────┘
 ```
 
-- **Host**：注册 `webServer` 路由 `POST /jira/api/search`；凭据经 `credentials` 服务解析（环境变量 / `$DSH_HOME/.credentials.yaml`，热加载）；查询用 `subprocess` 直接 `spawn curl`，认证头经 stdin（`--config -`）传入，令牌不进入命令行参数。
-- **Client**：`window.__ModuleLoader__.load({ id, factory })` 标准 web bundle；注册 `conversation.composer.dock`（活跃会话）与 `conversation.input.dock`（新会话，flex `order: 99` 置于输入框下方、与输入框等宽）。
+- **Host**：注册 `settings` 命名空间 `jira-tasks`（`baseUrl`，可读）与 `webServer` 路由 `POST /jira/api/search`；地址优先读设置文档，令牌经 `credentials` 服务解析（设置页写入 / 环境变量 / `$DSH_HOME/.credentials.yaml`，热加载）；查询用 `subprocess` 直接 `spawn curl`，认证头经 stdin（`--config -`）传入，令牌不进入命令行参数。
+- **Client**：`window.__ModuleLoader__.load({ id, factory })` 标准 web bundle；注册 `conversation.composer.dock`（活跃会话，注册 `order: 5`）与 `conversation.input.dock`（新会话，注册 `order: 10`）。新会话面板走 hero 布局：面板元素自身 `flex order: 99` 排在输入框之后下方，并以 `--dsh-composer-side-clearance` / `--dsh-composer-card-max-width` 与输入卡等宽。另注册 `settings.plugin.item`（`key: "jira-tasks"`）作为设置页卡片：地址经 `settingsScope` 写入命名空间，令牌经 `remote.credentials` 写入凭据存储。
 - **为什么不用 `shell` 服务**：`shell` 会套 `sandbox-exec`，部分 macOS 上不可用（`sandbox_apply: Operation not permitted`）；`subprocess` 是原始进程缝，无此问题。
-- **新会话显示**：DSH 壳在 hero（空白会话）阶段不渲染 `composer.dock`，故额外注册 `input.dock`，并用「会话是否已有消息」去重，避免双份面板。
+- **新会话显示**：DSH 壳在 hero（空白会话）阶段不渲染 `composer.dock`，故额外注册 `input.dock`，并用「会话是否已有消息」去重（新版 DSH 依据 `SessionSnapshot.blank`），避免双份面板。
 
 **与动态插件版的差异**
 
@@ -130,7 +155,7 @@ dsh plugin --profile web remove dsh-jira-tasks
 | 持久性 | 重启丢失 | 重启保留 |
 | Client→Host 通信 | `host.call` / `harness.handle` | `webServer` 路由 + `fetch` |
 | 客户端 bundle | 会话内注入 | `/plugins/dsh-jira-tasks/client.js` |
-| 配置 / 凭据 | 同一 `localStorage` 键、同一 `.credentials.yaml` | 完全相同 |
+| 配置 / 凭据 | 仅环境变量 / `.credentials.yaml`（无设置页卡片） | 设置页卡片 + 同一 `.credentials.yaml` 回退 |
 </details>
 
 ## License

package/lib/client.js

@@ -43,7 +43,16 @@ window.__ModuleLoader__.load({
       + ".jt-btn:hover{background:var(--dsw-alias-interactive-bg-hover, rgba(127,127,127,.1));opacity:1}"
       + ".jt-btn-primary{background:var(--dsw-alias-button-primary-fill, #2f6fed);border-color:transparent;color:var(--dsw-alias-label-primary-foreground, #fff)}"
       + ".jt-btn-primary:hover{background:var(--dsw-alias-button-primary-hover, #3a7bfd)}"
-      + ".jt-linklike{background:none;border:none;padding:0;cursor:pointer;color:var(--dsw-alias-brand-primary, #2f6fed);font-size:12px;text-decoration:underline}";
+      + ".jt-linklike{background:none;border:none;padding:0;cursor:pointer;color:var(--dsw-alias-brand-primary, #2f6fed);font-size:12px;text-decoration:underline}"
+      + ".jt-set-card{box-sizing:border-box;list-style:none;margin:0;border:1px solid var(--dsw-alias-border-l1, rgba(127,127,127,.28));background:var(--dsw-alias-bg-layer-1, rgba(127,127,127,.05));border-radius:10px;padding:10px 12px}"
+      + ".jt-set-head{display:flex;flex-direction:column;gap:2px;margin-bottom:8px}"
+      + ".jt-set-title{font-weight:600;font-size:13px;color:var(--dsw-alias-label-primary, #222)}"
+      + ".jt-set-desc{font-size:12px;color:var(--dsw-alias-label-secondary, #666);line-height:1.6}"
+      + ".jt-probe{display:flex;align-items:center;gap:6px;margin:0 0 8px;font-size:12px;color:var(--dsw-alias-label-secondary, #666);line-height:1.6;word-break:break-word}"
+      + ".jt-dot{flex:none;width:8px;height:8px;border-radius:50%;background:var(--dsw-alias-label-secondary, #999)}"
+      + ".jt-dot-ok{background:var(--dsw-alias-state-success-primary, #1a9d4f)}"
+      + ".jt-dot-fail{background:var(--dsw-alias-state-error-primary, #d93026)}"
+      + ".jt-dot-testing{background:var(--dsw-alias-state-warn-primary, #b76e00)}";
 
     var STORAGE_KEY = "dsh.jiraTasks.config.v1";
 
@@ -103,6 +112,15 @@ window.__ModuleLoader__.load({
       }).then(function (r) { return r.json(); });
     }
 
+    // 探测 JIRA 地址/令牌可用性；可选传入未保存的草稿值。
+    function testConnection(payload) {
+      return fetch("/jira/api/test", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload || {})
+      }).then(function (r) { return r.json(); });
+    }
+
     function JiraTasksDock(props) {
       var blankOnly = !!(props && props.blankOnly === true);
       var useWorkspaces = props && typeof props.useWorkspaces === "function" ? props.useWorkspaces : null;
@@ -264,6 +282,185 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // ---- 设置页卡片：设置 → 插件 → JIRA ----
+    // 地址存 settings 命名空间（可读）；令牌写 credentials（永不随响应回传）。
+    var SETTINGS_NS = "jira-tasks";
+    var TOKEN_REF = "JIRA_API_TOKEN";
+    var TOKEN_REFS = ["JIRA_API_TOKEN", "JIRA_TOKEN"];
+
+    function useScopeSnapshot(scope) {
+      var state = React.useState(function () { return scope.getSnapshot(); });
+      var snapshot = state[0], setSnapshot = state[1];
+      React.useEffect(function () {
+        var update = function () { setSnapshot(scope.getSnapshot()); };
+        var off = scope.subscribe(update);
+        update();
+        return off;
+      }, []);
+      return snapshot;
+    }
+
+    function createJiraSettingsCard(scope, credentials) {
+      function readTokenInfo() {
+        return credentials.describe(TOKEN_REFS).then(function (res) {
+          if (!res || !res.ok || !res.value) return { configured: false, writable: false };
+          for (var i = 0; i < TOKEN_REFS.length; i++) {
+            var info = res.value[TOKEN_REFS[i]];
+            if (info && info.configured) return { configured: true, writable: info.writable !== false };
+          }
+          var primary = res.value[TOKEN_REF];
+          return { configured: false, writable: primary ? primary.writable !== false : true };
+        }).catch(function () {
+          return { configured: false, writable: false };
+        });
+      }
+
+      return function JiraSettingsCard() {
+        var snapshot = useScopeSnapshot(scope);
+        var tokenInfoState = React.useState(null);
+        var tokenInfo = tokenInfoState[0], setTokenInfo = tokenInfoState[1];
+        var baseEditState = React.useState(undefined);
+        var baseEdit = baseEditState[0], setBaseEdit = baseEditState[1];
+        var tokenDraftState = React.useState("");
+        var tokenDraft = tokenDraftState[0], setTokenDraft = tokenDraftState[1];
+        var busyState = React.useState(false);
+        var busy = busyState[0], setBusy = busyState[1];
+        var failedState = React.useState("");
+        var failed = failedState[0], setFailed = failedState[1];
+        var probeState = React.useState({ phase: "idle" });
+        var probe = probeState[0], setProbe = probeState[1];
+        var probeGen = React.useRef(0);
+
+        React.useEffect(function () {
+          var alive = true;
+          readTokenInfo().then(function (info) { if (alive) setTokenInfo(info); });
+          return function () { alive = false; };
+        }, []);
+
+        // 自动测试：命名空间就绪后、以及已保存配置变更（含保存后）时各探测一次。
+        React.useEffect(function () {
+          if (snapshot.status !== "ready") return;
+          runProbe({});
+        }, [snapshot.status, snapshot.revision]);
+
+        var storedBase = snapshot.value && typeof snapshot.value.baseUrl === "string" ? snapshot.value.baseUrl : "";
+        var baseValue = baseEdit === undefined ? storedBase : baseEdit;
+        var dirty = (baseEdit !== undefined && baseEdit !== storedBase) || (tokenDraft || "").length > 0;
+        var writable = snapshot.writable !== false;
+
+        // 命名空间未挂载时不显示，避免留下一张无法操作的卡片。
+        if (snapshot.status === "unavailable") return null;
+
+        function save() {
+          if (busy || !dirty) return;
+          setBusy(true);
+          setFailed("");
+          var tasks = [];
+          if (baseEdit !== undefined && baseEdit !== storedBase) {
+            tasks.push(baseEdit === "" ? scope.unset("baseUrl") : scope.set("baseUrl", baseEdit));
+          }
+          var token = (tokenDraft || "").trim();
+          if (token) {
+            tasks.push(credentials.set(TOKEN_REF, token).then(function (res) {
+              if (res && res.ok === false) {
+                var err = res.error;
+                throw new Error((err && (err.message || err.code)) || "令牌保存失败");
+              }
+            }));
+          }
+          Promise.all(tasks).then(function () {
+            return readTokenInfo();
+          }).then(function (info) {
+            setTokenInfo(info);
+            setBaseEdit(undefined);
+            setTokenDraft("");
+            setBusy(false);
+          }).catch(function (err) {
+            setBusy(false);
+            setFailed(String((err && err.message) || err));
+          });
+        }
+
+        function discard() {
+          setBaseEdit(undefined);
+          setTokenDraft("");
+          setFailed("");
+        }
+
+        // 探测连接：payload 传入即测草稿，传空对象则测已保存/环境配置。
+        function runProbe(payload) {
+          var gen = ++probeGen.current;
+          setProbe({ phase: "testing", message: "正在测试连接…" });
+          testConnection(payload).then(function (res) {
+            if (gen !== probeGen.current) return;
+            if (res && res.ok) setProbe({ phase: "ok", message: "可用" + (res.user ? "：" + res.user : "") });
+            else if (res && res.code === "unconfigured") setProbe({ phase: "idle", message: "未配置地址或令牌" });
+            else setProbe({ phase: "fail", message: (res && res.error) || "不可用" });
+          }).catch(function (err) {
+            if (gen !== probeGen.current) return;
+            setProbe({ phase: "fail", message: String((err && err.message) || err) });
+          });
+        }
+
+        var tokenHint = tokenInfo === null
+          ? "正在读取令牌状态…"
+          : (tokenInfo.configured ? "令牌已配置；留空并保存可保持不变。" : "令牌未配置。含 “:” 时用 Basic，否则用 Bearer。");
+        var dotClass = probe.phase === "ok" ? "jt-dot jt-dot-ok"
+          : probe.phase === "fail" ? "jt-dot jt-dot-fail"
+            : probe.phase === "testing" ? "jt-dot jt-dot-testing" : "jt-dot";
+
+        return h("li", { className: "jt-set-card" },
+          h("div", { className: "jt-set-head" },
+            h("span", { className: "jt-set-title" }, "JIRA"),
+            h("span", { className: "jt-set-desc" }, "JIRA 地址与访问令牌。项目 Key / JQL 仍按工作区在会话面板的 ⚙ 中配置。")
+          ),
+          h("div", { className: "jt-field" },
+            h("label", { htmlFor: "jira-tasks-base-url" }, "JIRA 地址"),
+            h("input", {
+              id: "jira-tasks-base-url",
+              className: "jt-input",
+              value: baseValue,
+              placeholder: "http://jira.example.com/",
+              disabled: !writable || busy,
+              onChange: function (e) { setBaseEdit(e.target.value); },
+              onKeyDown: function (e) { if (e.key === "Enter") save(); }
+            })
+          ),
+          h("div", { className: "jt-field" },
+            h("label", { htmlFor: "jira-tasks-token" }, "访问令牌 / PAT"),
+            h("input", {
+              id: "jira-tasks-token",
+              className: "jt-input",
+              type: "password",
+              value: tokenDraft,
+              placeholder: tokenInfo && tokenInfo.configured ? "已配置，留空保持不变" : "粘贴令牌",
+              autoComplete: "off",
+              disabled: !writable || busy,
+              onChange: function (e) { setTokenDraft(e.target.value); },
+              onKeyDown: function (e) { if (e.key === "Enter") save(); }
+            })
+          ),
+          h("div", { className: "jt-hint", style: { marginBottom: "8px" } }, tokenHint),
+          h("div", { className: "jt-probe", role: "status" },
+            h("span", { className: dotClass, "aria-hidden": "true" }),
+            h("span", null, probe.message || "未测试")
+          ),
+          failed ? h("div", { className: "jt-error", style: { marginBottom: "8px" } }, "保存失败：" + failed) : null,
+          h("div", { className: "jt-buttons" },
+            h("button", {
+              className: "jt-btn",
+              style: { marginRight: "auto" },
+              disabled: busy || probe.phase === "testing",
+              title: "用当前填写的内容测试 JIRA 地址与令牌",
+              onClick: function () { runProbe({ baseUrl: baseValue, token: (tokenDraft || "").trim() }); }
+            }, probe.phase === "testing" ? "测试中…" : "测试连接"),
+            h("button", { className: "jt-btn", disabled: !dirty || busy, onClick: discard }, "放弃"),
+            h("button", { className: "jt-btn jt-btn-primary", disabled: !dirty || busy || !writable, onClick: save }, busy ? "保存中…" : "保存")
+          )
+        );
+      };
+    }
+
     function apply(ctx) {
       // ctx.effect(cb) 会立即执行 cb 并把其返回值作为卸载时的清理函数，
       // 所以样式注入必须放在回调内、返回移除函数，否则标签刚插入就被删除。
@@ -289,9 +486,19 @@ window.__ModuleLoader__.load({
           return h(JiraTasksDock, Object.assign({}, props, { blankOnly: true }));
         });
       });
+
+      // 设置页卡片：宿主注册了 jira-tasks 命名空间时，由插件配置 Tab 分发到本卡片。
+      var settingsScope = ctx.get("settingsScope");
+      var remote = ctx.get("remote");
+      if (settingsScope && remote && remote.credentials) {
+        var card = createJiraSettingsCard(settingsScope.bind({ namespace: SETTINGS_NS }), remote.credentials);
+        slots.inject("settings.plugin.item", function () {
+          return slots.register({ name: "settings.plugin.item", key: SETTINGS_NS }, card);
+        });
+      }
     }
 
-    exports.inject = ["slots"];
+    exports.inject = ["slots", "settingsScope", "remote", "remote.credentials"];
     exports.apply = apply;
     return module.exports;
   }

package/lib/index.js

@@ -1,9 +1,25 @@
 /**
  * dsh-jira-tasks — HOST half (persistent profile plugin).
- * Serves POST /jira/api/search: reads JIRA_BASE_URL / JIRA_API_TOKEN via the
- * credentials service, queries JIRA /rest/api/2/search through subprocess+curl
- * (auth header via stdin --config -), returns normalized issue JSON.
+ * Serves POST /jira/api/search: reads the JIRA base URL from the `jira-tasks`
+ * settings namespace and the token from the credentials service (falling back
+ * to JIRA_BASE_URL / JIRA_API_TOKEN for existing setups), queries JIRA
+ * /rest/api/2/search through subprocess+curl (auth header via stdin
+ * --config -), returns normalized issue JSON.
  */
+import z from '@deepseek-ai/schemastery';
+
+/** Settings namespace exposing the editable connection fields in the GUI. */
+const SETTINGS_NS = 'jira-tasks';
+
+/**
+ * Durable connection schema. `baseUrl` is a plain readable field; the token is
+ * deliberately NOT stored here — it stays in the credentials store (write-only
+ * from the client) so no secret ever lands in settings.yaml.
+ */
+const JiraSettingsSchema = z.object({
+  baseUrl: z.string().default('').description('JIRA 地址，例如 http://jira.example.com/')
+});
+
 export default {
   inject: ['subprocess', 'credentials', 'sandboxPolicy', 'webServer'],
   apply(ctx) {
@@ -39,6 +55,24 @@ export default {
       return undefined;
     }
 
+    // Register the GUI-editable section when the optional settings service is
+    // composed; without it the plugin keeps working from the composition/env.
+    ctx.inject(['settings'], (settingsCtx) => {
+      settingsCtx.settings.register(SETTINGS_NS, JiraSettingsSchema);
+    });
+
+    /** Base URL from the settings document, or '' when unset/unavailable. */
+    function settingsBaseUrl() {
+      try {
+        const settings = ctx.get('settings');
+        if (!settings) return '';
+        const section = settings.get(SETTINGS_NS);
+        return section && typeof section.baseUrl === 'string' ? section.baseUrl.trim() : '';
+      } catch (e) {
+        return '';
+      }
+    }
+
     function buildAuthHeader(token) {
       if (token.indexOf(':') !== -1) return 'Basic ' + Buffer.from(token, 'utf-8').toString('base64');
       return 'Bearer ' + token;
@@ -83,14 +117,57 @@ export default {
       return { exitCode: outcome.exitCode, stdout, stderr };
     }
 
+    // 从 JIRA 错误响应体/curl stderr 中提取可读信息。
+    function errorTextFrom(body, stderr, fallback) {
+      let message = (stderr || '').trim() || fallback;
+      try {
+        const parsed = JSON.parse(body);
+        if (parsed.errorMessages && parsed.errorMessages.length) message = parsed.errorMessages.join('；');
+        else if (parsed.message) message = parsed.message;
+      } catch (e) { /* body 非 JSON */ }
+      return message;
+    }
+
+    // 连通性/鉴权探测：GET /rest/api/2/myself，stdout 末尾追加 HTTP 状态码。
+    async function probeJira(baseUrl, token) {
+      const auth = buildAuthHeader(token);
+      const cleanBase = baseUrl.replace(/\/+$/, '');
+      let curl;
+      try {
+        curl = await subprocess.resolveExecutable('curl');
+      } catch (e) {
+        curl = '/usr/bin/curl';
+      }
+      const handle = subprocess.spawn({
+        argv: [
+          curl, '-sS', '--max-time', '15',
+          '-H', 'Accept: application/json',
+          '--config', '-',
+          '-w', '\n%{http_code}',
+          cleanBase + '/rest/api/2/myself'
+        ],
+        cwd: workspaceRoot,
+        stdio: {
+          stdin: { data: 'header = "Authorization: ' + auth + '"\n' },
+          stdout: { maxBytes: 1024 * 1024, spill: { maxBytes: 4 * 1024 * 1024 } },
+          stderr: { maxBytes: 256 * 1024, spill: { maxBytes: 1024 * 1024 } }
+        },
+        graceMs: 5000
+      });
+      const outcome = await handle.done;
+      const stdout = (handle.collected.stdout ? handle.collected.stdout.readFrom(0).text : '') || '';
+      const stderr = (handle.collected.stderr ? handle.collected.stderr.readFrom(0).text : '') || '';
+      return { exitCode: outcome.exitCode, stdout, stderr };
+    }
+
     async function handleSearch(args) {
       const projectKey = String((args && args.projectKey) || '').trim();
       if (!projectKey) return { ok: false, error: '未设置项目 Key' };
       try {
-        const baseUrl = await resolveFirst(['JIRA_BASE_URL', 'JIRA_URL']);
-        if (!baseUrl) return { ok: false, error: '未配置环境变量 JIRA_BASE_URL（或 JIRA_URL）' };
+        const baseUrl = settingsBaseUrl() || await resolveFirst(['JIRA_BASE_URL', 'JIRA_URL']);
+        if (!baseUrl) return { ok: false, error: '未配置 JIRA 地址（设置 → 插件 → JIRA，或环境变量 JIRA_BASE_URL）' };
         const token = await resolveFirst(['JIRA_API_TOKEN', 'JIRA_TOKEN']);
-        if (!token) return { ok: false, error: '未配置环境变量 JIRA_API_TOKEN（或 JIRA_TOKEN）' };
+        if (!token) return { ok: false, error: '未配置 JIRA 令牌（设置 → 插件 → JIRA，或环境变量 JIRA_API_TOKEN）' };
 
         const jql = buildJql(args && args.jql ? String(args.jql) : '', projectKey);
         const raw = await queryJira(baseUrl, token, jql);
@@ -98,13 +175,7 @@ export default {
         const stderr = raw.stderr;
 
         if (raw.exitCode !== 0) {
-          let message = stderr.trim() || ('curl 退出码 ' + String(raw.exitCode));
-          try {
-            const parsed = JSON.parse(stdout);
-            if (parsed.errorMessages && parsed.errorMessages.length) message = parsed.errorMessages.join('；');
-            else if (parsed.message) message = parsed.message;
-          } catch (e) { /* stdout 非 JSON */ }
-          return { ok: false, error: message };
+          return { ok: false, error: errorTextFrom(stdout, stderr, 'curl 退出码 ' + String(raw.exitCode)) };
         }
 
         let data;
@@ -135,6 +206,43 @@ export default {
       }
     }
 
+    // 设置卡片“测试连接”：用草稿值（未保存也可测）或已保存/环境配置探测 JIRA。
+    async function handleTest(args) {
+      try {
+        const draftBase = args && typeof args.baseUrl === 'string' ? args.baseUrl.trim() : '';
+        const draftToken = args && typeof args.token === 'string' ? args.token.trim() : '';
+        const baseUrl = draftBase || settingsBaseUrl() || await resolveFirst(['JIRA_BASE_URL', 'JIRA_URL']);
+        if (!baseUrl) return { ok: false, code: 'unconfigured', error: '未配置 JIRA 地址' };
+        const token = draftToken || await resolveFirst(['JIRA_API_TOKEN', 'JIRA_TOKEN']);
+        if (!token) return { ok: false, code: 'unconfigured', error: '未配置 JIRA 令牌' };
+
+        const raw = await probeJira(baseUrl, token);
+        if (raw.exitCode !== 0) {
+          return { ok: false, code: 'network', error: (raw.stderr || '').trim() || ('curl 退出码 ' + String(raw.exitCode)) };
+        }
+        const nl = raw.stdout.lastIndexOf('\n');
+        const body = nl === -1 ? raw.stdout : raw.stdout.slice(0, nl);
+        const httpCode = Number((nl === -1 ? '' : raw.stdout.slice(nl + 1)).trim()) || 0;
+
+        if (httpCode >= 200 && httpCode < 300) {
+          let data = {};
+          try { data = JSON.parse(body); } catch (e) { /* 空/非 JSON 也视为连通 */ }
+          return {
+            ok: true,
+            baseUrl: baseUrl.replace(/\/+$/, ''),
+            user: data.displayName || data.name || data.key || ''
+          };
+        }
+        return {
+          ok: false,
+          code: httpCode === 401 || httpCode === 403 ? 'auth' : 'http',
+          error: errorTextFrom(body, raw.stderr, 'HTTP ' + String(httpCode))
+        };
+      } catch (err) {
+        return { ok: false, code: 'error', error: String((err && err.message) || err) };
+      }
+    }
+
     if (webServer && typeof webServer.register === 'function') {
       webServer.register({
         kind: 'exact',
@@ -147,6 +255,17 @@ export default {
           }
         }
       });
+      webServer.register({
+        kind: 'exact',
+        path: '/jira/api/test',
+        handler: async (req, res) => {
+          try {
+            sendJson(res, await handleTest(await readBody(req)));
+          } catch (e) {
+            sendJson(res, { ok: false, code: 'error', error: String((e && e.message) || e) });
+          }
+        }
+      });
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-jira-tasks",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "JIRA open tasks panel for DeepSeek Harness (DSH): shows the current user's open/reopened issues below the composer, per-workspace project key, persistent profile bundle.",
   "type": "module",
   "main": "lib/index.js",
@@ -9,6 +9,9 @@
     "./client": "./lib/client.js",
     "./package.json": "./package.json"
   },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
   "files": [
     "lib",
     "cordis.patch.yml",
@@ -36,7 +39,9 @@
     "client": {
       "platform": "web",
       "inject": [
-        "@deepseek-ai/dsh-client-ui-conversation"
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-api-remotes"
       ]
     }
   }