dsh-model-health 0.1.3 → 0.2.0

package/dist/client.js

@@ -7,6 +7,9 @@
 // 模型列表 JSON，然后用 React 直接渲染表格。
 // 支持"测试全部"：并发 POST /api/model-health/test，逐个更新测试状态。
 //
+// 多语言：通过官方 locale 服务注册 zh/en 词典（与 dsh-plugin-mgr 同模式），
+// 语言跟随 harness 设置（设置 → 通用 → 语言），切换语言即时生效。
+//
 window.__ModuleLoader__.load({
     id: "dsh-model-health",
     factory: (require) => {
@@ -16,6 +19,65 @@ window.__ModuleLoader__.load({
         const React = require("react");
         const { useState, useEffect, useCallback } = React;
 
+        // ── 多语言词典（locale 服务，语言跟随 harness）─────────────────────────
+        const NS = "dsh-model-health";
+        const zh = {
+            tab: "模型健康",
+            title: "已配置模型",
+            updatedAt: "更新时间：",
+            testAll: "测试全部",
+            testingBtn: "测试中...",
+            showCols: "显示列：",
+            loading: "加载中...",
+            loadError: "读取模型列表失败：",
+            retry: "重试",
+            unknownError: "未知错误",
+            empty: "未配置任何模型，请在 设置 → 模型 中添加。",
+            colProvider: "Provider",
+            colModelId: "模型 ID",
+            colName: "名称",
+            colContextWindow: "上下文窗口",
+            colMaxTokens: "最大输出",
+            colInput: "输入模态",
+            colApi: "API 协议",
+            colBaseURL: "BaseURL",
+            colStatus: "状态",
+            colLatency: "延迟",
+            statusIdle: "未测试",
+            statusTesting: "测试中",
+            statusOk: "可用",
+            statusFail: "不可用",
+            statusSkip: "跳过",
+        };
+        const en = {
+            tab: "Model Health",
+            title: "Configured Models",
+            updatedAt: "Updated: ",
+            testAll: "Test All",
+            testingBtn: "Testing...",
+            showCols: "Columns: ",
+            loading: "Loading...",
+            loadError: "Failed to load model list: ",
+            retry: "Retry",
+            unknownError: "Unknown error",
+            empty: "No models configured. Add one in Settings → Models.",
+            colProvider: "Provider",
+            colModelId: "Model ID",
+            colName: "Name",
+            colContextWindow: "Context Window",
+            colMaxTokens: "Max Output",
+            colInput: "Modalities",
+            colApi: "API Protocol",
+            colBaseURL: "BaseURL",
+            colStatus: "Status",
+            colLatency: "Latency",
+            statusIdle: "Untested",
+            statusTesting: "Testing",
+            statusOk: "Available",
+            statusFail: "Unavailable",
+            statusSkip: "Skipped",
+        };
+
         // 内联样式（适配 DSH 明暗主题的 CSS 变量）
         const STYLES = {
             wrap: {
@@ -181,27 +243,27 @@ window.__ModuleLoader__.load({
             },
         };
 
-        // 列定义：optional=true 的列默认不显示，由多选框控制
+        // 列定义：optional=true 的列默认不显示，由多选框控制；label 为词典 key
         const COLUMNS = [
-            { key: "provider", label: "Provider" },
-            { key: "modelId", label: "模型 ID", code: true, optional: true },
-            { key: "modelName", label: "名称" },
-            { key: "contextWindow", label: "上下文窗口", optional: true },
-            { key: "maxTokens", label: "最大输出", optional: true },
-            { key: "input", label: "输入模态", optional: true },
-            { key: "api", label: "API 协议", optional: true },
-            { key: "baseURL", label: "BaseURL", code: true, optional: true },
-            { key: "_status", label: "状态" },
-            { key: "_latency", label: "延迟" },
+            { key: "provider", label: "colProvider" },
+            { key: "modelId", label: "colModelId", code: true, optional: true },
+            { key: "modelName", label: "colName" },
+            { key: "contextWindow", label: "colContextWindow", optional: true },
+            { key: "maxTokens", label: "colMaxTokens", optional: true },
+            { key: "input", label: "colInput", optional: true },
+            { key: "api", label: "colApi", optional: true },
+            { key: "baseURL", label: "colBaseURL", code: true, optional: true },
+            { key: "_status", label: "colStatus" },
+            { key: "_latency", label: "colLatency" },
         ];
 
-        // 状态标签映射
+        // 状态标签映射（值为词典 key）
         const STATUS_LABEL = {
-            idle: "未测试",
-            testing: "测试中",
-            ok: "可用",
-            fail: "不可用",
-            skip: "跳过",
+            idle: "statusIdle",
+            testing: "statusTesting",
+            ok: "statusOk",
+            fail: "statusFail",
+            skip: "statusSkip",
         };
         const STATUS_STYLE = {
             idle: STYLES.badgeIdle,
@@ -215,6 +277,8 @@ window.__ModuleLoader__.load({
          * 模型列表 section 组件。
          * fetch /api/model-health/json 获取数据 → React 渲染表格。
          * "测试全部" → 并发 POST /api/model-health/test，逐个更新状态。
+         * props: { t, locale } — t 为绑定了词典命名空间的翻译函数，
+         * locale 用于订阅语言变化触发重渲染。
          */
         // localStorage 持久化测试结果的 key
         const STORAGE_KEY = "dsh-model-health:test-results";
@@ -222,7 +286,17 @@ window.__ModuleLoader__.load({
         function loadStoredResults() {
             try {
                 const raw = localStorage.getItem(STORAGE_KEY);
-                return raw ? JSON.parse(raw) : {};
+                const parsed = raw ? JSON.parse(raw) : {};
+                const cleaned = {};
+                // 清理：残留的 testing（测试中刷新页面）归一为 idle；
+                // 旧版按数组下标存的纯数字 key 直接丢弃
+                for (const k in parsed) {
+                    if (/^\d+$/.test(k)) continue;
+                    const v = parsed[k];
+                    if (!v || typeof v !== "object") continue;
+                    cleaned[k] = v.status === "testing" ? { status: "idle" } : v;
+                }
+                return cleaned;
             } catch (e) {
                 return {};
             }
@@ -236,13 +310,14 @@ window.__ModuleLoader__.load({
             }
         }
 
-        function ModelListSection() {
+        function ModelListSection({ t, locale }) {
             const [state, setState] = useState({
                 loading: true,
                 error: null,
                 data: null,
             });
-            // testResults: { [index]: { status, latency?, error? } }
+            // testResults: { [modelKey]: { status, latency?, error? } }
+            // key 为 provider/modelId（与 host 侧一致），settings 增删/排序不错位；
             // 初始值从 localStorage 读取，实现跨刷新持久化
             const [testResults, setTestResults] = useState(loadStoredResults);
             const [testing, setTesting] = useState(false);
@@ -251,6 +326,13 @@ window.__ModuleLoader__.load({
             const [optionalCols, setOptionalCols] = useState({});
             // hover tooltip 状态：{ index, error } | null
             const [tooltip, setTooltip] = useState(null);
+            // 语言切换时强制重渲染（t 每次调用读取当前激活词典）
+            const [localeTick, setLocaleTick] = useState(0);
+
+            useEffect(() => {
+                if (!locale || typeof locale.subscribe !== "function") return;
+                return locale.subscribe(() => setLocaleTick((n) => n + 1));
+            }, [locale]);
 
             const loadData = useCallback(async () => {
                 setState((s) => ({ ...s, loading: true, error: null }));
@@ -258,7 +340,7 @@ window.__ModuleLoader__.load({
                     const resp = await fetch("/api/model-health/json", { cache: "no-store" });
                     if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
                     const json = await resp.json();
-                    if (!json.ok) throw new Error(json.error || "未知错误");
+                    if (!json.ok) throw new Error(json.error || t("unknownError"));
                     setState({ loading: false, error: null, data: json });
                     // 不清空 testResults，保留上次测试结果
                 } catch (e) {
@@ -277,47 +359,46 @@ window.__ModuleLoader__.load({
                 const total = data.models.length;
                 setTesting(true);
                 setProgress({ done: 0, total });
-                // 初始化所有为 testing
+                // 初始化所有为 testing（按 provider/modelId key）
                 const init = {};
-                for (let i = 0; i < total; i++) init[i] = { status: "testing" };
+                for (const m of data.models) init[m.key] = { status: "testing" };
                 setTestResults(init);
                 saveStoredResults(init);
 
                 let done = 0;
                 // 并发测试，但限制并发数避免压垮 host/网络
                 const CONCURRENCY = 6;
-                const indices = Array.from({ length: total }, (_, i) => i);
-                const queue = [...indices];
+                const queue = data.models.map((m) => m.key);
 
                 // 更新单个结果并同步到 localStorage
-                function updateResult(idx, result) {
+                function updateResult(key, result) {
                     setTestResults((s) => {
-                        const next = { ...s, [idx]: result };
+                        const next = { ...s, [key]: result };
                         saveStoredResults(next);
                         return next;
                     });
                 }
 
-                async function runOne(idx) {
+                async function runOne(key) {
                     try {
                         const resp = await fetch("/api/model-health/test", {
                             method: "POST",
                             headers: { "Content-Type": "application/json" },
-                            body: JSON.stringify({ index: idx }),
+                            body: JSON.stringify({ key }),
                             cache: "no-store",
                         });
                         const json = await resp.json();
                         if (!json.ok) {
-                            updateResult(idx, { status: "fail", error: json.error });
+                            updateResult(key, { status: "fail", error: json.error });
                         } else {
-                            updateResult(idx, {
+                            updateResult(key, {
                                 status: json.status || "fail",
                                 latency: json.latency,
                                 error: json.error,
                             });
                         }
                     } catch (e) {
-                        updateResult(idx, { status: "fail", error: e.message });
+                        updateResult(key, { status: "fail", error: e.message });
                     } finally {
                         done++;
                         setProgress({ done, total });
@@ -328,9 +409,9 @@ window.__ModuleLoader__.load({
                 // 限制并发的 worker pool
                 async function worker() {
                     while (queue.length > 0) {
-                        const idx = queue.shift();
-                        if (idx === undefined) break;
-                        await runOne(idx);
+                        const key = queue.shift();
+                        if (key === undefined) break;
+                        await runOne(key);
                     }
                 }
                 const workers = Array.from(
@@ -344,25 +425,32 @@ window.__ModuleLoader__.load({
 
             if (state.loading) {
                 return h("div", { style: STYLES.wrap },
-                    h("div", { style: STYLES.loading }, "加载中...")
+                    h("div", { style: STYLES.loading }, t("loading"))
                 );
             }
 
             if (state.error) {
                 return h("div", { style: STYLES.wrap },
                     h("div", { style: STYLES.error },
-                        "读取模型列表失败：", state.error
+                        t("loadError"), state.error
                     ),
                     h("button", {
                         style: STYLES.btn,
                         onClick: loadData,
-                    }, "重试")
+                    }, t("retry"))
                 );
             }
 
             const data = state.data || { models: [], count: 0, source: "", updatedAt: "" };
             const models = data.models || [];
-            const updatedAt = new Date(data.updatedAt || Date.now()).toLocaleString("zh-CN");
+            // 日期格式跟随当前语言（zh → zh-CN，en → en-US）
+            const activeLang =
+                locale && typeof locale.getLocale === "function"
+                    ? locale.getLocale().active
+                    : "zh";
+            const updatedAt = new Date(data.updatedAt || Date.now()).toLocaleString(
+                activeLang === "en" ? "en-US" : "zh-CN"
+            );
 
             // 统计测试结果
             const stats = { ok: 0, fail: 0, skip: 0, testing: 0 };
@@ -386,12 +474,12 @@ window.__ModuleLoader__.load({
 
             return h("div", { style: STYLES.wrap },
                 h("div", { style: STYLES.head },
-                    h("h2", { style: STYLES.title }, "已配置模型"),
+                    h("h2", { style: STYLES.title }, t("title")),
                     h("span", { style: STYLES.count }, data.count || models.length)
                 ),
                 h("div", { style: STYLES.toolbar },
                     h("span", { style: STYLES.meta },
-                        "更新时间：", updatedAt
+                        t("updatedAt"), updatedAt
                     ),
                     // 测试统计
                     (stats.ok + stats.fail + stats.skip > 0) && h("span", { style: STYLES.progress },
@@ -410,12 +498,12 @@ window.__ModuleLoader__.load({
                         },
                         disabled: testing || models.length === 0,
                         onClick: testAll,
-                    }, testing ? "测试中..." : "测试全部")
+                    }, testing ? t("testingBtn") : t("testAll"))
                 ),
                 // 可选列 toggle 按钮组
                 h("div", { style: { display: "flex", alignItems: "center", gap: 8, flexWrap: "wrap" } },
                     h("span", { style: { fontSize: 12, color: "var(--dsw-alias-label-tertiary, #888)" } },
-                        "显示列："
+                        t("showCols")
                     ),
                     optionalColumns.map((col) => {
                         const active = !!optionalCols[col.key];
@@ -439,12 +527,12 @@ window.__ModuleLoader__.load({
                                     ? "var(--dsw-alias-label-primary-foreground, #fff)"
                                     : "var(--dsw-alias-label-secondary, #555)",
                             },
-                        }, col.label);
+                        }, t(col.label));
                     })
                 ),
                 models.length === 0
                     ? h("div", { style: STYLES.center },
-                        "未配置任何模型，请在 设置 → 模型 中添加。"
+                        t("empty")
                     )
                     : h("div", { style: STYLES.tableWrap },
                         h("table", { style: STYLES.table },
@@ -454,7 +542,7 @@ window.__ModuleLoader__.load({
                                     h("th", {
                                         key: col.key,
                                         style: STYLES.th,
-                                    }, col.label)
+                                    }, t(col.label))
                                 )
                             )
                         ),
@@ -471,8 +559,9 @@ window.__ModuleLoader__.load({
                                     providerSpan[start] = k - start;
                                 }
                                 return models.map((row, i) => {
-                                    const tr = testResults[i] || { status: "idle" };
-                                    const statusLabel = STATUS_LABEL[tr.status] || tr.status;
+                                    const tr = testResults[row.key] || { status: "idle" };
+                                    const labelKey = STATUS_LABEL[tr.status];
+                                    const statusLabel = labelKey ? t(labelKey) : tr.status;
                                     const statusStyle = STATUS_STYLE[tr.status] || STYLES.badgeIdle;
                                     const latencyText = tr.latency != null ? `${tr.latency}ms` : "-";
                                     return h("tr", { key: (row.modelId || "") + i },
@@ -566,22 +655,28 @@ window.__ModuleLoader__.load({
             );
         }
 
-        // client 侧依赖：slots（注册 UI slot 的服务）
-        const inject = ["slots"];
+        // client 侧依赖：slots（注册 UI slot 的服务）+ locale（多语言词典）
+        const inject = ["slots", "locale"];
 
         /**
          * @param {import('@deepseek-ai/dsh-client-runtime/client').ClientContext} ctx
          */
         function apply(ctx) {
+            // 注册 zh/en 词典；t 每次调用读取当前激活语言
+            ctx.effect(() => ctx.locale.register(NS, { zh, en }), "dsh-model-health: dictionaries");
+            const t = ctx.locale.bind(NS);
+            const h = React.createElement;
+
             ctx.slots.inject("settings.section", () =>
                 ctx.slots.register(
                     {
                         name: "settings.section",
                         id: "model-health",
                         order: 50,
-                        label: "模型健康",
+                        label: () => t("tab"),
+                        locale: NS,
                     },
-                    ModelListSection
+                    () => h(ModelListSection, { t, locale: ctx.locale })
                 )
             );
         }

package/dist/index.js

@@ -1,5 +1,5 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
-import { readFileSync } from 'node:fs';
+import { readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { load as parseYaml } from 'js-yaml';
@@ -32,6 +32,23 @@ function readSettings() {
     const cfg = parseYaml(raw);
     return cfg && typeof cfg === 'object' ? cfg : {};
 }
+/** 按 mtime 缓存解析结果：并发测试时同一份 settings 只解析一次，文件变了自动失效。 */
+let settingsCache = null;
+function readSettingsCached() {
+    const settingsPath = join(dshHome(), 'settings.yaml');
+    try {
+        const mtimeMs = statSync(settingsPath).mtimeMs;
+        if (settingsCache && settingsCache.mtimeMs === mtimeMs)
+            return settingsCache.cfg;
+        const cfg = readSettings();
+        settingsCache = { mtimeMs, cfg };
+        return cfg;
+    }
+    catch {
+        settingsCache = null;
+        return readSettings();
+    }
+}
 /** 从 settings 配置对象中收集所有已配置的模型。 */
 export function collectModels(cfg) {
     const rows = [];
@@ -45,6 +62,7 @@ export function collectModels(cfg) {
             const models = Array.isArray(p.models) ? p.models : [];
             for (const m of models) {
                 rows.push({
+                    key: `${route}/${m.id || ''}`,
                     provider: route,
                     displayName: p.displayName || route,
                     modelId: m.id || '',
@@ -66,6 +84,7 @@ export function collectModels(cfg) {
         const models = Array.isArray(ds.models) ? ds.models : [];
         for (const m of models) {
             rows.push({
+                key: `deepseek/${m.id || ''}`,
                 provider: 'deepseek',
                 displayName: 'DeepSeek',
                 modelId: m.id || '',
@@ -106,6 +125,32 @@ function renderMarkdownTable(rows) {
         `_来源：${join(dshHome(), 'settings.yaml')}_`,
     ].join('\n');
 }
+/** 统一 JSON 响应：设状态码 + Content-Type + 序列化输出。 */
+function sendJson(res, code, obj) {
+    res.statusCode = code;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(JSON.stringify(obj));
+}
+/** 读 JSON body（限 64KB），且必须是 application/json（兼作 CSRF 门卫）。 */
+async function readJsonBody(req) {
+    const ct = String(req.headers['content-type'] ?? '');
+    if (!ct.includes('application/json')) {
+        throw new Error('Content-Type 必须是 application/json');
+    }
+    let body = '';
+    for await (const chunk of req) {
+        body += chunk;
+        if (body.length > 65536)
+            throw new Error('请求体过大');
+    }
+    if (body === '')
+        return {};
+    const parsed = JSON.parse(body);
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('请求体必须是 JSON 对象');
+    }
+    return parsed;
+}
 export function apply(ctx) {
     // ── 1. Tool 插件（对话中调用，返回 Markdown 表格）──────────────────
     ctx.tools.register(defineTool({
@@ -118,7 +163,7 @@ export function apply(ctx) {
             render: (_args, value) => [{ type: 'text', text: value }],
         },
         async execute() {
-            const cfg = readSettings();
+            const cfg = readSettingsCached();
             return renderMarkdownTable(collectModels(cfg));
         },
     }));
@@ -130,80 +175,61 @@ export function apply(ctx) {
         path: '/api/model-health/json',
         handler: (_req, res) => {
             try {
-                const cfg = readSettings();
+                const cfg = readSettingsCached();
                 const rows = collectModels(cfg);
-                const payload = JSON.stringify({
+                sendJson(res, 200, {
                     ok: true,
                     count: rows.length,
                     source: join(dshHome(), 'settings.yaml'),
                     updatedAt: new Date().toISOString(),
                     models: rows.map(toPublicRow),
                 });
-                res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                res.end(payload);
             }
             catch (e) {
-                const payload = JSON.stringify({
-                    ok: false,
-                    error: `读取模型列表失败：${e.message}`,
-                });
-                res.statusCode = 500;
-                res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                res.end(payload);
+                sendJson(res, 500, { ok: false, error: `读取模型列表失败：${e.message}` });
             }
         },
     });
     // ── 3. HTTP 路由（测试单个模型可用性）──────────────────────────────
-    //    POST /api/model-health/test  body: { "index": <number> }
-    //    对该模型发起一次最小 chat completions 请求，返回 { ok, index, status, latency, error? }
+    //    POST /api/model-health/test  body: { "key": "<provider>/<modelId>" }
+    //    按 key 定位模型（settings 增删/排序后不错位），
+    //    发起一次最小 chat completions 请求，返回 { ok, key, status, latency, error? }
     ctx.webServer.register({
         kind: 'exact',
         path: '/api/model-health/test',
         handler: async (req, res) => {
-            // 读取请求体
-            let body = '';
-            for await (const chunk of req)
-                body += chunk;
-            let index;
+            let key;
             try {
-                index = JSON.parse(body || '{}').index;
-                if (typeof index !== 'number' || !Number.isInteger(index) || index < 0) {
-                    throw new Error('index 必须是非负整数');
-                }
+                key = (await readJsonBody(req)).key;
+                if (typeof key !== 'string' || key === '')
+                    throw new Error('key 必须是非空字符串');
             }
             catch (e) {
-                res.statusCode = 400;
-                res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                res.end(JSON.stringify({ ok: false, error: `参数错误：${e.message}` }));
+                sendJson(res, 400, { ok: false, error: `参数错误：${e.message}` });
                 return;
             }
             // 查找模型配置
             let row;
             try {
-                const cfg = readSettings();
+                const cfg = readSettingsCached();
                 const rows = collectModels(cfg);
-                const found = rows[index];
+                const found = rows.find((r) => r.key === key);
                 if (!found) {
-                    res.statusCode = 404;
-                    res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                    res.end(JSON.stringify({ ok: false, error: `未找到索引为 ${index} 的模型` }));
+                    sendJson(res, 404, { ok: false, error: `未找到 key 为 ${key} 的模型（配置可能已变化，请刷新列表）` });
                     return;
                 }
                 row = found;
             }
             catch (e) {
-                res.statusCode = 500;
-                res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                res.end(JSON.stringify({ ok: false, error: e.message }));
+                sendJson(res, 500, { ok: false, error: e.message });
                 return;
             }
             // 仅支持 openai-completions 协议
             if (row.api !== 'openai-completions' && row.api !== 'deepseek') {
-                res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                res.end(JSON.stringify({
-                    ok: true, index, status: 'skip',
+                sendJson(res, 200, {
+                    ok: true, key, status: 'skip',
                     error: `不支持 ${row.api} 协议的测试`,
-                }));
+                });
                 return;
             }
             // 获取 API Key
@@ -220,11 +246,10 @@ export function apply(ctx) {
                 }
             }
             if (!apiKey) {
-                res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                res.end(JSON.stringify({
-                    ok: true, index, status: 'fail',
+                sendJson(res, 200, {
+                    ok: true, key, status: 'fail',
                     error: `未配置 ${row.apiKeyEnv} 的 API Key（请在 设置 → 模型 中添加）`,
-                }));
+                });
                 return;
             }
             // 发起最小测试请求（max_tokens=1，超时 10s）
@@ -250,24 +275,21 @@ export function apply(ctx) {
                 clearTimeout(timer);
                 const latency = Date.now() - start;
                 if (resp.ok) {
-                    res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                    res.end(JSON.stringify({ ok: true, index, status: 'ok', latency }));
+                    sendJson(res, 200, { ok: true, key, status: 'ok', latency });
                 }
                 else {
                     const text = await resp.text().catch(() => '');
-                    res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                    res.end(JSON.stringify({
-                        ok: true, index, status: 'fail', latency,
+                    sendJson(res, 200, {
+                        ok: true, key, status: 'fail', latency,
                         error: `HTTP ${resp.status}: ${text.slice(0, 300)}`,
-                    }));
+                    });
                 }
             }
             catch (e) {
                 clearTimeout(timer);
                 const latency = Date.now() - start;
                 const msg = e?.name === 'AbortError' ? '超时（10s）' : (e?.message || String(e));
-                res.setHeader('Content-Type', 'application/json; charset=utf-8');
-                res.end(JSON.stringify({ ok: true, index, status: 'fail', latency, error: msg }));
+                sendJson(res, 200, { ok: true, key, status: 'fail', latency, error: msg });
             }
         },
     });

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "dsh-model-health",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "DSH plugin that lists all configured models with availability/latency testing, by reading $DSH_HOME/settings.yaml.",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oxlyn/dsh-model-health.git"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "exports": {