@xxgxiaoyu/dsh-session-sync 0.0.0-stage → 0.8.3

package/lib/state.js

@@ -0,0 +1,236 @@
+/**
+ * Local state for dsh-session-sync.
+ *
+ * The state file holds exactly the facts that must survive restarts on THIS
+ * machine:
+ *   - self:          this device's stable id and display name
+ *   - peers:         everything learned about other devices, keyed by device id.
+ *                    `customName` lives here only — it never leaves this machine,
+ *                    so renaming a peer is private and cached across reboots,
+ *                    and survives the peer going offline and coming back.
+ *   - imports:       which remote session is stored locally under which id, so
+ *                    the UI can show "已拉取" and skip duplicate pulls.
+ *   - signatures:    content fingerprints of every session imported here. Two
+ *                    devices that each pull the other's copies would otherwise
+ *                    keep re-importing the same conversation under new ids.
+ *   - settings:      auto-pull switches, discovery port, etc.
+ *
+ * Everything is written atomically (tmp + rename) with 0600 permissions.
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import crypto from 'node:crypto'
+
+/** Resolve the harness home directory (`$DSH_HOME` or `~/.dsh`). */
+export function dshHome(config) {
+  if (typeof config?.home === 'string' && config.home.length > 0) return config.home
+  return process.env.DSH_HOME || path.join(os.homedir(), '.dsh')
+}
+
+/** Fresh state for a machine that has never run the plugin. */
+export function defaultState() {
+  return {
+    v: 1,
+    self: {
+      id: crypto.randomUUID(),
+      name: defaultDeviceName(),
+    },
+    peers: {},
+    imports: {},
+    signatures: {},
+    settings: {
+      autoPull: false,
+      autoPush: false,
+      // UI language: 'auto' follows the DSH locale (which itself falls back to
+      // the browser/OS language), 'zh' / 'en' pin the plugin's own copy.
+      locale: 'auto',
+      discoveryPort: 47801,
+      lanPort: 47802,
+      seeds: [],
+      // Where auto-pull stores what it fetches: an absolute directory
+      // (an existing workspace, or any folder the user created). Empty means
+      // "未分组" — imports land in the plugin's own unsorted folder, which no
+      // workspace owns, so DSH shows them under 未分组.
+      syncDir: '',
+      // Extra CIDRs / IPs that broadcast cannot reach (other subnets, VPN,
+      // routed VLANs). The scanner unicasts a hello to every host in them, which
+      // is the only way to find a peer across a router.
+      subnets: [],
+      // How many sessions transfer at once. 0 = pick from the machine
+      // (see resolveConcurrency on the host); 1..16 is an explicit cap.
+      concurrency: 0,
+    },
+  }
+}
+
+/** `10.0.0.0/24`, `192.168.5.7` — anything the sweeper can expand. */
+function isCidrOrIp(value) {
+  const [address, prefix] = value.trim().split('/')
+  if (prefix !== undefined && !/^\d{1,2}$/.test(prefix)) return false
+  const parts = address.split('.')
+  if (parts.length !== 4) return false
+  return parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255)
+}
+
+function defaultDeviceName() {
+  const host = os.hostname().replace(/\.local$/i, '')
+  return host || 'DSH 设备'
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/** Merge persisted state over the defaults so new fields appear on upgrade. */
+function normalize(raw) {
+  const base = defaultState()
+  if (!isPlainObject(raw)) return base
+  const self = isPlainObject(raw.self) ? raw.self : {}
+  const peers = isPlainObject(raw.peers) ? raw.peers : {}
+  const imports = isPlainObject(raw.imports) ? raw.imports : {}
+  const signatures = isPlainObject(raw.signatures) ? raw.signatures : {}
+  const settings = isPlainObject(raw.settings) ? raw.settings : {}
+  return {
+    v: 1,
+    self: {
+      id: typeof self.id === 'string' && self.id.length > 0 ? self.id : base.self.id,
+      name: typeof self.name === 'string' && self.name.trim().length > 0 ? self.name.trim() : base.self.name,
+    },
+    peers: Object.fromEntries(
+      Object.entries(peers).filter(([id, rec]) => typeof id === 'string' && isPlainObject(rec)),
+    ),
+    imports: Object.fromEntries(
+      Object.entries(imports).filter(([key, rec]) => typeof key === 'string' && isPlainObject(rec)),
+    ),
+    signatures: Object.fromEntries(
+      Object.entries(signatures).filter(([key, value]) => typeof key === 'string' && typeof value === 'string'),
+    ),
+    settings: { ...base.settings, ...pickSettings(settings) },
+  }
+}
+
+function pickSettings(settings) {
+  const out = {}
+  if (settings.locale === 'auto' || settings.locale === 'zh' || settings.locale === 'en') out.locale = settings.locale
+  if (typeof settings.autoPull === 'boolean') out.autoPull = settings.autoPull
+  if (typeof settings.autoPush === 'boolean') out.autoPush = settings.autoPush
+  if (Number.isInteger(settings.discoveryPort) && settings.discoveryPort > 0 && settings.discoveryPort < 65536) {
+    out.discoveryPort = settings.discoveryPort
+  }
+  if (Number.isInteger(settings.lanPort) && settings.lanPort > 0 && settings.lanPort < 65536) {
+    out.lanPort = settings.lanPort
+  }
+  if (typeof settings.syncDir === 'string' && (settings.syncDir === '' || /^(?:\/|[A-Za-z]:[\\/])/.test(settings.syncDir))) {
+    out.syncDir = settings.syncDir
+  }
+  if (Number.isInteger(settings.concurrency) && settings.concurrency >= 0 && settings.concurrency <= 16) {
+    out.concurrency = settings.concurrency
+  }
+  if (Array.isArray(settings.subnets)) {
+    out.subnets = settings.subnets
+      .filter((value) => typeof value === 'string' && isCidrOrIp(value))
+      .slice(0, 16)
+  }
+  if (Array.isArray(settings.seeds)) {
+    out.seeds = settings.seeds
+      .filter((value) => typeof value === 'string' && value.length > 0)
+      .slice(0, 32)
+  } else {
+    out.seeds = []
+  }
+  return out
+}
+
+/**
+ * Stores flush on process exit so a rename made less than one debounce window
+ * before the app is killed is not lost.
+ */
+const liveStores = new Set()
+process.once('exit', () => {
+  for (const store of liveStores) {
+    try {
+      store.saveNow()
+    } catch {
+      /* best effort during shutdown */
+    }
+  }
+})
+
+export class StateStore {
+  /**
+   * @param {{ dir: string }} options - `dir` is the plugin's own state directory.
+   */
+  constructor({ dir }) {
+    this.dir = dir
+    this.file = path.join(dir, 'state.json')
+    this.data = null
+    this.dirty = false
+    this._timer = null
+    this._lastWrite = 0
+    liveStores.add(this)
+  }
+
+  /** Drop the exit hook for a disposed plugin instance. */
+  dispose() {
+    if (this._timer !== null) {
+      clearTimeout(this._timer)
+      this._timer = null
+    }
+    liveStores.delete(this)
+    this.saveNow()
+  }
+
+  load() {
+    if (this.data !== null) return this.data
+    let raw
+    try {
+      raw = JSON.parse(fs.readFileSync(this.file, 'utf8'))
+    } catch {
+      raw = undefined
+    }
+    const existed = raw !== undefined
+    this.data = normalize(raw)
+    if (!existed) this.saveNow()
+    return this.data
+  }
+
+  /** Mutate in place, then schedule a debounced atomic write. */
+  update(fn) {
+    const data = this.load()
+    fn(data)
+    this.saveSoon()
+    return data
+  }
+
+  saveSoon(delay = 400) {
+    this.dirty = true
+    if (this._timer !== null) return
+    this._timer = setTimeout(() => {
+      this._timer = null
+      this.saveNow()
+    }, delay)
+    this._timer.unref?.()
+  }
+
+  saveNow() {
+    if (this.data === null) return
+    const text = `${JSON.stringify(this.data, null, 2)}\n`
+    try {
+      fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 })
+      const tmp = path.join(this.dir, `.state-${process.pid}-${Date.now()}.tmp`)
+      fs.writeFileSync(tmp, text, { mode: 0o600 })
+      fs.renameSync(tmp, this.file)
+      this._lastWrite = Date.now()
+      this.dirty = false
+    } catch (error) {
+      // A failing state write must never take the session bus down; the next
+      // successful write retries with the in-memory value intact.
+      console.warn('[dsh-session-sync] 状态写入失败:', error?.message ?? error)
+    }
+  }
+
+  flush() {
+    this.saveNow()
+  }
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@xxgxiaoyu/dsh-session-sync",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.8.3",
+  "description": "DSH LAN session sync: auto-discover devices running this plugin, browse/pull/push sessions over HTTP, verify them with SHA-256, and keep a local-only nickname per device.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/",
+    "cordis.patch.yml",
+    "README.md",
+    "README_ZH.md",
+    "CHANGELOG.md",
+    "CHANGELOG_ZH.md",
+    "LICENSE",
+    "icon.svg",
+    "screenshots.json",
+    "scripts/repair-sessions.mjs"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "deepseek",
+    "session-sync",
+    "lan",
+    "p2p",
+    "session"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ]
+    },
+    "manifestVersion": 1
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "acorn": "^8.19.0",
+    "jsdom": "^30.1.3",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/XXGxiaoyu/dsh-session-sync.git"
+  },
+  "homepage": "https://github.com/XXGxiaoyu/dsh-session-sync#readme",
+  "bugs": {
+    "url": "https://github.com/XXGxiaoyu/dsh-session-sync/issues"
+  },
+  "packageManager": "pnpm@11.15.1"
+}

package/screenshots.json

@@ -0,0 +1 @@
+[]

package/scripts/repair-sessions.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * Repair session logs imported by plugin builds before 0.5.5.
+ *
+ * Run with DSH closed (or just reload the app afterwards):
+ *   node scripts/repair-sessions.mjs            # repair, keeping *.bak copies
+ *   node scripts/repair-sessions.mjs --dry-run  # only report what would change
+ *   node scripts/repair-sessions.mjs --home ~/.dsh
+ */
+import os from 'node:os'
+import path from 'node:path'
+
+import { repairStoredSessions } from '../lib/repair.js'
+
+const args = process.argv.slice(2)
+const dryRun = args.includes('--dry-run')
+const homeFlag = args.indexOf('--home')
+const home = homeFlag >= 0 && args[homeFlag + 1] ? args[homeFlag + 1] : process.env.DSH_HOME ?? path.join(os.homedir(), '.dsh')
+const root = path.join(home, 'sessions')
+
+const summary = repairStoredSessions(root, {
+  dryRun,
+  log: (message) => console.log(message),
+})
+console.log(
+  `${dryRun ? 'would repair' : 'repaired'} ${summary.repaired} of ${summary.scanned} stored session(s)` +
+    (summary.locked > 0 ? ` (${summary.locked} carried a lock marker)` : ''),
+)
+if (!dryRun && summary.repaired > 0) {
+  console.log('Restart DSH, then open the conversation again. Originals are kept as *.bak next to each log.')
+}