dsh-deeppilot 0.2.0 → 0.2.2

package/lib/index.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import { createServer } from "node:http";
 import { createPrivateKey, randomBytes, randomUUID, sign, timingSafeEqual } from "node:crypto";
 import { access, mkdir, readFile, rename, writeFile } from "node:fs/promises";
@@ -11,6 +12,7 @@ import { connect } from "node:http2";
 import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { fileURLToPath } from "node:url";
+import { request } from "node:https";
 //#region src/token.ts
 /** Expand a leading ~ using the process home directory. */
 function expandHome(p) {
@@ -362,6 +364,9 @@ var BridgeConnection = class {
 					sessions: this.deps.bridge.listSessions()
 				}, env.id);
 				return;
+			case "c2s.pending.list":
+				this.send("s2c.pending.snapshot", this.deps.bridge.pendingSnapshot(), env.id);
+				return;
 			case "c2s.workspaces.list": {
 				if (!this.deps.bridge.capabilities.projectSelection) return this.fail(env.id, "E_UNSUPPORTED", "project selection unavailable on this host version");
 				const result = await this.deps.bridge.listWorkspaces();
@@ -395,10 +400,15 @@ var BridgeConnection = class {
 			}
 			case "c2s.session.open": {
 				const p = env.payload;
-				if (!p?.sessionId) return this.fail(env.id, "E_PROTOCOL", "sessionId required");
-				this.openSessions.add(p.sessionId);
-				this.deps.bridge.markSinkOpen(this, p.sessionId);
-				if (!await this.deps.bridge.openSession(this, p.sessionId, p.tailCount ?? 100)) this.fail(env.id, "E_NOT_FOUND", "session history unavailable");
+				if (!p?.sessionId || typeof p.sessionId !== "string") return this.fail(env.id, "E_PROTOCOL", "sessionId required");
+				const sessionId = p.sessionId;
+				this.openSessions.add(sessionId);
+				this.deps.bridge.markSinkOpen(this, sessionId);
+				if (!await this.deps.bridge.openSession(this, sessionId, p.tailCount ?? 100)) {
+					this.openSessions.delete(sessionId);
+					this.deps.bridge.markSinkClosed(this, sessionId);
+					return this.fail(env.id, "E_NOT_FOUND", "session history unavailable");
+				}
 				return;
 			}
 			case "c2s.session.close": {
@@ -526,21 +536,23 @@ var BridgeConnection = class {
 					});
 				}
 				const userSeq = await this.deps.bridge.sendPrompt(p.sessionId, text, images);
-				if (userSeq === null) return this.fail(env.id, "E_BUSY", "session busy or unavailable");
-				this.send("s2c.ack", { userSeq }, env.id);
+				if (!userSeq.ok) return this.fail(env.id, managementErrorCode(userSeq.kind), userSeq.message);
+				this.send("s2c.ack", { userSeq: userSeq.value }, env.id);
 				return;
 			}
 			case "c2s.approval.respond": {
 				const p = env.payload;
 				if (!p?.requestId || p.decision !== "allow" && p.decision !== "deny") return this.fail(env.id, "E_PROTOCOL", "requestId and decision required");
-				if (!await this.deps.bridge.respondApproval(p.requestId, p.decision)) return this.fail(env.id, "E_NOT_FOUND", "approval not pending");
+				const outcome = await this.deps.bridge.respondApproval(p.requestId, p.decision, typeof p.reason === "string" ? p.reason : void 0);
+				if (!outcome.ok) return this.fail(env.id, pendingResponseErrorCode(outcome.reason), pendingResponseMessage("approval", outcome.reason));
 				this.send("s2c.ack", {}, env.id);
 				return;
 			}
 			case "c2s.question.respond": {
 				const p = env.payload;
 				if (!p?.requestId || !Array.isArray(p.answers)) return this.fail(env.id, "E_PROTOCOL", "requestId and answers required");
-				if (!await this.deps.bridge.respondQuestion(p.requestId, p.answers)) return this.fail(env.id, "E_NOT_FOUND", "question not pending");
+				const outcome = await this.deps.bridge.respondQuestion(p.requestId, p.answers);
+				if (!outcome.ok) return this.fail(env.id, pendingResponseErrorCode(outcome.reason), pendingResponseMessage("question", outcome.reason));
 				this.send("s2c.ack", {}, env.id);
 				return;
 			}
@@ -612,6 +624,23 @@ var BridgeConnection = class {
 		}
 	}
 };
+/** Error code for a failed approval/question response outcome. */
+function pendingResponseErrorCode(reason) {
+	switch (reason) {
+		case "not-pending": return "E_NOT_FOUND";
+		case "bad-response": return "E_PROTOCOL";
+		case "transport": return "E_INTERNAL";
+	}
+}
+/** Human-readable failure detail; `question not pending` must only ever mean
+* "nothing pending", never "the host rejected the answer". */
+function pendingResponseMessage(kind, reason) {
+	switch (reason) {
+		case "not-pending": return kind + " not pending";
+		case "bad-response": return kind + " answer rejected by host: answer does not match the asked questions";
+		case "transport": return "host connection failed while answering " + kind;
+	}
+}
 function managementErrorCode(kind) {
 	switch (kind) {
 		case "unsupported": return "E_UNSUPPORTED";
@@ -677,6 +706,7 @@ var HostBridge = class {
 			replay: true,
 			approvals: true,
 			questions: true,
+			pendingSnapshot: true,
 			models: typeof this.apiProxy.sessions.models === "function" && typeof this.apiProxy.sessions.selectModel === "function",
 			sessionManagement: typeof this.apiProxy.sessions.rename === "function" && typeof this.apiProxy.workspace?.archiveSession === "function",
 			projectSelection: typeof this.apiProxy.workspace?.list === "function" && typeof this.apiProxy.workspace?.create === "function",
@@ -698,7 +728,7 @@ var HostBridge = class {
 	/** Whether the ring still holds everything after the cursor. */
 	canResumeFrom(cursor) {
 		const oldest = this.ring.length > 0 ? this.ring[0].seq : this.cursor + 1;
-		return cursor + 1 >= oldest;
+		return cursor <= this.cursor && cursor + 1 >= oldest;
 	}
 	sinkSessions = /* @__PURE__ */ new Map();
 	lastAssistantText = /* @__PURE__ */ new Map();
@@ -1040,6 +1070,27 @@ var HostBridge = class {
 	listSessions() {
 		return [...this.summaries.values()].sort((a, b) => b.lastActivityTs - a.lastActivityTs);
 	}
+	/**
+	* Complete transient interaction state. Unlike the replay ring, this remains
+	* authoritative after a long disconnect and is rehydrated by apiProxy's mux
+	* stream when the bridge itself restarts.
+	*/
+	pendingSnapshot() {
+		return {
+			approvals: [...this.approvals.entries()].map(([requestId, pending]) => ({
+				requestId,
+				sessionId: pending.sessionId,
+				toolName: pending.toolName,
+				summary: pending.reason,
+				riskLevel: riskOf(pending.toolName)
+			})),
+			questions: [...this.questions.entries()].map(([requestId, pending]) => ({
+				requestId,
+				sessionId: pending.sessionId,
+				questions: Array.isArray(pending.questions) ? pending.questions : []
+			}))
+		};
+	}
 	/** Tail history for an opened session; pushes s2c.session.tail to the sink. */
 	async openSession(sink, sessionId, tailCount) {
 		try {
@@ -1445,22 +1496,38 @@ var HostBridge = class {
 					clientTimeZone: localTimeZone()
 				}
 			});
-			if (!response.result || !response.result.ok) return null;
+			if (!response.result) return {
+				ok: false,
+				kind: "internal",
+				message: "prompt returned no result"
+			};
+			if (!response.result.ok) return hostSessionManagementError(response.result.error);
 			const row = this.summaries.get(sessionId);
 			if (row) {
 				row.lastActivityTs = Date.now();
 				this.pushSummary(row);
 			}
-			return Date.now();
-		} catch {
-			return null;
+			return {
+				ok: true,
+				value: Date.now()
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				kind: "internal",
+				message: String(error)
+			};
 		}
 	}
-	async respondApproval(requestId, decision) {
+	async respondApproval(requestId, decision, reason) {
 		const pending = this.approvals.get(requestId);
-		if (!pending) return false;
+		if (!pending) return {
+			ok: false,
+			reason: "not-pending"
+		};
 		this.approvals.delete(requestId);
 		const outcome = decision === "allow" ? "allowed-once" : "rejected";
+		const denialReason = typeof reason === "string" ? reason.trim().slice(0, 500) : "";
 		try {
 			const receipt = await this.apiProxy.respond({
 				type: "client-response",
@@ -1470,21 +1537,35 @@ var HostBridge = class {
 					value: {
 						sessionId: pending.sessionId,
 						approvalId: requestId,
-						outcome
+						outcome,
+						...denialReason.length > 0 ? { reason: denialReason } : {}
 					}
 				}
 			});
-			const accepted = Boolean(receipt?.accepted);
-			if (!accepted && !this.approvals.has(requestId)) this.approvals.set(requestId, pending);
-			return accepted;
+			if (!Boolean(receipt?.accepted)) {
+				const failure = receiptFailureReason(receipt);
+				if (failure !== "not-pending" && !this.approvals.has(requestId)) this.approvals.set(requestId, pending);
+				return {
+					ok: false,
+					reason: failure
+				};
+			}
+			this.bumpPendingFlags(pending.sessionId);
+			return { ok: true };
 		} catch {
 			if (!this.approvals.has(requestId)) this.approvals.set(requestId, pending);
-			return false;
+			return {
+				ok: false,
+				reason: "transport"
+			};
 		}
 	}
 	async respondQuestion(requestId, answers) {
 		const pending = this.questions.get(requestId);
-		if (!pending) return false;
+		if (!pending) return {
+			ok: false,
+			reason: "not-pending"
+		};
 		this.questions.delete(requestId);
 		try {
 			const receipt = await this.apiProxy.respond({
@@ -1494,19 +1575,65 @@ var HostBridge = class {
 					ok: true,
 					value: {
 						sessionId: pending.sessionId,
-						answer: { answers }
+						answer: { answers: normalizeAnswerItems(answers, pending.questions) }
 					}
 				}
 			});
-			const accepted = Boolean(receipt?.accepted);
-			if (!accepted && !this.questions.has(requestId)) this.questions.set(requestId, pending);
-			return accepted;
+			if (!Boolean(receipt?.accepted)) {
+				const failure = receiptFailureReason(receipt);
+				if (failure !== "not-pending" && !this.questions.has(requestId)) this.questions.set(requestId, pending);
+				return {
+					ok: false,
+					reason: failure
+				};
+			}
+			this.bumpPendingFlags(pending.sessionId);
+			return { ok: true };
 		} catch {
 			if (!this.questions.has(requestId)) this.questions.set(requestId, pending);
-			return false;
+			return {
+				ok: false,
+				reason: "transport"
+			};
 		}
 	}
 };
+/**
+* The host validates question answers strictly (core dsh-user-questions via
+* apiProxy): a present-but-empty `custom` fails `matchesQuestions`, and a
+* single-select question rejects `custom` combined with a selection. Clients
+* may send lenient shapes (the phone historically always attached
+* `"custom": ""`, which made EVERY option-only answer fail), so normalize to
+* exactly what the host accepts before forwarding.
+*/
+function normalizeAnswerItems(raw, questions) {
+	if (!Array.isArray(raw)) return [];
+	const askedById = /* @__PURE__ */ new Map();
+	if (Array.isArray(questions)) {
+		for (const q of questions) if (typeof q === "object" && q !== null && typeof q.id === "string") askedById.set(q.id, q);
+	}
+	const items = [];
+	for (const entry of raw) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const r = entry;
+		if (typeof r.id !== "string") continue;
+		const selected = [...new Set(Array.isArray(r.selected) ? r.selected.filter((s) => typeof s === "string") : [])];
+		const customText = typeof r.custom === "string" ? r.custom : "";
+		let custom;
+		if (customText.trim().length > 0) custom = customText;
+		if (custom !== void 0 && selected.length > 0 && askedById.get(r.id)?.multiSelect !== true) custom = void 0;
+		items.push({
+			id: r.id,
+			selected,
+			...custom !== void 0 ? { custom } : {}
+		});
+	}
+	return items;
+}
+/** Map an apiProxy respond receipt onto the failure vocabulary. */
+function receiptFailureReason(receipt) {
+	return receipt?.reason === "not-pending" ? "not-pending" : "bad-response";
+}
 function clampTail(n) {
 	if (!Number.isFinite(n)) return 100;
 	return Math.max(10, Math.min(500, Math.floor(n)));
@@ -1598,9 +1725,10 @@ function projectEvent(sessionId, event) {
 			kind: "message.final",
 			data: {
 				seq: event.seq,
-				role: "user",
+				role: userRoleOf(event.data),
 				text: messageText(event.data),
 				...attachmentProjection(event.data),
+				...contextProjectionOf(event.data),
 				ts: tsOf(event)
 			}
 		};
@@ -1644,27 +1772,99 @@ function projectEvent(sessionId, event) {
 					tool: {
 						name: String(data?.name ?? "tool"),
 						state: "running",
-						summary: summarizeArgs(data?.arguments)
+						summary: summarizeArgs(data?.arguments),
+						...data?.callId ? { callId: String(data.callId) } : {}
 					},
 					ts: tsOf(event)
 				}
 			};
 		}
-		case "tool/result": return {
-			kind: "tool.end",
-			data: {
-				seq: event.seq,
-				role: "tool",
-				ok: !event.data || event.data.error === void 0,
-				ts: tsOf(event)
-			}
-		};
+		case "tool/result": {
+			const data = event.data;
+			return {
+				kind: "tool.end",
+				data: {
+					seq: event.seq,
+					role: "tool",
+					ok: !event.data || data?.error === void 0,
+					...data?.callId ? { callId: String(data.callId) } : {},
+					ts: tsOf(event)
+				}
+			};
+		}
 		default: return null;
 	}
 }
 function tsOf(event) {
 	return typeof event.time === "number" ? event.time : Date.now();
 }
+/** Read the durable message source off one user/message payload. Handles both
+* bare-message payloads and older `{message: {...}}` wrappers; undefined when
+* the shape carries no readable source (legacy hosts). */
+function userMessageSource(data) {
+	if (!data || typeof data !== "object") return void 0;
+	const obj = data;
+	if (obj.source && typeof obj.source === "object") return obj.source;
+	if (obj.message && typeof obj.message === "object" && obj.message.source && typeof obj.message.source === "object") return obj.message.source;
+}
+/** Wire role for one user/message payload. A payload without any readable
+* source degrades to 'user' so history written by older hosts stays visible;
+* a present source follows the host's own trajectory rule — anything whose
+* `kind` is not 'user' is injected context and projects as 'system'. */
+function userRoleOf(data) {
+	const source = userMessageSource(data);
+	if (!source) return "user";
+	return source.kind === "user" ? "user" : "system";
+}
+/** Producer name of one injected-context source, mirroring how the DSH client
+* runtime derives its trajectory label: plugin name, skill name, instruction
+* paths, session-reference labels, or the raw kind as fallback. */
+function contextLabelOf(source) {
+	const kind = typeof source.kind === "string" ? source.kind : "";
+	const joined = (member) => {
+		const list = source[member];
+		if (!Array.isArray(list)) return void 0;
+		const names = list.flatMap((entry) => {
+			if (!entry || typeof entry !== "object") return [];
+			const record = entry;
+			return [typeof record.label === "string" ? record.label : typeof record.path === "string" ? record.path : ""];
+		}).filter((name) => name.length > 0);
+		return names.length > 0 ? names.join(", ") : void 0;
+	};
+	switch (kind) {
+		case "session-reference": return joined("references") ?? (kind || void 0);
+		case "agent-instructions": return joined("changes") ?? (kind || void 0);
+		case "plugin": return typeof source.plugin === "string" && source.plugin.length > 0 ? source.plugin : kind || void 0;
+		case "skill-invocation": return typeof source.name === "string" && source.name.length > 0 ? source.name : kind || void 0;
+		default: return kind || void 0;
+	}
+}
+/** Semantic ContextForm declared by the producer ('snapshot', 'notice', …);
+* anything unrecognized stays undefined so clients render it opaque. */
+function contextFormOf(source) {
+	if (typeof source.form !== "string" || source.form.length === 0) return void 0;
+	return [
+		"instructions",
+		"catalog",
+		"snapshot",
+		"notice",
+		"relay",
+		"recall"
+	].includes(source.form) ? source.form : void 0;
+}
+/** Optional `context` metadata for one system row; {} on user rows. */
+function contextProjectionOf(data) {
+	if (userRoleOf(data) !== "system") return {};
+	const source = userMessageSource(data);
+	if (!source) return {};
+	const label = contextLabelOf(source);
+	const form = contextFormOf(source);
+	if (!label && !form) return {};
+	return { context: {
+		...label ? { label } : {},
+		...form ? { form } : {}
+	} };
+}
 /** Extract plain text from user/assistant message payloads across shapes. */
 function messageText(data) {
 	if (typeof data === "string") return data;
@@ -1874,9 +2074,10 @@ function projectHistory(events) {
 			case "user/message":
 				messages.push({
 					...base,
-					role: "user",
+					role: userRoleOf(event.data),
 					text: messageText(event.data),
-					...attachmentProjection(event.data)
+					...attachmentProjection(event.data),
+					...contextProjectionOf(event.data)
 				});
 				break;
 			case "assistant/message": {
@@ -2123,9 +2324,13 @@ function parseReport(value) {
 	const lanAddresses = s.lanAddresses;
 	if (!Array.isArray(devices)) reject("devices");
 	if (!Array.isArray(lanAddresses) || lanAddresses.some((value) => typeof value !== "string")) reject("lanAddresses");
+	const releaseUrl = s.releaseUrl;
 	return {
 		protocolVersion: num(s, "protocolVersion", "protocolVersion"),
 		serverVersion: str(s, "serverVersion", "serverVersion"),
+		pluginVersion: str(s, "pluginVersion", "pluginVersion"),
+		...s.updateAvailable === true ? { updateAvailable: true } : {},
+		...typeof releaseUrl === "string" && releaseUrl.length > 0 ? { releaseUrl } : {},
 		enabled: bool(s, "enabled", "enabled"),
 		tokenPath: str(s, "tokenPath", "tokenPath"),
 		tokenReady: bool(s, "tokenReady", "tokenReady"),
@@ -2677,9 +2882,30 @@ function parseHelperEvent(line) {
 		return null;
 	}
 }
-function bundledHelperPath() {
+/** Build the list of candidate locations for the embedded tunnel helper, in
+*  priority order. The first existing executable wins at start() time. The
+*  order matters: explicit config (handled by the caller) > npm install
+*  layout > DSH-bundled layout > user data dir. */
+function bundledHelperCandidates() {
 	const here = dirname(fileURLToPath(import.meta.url));
-	return resolve(here, "..", "bin", `${process.platform}-${process.arch}`, "dsh-deeppilot-tunnel");
+	const pkgRoot = resolve(here, "..");
+	const fileName = process.platform === "win32" ? "dsh-deeppilot-tunnel.exe" : "dsh-deeppilot-tunnel";
+	const platformDir = `${process.platform}-${process.arch}`;
+	const candidates = [];
+	candidates.push(resolve(pkgRoot, "bin", platformDir, fileName));
+	candidates.push(resolve(pkgRoot, "..", "..", "..", "node_modules", "dsh-deeppilot", "bin", platformDir, fileName));
+	candidates.push(resolve(pkgRoot, "..", "..", "dsh-deeppilot", "bin", platformDir, fileName));
+	candidates.push(resolve(pkgRoot, "..", "..", "..", "..", "node_modules", "dsh-deeppilot", "bin", platformDir, fileName));
+	try {
+		const resolved = createRequire(import.meta.url).resolve(`dsh-deeppilot/bin/${platformDir}/${fileName}`);
+		if (!candidates.includes(resolved)) candidates.push(resolved);
+	} catch {}
+	const home = process.env.DSH_HOME?.trim() || process.env.HOME || process.env.USERPROFILE;
+	if (home && home.length > 0) {
+		const dataDir = resolve(home, ".dsh");
+		candidates.push(join(dataDir, "deeppilot", "bin", platformDir, fileName));
+	}
+	return candidates;
 }
 /** Owns exactly one embedded tunnel helper and restarts it after failures. */
 var RemoteSupervisor = class {
@@ -2702,21 +2928,42 @@ var RemoteSupervisor = class {
 	}
 	async start(originURL) {
 		if (!this.options.enabled || this.child !== void 0 || this.stopping) return;
-		const helper = expandHome(this.options.helperPath ?? bundledHelperPath());
 		const statePath = expandHome(this.options.statePath);
+		const configured = this.options.helperPath?.trim() ?? "";
+		const candidates = configured ? [expandHome(configured)] : bundledHelperCandidates();
+		let helper;
+		let lastError;
+		for (const candidate of candidates) try {
+			await access(candidate, constants.X_OK);
+			helper = candidate;
+			break;
+		} catch (error) {
+			lastError = error;
+		}
+		if (helper === void 0) {
+			if (this.stopping) return;
+			const platform = `${process.platform}-${process.arch}`;
+			const message = configured ? `embedded tunnel helper unavailable: ${configured}: ${String(lastError ?? "not found")}` : `embedded tunnel helper not found for ${platform} (tried: ${candidates.join(", ")}); set remote.helperPath to override`;
+			this.setStatus({
+				phase: "unavailable",
+				message
+			});
+			return;
+		}
 		try {
-			await access(helper, constants.X_OK);
 			await mkdir(statePath, {
 				recursive: true,
 				mode: 448
 			});
 		} catch (error) {
+			if (this.stopping) return;
 			this.setStatus({
 				phase: "unavailable",
-				message: `embedded tunnel helper unavailable: ${String(error)}`
+				message: `cannot create remote state dir: ${String(error)}`
 			});
 			return;
 		}
+		if (this.stopping) return;
 		this.setStatus({
 			phase: "starting",
 			message: void 0
@@ -2875,6 +3122,203 @@ function localLANIPv4Addresses() {
 	return [...new Set(candidates.map(({ address }) => address))];
 }
 //#endregion
+//#region src/update-check.ts
+/**
+* Lightweight self-update check for dsh-deeppilot.
+*
+* On Host boot we ask the GitHub Releases API (REST) which is the latest
+* stable tag, compare it to the installed plugin version, and surface a
+* "newer release exists" flag plus the GitHub release URL through the
+* report Remote. The settings page renders one small line at the bottom;
+* a successful check is enough — no manual button, no persistent cache
+* (the host process is the lifetime of the answer).
+*
+* Deliberately no third-party dependency: we use {@link https.request}
+* directly to keep parity with the rest of the project (remote-supervisor
+* uses node:http, host-bridge uses ws, etc).
+*
+* Failure policy: every network/parse error collapses to a single log
+* line and the in-memory snapshot stays "unknown". The bridge must never
+* crash because GitHub rate-limited us, returned a 5xx, or the user is
+* offline.
+*/
+/** GitHub repo (no .git suffix). Public, unauthenticated, low rate limit. */
+const RELEASES_PATH = "/repos/Mars-Sea/dsh-deeppilot/releases";
+/** Hard ceiling on the network round-trip. The host must never hang. */
+const FETCH_TIMEOUT_MS = 8e3;
+/** Per-page limit. We only need the first stable release, but pre-releases
+*  tend to be listed first; fetching 20 gives the comparator enough room. */
+const PER_PAGE = 20;
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseStableEntry(value) {
+	if (!isPlainObject(value)) return null;
+	const tag = value.tag_name;
+	if (typeof tag !== "string") return null;
+	if (value.prerelease === true || value.draft === true) return null;
+	if (parseStableTag(tag) === null) return null;
+	const url = value.html_url;
+	return {
+		tag,
+		url: typeof url === "string" ? url : null
+	};
+}
+/** Parse one stable release from the `tag_name` shape `vX.Y.Z` (the v is
+*  optional; `1.2.3` is also accepted). Pre-release tags like `0.3.0-rc.1`
+*  return null — the policy is "stable channel only". */
+function parseStableTag(tag) {
+	const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(tag.trim());
+	if (match === null) return null;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3])
+	};
+}
+/** Semver compare for X.Y.Z. Returns -1 / 0 / 1. */
+function compareSemver(a, b) {
+	const pa = parseStableTag(a);
+	const pb = parseStableTag(b);
+	if (pa === null && pb === null) return 0;
+	if (pa === null) return -1;
+	if (pb === null) return 1;
+	if (pa.major !== pb.major) return pa.major < pb.major ? -1 : 1;
+	if (pa.minor !== pb.minor) return pa.minor < pb.minor ? -1 : 1;
+	if (pa.patch !== pb.patch) return pa.patch < pb.patch ? -1 : 1;
+	return 0;
+}
+/** Hit the GitHub Releases API. Resolves with the first stable release
+*  GitHub returned, or null if the list contains no stable entries.
+*  Network / parse errors reject — the caller is responsible for
+*  collapsing them to a log line. */
+function fetchLatestStableRelease() {
+	return new Promise((resolve, reject) => {
+		const req = request({
+			method: "GET",
+			host: "api.github.com",
+			path: `${RELEASES_PATH}?per_page=${PER_PAGE}`,
+			headers: {
+				"user-agent": "dsh-deeppilot-update-check",
+				"accept": "application/vnd.github+json"
+			}
+		}, (res) => {
+			const status = res.statusCode ?? 0;
+			if (status < 200 || status >= 300) {
+				res.resume();
+				reject(/* @__PURE__ */ new Error(`github releases http ${status}`));
+				return;
+			}
+			const chunks = [];
+			res.on("data", (chunk) => chunks.push(chunk));
+			res.on("end", () => {
+				try {
+					const body = Buffer.concat(chunks).toString("utf8");
+					const parsed = JSON.parse(body);
+					if (!Array.isArray(parsed)) {
+						reject(/* @__PURE__ */ new Error("github releases: response is not an array"));
+						return;
+					}
+					for (const entry of parsed) {
+						const stable = parseStableEntry(entry);
+						if (stable !== null) {
+							resolve(stable);
+							return;
+						}
+					}
+					resolve(null);
+				} catch (error) {
+					reject(error instanceof Error ? error : new Error(String(error)));
+				}
+			});
+			res.on("error", (error) => reject(error));
+		});
+		req.setTimeout(FETCH_TIMEOUT_MS, () => {
+			req.destroy(/* @__PURE__ */ new Error("github releases: timeout after 8000ms"));
+		});
+		req.on("error", (error) => reject(error));
+		req.end();
+	});
+}
+/**
+* Process-wide check state. Constructed once in `apply()`, queried
+* synchronously by the report snapshot. The check itself fires once in
+* the background shortly after boot; the answer lives for the lifetime
+* of the host process — re-running the page in the Web UI does not
+* trigger another network call.
+*/
+var UpdateChecker = class {
+	log;
+	currentVersion;
+	fetchImpl;
+	initialDelayMs;
+	snapshot;
+	inflight = null;
+	constructor(options) {
+		this.log = options.log;
+		this.currentVersion = options.currentVersion;
+		this.fetchImpl = options.fetchImpl ?? fetchLatestStableRelease;
+		this.initialDelayMs = options.initialDelayMs ?? 2e3;
+		this.snapshot = {
+			currentVersion: this.currentVersion,
+			available: false,
+			releaseUrl: null,
+			latestVersion: null
+		};
+	}
+	/** Return the current in-memory snapshot — safe to call from any host
+	*  thread. Never throws, never awaits. */
+	get() {
+		return this.snapshot;
+	}
+	/**
+	* Schedule one background refresh after the configured initial delay.
+	* Used by the plugin entry to do the first check without blocking boot.
+	*/
+	scheduleInitial() {
+		if (this.initialDelayMs <= 0) {
+			this.runOnce();
+			return;
+		}
+		const timer = setTimeout(() => {
+			this.runOnce();
+		}, this.initialDelayMs);
+		if (typeof timer.unref === "function") timer.unref();
+	}
+	async runOnce() {
+		if (this.inflight !== null) {
+			await this.inflight;
+			return;
+		}
+		const task = (async () => {
+			try {
+				const stable = await this.fetchImpl();
+				if (stable === null) return;
+				if (compareSemver(stable.tag, this.currentVersion) > 0) this.snapshot = {
+					currentVersion: this.currentVersion,
+					available: true,
+					releaseUrl: stable.url,
+					latestVersion: stable.tag
+				};
+				else this.snapshot = {
+					currentVersion: this.currentVersion,
+					available: false,
+					releaseUrl: null,
+					latestVersion: null
+				};
+			} catch (error) {
+				this.log("update check failed: " + (error instanceof Error ? error.message : String(error)));
+			}
+		})();
+		this.inflight = task.finally(() => {
+			this.inflight = null;
+		});
+		return this.inflight;
+	}
+	/** No-op kept for API symmetry with the host lifecycle wiring. */
+	dispose() {}
+};
+//#endregion
 //#region src/index.ts
 /**
 * dsh-deeppilot — data bridge between the DSH host and DeepPilot
@@ -2933,7 +3377,7 @@ const Config = z.object({
 		relayToken: ""
 	})
 });
-const SERVER_VERSION = "0.2.0";
+const SERVER_VERSION = readOwnPackageVersion();
 const MAX_CLIENT_CONNECTIONS = 16;
 /**
 * Single-frame bound. Covers the protocol maximum (4 × 8 MB base64 images
@@ -2941,6 +3385,22 @@ const MAX_CLIENT_CONNECTIONS = 16;
 * pre-hello buffering far below ws's 100 MiB default.
 */
 const MAX_FRAME_BYTES = 67108864;
+/**
+* Resolve the host plugin's own version from the installed package.json.
+* Sourced at boot so the wire / UI always agrees with what npm published.
+* `createRequire(import.meta.url)` is the tsdown-bundled ESM equivalent of
+* CommonJS's `require`; the package.json sits next to lib/index.js after
+* the build, so `../package.json` resolves to the published manifest.
+*/
+function readOwnPackageVersion() {
+	try {
+		const pkg = createRequire(import.meta.url)("../package.json");
+		if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+	} catch {}
+	const envVersion = process.env.npm_package_version;
+	if (typeof envVersion === "string" && envVersion.length > 0) return envVersion;
+	return "0.0.0+unknown";
+}
 function rejectUpgrade(socket, status, reason) {
 	const body = JSON.stringify({ error: reason });
 	socket.end("HTTP/1.1 " + status + " Forbidden\r\nContent-Type: application/json\r\nContent-Length: " + Buffer.byteLength(body) + "\r\nConnection: close\r\n\r\n" + body);
@@ -3207,6 +3667,10 @@ function apply(ctx, options) {
 	let enrollAttemptFor;
 	let enrollLastAttemptAt = 0;
 	const ensureRelayEnrolled = async (url) => {
+		if (!/^https:\/\//i.test(url.trim())) {
+			log("push relay enrollment refused: relayUrl must be an https URL");
+			return;
+		}
 		if (enrollmentCell.token) return enrollmentCell.token;
 		const fingerprint = url + ":" + String(enrollmentCell.enrollKey ?? "");
 		if (fingerprint !== enrollAttemptFor) {
@@ -3239,7 +3703,14 @@ function apply(ctx, options) {
 		}
 	};
 	let cachedSender;
+	/**
+	* Last failed APNs-sender build. The config fingerprint cannot see the
+	* filesystem, so remembering a failure forever meant "copy the .p8 into
+	* place later" never recovered without an edit or restart; throttle the
+	* retry by time instead — same pattern as relay enrollment below.
+	*/
 	let senderFailedFor;
+	const SENDER_FAILURE_RETRY_MS = 6e4;
 	/**
 	* Lazily build the push sender for the current config. A broken config
 	* (unreadable .p8) disables push for that fingerprint with exactly one log
@@ -3248,7 +3719,7 @@ function apply(ctx, options) {
 	const senderFor = async (resolved) => {
 		const fingerprint = JSON.stringify(resolved);
 		if (cachedSender?.fingerprint === fingerprint) return cachedSender.send;
-		if (senderFailedFor === fingerprint) return void 0;
+		if (senderFailedFor?.fingerprint === fingerprint && Date.now() - senderFailedFor.at < SENDER_FAILURE_RETRY_MS) return;
 		if (cachedSender) {
 			await cachedSender.dispose?.().catch(() => {});
 			cachedSender = void 0;
@@ -3269,7 +3740,10 @@ function apply(ctx, options) {
 			try {
 				await readFile(expandHome(resolved.keyPath), "utf8");
 			} catch (error) {
-				senderFailedFor = fingerprint;
+				senderFailedFor = {
+					fingerprint,
+					at: Date.now()
+				};
 				log("apns push unavailable (key unreadable at " + resolved.keyPath + "): " + String(error));
 				return;
 			}
@@ -3373,6 +3847,12 @@ function apply(ctx, options) {
 		phase: currentConfig().remote?.enabled === true ? "stopped" : "disabled",
 		updatedAt: Date.now()
 	};
+	const updateChecker = new UpdateChecker({
+		log,
+		currentVersion: SERVER_VERSION
+	});
+	updateChecker.scheduleInitial();
+	const updateInfo = () => updateChecker.get();
 	applyReportRemote(ctx, async () => {
 		let tokenReady = false;
 		let devices = [];
@@ -3391,9 +3871,13 @@ function apply(ctx, options) {
 				} } : {}
 			}));
 		} catch {}
+		const update = updateInfo();
 		return {
 			protocolVersion: 1,
 			serverVersion: SERVER_VERSION,
+			pluginVersion: update.currentVersion,
+			...update.available ? { updateAvailable: true } : {},
+			...update.releaseUrl !== null ? { releaseUrl: update.releaseUrl } : {},
 			enabled: currentConfig().enabled === true,
 			tokenPath: expandHome(currentConfig().authTokenPath ?? join(bridgeDataDir(), "auth-token")),
 			tokenReady,
@@ -3422,6 +3906,16 @@ function apply(ctx, options) {
 			}]
 		};
 		const url = (push.relayUrl ?? "").trim() || DEFAULT_RELAY_URL;
+		if (!/^https:\/\//i.test(url)) return {
+			url,
+			overall: "failed",
+			tokenIssued: false,
+			steps: [{
+				id: "health",
+				ok: false,
+				message: "relayUrl 必须是 https 地址：注册请求携带共享密钥，明文 HTTP 会把它暴露给链路上的任何节点"
+			}]
+		};
 		if (!enrollmentCell.clientId && enrollmentCell.enrollKey) {
 			enrollmentCell.clientId = "u_" + randomBytes(16).toString("base64url");
 			persistEnrollment();