@jaychang1989/dsh-webchat 0.5.2 → 0.7.0

package/lib/index.js

@@ -1,35 +1,35 @@
 /**
- * dsh-webchat — minimal launcher half.
+ * dsh-webchat — host half.
  *
- * The DeepSeek web app IS the client: chat.deepseek.com already ships the model
- * picker, deep think, smart search, history and attachments. This plugin does
- * not reimplement any of that any more — it opens that page in a window and
- * gets out of the way. Everything the previous release did around it (a custom
- * chat panel, transcript storage, /api/dsh-webchat engine routes, the
- * webchat_status/send/recover/import/transfer tools, transfer distillation)
- * has been removed.
+ * Two jobs:
  *
- * Why a window and not a pane: chat.deepseek.com sends
- * `Content-Security-Policy: frame-ancestors 'none'`, so it cannot be framed,
- * and the desktop build runs with `webviewTag: false`, so it cannot be a
- * `<webview>` either. A real window is the only faithful way to show the
- * official page.
+ * 1. **Session survival.** The browser half renders chat.deepseek.com inside
+ *    the DSH window through the shell's native browser guest, and the shell
+ *    gives every guest a process-lifetime partition — so the DeepSeek login is
+ *    gone after every restart. This half runs in the Electron main process, the
+ *    only place that can read a partition's cookies (HttpOnly ones included),
+ *    so it snapshots them to disk and puts them back on the next run. The
+ *    browser half captures the page's own storage and calls these routes.
  *
- * Three strategies are tried in order, so the button always does something:
- *   1. `app-window`       — a BrowserWindow created by this process (the DSH
- *                           desktop app is Electron). Focused instead of
- *                           duplicated when one is already open.
- *   2. `app-window-shell` — a chromeless Edge/Chrome window (`--app=`) with its
- *                           own user-data-dir, for hosts where (1) is denied.
- *   3. `system-browser`   — the OS default browser.
+ * 2. **A window fallback.** Where no guest bridge exists (a plain `dsh web`
+ *    profile) the page cannot be embedded at all, so the browser half asks this
+ *    half to open it in a window. Three strategies are tried in order:
+ *      - `app-window`       — a BrowserWindow created by this process (the DSH
+ *                             desktop app is Electron), focused instead of
+ *                             duplicated when one is already open;
+ *      - `app-window-shell` — a chromeless Edge/Chrome window (`--app=`) with
+ *                             its own user-data-dir;
+ *      - `system-browser`   — the OS default browser.
  *
- * The browser half (./client) renders the single button that calls this.
+ * Routes: `GET /state` (diagnostics), `POST /open` (the fallback),
+ * `POST /session/restore` and `POST /session/save` (the snapshot).
  */
 
 import { spawn } from 'node:child_process'
-import { existsSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
-import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
 
 /**
  * A CommonJS `require` anchored at this module. Electron hands `electron` to
@@ -47,10 +47,188 @@ export const inject = ['webServer']
 /** The page this plugin exists to open. */
 export const PAGE_URL = 'https://chat.deepseek.com/'
 
-/** Route family; the browser half spells the same two paths. */
+/** Route family; the browser half spells the same paths. */
 export const ROUTES = {
   state: '/api/dsh-webchat/state',
   open: '/api/dsh-webchat/open',
+  restore: '/api/dsh-webchat/session/restore',
+  save: '/api/dsh-webchat/session/save',
+}
+
+/**
+ * The shell hands browser guests a **process-lifetime** session partition
+ * (`dsh-sidebar-browser-<uuid>`, no `persist:` prefix, fresh name every run), so
+ * cookies and site storage die with the app — DSH's own side-card browser
+ * behaves the same way. The plugin cannot ask for another partition: the main
+ * process compares `params.partition` against the lease it issued.
+ *
+ * So this half keeps the guest's session alive across restarts by hand. It runs
+ * in the Electron main process, which is what makes it possible at all: only
+ * there can `session.cookies` be read, and that includes HttpOnly cookies, which
+ * a renderer can never see. Site storage is captured by the browser half.
+ *
+ * The snapshot holds live session credentials in plain text under the user's own
+ * profile directory (that directory is user-private by default). Deleting the
+ * file logs the plugin's guest out.
+ */
+export const SESSION_FILE = () => sessionFilePath === null
+  ? join(homedir(), '.dsh', 'dsh-webchat', 'session.json')
+  : sessionFilePath
+
+/** Overridable snapshot path, so tests never touch the real profile directory. */
+let sessionFilePath = null
+
+/** Point the snapshot somewhere else. Test seam; production leaves it unset. */
+export function setSessionFile(path) {
+  sessionFilePath = path
+}
+
+/** Overridable Electron lookup, so the routes' glue is testable outside Electron. */
+let electronLoader = null
+
+/** Replace the Electron lookup. Test seam; production leaves it unset. */
+export function setElectronLoader(loader) {
+  electronLoader = loader
+}
+
+/** A partition name the shell issues for a browser guest, and nothing else. */
+const GUEST_PARTITION = /^dsh-sidebar-browser-[0-9a-f-]{8,}$/
+
+/** Electron reachability, probed once and reported through the state route. */
+let electronStatus = 'unknown'
+
+/** Read a JSON request body; a malformed or oversized body reads as null. */
+function readJsonBody(req, limit = 2 * 1024 * 1024) {
+  return new Promise((resolve) => {
+    let size = 0
+    const chunks = []
+    req.on('data', (chunk) => {
+      size += chunk.length
+      if (size > limit) {
+        req.destroy()
+        resolve(null)
+        return
+      }
+      chunks.push(chunk)
+    })
+    req.on('end', () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}'))
+      } catch (error) {
+        resolve(null)
+      }
+    })
+    req.on('error', () => resolve(null))
+  })
+}
+
+/**
+ * Read the saved snapshot.
+ * @param file - snapshot path.
+ * @returns the snapshot, or null when there is nothing usable on disk.
+ */
+export function readSnapshot(file) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'))
+    if (parsed === null || typeof parsed !== 'object') return null
+    return {
+      cookies: Array.isArray(parsed.cookies) ? parsed.cookies : [],
+      storage: Array.isArray(parsed.storage) ? parsed.storage : [],
+      savedAt: typeof parsed.savedAt === 'string' ? parsed.savedAt : '',
+    }
+  } catch (error) {
+    return null
+  }
+}
+
+/** Write the snapshot atomically, user-private, so a crash cannot truncate it. */
+export function writeSnapshot(file, snapshot) {
+  mkdirSync(dirname(file), { recursive: true })
+  const temp = `${file}.tmp`
+  writeFileSync(temp, `${JSON.stringify(snapshot, null, 2)}\n`, { mode: 0o600 })
+  renameSync(temp, file)
+}
+
+/**
+ * Copy saved cookies onto a partition's session.
+ * @param cookies - `session.cookies` of the live partition.
+ * @param snapshot - a snapshot from {@link readSnapshot}.
+ * @returns how many cookies the session accepted.
+ */
+export async function restoreCookies(cookies, snapshot) {
+  let restored = 0
+  for (const cookie of snapshot.cookies) {
+    if (cookie === null || typeof cookie !== 'object') continue
+    if (typeof cookie.name !== 'string' || typeof cookie.value !== 'string') continue
+    const domain = typeof cookie.domain === 'string' ? cookie.domain : ''
+    if (domain === '') continue
+    const path = typeof cookie.path === 'string' && cookie.path !== '' ? cookie.path : '/'
+    const details = {
+      url: `${cookie.secure === true ? 'https' : 'http'}://${domain.replace(/^\./, '')}${path}`,
+      name: cookie.name,
+      value: cookie.value,
+      domain,
+      path,
+      secure: cookie.secure === true,
+      httpOnly: cookie.httpOnly === true,
+    }
+    if (typeof cookie.expirationDate === 'number') details.expirationDate = cookie.expirationDate
+    if (typeof cookie.sameSite === 'string') details.sameSite = cookie.sameSite
+    try {
+      await cookies.set(details)
+      restored += 1
+    } catch (error) {
+      // A cookie the running Electron refuses (bad domain, expired, …) is not
+      // worth failing the whole restore for.
+    }
+  }
+  return restored
+}
+
+/**
+ * Serialize a partition's cookies, HttpOnly ones included.
+ * @param cookies - `session.cookies` of the live partition.
+ * @returns plain objects safe to write to disk.
+ */
+export async function captureCookies(cookies) {
+  const list = await cookies.get({})
+  return list.map((cookie) => ({
+    name: cookie.name,
+    value: cookie.value,
+    domain: cookie.domain,
+    path: cookie.path,
+    secure: cookie.secure === true,
+    httpOnly: cookie.httpOnly === true,
+    ...(typeof cookie.expirationDate === 'number' ? { expirationDate: cookie.expirationDate } : {}),
+    ...(typeof cookie.sameSite === 'string' ? { sameSite: cookie.sameSite } : {}),
+  }))
+}
+
+/**
+ * The live session of a guest partition, through the Electron main process.
+ * @param partition - the partition name the shell issued for the lease.
+ * @returns the Electron session.
+ * @throws when this process cannot reach Electron or refuses the partition.
+ */
+async function partitionSession(partition) {
+  if (!GUEST_PARTITION.test(partition)) throw new Error('dsh-webchat: not a browser-guest partition')
+  const electron = await electronApi()
+  if (electron.session === undefined) throw new Error('dsh-webchat: this process exposes no Electron session API')
+  return electron.session.fromPartition(partition)
+}
+
+/**
+ * Probe Electron once, for the state route's diagnostics.
+ * @returns a short status string.
+ */
+export async function electronProbe() {
+  try {
+    const electron = await electronApi()
+    electronStatus = electron.session === undefined ? 'no session API' : 'ready'
+  } catch (error) {
+    electronStatus = messageOf(error)
+  }
+  return electronStatus
 }
 
 /**
@@ -102,23 +280,28 @@ function messageOf(error) {
  * loader resolves bare specifiers itself and does not always hand `electron`
  * to Electron's own resolver, so a CommonJS require — which Electron serves
  * natively — is the fallback.
+ *
+ * Either `BrowserWindow` (the window strategy) or `session` (the guest session
+ * snapshot) makes the module usable, so the two callers check their own need.
  * @returns the Electron module.
- * @throws with every probe failure joined, when neither path yields a window API.
+ * @throws with every probe failure joined, when neither path yields Electron.
  */
 async function electronApi() {
-  const usable = (mod) => (mod !== null && typeof mod === 'object' && mod.BrowserWindow !== undefined ? mod : undefined)
+  if (electronLoader !== null) return electronLoader()
+  const usable = (mod) => (mod !== null && typeof mod === 'object'
+    && (mod.BrowserWindow !== undefined || mod.session !== undefined) ? mod : undefined)
   const failures = []
   try {
     const fromImport = usable(await import('electron'))
     if (fromImport !== undefined) return fromImport
-    failures.push('esm import resolved but exposed no BrowserWindow')
+    failures.push('esm import resolved but exposed neither BrowserWindow nor session')
   } catch (error) {
     failures.push(`esm import failed: ${messageOf(error)}`)
   }
   try {
     const fromRequire = usable(requireHere('electron'))
     if (fromRequire !== undefined) return fromRequire
-    failures.push('cjs require resolved but exposed no BrowserWindow')
+    failures.push('cjs require resolved but exposed neither BrowserWindow nor session')
   } catch (error) {
     failures.push(`cjs require failed: ${messageOf(error)}`)
   }
@@ -163,7 +346,9 @@ function shellProfileDir() {
 
 /** Open — or focus — a window owned by this process. */
 async function openAppWindow() {
-  const { BrowserWindow } = await electronApi()
+  const electron = await electronApi()
+  const { BrowserWindow } = electron
+  if (BrowserWindow === undefined) throw new Error('this process exposes no Electron BrowserWindow')
   const slot = windowSlot()
   if (slot.current !== null && slot.current.isDestroyed() === false) {
     slot.current.focus()
@@ -263,12 +448,25 @@ export function apply(ctx) {
         return
       }
       const slot = windowSlot()
+      const file = SESSION_FILE()
+      const snapshot = readSnapshot(file)
       json(res, 200, {
         ok: true,
         url: PAGE_URL,
         appWindowOpen: slot.current !== null && slot.current.isDestroyed() === false,
         last: lastAttempt,
         attempts: lastAttempts,
+        // Counts only: this endpoint is unauthenticated, so the cookie values
+        // themselves never leave the snapshot file.
+        session: {
+          file,
+          electron: electronStatus,
+          saved: snapshot === null ? null : {
+            cookies: snapshot.cookies.length,
+            storage: snapshot.storage.length,
+            savedAt: snapshot.savedAt,
+          },
+        },
       })
     },
   }), 'dsh-webchat: state route')
@@ -286,4 +484,76 @@ export function apply(ctx) {
       json(res, result.ok ? 200 : 502, result)
     },
   }), 'dsh-webchat: open route')
+
+  // The guest's session lives in a process-lifetime partition, so the browser
+  // half asks this side to put the saved cookies back before it navigates…
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: ROUTES.restore,
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        res.writeHead(405, { allow: 'POST' })
+        res.end()
+        return
+      }
+      const body = await readJsonBody(req)
+      const partition = body !== null && typeof body.partition === 'string' ? body.partition : ''
+      // Validate before anything else: this half must never touch a session the
+      // shell did not hand out for a browser guest.
+      if (!GUEST_PARTITION.test(partition)) {
+        json(res, 400, { ok: false, error: 'dsh-webchat: not a browser-guest partition' })
+        return
+      }
+      const snapshot = readSnapshot(SESSION_FILE())
+      if (snapshot === null) {
+        json(res, 200, { ok: true, cookies: 0, storage: null, savedAt: '' })
+        return
+      }
+      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 })
+      }
+    },
+  }), 'dsh-webchat: session restore route')
+
+  // …and asks it to refresh that snapshot as the page is used.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: ROUTES.save,
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        res.writeHead(405, { allow: 'POST' })
+        res.end()
+        return
+      }
+      const body = await readJsonBody(req)
+      const partition = body !== null && typeof body.partition === 'string' ? body.partition : ''
+      if (!GUEST_PARTITION.test(partition)) {
+        json(res, 400, { ok: false, error: 'dsh-webchat: not a browser-guest partition' })
+        return
+      }
+      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) })
+      }
+    },
+  }), 'dsh-webchat: session save route')
+
+  void electronProbe()
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaychang1989/dsh-webchat",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "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",
@@ -48,7 +48,11 @@
       "patch": "./cordis.patch.yml"
     },
     "client": {
-      "platform": "web"
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-sidebar"
+      ]
     }
   },
   "files": [