@drscrewdriver/dsh-better-display 0.3.3-fork.1

package/src/client/deliverables.ts

@@ -0,0 +1,122 @@
+import type { TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { MarkdownFileMentions } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { ReaderFlowEntry } from './tool-activity.js';
+import { inputFields, stringValue, toolIdentity } from './tool-activity.js';
+
+interface ProducedEntry {
+  readonly seq?: number;
+  readonly path: string;
+}
+
+interface DeliverablesData {
+  readonly produced: readonly ProducedEntry[];
+}
+
+/** Extract standard filename without directory components. */
+export function basename(path: string): string {
+  const normalized = path.replace(/[/\\]+$/, '');
+  const at = Math.max(normalized.lastIndexOf('/'), normalized.lastIndexOf('\\'));
+  return at === -1 ? normalized : normalized.slice(at + 1);
+}
+
+/** Extract parent directory of a path (or '.' if top-level). */
+export function dirname(path: string): string {
+  const normalized = path.replace(/[/\\]+$/, '');
+  const at = Math.max(normalized.lastIndexOf('/'), normalized.lastIndexOf('\\'));
+  return at === -1 ? '.' : normalized.slice(0, at) || '.';
+}
+
+/**
+ * The produced-files chip row waits for turn close. Live writes still
+ * accumulate, but the row must not interrupt an in-progress process.
+ */
+export function showDeliverablesRow(status: 'open' | 'closed' | 'unknown', paths: readonly string[]): boolean {
+  return status === 'closed' && paths.length > 0
+}
+
+/**
+ * Extract all unique file paths produced/modified in one turn.
+ * Respects official deliverables data when available, and falls back to
+ * inspecting successful write/edit tool invocations in the turn flow.
+ */
+export function getTurnDeliverables(turn: TurnLocation | undefined, flow?: readonly ReaderFlowEntry[]): readonly string[] {
+  const paths: string[] = [];
+  const seen = new Set<string>();
+
+  // 1. Check official deliverables turn data from @deepseek-ai/dsh-client-ui-deliverables
+  const deliverables = (turn?.data as { get(key: string): unknown } | undefined)?.get('deliverables') as DeliverablesData | undefined;
+  if (deliverables?.produced && Array.isArray(deliverables.produced)) {
+    for (const item of deliverables.produced) {
+      if (typeof item?.path === 'string' && item.path.trim().length > 0) {
+        const clean = item.path.trim();
+        if (!seen.has(clean)) {
+          seen.add(clean);
+          paths.push(clean);
+        }
+      }
+    }
+  }
+
+  if (paths.length > 0) return paths;
+
+  // 2. Fallback: inspect successful file modification tool calls in the flow
+  if (flow) {
+    for (const item of flow) {
+      if (item.kind !== 'tool' || !item.block) continue;
+      // Skip failed tool results
+      if ('isError' in item.block && item.block.isError) continue;
+      const { name, raw } = toolIdentity(item);
+      const toolName = name !== '工具调用' ? name : ((item.block as unknown as { name?: string }).name || (item.block as unknown as { call?: { name?: string } }).call?.name);
+      const toolRaw = raw || ((item.block as unknown as { argsRaw?: string }).argsRaw || (item.block as unknown as { call?: { argsRaw?: string } }).call?.argsRaw || '');
+      if (toolName === 'write' || toolName === 'edit' || toolName === 'apply_patch') {
+        const args = inputFields(toolRaw);
+        const target = stringValue(args, 'file_path', 'path', 'filename', 'filePath');
+        if (target && !seen.has(target)) {
+          seen.add(target);
+          paths.push(target);
+        }
+      } else if (toolName === 'str_replace_editor') {
+        const args = inputFields(toolRaw);
+        const cmd = stringValue(args, 'command');
+        if (cmd === 'create' || cmd === 'str_replace' || cmd === 'insert') {
+          const target = stringValue(args, 'path');
+          if (target && !seen.has(target)) {
+            seen.add(target);
+            paths.push(target);
+          }
+        }
+      }
+    }
+  }
+
+  return paths;
+}
+
+/** The single produced path whose basename is exactly value, or undefined. */
+function onlyPathWithBasename(paths: readonly string[], value: string): string | undefined {
+  const matches = paths.filter(path => basename(path) === value);
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
+/**
+ * File-mention resolver: converts inline-code tokens matching produced paths
+ * into clickable file references that open the corresponding file on the host.
+ */
+export function createProducedFileMentions(
+  paths: readonly string[],
+  openFile: (path: string) => void,
+): MarkdownFileMentions {
+  return {
+    resolve(value: string) {
+      if (!value || value.includes('\n')) return undefined;
+      const clean = value.trim();
+      const path = paths.includes(clean) ? clean : onlyPathWithBasename(paths, clean);
+      if (path === undefined) return undefined;
+      return {
+        open: () => { openFile(path); },
+        label: `打开 ${path}`,
+        title: path,
+      };
+    },
+  };
+}

package/src/client/entry-policy.ts

@@ -0,0 +1,20 @@
+/** Select the reading view on entry, without fighting a later explicit tab choice. */
+export class ReaderEntryPolicy {
+  private entered = false;
+
+  constructor(private readonly requested: boolean, private readonly consumeRequest: () => void = () => {}) {}
+
+  select(view: string | null | undefined): 'reader' | null {
+    const requested = !this.entered && this.requested;
+    if (!this.entered) {
+      this.entered = true;
+      if (this.requested) this.consumeRequest();
+    }
+    return (requested || view == null) && view !== 'reader' ? 'reader' : null;
+  }
+}
+
+export function readerEntryRequested(search: string): boolean {
+  const value = new URLSearchParams(search).get('reader');
+  return value === '1' || /^0\.1\.0-trial\.\d+$/.test(value ?? '');
+}

package/src/client/entry.tsx

@@ -0,0 +1,40 @@
+import { useLayoutEffect } from 'react';
+import type { Context } from '@deepseek-ai/cordis';
+import type { ConversationStore } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { PropsRuntime, PropsStore, StoreDecl } from '@deepseek-ai/dsh-client-ui-slots';
+import type {} from '@deepseek-ai/dsh-client-ui-renderer/client';
+import { ReaderEntryPolicy, readerEntryRequested } from './entry-policy.js';
+
+function isConversationStore(store: StoreDecl | undefined): store is ConversationStore {
+  return typeof store === 'object' && store !== null
+    && store.spec.persist === 'dsh.conversation'
+    && typeof store.spec.actions.setView === 'function';
+}
+
+type EntryProps = PropsRuntime<'conversation.input.dock'> & PropsStore<ConversationStore> & { policy: ReaderEntryPolicy };
+
+function ReaderEntry({ useStore, actions, policy }: EntryProps) {
+  const view = useStore(state => state.view);
+  useLayoutEffect(() => {
+    const next = policy.select(view);
+    if (next) actions.setView(next);
+  }, [view, actions, policy]);
+  return null;
+}
+
+/** Reuse the native store handle; its framework-owned instance preserves drafts. */
+export function installReaderEntry(ctx: Context): () => void {
+  const native = ctx.slots.entriesOfSlot('conversation.session')[0]?.store;
+  if (!isConversationStore(native)) throw new Error('DSH Reader cannot bind the native conversation view store.');
+  const policy = new ReaderEntryPolicy(readerEntryRequested(location.search), () => {
+    const url = new URL(location.href);
+    url.searchParams.delete('reader');
+    history.replaceState(history.state, '', `${url.pathname}${url.search}${url.hash}`);
+  });
+  return ctx.slots.register({
+    name: 'conversation.input.dock',
+    id: 'dsh-better-display-entry',
+    store: native,
+    inject: () => ({ policy }),
+  }, ReaderEntry);
+}

package/src/client/fold-choreography.ts

@@ -0,0 +1,55 @@
+import type { LiveStep, LiveTurnItem } from './live-turn.js';
+
+/** Presentation clock, not model/network time. */
+export const FOLD_TIMING = {
+  collapse: 320,
+  count: 160,
+  settle: 80,
+  reveal: 180,
+  /**
+   * Slack added to every phase deadline before the watchdog forces the next phase.
+   *
+   * The choreography advances on animation promises and rendered frames. Both are
+   * best-effort: a cancelled animation *rejects* and a compositor that never
+   * finishes one leaves its promise pending, while a backgrounded tab stops
+   * delivering frames. Without a deadline the machine would sit in a non-idle
+   * phase forever, and a non-idle phase freezes both the frame source and the text
+   * reveal, so the turn would look stuck until a remount. This is the liveness
+   * guarantee that does not depend on any of them.
+   */
+  watchdogSlack: 240,
+} as const;
+export type FoldPhase = 'idle' | 'collapse' | 'count' | 'settle' | 'reveal';
+export type FlowRow =
+  | { kind: 'summary'; key: string; item: Extract<LiveTurnItem, { kind: 'fold' }> }
+  | { kind: 'step'; key: string; step: LiveStep; foldKey?: string };
+
+/** A step always has the same parent and React key, even when its membership changes. */
+export function flowRows(items: readonly LiveTurnItem[]): FlowRow[] {
+  return items.flatMap((item): FlowRow[] => item.kind === 'fold'
+    ? [{ kind: 'summary', key: item.key, item }, ...item.steps.map(step => ({ kind: 'step' as const, key: step.key, step, foldKey: item.key }))]
+    : [{ kind: 'step', key: item.key, step: item.step }]);
+}
+
+export function retiringKeys(before: readonly LiveTurnItem[], after: readonly LiveTurnItem[], open: Readonly<Record<string, boolean>>): string[] {
+  const folded = new Set(flowRows(after).filter(row => row.kind === 'step' && row.foldKey && !open[row.foldKey]).map(row => row.key));
+  return flowRows(before).filter(row => row.kind === 'step' && !row.foldKey && folded.has(row.key)).map(row => row.key);
+}
+
+/** Insert only new summary slots. Never admit incoming content during shrink. */
+export function collapseRows(before: readonly LiveTurnItem[], target: readonly LiveTurnItem[]): FlowRow[] {
+  const rows = flowRows(before);
+  const headers = new Set(rows.filter(row => row.kind === 'summary').map(row => row.key));
+  for (const item of target) {
+    if (item.kind !== 'fold' || headers.has(item.key)) continue;
+    const members = new Set(item.steps.map(step => step.key));
+    const at = rows.findIndex(row => members.has(row.key));
+    if (at >= 0) rows.splice(at, 0, { kind: 'summary', key: item.key, item: { ...item, summary: item.summary.replace(/\d+/g, '0') } });
+  }
+  return rows;
+}
+
+export function containsNewUser(before: readonly LiveTurnItem[], after: readonly LiveTurnItem[]): boolean {
+  const users = new Set(before.filter(item => item.kind === 'user').map(item => item.key));
+  return after.some(item => item.kind === 'user' && !users.has(item.key));
+}

package/src/client/fold-intensity.ts

@@ -0,0 +1,36 @@
+/** Three-stop fold intensity persisted on `dsh.reader.v1`. Default is standard. */
+export type FoldIntensity = 0 | 1 | 2;
+
+export const FOLD_INTENSITY_DEFAULT: FoldIntensity = 1;
+
+/** Level 0: nothing auto-folds. Level 1: current-main choreography. Level 2: process summaries. */
+export function foldIntensityOf(state: unknown): FoldIntensity {
+  const rec = state && typeof state === 'object' ? state as Record<string, unknown> : {};
+  if (rec.foldIntensity === 0 || rec.foldIntensity === 1 || rec.foldIntensity === 2) return rec.foldIntensity;
+  if (rec.processOnly === true) return 2;
+  if (rec.autoFold === false) return 0;
+  return FOLD_INTENSITY_DEFAULT;
+}
+
+export function frostedGlassOf(state: unknown): boolean {
+  if (state && typeof state === 'object' && 'frostedGlass' in state) {
+    return (state as { frostedGlass?: unknown }).frostedGlass === true;
+  }
+  return state === true;
+}
+
+/** Bubbles default on: snapshots persisted before the preference read as on. */
+export function bubblesOf(state: unknown): boolean {
+  if (state && typeof state === 'object' && 'bubbles' in state) {
+    return (state as { bubbles?: unknown }).bubbles !== false;
+  }
+  return true;
+}
+
+export function autoFoldFromIntensity(intensity: FoldIntensity): boolean {
+  return intensity !== 0;
+}
+
+export function processOnlyFromIntensity(intensity: FoldIntensity): boolean {
+  return intensity === 2;
+}

package/src/client/index.tsx

@@ -0,0 +1,222 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type {} from '@deepseek-ai/dsh-api-remotes/client';
+import type {} from '@deepseek-ai/dsh-api-session-controller/client';
+import type {} from '@deepseek-ai/dsh-client-connection/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import { resolveWorkspacePath } from '@deepseek-ai/dsh-util-workspace-path';
+import * as workspacePathPkg from '@deepseek-ai/dsh-util-workspace-path';
+import { dirname } from './deliverables.js';
+import type {} from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type {} from '@deepseek-ai/dsh-client-ui-renderer/client';
+import { Reader } from './Reader.js';
+import { createReaderStore } from './store.js';
+import { installReaderEntry } from './entry.js';
+import { installBetterDisplaySettings } from './settings.js';
+import { fillComposerDom } from './mcp-app.js';
+import { fileAddressFor, modeFromSnapshot, openDeliverableFile } from './open-file.js';
+import type { ReaderInjected } from './types.js';
+import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import { installOfficialSlots, officialChildren, type CompositionRegistry } from './official-slots.js';
+
+/** Structural face of the sanctioned per-session composer writer. */
+interface ComposerShell {
+  setDraft: (text: string) => void;
+}
+interface ConversationFace {
+  input?: { shell?: (id: SessionId) => ComposerShell };
+}
+
+interface SidebarRightFace {
+  openResource?: (address: string, options?: { params?: { line?: number } }) => void;
+}
+
+const officialFileAddressFor = (workspacePathPkg as {
+  fileAddressFor?: typeof fileAddressFor;
+}).fileAddressFor;
+
+async function openWorkspacePath(
+  ctx: Context,
+  path: string,
+): Promise<void> {
+  const remote = ctx.remote as unknown as { session?: { openWorkspacePath: (arg: { path: string }) => Promise<{ ok: boolean; error?: { message: string } }> } } | undefined;
+  const remoteSession = remote?.session
+    ?? (ctx.get?.('remote.session') as unknown as { openWorkspacePath: (arg: { path: string }) => Promise<{ ok: boolean; error?: { message: string } }> } | undefined)
+    ?? ((ctx.get?.('remote') as unknown as { session?: { openWorkspacePath: (arg: { path: string }) => Promise<{ ok: boolean; error?: { message: string } }> } })?.session);
+  if (remoteSession?.openWorkspacePath) {
+    const result = await remoteSession.openWorkspacePath({ path });
+    if (!result?.ok) {
+      console.warn('[dsh-better-display] openWorkspacePath failed:', result?.error?.message);
+    }
+  } else {
+    console.warn('[dsh-better-display] remote.session is not available');
+  }
+}
+
+export type { ReaderBlockOwner } from './types.js';
+export { McpAppFrame } from './McpAppFrame.js';
+export const name = 'dsh-better-display-client';
+export const inject = ['slots', 'sessions', 'conversation', 'uiConversation', 'remote', 'remote.session'];
+
+export function apply(ctx: Context): void {
+  const store = createReaderStore();
+  // conversation.view is session-scoped, so session persist keys are
+  // `dsh.reader.v1.<sessionId>`. One root instance keeps glass, fold
+  // intensity, and open-mode on the unsuffixed `dsh.reader.v1` key.
+  const prefs = store.create();
+  installBetterDisplaySettings(ctx, prefs);
+  ctx.slots.inject('conversation.chat.node', function* () {
+    yield ctx.slots.register({
+    name: 'conversation.view',
+    id: 'reader',
+    order: -5,
+    label: () => '阅读',
+    locale: 'chat',
+    children: {
+      'dsh-better-display.block': { kind: 'chain', scope: 'session' },
+      ...officialChildren(ctx.slots as unknown as CompositionRegistry),
+    },
+    store,
+    inject: (sessionId: SessionId): ReaderInjected => {
+      const session = () => {
+        const current = ctx.sessions.binding(sessionId)?.session;
+        if (!current) throw new Error('阅读页对应的会话已关闭。');
+        return current;
+      };
+      return {
+        openPrefs: prefs,
+        officialImageLoader: Object.assign(
+          (attachment: ImageAttachmentRef) => ctx.uiConversation.imageUrl(sessionId, attachment),
+          { peek: (attachment: ImageAttachmentRef) => ctx.uiConversation.peekImageUrl(sessionId, attachment) },
+        ),
+        officialFileMentions: owner => ctx.get('chatFileMentions')?.forClosing(owner, sessionId),
+        officialPreviewFile: path => {
+          const cwd = ctx.sessions.list.getSnapshot().byId[sessionId]?.cwd;
+          const sidebar = ctx.get('sidebarRight') as SidebarRightFace | undefined;
+          if (!sidebar?.openResource) throw new Error('文件预览面板不可用。');
+          sidebar.openResource((officialFileAddressFor ?? fileAddressFor)(sessionId, cwd, path));
+        },
+        officialHost: {
+          getSnapshot: () => ctx.remote.$host,
+          subscribe: listener => ctx.on('connection/reset', listener),
+        },
+        loadOlder: async () => { await session().loadOlder(); },
+        loadImage: async attachment => {
+          const receipt = await session().readAttachment(attachment.attachmentId);
+          if (!receipt.ok) throw new Error(receipt.error.message);
+          return { data: Uint8Array.from(receipt.value.data), mediaType: receipt.value.attachment.mediaType };
+        },
+        openFile: async (path, options) => {
+          try {
+            const cwd = ctx.sessions?.list?.getSnapshot?.()?.byId[sessionId]?.cwd;
+            const sidebar = (
+              ctx.get?.('sidebarRight')
+              ?? (ctx as unknown as { sidebarRight?: SidebarRightFace }).sidebarRight
+            ) as SidebarRightFace | undefined;
+            await openDeliverableFile({
+              path,
+              mode: modeFromSnapshot(prefs),
+              sessionId,
+              cwd,
+              resolveWorkspacePath,
+              openExternal: async (absolutePath) => { await openWorkspacePath(ctx, absolutePath); },
+              openSidebar: typeof sidebar?.openResource === 'function'
+                ? (address) => { sidebar.openResource!(address, options?.line === undefined ? undefined : { params: { line: options.line } }); }
+                : undefined,
+              fileAddressFor: officialFileAddressFor ?? fileAddressFor,
+              warn: (message, extra) => { console.warn(message, extra); },
+            });
+          } catch (error) {
+            console.warn('[dsh-better-display] openFile error:', error);
+          }
+        },
+        revealFile: async (path: string) => {
+          try {
+            const cwd = ctx.sessions?.list?.getSnapshot?.()?.byId[sessionId]?.cwd;
+            const targetPath = resolveWorkspacePath(cwd, path);
+            // 1. Try dedicated host endpoint for native file highlighting (open -R / explorer /select)
+            try {
+              const res = await fetch('/better-display/reveal', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ path: targetPath }),
+              });
+              if (res.ok) {
+                const data = await res.json();
+                if (data.ok) return;
+              }
+            } catch {
+              // Server endpoint not yet available, fallback to directory open
+            }
+
+            // 2. Fallback to official opener with parent directory
+            const parentDir = dirname(targetPath);
+            const remote = ctx.remote as unknown as { session?: { openWorkspacePath: (arg: { path: string }) => Promise<{ ok: boolean; error?: { message: string } }> } } | undefined;
+            const remoteSession = remote?.session
+              ?? (ctx.get?.('remote.session') as unknown as { openWorkspacePath: (arg: { path: string }) => Promise<{ ok: boolean; error?: { message: string } }> } | undefined);
+            if (remoteSession?.openWorkspacePath) {
+              await remoteSession.openWorkspacePath({ path: parentDir });
+            }
+          } catch (error) {
+            console.warn('[dsh-better-display] revealFile error:', error);
+          }
+        },
+        forkAt: (seq: number) => {
+          // A missing anchor would silently fork the whole session instead of
+          // the intended turn prefix, so refuse it loudly rather than guessing.
+          if (typeof seq !== 'number' || !Number.isFinite(seq)) {
+            console.warn('[dsh-better-display] fork refused: missing anchor seq');
+            return;
+          }
+          try {
+            const sessionsApi = ctx.sessions as unknown as {
+              fork: (arg: { sessionId: string; atSeq: number; increaseTitle: boolean }) => Promise<string>;
+              open: (sessionId: string) => void;
+            } | undefined;
+            if (sessionsApi?.fork) {
+              sessionsApi.fork({ sessionId, atSeq: seq, increaseTitle: true })
+                .then(childId => { sessionsApi.open?.(childId); })
+                .catch(err => { console.warn('[dsh-better-display] fork failed:', err); });
+            }
+          } catch (error) {
+            console.warn('[dsh-better-display] forkAt error:', error);
+          }
+        },
+        loadThrough: async (seq: unknown) => {
+          try {
+            const current = session() as unknown as { loadThrough?: (seq: unknown) => Promise<void> };
+            if (typeof current?.loadThrough === 'function') {
+              await current.loadThrough(seq);
+            } else {
+              await session().loadOlder();
+            }
+          } catch (error) {
+            console.warn('[dsh-better-display] loadThrough error:', error);
+          }
+        },
+        fillComposer: (text: string) => {
+          // Sanctioned path: the conversation input shell owns the Lexical
+          // editor, so setDraft lands in the draft store deterministically.
+          try {
+            const conversation = (ctx as unknown as { conversation?: ConversationFace }).conversation;
+            const shell = conversation?.input?.shell?.(sessionId);
+            if (shell && typeof shell.setDraft === 'function') {
+              shell.setDraft(text);
+              return true;
+            }
+          } catch {
+            // Fall through to the DOM path below.
+          }
+          try {
+            return fillComposerDom(text);
+          } catch {
+            return false;
+          }
+        },
+
+      };
+    },
+    }, Reader);
+    yield installOfficialSlots(ctx);
+    yield installReaderEntry(ctx);
+  });
+}