@sparkelf/dsh-plus 0.2.1-rc.2.4 → 0.2.2-alpha.2.1

package/patches/state-dot-brand-blue.patch

@@ -0,0 +1,185 @@
+diff --git a/packages/client/ui-primitives/src/StateDot.module.css b/packages/client/ui-primitives/src/StateDot.module.css
+index 1a692c6..3aa3186 100644
+--- a/packages/client/ui-primitives/src/StateDot.module.css
++++ b/packages/client/ui-primitives/src/StateDot.module.css
+@@ -1,4 +1,12 @@
+-/* Solid states keep the 10px layout slot but paint one 6px currentColor core. */
++/* Ongoing blue has no alias token (state-business-primary is the 500 step,
++ * not this 450) — component-level var pinned to the static scale instead. */
++.dot,
++.matrix {
++  --dsh-state-ongoing: var(--dsw-static-deepseek-450);
++}
++
++/* Solid states: same-color halo via a 0.10-opacity outer layer (::before)
++ * with a 6/10-scale solid core. Layer color rides currentColor set per state. */
+ .dot {
+   position: relative;
+   display: inline-block;
+@@ -31,70 +39,29 @@
+   color: var(--dsw-alias-state-idle-primary);
+ }
+ 
+-/* Ongoing is the sole non-dot state: a quiet full ring sits behind a centered
+- * breathing arc while the complete glyph rotates continuously. Both animations
+- * share one 1.5s period so pinning their start times aligns them together. */
+-.spinner {
++/* Pixel chase: each outer cell holds a discrete brightness step (flat keyframe
++ * holds, no tweening — the retro feel), peaking when the chase hits it and
++ * decaying over the next three cells. Phase offsets come from per-rect
++ * animation-delay (index * -125ms) set inline by the component. */
++.matrix {
+   flex: none;
+-  color: var(--dsw-alias-label-tertiary);
+-}
+-
+-.spinnerMotion {
+-  transform-origin: center;
+-  animation: dsh-state-dot-spin 1.5s linear infinite;
+-}
+-
+-.spinnerTrack,
+-.spinnerArc {
+-  fill: none;
+-  stroke: currentColor;
+-  stroke-width: 2;
+-  stroke-linecap: round;
+-}
+-
+-.spinnerTrack {
+-  opacity: 0.25;
++  color: var(--dsh-state-ongoing);
+ }
+ 
+-.spinnerArc {
+-  stroke-dasharray: 12 150;
+-  animation: dsh-state-dot-dash 1.5s ease-in-out infinite;
++.cell {
++  fill: currentColor;
++  opacity: 0.15;
++  animation: dsh-state-dot-chase 1s infinite;
+ }
+ 
+-@keyframes dsh-state-dot-spin {
+-  to { transform: rotate(360deg); }
+-}
+-
+-@keyframes dsh-state-dot-dash {
+-  0% {
+-    stroke-dasharray: 12 150;
+-    stroke-dashoffset: 0;
+-  }
+-
+-  50% {
+-    stroke-dasharray: 24 150;
+-    stroke-dashoffset: -6;
+-  }
+-
+-  100% {
+-    stroke-dasharray: 12 150;
+-    stroke-dashoffset: 0;
+-  }
+-}
+-
+-@media (prefers-reduced-motion: reduce) {
+-  .spinnerMotion,
+-  .spinnerArc {
+-    animation: none;
+-  }
+-
+-  .spinnerArc {
+-    stroke-dasharray: 18 150;
+-    stroke-dashoffset: -3;
+-  }
++@keyframes dsh-state-dot-chase {
++  0%, 12.4% { opacity: 1; }
++  12.5%, 24.9% { opacity: 0.6; }
++  25%, 37.4% { opacity: 0.35; }
++  37.5%, 100% { opacity: 0.15; }
+ }
+ 
+ .step { display: inline-flex; flex: none; align-items: center; justify-content: center; box-sizing: border-box; border-radius: 50%; corner-shape: round; border: 1.5px solid var(--dsw-alias-label-tertiary); color: var(--dsw-alias-label-primary-foreground); }
+ .step[data-state='done'] { border-color: var(--dsw-alias-state-success-primary); background: var(--dsw-alias-state-success-primary); }
+ .step[data-state='error'] { border-color: var(--dsw-alias-state-error-primary); background: var(--dsw-alias-state-error-primary); }
+-.step[data-state='warning'] { border-color: var(--dsw-alias-state-warn-primary); }
++.step[data-state='warning'] { border-color: var(--dsw-alias-state-warn-primary); }
+
+diff --git a/packages/client/ui-primitives/src/StateDot.tsx b/packages/client/ui-primitives/src/StateDot.tsx
+index ec480c6..f54ebdd 100644
+--- a/packages/client/ui-primitives/src/StateDot.tsx
++++ b/packages/client/ui-primitives/src/StateDot.tsx
+@@ -3,35 +3,15 @@ import css from './StateDot.module.css'
+ import { IconCheckOutlineRegular } from './icons/index.tsx'
+ 
+ /**
+- * State semantic: green done / amber user-attention / tertiary-grey loading /
++ * State semantic: green done / amber user-attention / blue running ring /
+  * red error / neutral-grey idle for a tracked subject with nothing in progress.
+  */
+ export type StateDotState = 'done' | 'warning' | 'ongoing' | 'error' | 'idle'
+ 
+-/**
+- * Pin the loader's CSS animations to document time zero. A CSS animation starts
+- * when its element is inserted and restarts when the element is moved or shown
+- * again, so loaders started at different moments rotate out of phase; one shared
+- * start time keeps every visible loader in step. Mount pins the first start; the
+- * element's own `animationstart` listener pins each restart.
+- * @param element - the mounted loader, or null on unmount.
+- */
+-function syncSpinner(element: SVGSVGElement | null): void {
+-  if (element === null) return
+-  pinSpinner(element)
+-  element.addEventListener('animationstart', () => { pinSpinner(element) })
+-}
+-
+-/**
+- * Set every CSS animation in the loader's subtree to start at document time zero.
+- * @param element - the mounted loader.
+- */
+-function pinSpinner(element: SVGSVGElement): void {
+-  // jsdom (the unit lane) implements no Web Animations despite lib.dom's
+-  // non-optional typing; the optional call leaves that lane unsynced.
+-  const spinner = element as { getAnimations?: SVGSVGElement['getAnimations'] }
+-  for (const animation of spinner.getAnimations?.({ subtree: true }) ?? []) animation.startTime = 0
+-}
++/** Outer 3x3 matrix cells (2px pixels on a 10px grid), clockwise from top-left. */
++const MATRIX_CELLS: readonly (readonly [number, number])[] = [
++  [0, 0], [4, 0], [8, 0], [8, 4], [8, 8], [4, 8], [0, 8], [0, 4],
++]
+ 
+ /**
+  * Render a state dot.
+@@ -51,18 +31,26 @@ export function StateDot({ state, size, className, appearance = 'dot' }: {
+   if (state === 'ongoing') {
+     return (
+       <svg
+-        ref={syncSpinner}
+-        className={clsx(css.spinner, className)}
++        className={clsx(css.matrix, className)}
+         data-state="ongoing"
+         width={edge}
+         height={edge}
+-        viewBox="0 0 24 24"
++        viewBox="0 0 10 10"
++        shapeRendering="crispEdges"
+         aria-hidden="true"
+       >
+-        <g className={css.spinnerMotion}>
+-          <circle className={css.spinnerTrack} cx="12" cy="12" r="9.5" />
+-          <circle className={css.spinnerArc} cx="12" cy="12" r="9.5" />
+-        </g>
++        {MATRIX_CELLS.map(([x, y], index) => (
++          <rect
++            key={`${x}-${y}`}
++            className={css.cell}
++            x={x}
++            y={y}
++            width="2"
++            height="2"
++            /* Negative delay phases the chase so every cell animates from mount. */
++            style={{ animationDelay: `${(index - MATRIX_CELLS.length) * 125}ms` }}
++          />
++        ))}
+       </svg>
+     )
+   }

package/patches/ui-settings-compact-phone.patch

@@ -0,0 +1,76 @@
+diff --git a/packages/client/ui-settings-general/src/client/SettingsRoot.module.css b/packages/client/ui-settings-general/src/client/SettingsRoot.module.css
+--- a/packages/client/ui-settings-general/src/client/SettingsRoot.module.css
++++ b/packages/client/ui-settings-general/src/client/SettingsRoot.module.css
+@@ -246,3 +246,64 @@
+    ui-web base.css's `body > :not(#root)` subtraction covers it wherever it
+    overlaps a chrome row's drag — including above every column, which an in-root
+    overlay could not promise once a chrome row declares drag itself. */
++
++/*
++ * A phone has no room for the desktop two-column shell. The rail keeps its 188px and the panel is
++ * capped at 100vw - 48px, which leaves the content about a hundred pixels: labels wrap to one
++ * character per line and a pairing QR computes to zero. Below this width the panel fills the
++ * viewport and the rail becomes a horizontal strip above the content, so the content keeps the
++ * panel's own width and the phone's safe areas are respected.
++ */
++@media (max-width: 640px) {
++  .overlay {
++    align-items: stretch;
++    justify-content: stretch;
++  }
++
++  .panel {
++    width: 100vw;
++    max-width: 100vw;
++    height: 100vh;
++    height: 100dvh;
++    border-radius: 0;
++  }
++
++  /* The panel stacks vertically so the rail sits above the content instead of beside it. */
++  .panel {
++    flex-direction: column;
++  }
++
++  .nav {
++    flex: none;
++    width: 100%;
++    gap: 10px;
++    padding: max(12px, env(safe-area-inset-top)) 14px 0;
++  }
++
++  .navTitle {
++    padding: 0 2px;
++  }
++
++  /* One scrollable row of destinations instead of a fixed 188px column. */
++  .navList {
++    flex-direction: row;
++    gap: 8px;
++    overflow-x: auto;
++    overflow-y: hidden;
++    scrollbar-width: none;
++    padding-bottom: 4px;
++  }
++
++  .navList::-webkit-scrollbar {
++    display: none;
++  }
++
++  .navCell {
++    flex: 1 0 auto;
++    width: auto;
++    min-height: 44px;
++    white-space: nowrap;
++  }
++
++  /* Takes the space the rail leaves and scrolls its own options. */
++  .content {
++    flex: 1;
++    min-height: 0;
++  }
++
++  .options {
++    padding-bottom: env(safe-area-inset-bottom);
++  }
++}

package/patches/web-runtime-compat.patch

@@ -0,0 +1,83 @@
+diff --git a/packages/bundle/web-app/src/index.ts b/packages/bundle/web-app/src/index.ts
+index b93b559620..8b40aae24d 100644
+--- a/packages/bundle/web-app/src/index.ts
++++ b/packages/bundle/web-app/src/index.ts
+@@ -14,13 +14,14 @@
+ 
+ import { spawn, type ChildProcess } from 'node:child_process'
+ import { createRequire } from 'node:module'
++import { networkInterfaces } from 'node:os'
+ import { dirname, join } from 'node:path'
+ import type { Context } from '@deepseek-ai/cordis'
+ import z from '@deepseek-ai/schemastery'
+ import { auditStartupEntries } from '@deepseek-ai/dsh-app-boot'
+ import type {} from '@deepseek-ai/dsh-client-connection'
+ import * as FrontendStatic from '@deepseek-ai/dsh-host-frontend-static'
+-import { bindUrlHost, isLoopbackHost } from '@deepseek-ai/dsh-host-webserver'
++import { bindUrlHost, isLoopbackHost, isWildcardHost } from '@deepseek-ai/dsh-host-webserver'
+ import { launchedThroughSsh, launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment'
+ import { scrubbedParentEnv } from '@deepseek-ai/dsh-subprocess'
+ import type {} from '@deepseek-ai/cordis-plugin-loader'
+@@ -70,6 +71,17 @@ export interface Config {
+    * Absent or YAML `null` advertises the bind-address URL.
+    */
+   publicUrl?: string
++  /**
++   * Non-loopback authorities a deployment serves this GUI on, appended to the
++   * sampled LAN literals. The listener's own bind address is accepted
++   * separately, so this list carries only what the bind cannot name: a reverse
++   * proxy's host, or a public origin a browser actually uses.
++   *
++   * Superseded by the `connection` row's own `trustedHosts`, which is where a
++   * deployment adds authorities today. Kept so a profile layer written against
++   * the pre-rename row keeps reaching the host fence.
++   */
++  trustedHosts?: string[]
+ }
+ 
+ export const Config: z<Config> = z.object({
+@@ -77,6 +89,7 @@ export const Config: z<Config> = z.object({
+   printUrl: z.boolean().default(true),
+   surfaceContext: z.boolean().default(true),
+   publicUrl: z.transform(z.string(), value => parsePublicUrl(value).href),
++  trustedHosts: z.array(String).default([]),
+ })
+ 
+ /** Environment variable naming the advertised URL of this Web GUI. */
+@@ -204,6 +217,36 @@ export function apply(ctx: Context, config: Config): void {
+   const appRootUrl = (): string => publicUrl ?? ctx.webServer.getOrigin()
+   ctx.provide('webApp', { getAdvertisedUrl: appRootUrl } satisfies WebApp)
+   ctx.plugin(FrontendStatic, { distIndex: internals.resolveDistIndex() })
++
++  // WEB_RUNTIME_COMPAT: alpha.2 renamed the bind-dependent service from
++  // `webRuntime` to `webStartup` and taught its own rows the new name. A
++  // third-party bundle cannot follow the rename: dsh-better-sidebar and
++  // dsh-video-preview declare `inject: [..., 'webRuntime', ...]`, and Cordis
++  // holds an injected row pending until the named service appears. A deployment
++  // that mounts them loses the sidebar routes and the video preview that are the
++  // whole reason they are mounted, so the old shape is published beside the new
++  // one for as long as those bundles ask for it.
++  //
++  // The shape is the pre-rename service: LAN literals sampled once from a
++  // wildcard bind, then this invocation's and the deployment's own authorities.
++  // `webStartup` already carries the flag-supplied half, so it is read rather
++  // than re-parsed, and `isWildcardHost` is the webserver's own predicate
++  // rather than a string comparison against the IPv4 any-address. This row's
++  // `trustedHosts` reaches the fence again here: alpha.2 moved the deployment
++  // list to the `connection` row, which leaves a profile layer written against
++  // the old row — one that serves a reverse-proxied origin — configuring a key
++  // nothing reads.
++  const compatLanAddresses = isWildcardHost(boundHost)
++    ? Object.values(networkInterfaces()).flat()
++      .filter((iface): iface is NonNullable<typeof iface> => iface !== undefined && iface.family === 'IPv4' && !iface.internal)
++      .map(iface => iface.address)
++    : []
++  const compatStartup = ctx.get('webStartup') as { trustedHosts?: readonly string[] } | undefined
++  ctx.provide('webRuntime', {
++    lanAddresses: compatLanAddresses,
++    trustedHosts: [...compatLanAddresses, ...config.trustedHosts ?? [], ...compatStartup?.trustedHosts ?? []],
++  })
++
+   if (config.surfaceContext) {
+     ctx.inject(['shellEnv'], (runtimeCtx) => {
+       runtimeCtx.shellEnv.register({

package/patches/workspace-storage-restore.patch

@@ -0,0 +1,186 @@
+diff --git a/packages/workspace/workspace/src/index.ts b/packages/workspace/workspace/src/index.ts
+index 00eaf0030c..b6e761e1cb 100644
+--- a/packages/workspace/workspace/src/index.ts
++++ b/packages/workspace/workspace/src/index.ts
+@@ -10,7 +10,7 @@ import { mkdir, stat } from 'node:fs/promises'
+ import { Context, Service } from '@deepseek-ai/cordis'
+ import type { SessionHeader, SessionId } from '@deepseek-ai/dsh-session'
+ import type {} from '@deepseek-ai/dsh-session-persistence'
+-import type { DomainGlobal, KvTable } from '@deepseek-ai/dsh-storage-domain'
++import type { Domain, DomainGlobal, KvTable } from '@deepseek-ai/dsh-storage-domain'
+ import { WorkspaceEntity } from './entity.ts'
+ import type { WorkspaceEntityHost } from './entity.ts'
+ 
+@@ -170,6 +170,7 @@ const compareHeaders = (left: SessionHeader, right: SessionHeader): number =>
+ export class WorkspaceRegistry extends Service {
+   static inject = ['storageDomain', 'sessionPersistence']
+ 
++  private domain?: Domain<typeof workspaceDomainSpec>
+   private table?: KvTable<WorkspaceId, WorkspaceRecord>
+   private global?: DomainGlobal<WorkspaceDomainState>
+   private state?: WorkspaceDomainState
+@@ -195,8 +196,53 @@ export class WorkspaceRegistry extends Service {
+ 
+   /** Open the domain, finish bootstrap when required, and rebuild the ordered cache. */
+   protected async [Service.init](): Promise<void> {
++    this.ctx.effect(() => () => this.domain?.close(), 'workspace.domainClose')
++    await this.openDomain()
++  }
++
++  /**
++   * Replace external durable files while no Workspace storage handle is open.
++   * Existing mutations settle first; the domain always reopens through startup
++   * initialization so records, archive state, and Session indexes share one new
++   * baseline.
++   * @param restore - File replacement operation run while Workspace storage is closed.
++   * @returns the operation result after the new durable baseline is available.
++   */
++  async withStorageRestore<T>(restore: () => Promise<T>): Promise<T> {
++    // The restore replaces durable files, so the domain must be closed first;
++    // the finally clause reuses the startup path to rebuild every cache.
++    return await this.enqueueOperation(async () => {
++      // The queue slot runs recoverPendingMutation first, which requires the
++      // registry state, so the open domain is present by this point.
++      const domain = this.domain as Domain<typeof workspaceDomainSpec>
++      const previousArchivedSessions = this.requireState().archivedSessionIds.length
++      await domain.close()
++      delete this.domain
++      delete this.table
++      delete this.global
++      delete this.state
++      this.entities.clear()
++      this.headers.clear()
++      this.sessionPaths.clear()
++      this.invalidSessionPaths.clear()
++      try {
++        return await restore()
++      } finally {
++        await this.openDomain()
++        console.info('[workspace] storage restore baseline loaded', {
++          previousArchivedSessions,
++          restoredArchivedSessions: this.requireState().archivedSessionIds.length,
++          workspaces: this.entities.size,
++          indexedSessionHeaders: this.headers.size,
++        })
++      }
++    })
++  }
++
++  /** Open the durable domain and rebuild every registry cache from its contents. */
++  private async openDomain(): Promise<void> {
+     const domain = await this.ctx.storageDomain.open(workspaceDomainSpec)
+-    this.ctx.effect(() => () => domain.close(), 'workspace.domainClose')
++    this.domain = domain
+     this.table = domain.table('workspaces')
+     this.global = domain.global
+     this.state = domain.global.get()
+diff --git a/packages/workspace/workspace/tests/workspace.spec.ts b/packages/workspace/workspace/tests/workspace.spec.ts
+index ef3116b3d7..67721e6474 100644
+--- a/packages/workspace/workspace/tests/workspace.spec.ts
++++ b/packages/workspace/workspace/tests/workspace.spec.ts
+@@ -1378,6 +1378,105 @@ describe('first-use Workspace preparation', () => {
+   })
+ })
+ 
++describe('WorkspaceRegistry storage restore', () => {
++  const contexts: Context[] = []
++
++  afterEach(async () => {
++    for (const ctx of contexts.splice(0)) await ctx.fiber.dispose()
++  })
++
++  it('serves the replaced baseline, not the pre-restore window, once the restore returns', async () => {
++    const kept = await makeDir('restore-kept')
++    const restored = await makeDir('restore-kept-2')
++    const h = await harness({ sessions: [header('kept', kept, 100)] })
++    contexts.push(h.ctx)
++    const created = await h.registry.create(kept)
++    expect(h.registry.list().map(workspace => workspace.id)).toEqual([created.id])
++
++    // A restore replaces the durable medium wholesale: the registry must
++    // observe the replacement only after reopening, never the old window.
++    const id = WorkspaceId('restored-workspace')
++    const replaced = await h.registry.withStorageRestore(async () => {
++      const medium = h.pool.media.get('workspace')!
++      medium.tables.set('workspaces', new Map([[id, {
++        path: restored,
++        title: 'restored',
++        sessionIds: [],
++        createdAt: '1970-01-01T00:00:01.000Z',
++        updatedAt: '1970-01-01T00:00:01.000Z',
++      }]]))
++      medium.global = {
++        initialized: true,
++        workspaceIds: [id],
++        archivedSessionIds: [SessionId('archived-before-restore')],
++        pinnedSessionIds: [],
++      }
++      return 'replaced'
++    })
++
++    expect(replaced).toBe('replaced')
++    // Both the record set and the registry-global archive set come from the
++    // reopened domain; the pre-restore workspace and archive set are gone.
++    expect(h.registry.list().map(workspace => workspace.path)).toEqual([restored])
++    expect(h.registry.archivedSessionIds).toEqual([SessionId('archived-before-restore')])
++    expect(h.registry.list().map(workspace => workspace.id)).not.toContain(created.id)
++  })
++
++  it('reopens through startup bootstrap so a restored empty baseline is rebuilt', async () => {
++    const dir = await makeDir('restore-rebuild')
++    const h = await harness({ sessions: [header('rebuild', dir, 100)] })
++    contexts.push(h.ctx)
++    await h.registry.create(dir)
++    expect(h.registry.list()).toHaveLength(1)
++
++    await h.registry.withStorageRestore(async () => {
++      const medium = h.pool.media.get('workspace')!
++      medium.tables.set('workspaces', new Map())
++      medium.global = null
++    })
++
++    // The restored medium carries no initialized marker, so the reopened
++    // registry bootstraps the header history again instead of serving a stale cache.
++    expect(storedState(h.pool).initialized).toBe(true)
++    expect(h.registry.list()).toHaveLength(1)
++  })
++
++  it('rebuilds every cache on the restored baseline after the replacement throws', async () => {
++    const dir = await makeDir('restore-throws')
++    const h = await harness({ sessions: [header('throws', dir, 100)] })
++    contexts.push(h.ctx)
++    await h.registry.create(dir)
++
++    await expect(h.registry.withStorageRestore(async () => {
++      const medium = h.pool.media.get('workspace')!
++      medium.tables.set('workspaces', new Map())
++      medium.global = null
++      throw new Error('replacement failed')
++    })).rejects.toThrow('replacement failed')
++
++    // The reopen runs in the finally arm, so the registry is still usable:
++    // the restored empty medium is bootstrapped from the Session headers again.
++    expect(h.registry.list().map(workspace => workspace.path)).toEqual([dir])
++    await expect(h.registry.create(dir)).resolves.toBeDefined()
++  })
++
++  it('serializes a queued mutation behind the restore it was issued during', async () => {
++    const dir = await makeDir('restore-queued')
++    const h = await harness({ sessions: [header('queued', dir, 100)] })
++    contexts.push(h.ctx)
++    const created = await h.registry.create(dir)
++    const order: string[] = []
++    // The restore takes the registry queue slot synchronously, so the delete
++    // issued next runs only after the domain was closed and reopened.
++    const restoring = h.registry.withStorageRestore(async () => { order.push('restore') })
++    const deleting = h.registry.delete(created.id).then((ok) => { order.push('delete'); return ok })
++    await Promise.all([restoring, deleting])
++    expect(order).toEqual(['restore', 'delete'])
++    expect(await deleting).toBe(true)
++    expect(h.registry.list()).toEqual([])
++  })
++})
++
+ // The registry knows no family: the providers merge theirs, and this suite merges its own.
+ declare module '@deepseek-ai/dsh-workspace/types' {
+   interface SessionActivityKindMap {