dsh-select-quote 0.3.2 → 0.3.3

package/README.md

@@ -51,7 +51,7 @@ dsh web --patch "$PWD/dev.patch.yml"
 
 ## 已知限制
 
-- **待发批注只在内存里**：刷新页面或切换会话后会丢，卡片不持久化；已发送消息里的批注不受影响。
+- **待发批注按会话持久化**：刷新页面、重启客户端后回到原会话，未发送的批注会原样回来（和草稿同一套机制）；保留最近 20 个会话、7 天。发送即清除，切换会话跟着切，hero 里换工作区等于换会话，批注不跟着搬。
 - **占用了用户气泡的渲染**：本插件以最低优先级替换内置 `user` 节点。其它插件若替换同一个键（例如 `dsh-easyrewrite` 用 `-1`），会被本插件屏蔽。
 - **卡片宽度有限**：输入框内每条摘要最宽约为输入框的 1/4，超长标题走省略号。
 - **划词只在对话区生效**：不介入编辑器、终端等面板。
@@ -92,7 +92,7 @@ pnpm run sync:desktop -- --watch  # 常驻：lib/ 一变就推
 pnpm dev:desktop                  # 增量重建 + 推送，一条命令
 ```
 
-目标路径按 `$DSH_HOME`（默认 `~/.dsh`）与 profile 名推导，profile 用 `--profile <name>` 或 `$DSH_PROFILE` 指定，默认 `desktop`。字节没变就不写，避免空重载。重载会重置插件的内存状态，未发送的批注会丢。
+目标路径按 `$DSH_HOME`（默认 `~/.dsh`）与 profile 名推导，profile 用 `--profile <name>` 或 `$DSH_PROFILE` 指定，默认 `desktop`。字节没变就不写，避免空重载。模块级重载会重置内存状态，但未发送的批注已按会话持久化，重新挂载后会自己回来。
 
 发布：先把源码与产物 `lib/` 一起提交，再跑
 

package/lib/client.js

@@ -975,9 +975,17 @@ function collectCleanText(root) {
 	return entries;
 }
 function flowItemOf(node) {
-	const item = (node instanceof Element ? node : node.parentElement)?.closest(FLOW_ITEM);
+	const item = (node instanceof Element ? node : node?.parentElement)?.closest(FLOW_ITEM);
 	return item instanceof HTMLElement ? item : null;
 }
+/**
+* True when the node lives inside a conversation message. Selections in the
+* sidebar, settings, model picker or any other app chrome are not quotes, so
+* the toolbar must stay away from them.
+*/
+function isInsideTranscript(node) {
+	return flowItemOf(node) !== null;
+}
 function pointOffset(entries, container, offset) {
 	for (const entry of entries) if (entry.node === container) return entry.start + Math.min(offset, entry.end - entry.start);
 	if (!(container instanceof Element)) return null;
@@ -1317,22 +1325,6 @@ function findElementByText(text) {
 	}
 	return best;
 }
-//#endregion
-//#region src/client/runtime.ts
-/**
-* Shared runtime handles across slot scopes.
-* The selection toolbar mounts at root (`shell.overlay`) while the annotation
-* panel is session-scoped — pending annotations use one shared store key so
-* both sides always read the same list.
-*/
-const runtime = {};
-function setRuntimeSession(sessionId) {
-	if (sessionId) runtime.sessionId = sessionId;
-}
-/** Store partition for pending annotations (single active composer). */
-function annotationStoreKey() {
-	return "pending";
-}
 const DRAFT_MARKER_RE = /\u200B/g;
 /** Plain text from Chat user-node content blocks (string or block array). */
 function contentBlocksToText(content) {
@@ -1525,11 +1517,27 @@ function scanAnnotatedMessage(text) {
 	};
 }
 //#endregion
+//#region src/client/runtime.ts
+/**
+* Shared runtime handles across slot scopes.
+*
+* The selection toolbar mounts at root (`shell.overlay`) while the annotation
+* panel is session-scoped, so both sides read one partition keyed by the
+* session the host minted for the active composer.
+*/
+const runtime = {};
+function setRuntimeSession(sessionId) {
+	if (sessionId) runtime.sessionId = sessionId;
+}
+//#endregion
 //#region src/client/state/annotation-store.ts
 /** Per-session pending selection annotations (composer-side store). */
 const EMPTY$1 = [];
+/** Bucket for annotations added before a session id is known (never persisted). */
+const MEMORY_KEY = "pending";
 const bySession = /* @__PURE__ */ new Map();
 const listeners = /* @__PURE__ */ new Set();
+let persistence = null;
 function notify() {
 	for (const listener of [...listeners]) listener();
 }
@@ -1539,12 +1547,25 @@ function subscribeAnnotations(listener) {
 		listeners.delete(listener);
 	};
 }
-function key(sessionId) {
-	return sessionId ?? annotationStoreKey();
+/**
+* Store partition: the live session when one is bound, otherwise a memory-only
+* bucket. The host always mints a session before the composer accepts text, so
+* the bucket is the "cannot happen" path and never reaches storage.
+*/
+function partition(sessionId) {
+	return sessionId ?? runtime.sessionId ?? MEMORY_KEY;
+}
+/** Attach the persistence port (null detaches it). */
+function setAnnotationPersistence(port) {
+	persistence = port;
+}
+function persist(partitionKey) {
+	if (!persistence || partitionKey === MEMORY_KEY) return;
+	persistence.save(partitionKey, bySession.get(partitionKey) ?? EMPTY$1);
 }
 /** Append one selection; an identical text+comment pair is reused. */
 function saveAnnotation(sessionId, input) {
-	const k = key(sessionId);
+	const k = partition(sessionId);
 	const comment = input.comment?.trim() ?? "";
 	const current = bySession.get(k) ?? EMPTY$1;
 	const duplicate = current.find((item) => item.text === input.text && (item.comment ?? "") === comment);
@@ -1556,14 +1577,15 @@ function saveAnnotation(sessionId, input) {
 		sources: input.sources?.length ? input.sources : [{ text: input.text }]
 	};
 	bySession.set(k, [...current, annotation]);
+	persist(k);
 	notify();
 	return annotation;
 }
 function getAnnotations(sessionId) {
-	return bySession.get(key(sessionId)) ?? EMPTY$1;
+	return bySession.get(partition(sessionId)) ?? EMPTY$1;
 }
 function updateAnnotationComment(sessionId, id, comment) {
-	const k = key(sessionId);
+	const k = partition(sessionId);
 	const current = bySession.get(k);
 	if (!current) return;
 	const next = current.map((item) => {
@@ -1578,20 +1600,59 @@ function updateAnnotationComment(sessionId, id, comment) {
 		};
 	});
 	bySession.set(k, next);
+	persist(k);
 	notify();
 }
 function removeAnnotation(sessionId, id) {
-	const k = key(sessionId);
+	const k = partition(sessionId);
 	const current = bySession.get(k);
 	if (!current) return;
 	const next = current.filter((item) => item.id !== id);
 	if (next.length === current.length) return;
 	if (next.length === 0) bySession.delete(k);
 	else bySession.set(k, next);
+	if (next.length === 0 && k !== MEMORY_KEY) persistence?.clear(k);
+	else persist(k);
 	notify();
 }
 function clearAnnotations(sessionId) {
-	if (bySession.delete(key(sessionId))) notify();
+	const k = partition(sessionId);
+	if (!bySession.delete(k)) return;
+	if (k !== MEMORY_KEY) persistence?.clear(k);
+	notify();
+}
+/**
+* Bind the active session and adopt whatever it left unsent.
+*
+* Called from render-phase bridges, so adoption is deferred to a microtask:
+* the resulting notify() must not land inside another component's render.
+* Re-binding the same session is a no-op.
+*/
+function bindAnnotationSession(sessionId) {
+	if (!sessionId || sessionId === runtime.sessionId) return;
+	setRuntimeSession(sessionId);
+	queueMicrotask(() => adoptPersistedAnnotations(sessionId));
+}
+/**
+* Adopt persisted annotations for a session.
+*
+* In-memory entries win on conflict — they can only be newer, because anything
+* added after the bind is persisted immediately. Annotations parked in the
+* memory-only bucket (added before the bind) move over as well.
+*/
+function adoptPersistedAnnotations(sessionId) {
+	if (!persistence) return;
+	const stored = persistence.load(sessionId);
+	const current = bySession.get(sessionId) ?? EMPTY$1;
+	const orphaned = bySession.get(MEMORY_KEY) ?? EMPTY$1;
+	const merged = /* @__PURE__ */ new Map();
+	for (const item of stored) merged.set(item.id, item);
+	for (const item of [...current, ...orphaned]) merged.set(item.id, item);
+	const next = [...merged.values()];
+	if (next.length === current.length && next.every((item, i) => item.id === current[i]?.id) && orphaned.length === 0) return;
+	bySession.set(sessionId, next);
+	if (orphaned.length > 0) bySession.delete(MEMORY_KEY);
+	notify();
 }
 function annotationTitle(annotation) {
 	return previewTitle(annotation.text);
@@ -2347,6 +2408,31 @@ function useSendIntercept({ itemCount, draftRef, setDraft, onFolded }) {
 //#region src/client/composer/AnnotationPanel.tsx
 const EMPTY = [];
 /**
+* True while an IME composition is in flight.
+*
+* Composition events bubble, so a capture listener on the document sees them
+* wherever the composer lives. Anything that writes the draft must check this:
+* replacing editor content mid-composition drops the composing text.
+*/
+function useComposing() {
+	const composing = (0, react.useRef)(false);
+	(0, react.useEffect)(() => {
+		const onStart = () => {
+			composing.current = true;
+		};
+		const onEnd = () => {
+			composing.current = false;
+		};
+		document.addEventListener("compositionstart", onStart, true);
+		document.addEventListener("compositionend", onEnd, true);
+		return () => {
+			document.removeEventListener("compositionstart", onStart, true);
+			document.removeEventListener("compositionend", onEnd, true);
+		};
+	}, []);
+	return composing;
+}
+/**
 * Composer annotation summary (`conversation.input.overlay`).
 *
 * Pending selections never enter the editor as text: the summary card is the
@@ -2360,6 +2446,7 @@ function AnnotationPanel({ useInput, inputActions, sessionId }) {
 	const draftRef = (0, react.useRef)(draft);
 	const actionsRef = (0, react.useRef)(inputActions);
 	const sessionRef = (0, react.useRef)(sessionId);
+	const composing = useComposing();
 	draftRef.current = draft;
 	actionsRef.current = inputActions;
 	sessionRef.current = sessionId;
@@ -2370,7 +2457,7 @@ function AnnotationPanel({ useInput, inputActions, sessionId }) {
 		setItems(getAnnotations());
 	}, []);
 	(0, react.useEffect)(() => {
-		if (sessionId) setRuntimeSession(sessionId);
+		bindAnnotationSession(sessionId);
 	}, [sessionId]);
 	(0, react.useEffect)(() => {
 		ensureToolbarStyles();
@@ -2406,6 +2493,19 @@ function AnnotationPanel({ useInput, inputActions, sessionId }) {
 		setDraft,
 		onFolded: () => setItems(EMPTY)
 	});
+	(0, react.useEffect)(() => {
+		if (composing.current) return;
+		if (items.length === 0) {
+			if (draft.includes("​")) setDraft(stripDraftMarker(draft));
+			return;
+		}
+		if (!draft.includes("​") && draft.trim() === "") setDraft(withDraftMarker(draft));
+	}, [
+		items,
+		draft,
+		setDraft,
+		composing
+	]);
 	const onRemoveAll = (0, react.useCallback)(() => {
 		clearAnnotations();
 		setItems(EMPTY);
@@ -2505,7 +2605,8 @@ function toolbarPosition(rect) {
 	};
 }
 /**
-* Read the live selection when it is a non-empty range outside the composer.
+* Read the live selection when it is a non-empty range inside a conversation
+* message and outside the composer / our own chrome.
 */
 function readSelectionSnapshot(toolbarRoot) {
 	const selection = window.getSelection();
@@ -2514,6 +2615,7 @@ function readSelectionSnapshot(toolbarRoot) {
 	if (!anchorNode || !focusNode) return null;
 	if (isInsideComposerInput(anchorNode) || isInsideComposerInput(focusNode)) return null;
 	if (toolbarRoot?.contains(anchorNode) || toolbarRoot?.contains(focusNode)) return null;
+	if (!isInsideTranscript(anchorNode) || !isInsideTranscript(focusNode)) return null;
 	const text = selection.toString().replace(/\r\n/g, "\n").trim();
 	if (!text) return null;
 	const rect = getRangeFirstLineRect(selection.getRangeAt(0));
@@ -2562,7 +2664,7 @@ function SelectionToolbar({ sessionId }) {
 	activeRef.current = active;
 	(0, react.useEffect)(() => {
 		ensureToolbarStyles();
-		if (sessionId) setRuntimeSession(sessionId);
+		if (sessionId) bindAnnotationSession(sessionId);
 	}, [sessionId]);
 	const hide = (0, react.useCallback)(() => {
 		setActive(null);
@@ -3033,6 +3135,204 @@ function UserMessageDisplay({ node, renderMessageImages }) {
 	});
 }
 //#endregion
+//#region src/client/state/annotation-persistence.ts
+/** localStorage prefix; a session id is appended as `.<sessionId>`. */
+const ANNOTATION_KEY_PREFIX = "dsh.select-quote.annotations";
+const PAYLOAD_VERSION = 1;
+function keyForSession(sessionId) {
+	return `${ANNOTATION_KEY_PREFIX}.${sessionId}`;
+}
+function sessionIdOfKey(key) {
+	const prefix = `${ANNOTATION_KEY_PREFIX}.`;
+	return key.startsWith(prefix) ? key.slice(prefix.length) : null;
+}
+function isAnnotation(value) {
+	if (!value || typeof value !== "object") return false;
+	const item = value;
+	return typeof item.id === "string" && typeof item.text === "string" && Array.isArray(item.sources);
+}
+/** Tolerant read: a corrupt or foreign payload degrades to "nothing stored". */
+function itemsOf(value) {
+	if (!value || typeof value !== "object") return [];
+	const payload = value;
+	if (!Array.isArray(payload.items)) return [];
+	return payload.items.filter(isAnnotation);
+}
+function encode(items, now) {
+	return JSON.stringify({
+		v: PAYLOAD_VERSION,
+		updatedAt: now,
+		items
+	});
+}
+function decode(raw) {
+	if (raw === null) return [];
+	try {
+		return itemsOf(JSON.parse(raw));
+	} catch {
+		return [];
+	}
+}
+/** One warn per session, never a throw: a full quota must not break typing. */
+let quotaWarned = false;
+function warnQuota() {
+	if (quotaWarned) return;
+	quotaWarned = true;
+	console.warn("dsh-select-quote: annotation persistence disabled (storage write failed)");
+}
+/**
+* Direct localStorage backend (the documented fallback). Writes are wrapped so
+* a quota failure degrades to memory-only instead of breaking the composer.
+*/
+function createStoragePersistence(storage) {
+	let degraded = false;
+	return {
+		load: (sessionId) => decode(storage.getItem(keyForSession(sessionId))),
+		save: (sessionId, items) => {
+			if (degraded) return;
+			try {
+				storage.setItem(keyForSession(sessionId), encode(items, Date.now()));
+			} catch {
+				degraded = true;
+				warnQuota();
+			}
+		},
+		clear: (sessionId) => {
+			try {
+				storage.removeItem(keyForSession(sessionId));
+			} catch {}
+		},
+		prune: (now) => pruneSessions(storage, now)
+	};
+}
+/**
+* Host store backend: the same `defineStore` the composer draft uses, so the
+* write path, per-session keying and failure semantics are the host's.
+*/
+function createHostStorePersistence(defineStore, storage) {
+	const handle = defineStore({
+		init: () => ({
+			v: PAYLOAD_VERSION,
+			updatedAt: 0,
+			items: []
+		}),
+		persist: ANNOTATION_KEY_PREFIX,
+		actions: { replace(draft, items, now) {
+			draft.items = [...items];
+			draft.updatedAt = now;
+		} }
+	});
+	const instances = /* @__PURE__ */ new Map();
+	const instanceOf = (sessionId) => {
+		const cached = instances.get(sessionId);
+		if (cached) return cached;
+		const instance = handle.create(sessionId);
+		instances.set(sessionId, instance);
+		return instance;
+	};
+	return {
+		load: (sessionId) => itemsOf(instanceOf(sessionId).getSnapshot()),
+		save: (sessionId, items) => instanceOf(sessionId).actions.replace(items, Date.now()),
+		clear: (sessionId) => {
+			instanceOf(sessionId).clearPersisted();
+			instances.delete(sessionId);
+		},
+		prune: (now) => {
+			const removed = pruneSessions(storage, now);
+			for (const sessionId of removed) instances.delete(sessionId);
+			return removed;
+		}
+	};
+}
+/** Retention: newest `maxSessions` within `maxAgeMs`, by payload timestamp. */
+function pruneSessions(storage, now = Date.now(), options = {}) {
+	const maxSessions = options.maxSessions ?? 20;
+	const maxAgeMs = options.maxAgeMs ?? 6048e5;
+	const rows = [];
+	for (const key of storage.keys()) {
+		const sessionId = sessionIdOfKey(key);
+		if (sessionId === null) continue;
+		const raw = storage.getItem(key);
+		let updatedAt = 0;
+		try {
+			const parsed = JSON.parse(raw ?? "null");
+			if (parsed && typeof parsed.updatedAt === "number") updatedAt = parsed.updatedAt;
+		} catch {
+			updatedAt = 0;
+		}
+		rows.push({
+			sessionId,
+			updatedAt
+		});
+	}
+	const removed = /* @__PURE__ */ new Set();
+	for (const row of rows) if (now - row.updatedAt > maxAgeMs) removed.add(row.sessionId);
+	rows.sort((a, b) => b.updatedAt - a.updatedAt);
+	for (const row of rows.slice(maxSessions)) removed.add(row.sessionId);
+	for (const sessionId of removed) storage.removeItem(keyForSession(sessionId));
+	return [...removed];
+}
+function createNoopPersistence() {
+	return {
+		load: () => [],
+		save: () => {},
+		clear: () => {},
+		prune: () => []
+	};
+}
+//#endregion
+//#region src/client/state/annotation-storage.ts
+/**
+* Backend selection for annotation persistence.
+*
+* Kept apart from `annotation-persistence.ts` because reaching the host's
+* client-store needs a guarded `require`, and that is the one thing the pure
+* module cannot do — verify-bundle imports the pure module straight into Node,
+* where a `declare` statement is not valid JavaScript.
+*
+* Preference order: the host store (same engine and keying as the composer
+* draft), plain localStorage, and a no-op when the environment has no storage
+* at all.
+*/
+/** The host package is a platform seed word; older hosts may not carry it. */
+const HOST_STORE_MODULE = "@deepseek-ai/dsh-client-store";
+function hostDefineStore() {
+	try {
+		const loaded = require(HOST_STORE_MODULE);
+		return typeof loaded?.defineStore === "function" ? loaded.defineStore : null;
+	} catch {
+		return null;
+	}
+}
+function browserStorage() {
+	try {
+		const storage = globalThis.localStorage;
+		if (!storage) return null;
+		return {
+			getItem: (key) => storage.getItem(key),
+			setItem: (key, value) => storage.setItem(key, value),
+			removeItem: (key) => storage.removeItem(key),
+			keys: () => {
+				const out = [];
+				for (let i = 0; i < storage.length; i += 1) {
+					const key = storage.key(i);
+					if (key !== null) out.push(key);
+				}
+				return out;
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+function createAnnotationPersistence() {
+	const storage = browserStorage();
+	const defineStore = hostDefineStore();
+	if (storage && defineStore) return createHostStorePersistence(defineStore, storage);
+	if (storage) return createStoragePersistence(storage);
+	return createNoopPersistence();
+}
+//#endregion
 //#region src/client/index.tsx
 /**
 * Browser half of dsh-select-quote.
@@ -3077,6 +3377,12 @@ function apply(ctx) {
 		syncPendingAnnotationJobs(getAnnotations());
 		return subscribeAnnotations(() => syncPendingAnnotationJobs(getAnnotations()));
 	}, "dsh-select-quote: pending annotation marks");
+	ctx.effect(() => {
+		const port = createAnnotationPersistence();
+		setAnnotationPersistence(port);
+		port.prune();
+		return () => setAnnotationPersistence(null);
+	}, "dsh-select-quote: annotation persistence");
 	ctx.slots.inject("shell.overlay", () => {
 		ctx.slots.register({
 			name: "shell.overlay",
@@ -3108,7 +3414,7 @@ function apply(ctx) {
 }
 /** Invisible session-scoped bridge that publishes sessionId for the root toolbar. */
 function SessionBridge({ sessionId }) {
-	setRuntimeSession(sessionId);
+	bindAnnotationSession(sessionId);
 	return null;
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-select-quote",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "DeepSeek Harness web plugin: annotate text selected in the conversation — the selection rides along with your next message, is marked in the source text, and the model points back at it.",
   "keywords": [
     "deepseek",