@jaychang1989/dsh-webchat 0.7.0 → 0.7.1

package/README.en.md

@@ -54,12 +54,17 @@ Click again to collapse the panel. Switching to another panel (Plugins, Automati
 
 ## Staying signed in
 
-The host hands browser guests a **process-lifetime** partition (a fresh random name per run, with no `persist:` prefix), so cookies and site storage would die with the app — DSH's own side-card browser behaves the same way. This plugin takes that over: its host half runs inside the **Electron main process**, which is the only place a partition's cookies can be read (**HttpOnly ones included**; a renderer can never see them). It snapshots the cookies and the page's localStorage while you use the page, and puts them back **before** the page loads on the next run.
+The host hands browser guests a **process-lifetime** partition (a fresh random name per run, with no `persist:` prefix), so cookies and site storage would die with the app — DSH's own side-card browser behaves the same way. This plugin takes that over through **two channels**, because the host half does not always reach Electron:
+
+1. **Site storage** (localStorage) and the **page's own cookies**: carried by the guest itself, generically — no key names, no Electron.
+2. **Partition cookies, HttpOnly included**: only the Electron main process can read those. Used when reachable; `session.electron` in `GET /api/dsh-webchat/state` says plainly whether it is.
+
+The order: reserve the lease → restore first (cookies land before the first navigation, so the page's very first request already carries them) → write storage and the page's cookies once the first load finishes → reload once → snapshot as the page is used.
 
 - Location: `%USERPROFILE%\.dsh\dsh-webchat\session.json`
 - **Deleting that file logs the plugin's guest out** — it keeps nothing else behind.
 - The file holds live session credentials in **plain text**. It sits in your own profile directory (user-private by default), but it is not as protected as a browser's encrypted cookie store.
-- If DeepSeek changes how it stores the session you may have to sign in once more; the snapshot is then taken again automatically.
+- If DeepSeek keeps the session in an HttpOnly cookie *and* the host half cannot reach Electron, only the storage part can be kept — signing in again would then still happen.
 
 ## Known limitations
 

package/README.md

@@ -54,12 +54,17 @@ dsh plugin --profile desktop add github:jaychang1989/dsh-webchat
 
 ## 登录状态
 
-桌面端给浏览器访客的分区是**进程内**的（每次运行随机命名、不带 `persist:`），所以 cookie 和站点存储本来会随退出一起消失——DSH 自带的侧栏浏览器也是这样。本插件把这个接管了：宿主半区运行在 **Electron 主进程里**，因此能读到该分区的 cookie（**含 HttpOnly**，渲染进程永远看不到），它会在你使用过程中把 cookie 与页面的 localStorage 快照下来，下次启动时**先回灌、再加载页面**。
+桌面端给浏览器访客的分区是**进程内**的（每次运行随机命名、不带 `persist:`），所以 cookie 和站点存储本来会随退出一起消失——DSH 自带的侧栏浏览器也是这样。本插件把这个接管了，用**两条通道**——因为宿主半区不一定拿得到 Electron：
+
+1. **站点存储**（localStorage）与**页面自己的 cookie**：由页面侧通用搬运，不依赖任何键名，也不依赖 Electron；
+2. **分区 cookie（含 HttpOnly）**：只有宿主的 Electron 主进程读得到。能拿到就走这条；`GET /api/dsh-webchat/state` 的 `session.electron` 会如实说明。
+
+顺序：拿到租约 → 回灌（cookie 在首次导航前写回，页面第一个请求就带着它）→ 首次加载完成后再写入存储与 cookie → 刷新一次 → 之后按使用情况快照。
 
 - 文件位置：`%USERPROFILE%\.dsh\dsh-webchat\session.json`
 - **删掉这个文件就等于退出登录**（本插件不会再有别的残留）。
 - 文件里是**明文**会话凭据。它在你自己的用户目录下（默认只有你的账户可读），但确实不如浏览器那种加密 cookie 库。
-- 若 DeepSeek 更换登录态的存储方式，可能要重新登录一次——之后会自动重新快照。
+- 如果 DeepSeek 的登录态是 HttpOnly cookie、而宿主又拿不到 Electron，就只能保留存储部分——那种情况下重登仍会发生。
 
 ## 已知限制
 

package/lib/client.js

@@ -207,28 +207,50 @@ window.__ModuleLoader__.load({
 			return box
 		}
 
-		/** Read the guest page's own storage as `[[key, value], …]`. */
-		function readStorage(element) {
+		/**
+		 * Read everything the guest page itself can reach: its storage and its
+		 * own cookie string. That string cannot carry HttpOnly cookies — only the
+		 * host half can, and only when it reaches Electron — but it is what keeps
+		 * a login alive when it cannot.
+		 * @param element - the live webview.
+		 * @returns the guest state as JSON text.
+		 */
+		function readGuestState(element) {
 			return element.executeJavaScript(
-				"JSON.stringify(Object.keys(localStorage).map(function (key) { return [key, localStorage.getItem(key)] }))",
+				"JSON.stringify({ storage: Object.keys(localStorage).map(function (key) { return [key, localStorage.getItem(key)] }), cookie: document.cookie })",
 			)
 		}
 
-		/** Write `[[key, value], …]` back into the guest page's storage. */
-		function writeStorage(element, entries) {
+		/**
+		 * Write a guest state back into the page: storage keys, then cookies.
+		 * Cookies are re-scoped to the site root, which is where a login cookie
+		 * belongs; the original attributes are not recoverable from
+		 * `document.cookie`.
+		 * @param element - the live webview.
+		 * @param state - `{ storage, cookie }`.
+		 */
+		function writeGuestState(element, state) {
 			return element.executeJavaScript(
-				"(function () { var entries = " + JSON.stringify(entries) + ";"
-				+ " for (var i = 0; i < entries.length; i++) { try { localStorage.setItem(entries[i][0], entries[i][1]) } catch (error) {} }"
-				+ " return entries.length })()",
+				"(function () { var state = " + JSON.stringify(state) + ";"
+				+ " var storage = Array.isArray(state.storage) ? state.storage : [];"
+				+ " for (var i = 0; i < storage.length; i++) { try { localStorage.setItem(storage[i][0], storage[i][1]) } catch (error) {} }"
+				+ " if (typeof state.cookie === 'string' && state.cookie !== '') {"
+				+ " var parts = state.cookie.split('; ');"
+				+ " for (var j = 0; j < parts.length; j++) {"
+				+ " var pair = parts[j];"
+				+ " if (pair.indexOf('=') === -1) continue;"
+				+ " try { document.cookie = pair + '; path=/' } catch (error) {}"
+				+ " } }"
+				+ " return true })()",
 			)
 		}
 
 		/**
-		 * Ask the host to copy the saved cookies onto this run's partition. This
-		 * runs before the first navigation, so the page's first request already
-		 * carries them.
+		 * Ask the host to put the saved session back before the page is
+		 * navigated: cookies through the shell's session API where that is
+		 * reachable, and the guest's own storage and cookie string either way.
 		 * @param partition - the partition the shell issued for the lease.
-		 * @returns the saved site storage, or null when there is none usable.
+		 * @returns `{ storage, cookie }` to apply, or null when there is nothing.
 		 */
 		async function restoreGuestSession(partition) {
 			try {
@@ -238,11 +260,14 @@ window.__ModuleLoader__.load({
 					body: JSON.stringify({ partition }),
 				})
 				const payload = await response.json()
-				if (payload === null || typeof payload !== "object" || payload.ok !== true) {
-					console.warn("[dsh-webchat] session restore:", payload === null ? "no answer" : payload.error || "failed")
-					return null
+				if (payload === null || typeof payload !== "object") return null
+				if (payload.ok !== true) {
+					console.warn("[dsh-webchat] session cookies:", payload.error || "not restored")
 				}
-				return Array.isArray(payload.storage) && payload.storage.length > 0 ? payload.storage : null
+				const storage = Array.isArray(payload.storage) ? payload.storage : []
+				const cookie = typeof payload.cookie === "string" ? payload.cookie : ""
+				if (storage.length === 0 && cookie === "") return null
+				return { storage, cookie }
 			} catch (error) {
 				console.warn("[dsh-webchat] session restore failed:", error)
 				return null
@@ -250,23 +275,26 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * Ask the host to refresh the snapshot. Cookies are read host-side;
-		 * `withStorage` additionally ships the page's storage, which the unload
-		 * beacon deliberately skips (the host then keeps the previous one).
-		 * @param withStorage - whether to include the guest's storage.
+		 * Ask the host to refresh the snapshot. `withState` ships what only the
+		 * guest can read; the unload beacon deliberately skips it (the host then
+		 * keeps the previous values).
+		 * @param withState - whether to include the guest's own state.
 		 * @param target - the guest record; defaults to the live one, which
 		 *   disposal clears before its last save.
 		 */
-		async function saveGuestSession(withStorage, target) {
+		async function saveGuestSession(withState, target) {
 			const record = target === undefined ? guest : target
 			if (record === null || record === undefined) return
 			const body = { partition: record.partition }
-			if (withStorage) {
+			if (withState) {
 				try {
-					const parsed = JSON.parse(await readStorage(record.element))
-					if (Array.isArray(parsed)) body.storage = parsed
+					const state = JSON.parse(await readGuestState(record.element))
+					if (state !== null && typeof state === "object") {
+						if (Array.isArray(state.storage)) body.storage = state.storage
+						if (typeof state.cookie === "string") body.cookie = state.cookie
+					}
 				} catch (error) {
-					// Not ready, or nothing stored: cookies still get saved.
+					// Not ready: the host still snapshots whatever it can reach.
 				}
 			}
 			try {
@@ -294,8 +322,9 @@ window.__ModuleLoader__.load({
 						|| typeof reservation.lease !== "string" || typeof reservation.partition !== "string") {
 						throw new Error("the desktop browser bridge returned no reservation")
 					}
-					// Cookies land on the partition before anything is requested.
-					const storage = await restoreGuestSession(reservation.partition)
+					// Cookies land on the partition before anything is requested; the
+					// guest's own storage and cookie string come back with them.
+					const restored = await restoreGuestSession(reservation.partition)
 					const element = document.createElement("webview")
 					element.setAttribute("name", reservation.lease)
 					element.setAttribute("partition", reservation.partition)
@@ -317,17 +346,17 @@ window.__ModuleLoader__.load({
 							failure = messageOf(error)
 						})
 					}, { once: true })
-					// Site storage can only be written while the page is on its own
-					// origin, so it is restored after the first load and then the
-					// page is asked to load once more — this time already signed in.
-					// Until that settles, snapshots are skipped: the freshly loaded
-					// page still has empty storage, and saving that would erase the
-					// very snapshot being restored.
-					let storageState = storage === null ? "none" : "pending"
+					// Storage and cookies can only be written while the page is on
+					// its own origin, so both are restored after the first load and
+					// the page is then asked to load once more — this time already
+					// signed in. Until that settles, snapshots are skipped: the
+					// freshly loaded page still has empty storage, and saving that
+					// would erase the very snapshot being restored.
+					let storageState = restored === null ? "none" : "pending"
 					element.addEventListener("did-finish-load", function () {
 						if (storageState !== "pending") return
 						storageState = "restoring"
-						Promise.resolve(writeStorage(element, storage))
+						Promise.resolve(writeGuestState(element, restored))
 							.then(function () {
 								storageState = "done"
 								element.reload()

package/lib/index.js

@@ -134,6 +134,10 @@ export function readSnapshot(file) {
     return {
       cookies: Array.isArray(parsed.cookies) ? parsed.cookies : [],
       storage: Array.isArray(parsed.storage) ? parsed.storage : [],
+      // The page's own `document.cookie` string, kept by the browser half. It
+      // cannot carry HttpOnly cookies, but it is what survives when this process
+      // has no Electron session API at all.
+      cookie: typeof parsed.cookie === 'string' ? parsed.cookie : '',
       savedAt: typeof parsed.savedAt === 'string' ? parsed.savedAt : '',
     }
   } catch (error) {
@@ -288,8 +292,17 @@ function messageOf(error) {
  */
 async function electronApi() {
   if (electronLoader !== null) return electronLoader()
-  const usable = (mod) => (mod !== null && typeof mod === 'object'
-    && (mod.BrowserWindow !== undefined || mod.session !== undefined) ? mod : undefined)
+  // Electron's ESM namespace can carry the real API under `default` when its
+  // named exports are not statically detectable, and this loader hands back
+  // exactly that shape, so both forms are accepted.
+  const usable = (mod) => {
+    if (mod === null || typeof mod !== 'object') return undefined
+    if (mod.BrowserWindow !== undefined || mod.session !== undefined) return mod
+    const inner = mod.default
+    if (inner !== null && typeof inner === 'object'
+      && (inner.BrowserWindow !== undefined || inner.session !== undefined)) return inner
+    return undefined
+  }
   const failures = []
   try {
     const fromImport = usable(await import('electron'))
@@ -506,18 +519,28 @@ export function apply(ctx) {
       }
       const snapshot = readSnapshot(SESSION_FILE())
       if (snapshot === null) {
-        json(res, 200, { ok: true, cookies: 0, storage: null, savedAt: '' })
+        json(res, 200, { ok: true, cookies: 0, storage: null, cookie: '', savedAt: '' })
         return
       }
+      let restored = 0
+      let error = ''
       try {
         const session = await partitionSession(partition)
-        const restored = await restoreCookies(session.cookies, snapshot)
-        json(res, 200, { ok: true, cookies: restored, storage: snapshot.storage, savedAt: snapshot.savedAt })
-      } catch (error) {
-        // No snapshot is worse than an unreachable session: the guest must still
-        // load, so this answers with a reason instead of a failure status.
-        json(res, 200, { ok: false, error: messageOf(error), storage: null })
+        restored = await restoreCookies(session.cookies, snapshot)
+      } catch (failure) {
+        // Without a session API the HttpOnly cookies cannot come back, but the
+        // guest still gets its storage and its own cookie string, so this is
+        // reported rather than fatal.
+        error = messageOf(failure)
       }
+      json(res, 200, {
+        ok: error === '',
+        error,
+        cookies: restored,
+        storage: snapshot.storage,
+        cookie: snapshot.cookie,
+        savedAt: snapshot.savedAt,
+      })
     },
   }), 'dsh-webchat: session restore route')
 
@@ -537,21 +560,29 @@ export function apply(ctx) {
         json(res, 400, { ok: false, error: 'dsh-webchat: not a browser-guest partition' })
         return
       }
+      const file = SESSION_FILE()
+      const previous = readSnapshot(file)
+      // A save without site storage (the unload beacon) must not erase what an
+      // earlier save captured.
+      const storage = body !== null && Array.isArray(body.storage)
+        ? body.storage
+        : (previous === null ? [] : previous.storage)
+      const cookie = body !== null && typeof body.cookie === 'string'
+        ? body.cookie
+        : (previous === null ? '' : previous.cookie)
+      // The snapshot is written even when this process cannot reach Electron:
+      // site storage and the page's own cookie string are carried by the guest
+      // and are still worth keeping.
+      let cookies = []
+      let error = ''
       try {
         const session = await partitionSession(partition)
-        const cookies = await captureCookies(session.cookies)
-        const file = SESSION_FILE()
-        const previous = readSnapshot(file)
-        // A save without site storage (the unload beacon) must not erase what an
-        // earlier save captured.
-        const storage = body !== null && Array.isArray(body.storage)
-          ? body.storage
-          : (previous === null ? [] : previous.storage)
-        writeSnapshot(file, { version: 1, savedAt: new Date().toISOString(), cookies, storage })
-        json(res, 200, { ok: true, cookies: cookies.length, storage: storage.length })
-      } catch (error) {
-        json(res, 502, { ok: false, error: messageOf(error) })
+        cookies = await captureCookies(session.cookies)
+      } catch (failure) {
+        error = messageOf(failure)
       }
+      writeSnapshot(file, { version: 1, savedAt: new Date().toISOString(), cookies, storage, cookie })
+      json(res, 200, { ok: true, cookies: cookies.length, storage: storage.length, cookie: cookie !== '', error })
     },
   }), 'dsh-webchat: session save route')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaychang1989/dsh-webchat",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Opens the official DeepSeek web app (chat.deepseek.com) inside DeepSeek Harness: one sidebar entry renders the real page in the center column, through the same native browser guest the built-in side-card browser uses. No chat UI, no agent tools, no runtime dependencies.",
   "keywords": [
     "dsh",