@linxin666/dsh-remote-web-ui 0.1.20 → 0.2.0

package/src/pairing.ts

@@ -16,6 +16,8 @@
  */
 
 import { randomBytes } from 'node:crypto'
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
 
 /** The observable pairing phases the panel renders. */
 export type PairingPhase =
@@ -95,6 +97,13 @@ export interface PairingConfig {
   maxDevices: number
   /** Cookie name carrying the device id. */
   cookieName: string
+  /**
+   * Path to a JSON file where paired device sessions are persisted. When
+   * set, sessions survive process restarts (the phone keeps its 365-day
+   * cookie), so re-pairing after a dsh web restart is not required. When
+   * unset (default), sessions stay memory-only — the previous behavior.
+   */
+  devicesFile?: string
 }
 
 /** Result of one accept() attempt. */
@@ -154,7 +163,65 @@ export class PairingService {
   constructor(
     public config: PairingConfig,
     private readonly clock: PairingClock = defaultClock,
-  ) {}
+  ) {
+    this.loadPersisted()
+  }
+
+  /**
+   * Restore device sessions persisted by a previous process run. A corrupt
+   * or missing file is tolerated (an empty device table, never a throw) —
+   * persistence is an availability convenience, not a security boundary.
+   */
+  private loadPersisted(): void {
+    const file = this.config.devicesFile
+    if (file === undefined) return
+    try {
+      const saved = JSON.parse(readFileSync(file, 'utf8')) as unknown
+      if (typeof saved !== 'object' || saved === null) return
+      for (const [deviceId, session] of Object.entries(saved)) {
+        if (typeof deviceId !== 'string') continue
+        if (typeof session !== 'object' || session === null) continue
+        const { createdAt, lastSeenAt } = session as { createdAt?: unknown; lastSeenAt?: unknown }
+        if (typeof createdAt !== 'number' || typeof lastSeenAt !== 'number') continue
+        this.devices.set(deviceId, { createdAt, lastSeenAt })
+      }
+      this.clampToMaxDevices()
+    } catch {
+      // Unreadable/corrupt: start empty rather than refusing to boot.
+    }
+  }
+
+  /** FIFO-cap the device table (a persisted file may outlive a lowered cap). */
+  private clampToMaxDevices(): void {
+    if (this.devices.size <= this.config.maxDevices) return
+    const overflow = this.devices.size - this.config.maxDevices
+    const ordered = [...this.devices.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt)
+    for (const [id] of ordered.slice(0, overflow)) this.devices.delete(id)
+  }
+
+  /**
+   * Write the current device table to the configured file. Called on the
+   * mutation boundaries that change the set of live sessions (accept and
+   * stop); `lastSeenAt` refreshes are deliberately not persisted here so a
+   * per-request write storm is avoided — after a restart the phone's first
+   * heartbeat re-warms its own session.
+   *
+   * Device ids are session credentials (the gate authorizes requests by the
+   * cookie's device id), so the file is written 0600 via a temp file and
+   * atomic rename; a crash mid-write can never leave a half-written store.
+   */
+  private persist(): void {
+    const file = this.config.devicesFile
+    if (file === undefined) return
+    try {
+      mkdirSync(dirname(file), { recursive: true })
+      const temp = `${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`
+      writeFileSync(temp, JSON.stringify(Object.fromEntries(this.devices)), { mode: 0o600 })
+      renameSync(temp, file)
+    } catch (error) {
+      console.error('remote-web-ui: failed to persist paired devices', error)
+    }
+  }
 
   /** The default LAN base URL (the first interface; undefined when not LAN-reachable). */
   get lanBaseUrl(): string | undefined {
@@ -254,6 +321,7 @@ export class PairingService {
       if (oldest !== undefined) this.devices.delete(oldest.id)
     }
     this.devices.set(deviceId, { createdAt: now, lastSeenAt: now })
+    this.persist()
     this.notify()
     return { ok: true, deviceId }
   }
@@ -266,6 +334,7 @@ export class PairingService {
   stop(): void {
     this.tokens.clear()
     this.devices.clear()
+    this.persist()
     this.stopped = true
     this.notify()
   }

package/src/routes.ts

@@ -264,7 +264,7 @@ export function makeRoutes(deps: PairRoutesDeps): WebRoute[] {
       const workspaceQuery = workspaceId === undefined ? '' : `&workspace=${encodeURIComponent(workspaceId)}`
       writeJson(res, 200, {
         ok: true,
-        url: `${base}/?pair=${token}${workspaceQuery}`,
+        url: `${base}/m/?pair=${token}${workspaceQuery}`,
         token,
         expiresAt,
         // Every constructible base, so a multi-homed panel can switch the

package/src/update.ts

@@ -1,8 +1,8 @@
 /**
  * Remote update support for the dsh-web-ui family — host half. Detects the
- * installed aggregate package (@linxin666/dsh-web-ui-all) and its family
- * children, probes the npm registry for newer releases, and runs the actual
- * update as `pnpm update --latest` inside the owning dsh profile directory.
+ * installed aggregate package (@linxin666/dsh-web-ui-all), or the directly
+ * installed family packages when the aggregate is absent, probes npm for newer
+ * releases, and runs `pnpm update --latest` inside the owning dsh profile.
  *
  * Pure logic with injected seams (manifest reading, registry fetches, process
  * spawning) so the whole surface is unit-testable without touching disk,
@@ -235,10 +235,13 @@ export function resolveUpdateTarget(
   const profileManifest = readManifest(join(profile.dir, 'package.json'))
   const spec = (profileManifest?.dependencies as Record<string, DependencySpec> | undefined)?.[anchor]
   if (isLinkedSpec(spec)) return { error: 'link' }
+  // Standalone installs carry no aggregate: the anchor's own dependency
+  // list misses every sibling @linxin666/* plugin installed directly into
+  // the profile, so union the profile's direct family deps (#377).
   return {
     profileName: profile.name,
     profileDir: profile.dir,
-    packages: [anchor, ...familyChildren(manifest)],
+    packages: familyUpdatePackages(anchor, manifest, profileManifest),
   }
 }
 
@@ -253,6 +256,21 @@ export function familyChildren(anchorManifest: Record<string, unknown>): string[
   return names
 }
 
+/** Registry-managed family packages covered by one update operation. */
+function familyUpdatePackages(
+  anchor: string,
+  anchorManifest: Record<string, unknown>,
+  profileManifest: Record<string, unknown> | undefined,
+): string[] {
+  const names = new Set([anchor, ...familyChildren(anchorManifest)])
+  const dependencies = profileManifest?.dependencies
+  if (typeof dependencies !== 'object' || dependencies === null) return [...names]
+  for (const [name, spec] of Object.entries(dependencies)) {
+    if (name.startsWith(FAMILY_SCOPE) && typeof spec === 'string' && !isLinkedSpec(spec)) names.add(name)
+  }
+  return [...names]
+}
+
 /**
  * Probe the npm registry for one package's latest release.
  * @param name - the package name (scope slash URL-encoded).
@@ -292,14 +310,21 @@ export async function fetchLatestVersion(
 const VERSION_UNKNOWN = '0.0.0'
 
 /** The resolved current version of one family package (probe failure tolerated). */
-function readInstalledVersion(resolve: (specifier: string) => string | undefined, name: string): string {
+function readInstalledVersion(
+  resolve: (specifier: string) => string | undefined,
+  name: string,
+  profileDir?: string,
+): string {
   try {
     const path = resolve(name + '/package.json')
     const version = path === undefined ? undefined : readManifest(path)?.version
-    return typeof version === 'string' ? version : VERSION_UNKNOWN
-  } catch {
-    return VERSION_UNKNOWN
-  }
+    if (typeof version === 'string') return version
+  } catch { /* fall through to the profile's direct dependency path */ }
+  // Names originate in the profile dependency map, but still validate the
+  // npm package shape before using one as path segments.
+  if (profileDir === undefined || !/^@linxin666\/[a-z0-9][a-z0-9._-]*$/.test(name)) return VERSION_UNKNOWN
+  const version = readManifest(join(profileDir, 'node_modules', ...name.split('/'), 'package.json'))?.version
+  return typeof version === 'string' ? version : VERSION_UNKNOWN
 }
 
 /**
@@ -331,7 +356,10 @@ export async function checkUpdates(deps: UpdateCheckDeps): Promise<UpdateStatus>
   if (profile === undefined) {
     return { mode: 'link', packages: [], outdated: false }
   }
-  const names = [anchor, ...familyChildren(manifest)]
+  // Union the profile's direct family deps so standalone installs (no
+  // aggregate) still check every installed @linxin666/* plugin (#377);
+  // familyUpdatePackages skips link:/file: development dependencies.
+  const names = familyUpdatePackages(anchor, manifest, profileManifest)
   // The registry probes are independent: run them together instead of
   // serializing up to N x 10s of registry latency behind one status call.
   const latestList = await Promise.all(names.map(name => deps.fetchLatest(name)))
@@ -340,7 +368,7 @@ export async function checkUpdates(deps: UpdateCheckDeps): Promise<UpdateStatus>
   names.forEach((name, index) => {
     const latest = latestList[index]
     if (latest === undefined) probeFailures++
-    const current = readInstalledVersion(deps.resolve, name)
+    const current = readInstalledVersion(deps.resolve, name, profile.dir)
     packages.push({
       name,
       current,
@@ -604,7 +632,7 @@ export async function runUpdateVerified(deps: UpdateRunVerifiedDeps): Promise<Up
   // green exit that left everything in place could be mistaken for success.
   const before = new Map<string, string>()
   for (const name of deps.run.packages) {
-    const version = readInstalledVersion(deps.check.resolve, name)
+    const version = readInstalledVersion(deps.check.resolve, name, deps.run.profileDir)
     if (version !== VERSION_UNKNOWN) before.set(name, version)
   }
   const result = await runUpdate(deps.run)