dsh-magpie-connector 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.4.2
+
+- **Only the checked line is re-measured.** 0.4.1 refreshed the whole latency pass after a line check, so every saved row's reading changed even though only one line was checked. `GET /api/dsh-magpie-connector/latency` now accepts `?line=<id>`: the host probes just that saved line and returns only its reading, and the settings page merges it into that row while every other row keeps its previous value. Unknown or unsaved ids measure nothing. The full pass on panel open and after a successful save is unchanged, and there is still no polling.
+
+## 0.4.1
+
+- **Check refreshes latency.** A completed line check on a **saved** line now also re-runs the settings-page latency measurement (one `GET /api/dsh-magpie-connector/latency` pass), so the signal reading next to that line reflects the same moment as the check instead of the last panel open or save. Unsaved drafts trigger nothing (they have no latency row), the host measurement stays single-flight with its 600 ms deadline, and there is still no polling.
+
 ## 0.4.0
 
 - **Line panel polish.** Settings now collapses every configured line by default (it no longer force-expands the active one); clicking a line header toggles it, and the add/remove/reorder actions are always-visible DSH product-icon buttons with accessible names and tooltips. A newly added line still opens for editing and stays open through its first save (including when it was moved before saving) and when a save fails.

package/lib/client/SettingsPage.js

@@ -91,20 +91,49 @@ export function MagpieSettings({ api }) {
                 setCards({ status: 'error', error: errorText(error), cards: [] });
         }
     };
-    /** One measurement per panel open (and after a successful line write); failures stay silent. */
-    const readLatency = async () => {
+    /** One measurement per panel open (and after a successful line write); failures stay silent.
+     * With `only`, just that saved line is re-measured and merged in — the other rows keep their
+     * reading instead of all flipping to 测速中 (the line-check refresh). */
+    const readLatency = async (only) => {
         const epoch = ++latencyEpoch.current;
-        setLatency({ phase: 'measuring' });
+        if (only === undefined)
+            setLatency({ phase: 'measuring' });
+        else
+            setLatency(current => current.phase === 'done' ? { phase: 'done', readings: current.readings, measuring: new Set([only]) } : current);
+        const settle = () => {
+            // Superseded by a newer pass: drop the stale result but never leave the row stuck on 测速中.
+            if (only === undefined)
+                return;
+            setLatency(current => current.phase === 'done' ? { phase: 'done', readings: current.readings } : current);
+        };
         try {
-            const response = await api({ method: 'GET', path: 'latency' });
-            if (epoch !== latencyEpoch.current)
+            const response = await api({ method: 'GET', path: 'latency', ...(only === undefined ? {} : { query: { line: only } }) });
+            if (epoch !== latencyEpoch.current) {
+                settle();
                 return;
+            }
             const readings = isOk(response) ? parseLatency(response.body) : undefined;
-            setLatency(readings ? { phase: 'done', readings } : { phase: 'failed' });
+            if (only === undefined) {
+                setLatency(readings ? { phase: 'done', readings } : { phase: 'failed' });
+                return;
+            }
+            setLatency(current => {
+                const merged = new Map(current.phase === 'done' ? current.readings : []);
+                if (readings)
+                    for (const [id, ms] of readings)
+                        merged.set(id, ms);
+                return { phase: 'done', readings: merged };
+            });
         }
         catch {
-            if (epoch === latencyEpoch.current)
+            if (epoch !== latencyEpoch.current) {
+                settle();
+                return;
+            }
+            if (only === undefined)
                 setLatency({ phase: 'failed' });
+            else
+                settle();
         }
     };
     const clearUsage = () => {
@@ -250,7 +279,7 @@ export function MagpieSettings({ api }) {
         }
     };
     const groupNote = (provider) => noteScope === provider ? { notice, alert: usageAlert } : {};
-    return h('div', { className: 'dmg-settings' }, h('style', null, settingsCss), h('p', { className: 'dmg-intro' }, '通过自托管的 Magpie 网关使用模型。用量卡片只读，打开本页时读取一次，之后只在你点击卡片上的刷新时重新读取。'), settingsError ? h('p', { className: 'dmg-error', role: 'alert' }, `无法读取设置：${settingsError}`) : null, settings ? h(Connection, { settings, saving: savingSettings, mutateSettings, api, latency,
+    return h('div', { className: 'dmg-settings' }, h('style', null, settingsCss), h('p', { className: 'dmg-intro' }, '通过自托管的 Magpie 网关使用模型。用量卡片只读，打开本页时读取一次，之后只在你点击卡片上的刷新时重新读取。'), settingsError ? h('p', { className: 'dmg-error', role: 'alert' }, `无法读取设置：${settingsError}`) : null, settings ? h(Connection, { settings, saving: savingSettings, mutateSettings, api, latency, onRefreshLatency: (lineId) => { void readLatency(lineId); },
         usage: h(UsageStatus, { cards, busy, ...(noteScope === undefined ? { notice, alert: usageAlert } : {}), onFetchAll: () => { void fetchAll(); }, saving: savingSettings }) })
         : settingsError ? null : h('p', { role: 'status', className: 'dmg-hint' }, '正在读取设置…'), ...providerOrder(groups, cardList).map(provider => h(ProviderGroup, {
         key: provider, provider,
@@ -328,7 +357,7 @@ function lineDrafts(settings) {
     }));
 }
 const lineSignature = (draft) => JSON.stringify([draft.id ?? null, draft.baseUrl.trim(), draft.accessMode]);
-function Connection({ settings, saving, mutateSettings, api, usage, latency }) {
+function Connection({ settings, saving, mutateSettings, api, usage, latency, onRefreshLatency }) {
     const baseline = lineDrafts(settings);
     const [drafts, setDrafts] = useState(baseline);
     const [expanded, setExpanded] = useState(null);
@@ -477,6 +506,10 @@ function Connection({ settings, saving, mutateSettings, api, usage, latency }) {
                 return;
             }
             setChecks(current => ({ ...current, [draft.draftId]: { signature, activeLineId: activeId, result: snapshot } }));
+            // A completed check is a fresh network sample of this line: re-measure just that saved
+            // line (unsaved drafts have no reading row, so they trigger nothing).
+            if (draft.id)
+                onRefreshLatency(draft.id);
         }
         catch (error) {
             if (epoch === checkEpoch.current)

package/lib/client/latency.d.ts

@@ -1,4 +1,5 @@
-/** One measurement pass over every saved line: readings keyed by line id. */
+/** One measurement pass over every saved line: readings keyed by line id. `measuring` marks a
+ * single row being re-measured on its own (line check), so other rows keep their reading. */
 export type LatencyState = {
     phase: 'idle';
 } | {
@@ -6,6 +7,7 @@ export type LatencyState = {
 } | {
     phase: 'done';
     readings: ReadonlyMap<string, number | null>;
+    measuring?: ReadonlySet<string>;
 } | {
     phase: 'failed';
 };

package/lib/client/latency.js

@@ -38,6 +38,8 @@ export function lineLatency(state, line) {
         return { state: 'failed' };
     if (state.phase !== 'done')
         return { state: 'measuring' };
+    if (state.measuring?.has(line.id))
+        return { state: 'measuring' };
     if (!state.readings.has(line.id))
         return { state: 'idle' };
     const ms = state.readings.get(line.id) ?? null;

package/lib/client.js

@@ -79,6 +79,7 @@ window.__ModuleLoader__.load({
 			if (!(!!line.id && parseable(line.baseUrl))) return { state: "idle" };
 			if (state.phase === "failed") return { state: "failed" };
 			if (state.phase !== "done") return { state: "measuring" };
+			if (state.measuring?.has(line.id)) return { state: "measuring" };
 			if (!state.readings.has(line.id)) return { state: "idle" };
 			const ms = state.readings.get(line.id) ?? null;
 			return ms === null ? {
@@ -423,23 +424,57 @@ window.__ModuleLoader__.load({
 					});
 				}
 			};
-			/** One measurement per panel open (and after a successful line write); failures stay silent. */
-			const readLatency = async () => {
+			/** One measurement per panel open (and after a successful line write); failures stay silent.
+			* With `only`, just that saved line is re-measured and merged in — the other rows keep their
+			* reading instead of all flipping to 测速中 (the line-check refresh). */
+			const readLatency = async (only) => {
 				const epoch = ++latencyEpoch.current;
-				setLatency({ phase: "measuring" });
+				if (only === void 0) setLatency({ phase: "measuring" });
+				else setLatency((current) => current.phase === "done" ? {
+					phase: "done",
+					readings: current.readings,
+					measuring: /* @__PURE__ */ new Set([only])
+				} : current);
+				const settle = () => {
+					if (only === void 0) return;
+					setLatency((current) => current.phase === "done" ? {
+						phase: "done",
+						readings: current.readings
+					} : current);
+				};
 				try {
 					const response = await api({
 						method: "GET",
-						path: "latency"
+						path: "latency",
+						...only === void 0 ? {} : { query: { line: only } }
 					});
-					if (epoch !== latencyEpoch.current) return;
+					if (epoch !== latencyEpoch.current) {
+						settle();
+						return;
+					}
 					const readings = isOk(response) ? parseLatency(response.body) : void 0;
-					setLatency(readings ? {
-						phase: "done",
-						readings
-					} : { phase: "failed" });
+					if (only === void 0) {
+						setLatency(readings ? {
+							phase: "done",
+							readings
+						} : { phase: "failed" });
+						return;
+					}
+					setLatency((current) => {
+						const merged = new Map(current.phase === "done" ? current.readings : []);
+						if (readings) for (const [id, ms] of readings) merged.set(id, ms);
+						return {
+							phase: "done",
+							readings: merged
+						};
+					});
 				} catch {
-					if (epoch === latencyEpoch.current) setLatency({ phase: "failed" });
+					if (epoch !== latencyEpoch.current) {
+						settle();
+						return;
+					}
+					if (only === void 0) setLatency({ phase: "failed" });
+					else settle();
 				}
 			};
 			const clearUsage = () => {
@@ -586,6 +621,9 @@ window.__ModuleLoader__.load({
 				mutateSettings,
 				api,
 				latency,
+				onRefreshLatency: (lineId) => {
+					readLatency(lineId);
+				},
 				usage: (0, react.createElement)(UsageStatus, {
 					cards,
 					busy,
@@ -740,7 +778,7 @@ window.__ModuleLoader__.load({
 			draft.baseUrl.trim(),
 			draft.accessMode
 		]);
-		function Connection({ settings, saving, mutateSettings, api, usage, latency }) {
+		function Connection({ settings, saving, mutateSettings, api, usage, latency, onRefreshLatency }) {
 			const baseline = lineDrafts(settings);
 			const [drafts, setDrafts] = (0, react.useState)(baseline);
 			const [expanded, setExpanded] = (0, react.useState)(null);
@@ -922,6 +960,7 @@ window.__ModuleLoader__.load({
 							result: snapshot
 						}
 					}));
+					if (draft.id) onRefreshLatency(draft.id);
 				} catch (error) {
 					if (epoch === checkEpoch.current) setCheckErrors((current) => ({
 						...current,

package/lib/host/latency.d.ts

@@ -10,21 +10,16 @@ export interface LatencyControllerOptions {
     measure?: Measure;
     timeoutMs?: number;
 }
-/**
- * Read-only settings-page measurement: one TCP connect per saved line with a
- * parseable address, all in parallel, each capped by the selection deadline.
- * Measurements are single-flight (concurrent reads share one pass), never touch
- * settings, credentials or the selector cache, and are aborted on dispose.
- */
 export declare class LatencyController {
     private readonly lines;
     private readonly measure;
     private readonly timeoutMs;
     private readonly controllers;
-    private inFlight;
+    private readonly passes;
     private disposed;
     constructor(lines: () => LineSettings[], options?: LatencyControllerOptions);
-    read(): Promise<Response>;
-    private measureOnce;
+    /** `lineId` narrows the pass to one saved line (the line-check refresh); omit for the full panel pass. */
+    read(lineId?: string): Promise<Response>;
+    private pass;
     dispose(): void;
 }

package/lib/host/latency.js

@@ -6,32 +6,42 @@ const measureSocket = async (host, port, timeoutMs, signal) => {
 /**
  * Read-only settings-page measurement: one TCP connect per saved line with a
  * parseable address, all in parallel, each capped by the selection deadline.
- * Measurements are single-flight (concurrent reads share one pass), never touch
- * settings, credentials or the selector cache, and are aborted on dispose.
+ * A `lineId` request measures only that saved line (the line-check refresh).
+ * Passes are single-flight per scope (a full pass also serves line requests),
+ * never touch settings, credentials or the selector cache, and are aborted on
+ * dispose.
  */
+const FULL = '*';
 export class LatencyController {
     lines;
     measure;
     timeoutMs;
     controllers = new Set();
-    inFlight;
+    passes = new Set();
     disposed = false;
     constructor(lines, options = {}) {
         this.lines = lines;
         this.measure = options.measure ?? measureSocket;
         this.timeoutMs = options.timeoutMs ?? PROBE_TIMEOUT_MS;
     }
-    async read() {
+    /** `lineId` narrows the pass to one saved line (the line-check refresh); omit for the full panel pass. */
+    async read(lineId) {
         if (this.disposed)
             return Response.json({ lines: [] });
-        const readings = await this.measureOnce();
-        return Response.json({ lines: readings });
+        const scope = lineId ?? FULL;
+        const readings = await this.pass(scope, lineId);
+        return Response.json({ lines: scope === FULL ? readings : readings.filter(reading => reading.id === lineId) });
     }
-    measureOnce() {
-        if (this.inFlight)
-            return this.inFlight;
+    pass(scope, lineId) {
+        for (const entry of this.passes) {
+            // A running full pass already measures this line; reuse it instead of probing twice.
+            if (entry.scope === scope || (scope !== FULL && entry.scope === FULL))
+                return entry.promise;
+        }
         const targets = [];
         for (const line of this.lines()) {
+            if (lineId !== undefined && line.id !== lineId)
+                continue;
             const endpoint = endpointOf(line.baseUrl);
             if (endpoint)
                 targets.push({ id: line.id, host: endpoint.host, port: endpoint.port });
@@ -49,8 +59,9 @@ export class LatencyController {
                 this.controllers.delete(controller);
             }
         }));
-        this.inFlight = measuring.finally(() => { this.inFlight = undefined; });
-        return this.inFlight;
+        const entry = { scope, promise: measuring.finally(() => { this.passes.delete(entry); }) };
+        this.passes.add(entry);
+        return entry.promise;
     }
     dispose() {
         if (this.disposed)

package/lib/host/routes.js

@@ -73,7 +73,7 @@ export function registerRoutes(fetch, runtime, speed = new SpeedController(), ca
             return Response.json(speed.get(session, runtime.current.catalog));
         },
         lineCheck: async (_request, body) => runtime.lineCheck(body),
-        latency: async () => latency.read(),
+        latency: async (request) => latency.read(new URL(request.url).searchParams.get('line') ?? undefined),
     };
     /** GET-only latency diagnostics; every other resource keeps the GET/POST surface. */
     const resources = ['settings', 'cards', 'speed', 'latency'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-magpie-connector",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "DeepSeek Harness plugin: connect a self-hosted Magpie gateway with one real provider route per upstream owner (grouped model picker on stock DSH), automatic multi-line failover, read-only usage cards, model visibility, default effort and per-session fast mode",
   "license": "MIT",
   "author": "prgrmrwy",