+
+ )
+}
diff --git a/src/client/OrphanedTab.tsx b/src/client/OrphanedTab.tsx
index c62ce8b..2884a4d 100644
--- a/src/client/OrphanedTab.tsx
+++ b/src/client/OrphanedTab.tsx
@@ -20,7 +20,7 @@ export function OrphanedTab(props: TabComponentProps): ReactNode {
+ {title}
+
+ {load.status === 'loading' && {t('loading')}
}
+ {load.status === 'error' && {load.message}
}
+ {load.status === 'binary' &&
{t('pluginNotLoaded')}
-
)
diff --git a/src/client/Sidebar.tsx b/src/client/Sidebar.tsx
index 39b0356..d72b3af 100644
--- a/src/client/Sidebar.tsx
+++ b/src/client/Sidebar.tsx
@@ -15,10 +15,10 @@ import clsx from 'clsx'
import { IconChevronRightOutline14, IconFullscreenOutline16, IconPanelLeftOutline16, Tooltip } from '@deepseek-ai/dsh-client-ui-primitives'
import type { Context, SidebarConversation, SidebarSessionList } from '../context-types.ts'
import {
- agentUuidOf, allLeaves, closeTab, isAgentTabId, leafWithTab, mapLeaf, moveTab, moveTabToEdge, openDiffTab,
+ agentUuidOf, closeTab, isAgentTabId, leafWithTab, mapLeaf, moveTab, moveTabToEdge, openDiffTab,
reconcileAgentTerminals,
resizeSplit, setWidth, toggleExpanded, togglePanel,
- TERMINAL_LIMIT, type DropZone, type SidebarState, type SidebarStore, type SidebarTab, type SplitNode,
+ type DropZone, type SidebarState, type SidebarStore, type SidebarTab, type SplitNode,
} from './state.ts'
import { Workbench, type WorkbenchActions } from './split-pane.tsx'
import type { NewTabOption } from './TabBar.tsx'
@@ -27,7 +27,7 @@ import { relativeTo } from './paths.ts'
import { OrphanedTab } from './OrphanedTab.tsx'
import { detectNewDirectSubagent } from './subagent-detect.ts'
import { t } from './locales.ts'
-import { api } from './api.ts'
+import { api, type SessionScope } from './api.ts'
import css from './sidebar.module.css'
/** How many consecutive reconnect failures stop the agent-terminals push loop
@@ -66,7 +66,7 @@ function TabContent(props: {
/** The + menu options for the current state, driven by the tab registry.
* Hidden tabs (editor/diff) never show; `available` returning false shows
* a disabled row (e.g. terminal at capacity) instead of hiding the option. */
-function buildNewTabOptions(state: SidebarState, ctx: Context): NewTabOption[] {
+function buildNewTabOptions(state: SidebarState, ctx: Context, scope: SessionScope): NewTabOption[] {
const service = ctx.betterSidebar
if (service === undefined) return []
return service.getTabs()
@@ -75,7 +75,7 @@ function buildNewTabOptions(state: SidebarState, ctx: Context): NewTabOption[] {
.map(d => ({
id: d.id,
label: typeof d.title === 'function' ? d.title() : d.title,
- disabled: !(d.available?.(state) ?? true),
+ disabled: !(d.available?.(ctx, scope, state) ?? true),
icon: typeof d.icon === 'function' ? d.icon(16) : d.icon,
}))
}
@@ -433,7 +433,7 @@ export function Sidebar(props: { ctx: Context; store: SidebarStore }) {
{tab.type}
+ {tab.type}
+ <>
(method: string, payload: Record, signal?: AbortSignal): Promise {
let response: Response
diff --git a/src/client/binary-download.tsx b/src/client/binary-download.tsx
new file mode 100644
index 0000000..71ea3ef
--- /dev/null
+++ b/src/client/binary-download.tsx
@@ -0,0 +1,23 @@
+/**
+ * The "no preview — download instead" pane: shown by the editor host when no
+ * viewer can render a file (binary without a registered renderer, or the
+ * `binary-download` strategy) and registered as the `binary-download` viewer
+ * component so the declarative route and the host fallback share one UI.
+ */
+import type { ReactNode } from 'react'
+import type { SessionScope } from './api.ts'
+import { downloadUrl } from './api.ts'
+import { t } from './locales.ts'
+import css from './sidebar.module.css'
+
+export function BinaryDownload(props: { scope: SessionScope; path: string }): ReactNode {
+ const { scope, path } = props
+ return (
+ { /* no-op */ })}
- onOpenFile={(path) => { openSidebarFile(ctx, store, scope.sessionId, path) }}
- onReferenceFile={onReferenceFile ?? (() => { /* no-op */ })}
- />
- ),
- },
- {
- id: 'git',
- title: () => t('git'),
- icon: (size: number) => { openSidebarFile(ctx, store, scope.sessionId, path) }}
- onOpenDiff={onOpenDiff ?? (() => { /* no-op */ })}
- />
- ),
- },
- {
- id: 'subagent',
- title: () => t('subagent'),
- icon: (size: number) => { onSubagentJump?.(address.childSessionId) }}
- />
- ),
- },
- {
- id: 'terminal',
- title: () => t('terminal'),
- icon: (size: number) => ` ids through `createTab`.
+ */
+import { IconBranchOutline16, IconCodeOutline16, IconFolderOpen16, IconThinkOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
+import type { Context } from '../../context-types.ts'
+import { allLeaves, isAgentTabId, type SidebarState } from '../state.ts'
+import { t } from '../locales.ts'
+import { openSidebarFile } from '../intercept.tsx'
+import { ExplorerView } from '../ExplorerView.tsx'
+import { EditorHost } from '../EditorHost.tsx'
+import { TerminalView } from '../TerminalView.tsx'
+import { GitView } from '../GitView.tsx'
+import { DiffTab } from '../DiffTab.tsx'
+import { SubagentView } from '../SubagentView.tsx'
+import { IconTerminalOutline16, IconDiffOutline16 } from '../icons.tsx'
+import type { TabDescriptor } from '../service.ts'
+
+/** How many UI-owned terminals may be open at once (agent-owned ones are uncapped). */
+export const TERMINAL_LIMIT = 3
+
+/** Count UI-owned terminals (agent:` tabs excluded — they are the model's). */
+function uiTerminalCount(state: SidebarState): number {
+ return allLeaves(state.splits)
+ .flatMap(leaf => leaf.tabs)
+ .filter(tab => tab.type === 'terminal' && !isAgentTabId(tab.id)).length
+}
+
+/** The 6 built-in tab descriptors. */
+export function builtinTabs(ctx: Context): readonly TabDescriptor[] {
+ return [
+ {
+ id: 'editor',
+ title: () => t('editor'),
+ icon: (size: number) => { /* no-op */ })}
+ onOpenFile={(path) => { openSidebarFile(ctx, store, scope.sessionId, path) }}
+ onReferenceFile={onReferenceFile ?? (() => { /* no-op */ })}
+ />
+ ),
+ },
+ {
+ id: 'git',
+ title: () => t('git'),
+ icon: (size: number) => { openSidebarFile(ctx, store, scope.sessionId, path) }}
+ onOpenDiff={onOpenDiff ?? (() => { /* no-op */ })}
+ />
+ ),
+ },
+ {
+ id: 'subagent',
+ title: () => t('subagent'),
+ icon: (size: number) => { onSubagentJump?.(address.childSessionId) }}
+ />
+ ),
+ },
+ {
+ id: 'terminal',
+ title: () => t('terminal'),
+ icon: (size: number) => ` ids and bump `nextTerminal`).
- * - `matchFileViewer` resolves viewers by priority (desc), then `detect`
- * (content sniff), then `exts` (lowercase, no dot).
+ * - `matchFileViewer` walks descriptors in priority order (desc, stable):
+ * per descriptor it tries `detect` first (when `head` bytes are given),
+ * then `exts`; `exts: []` is a catch-all that matches any path.
*/
import type { ReactNode } from 'react'
import type { Context } from '../context-types.ts'
import {
- activateTab, allLeaves, closeTab as closeTabReducer, firstLeaf, mapLeaf,
+ activateTab, allLeaves, closeTab as closeTabReducer, openTabInActivePane,
type SidebarState, type SidebarStore, type SidebarTab,
} from './state.ts'
import type { SessionScope } from './api.ts'
@@ -52,14 +54,24 @@ export interface TabDescriptor {
order?: number
/** Hide from the + menu (the editor tab is opened by file-open, not by the menu). */
hidden?: boolean
- /** + menu disabled predicate (e.g. terminal at capacity). */
- available?: (state: SidebarState) => boolean
+ /**
+ * + menu disabled predicate (e.g. terminal at capacity). Receives the
+ * session scope and the live sidebar state (counts, expansions).
+ */
+ available?: (ctx: Context, scope: SessionScope, state: SidebarState) => boolean
+ /**
+ * Single-instance sugar: `true` is shorthand for `dedupeKey: () => id`
+ * (opening the tab focuses an existing one of the same type instead of
+ * creating a duplicate). An explicit `dedupeKey` always wins when both
+ * are given. Builtins: explorer/git/subagent use `single: true`.
+ */
+ single?: boolean
/**
* If provided, opening a tab whose `dedupeKey(tab)` matches an existing
* tab's key focuses the existing one instead of creating a new one.
* Returning `undefined` means "no dedup — always open a new tab".
- * Builtins: explorer/git/subagent use `() => id`; editor uses `tab => tab.path`;
- * diff uses `tab => tab.id` (openDiffTab mints change-derived ids).
+ * Builtins: editor uses `tab => tab.path`; diff uses `tab => tab.id`
+ * (openDiffTab mints change-derived ids).
*/
dedupeKey?: (tab: SidebarTab) => string | undefined
/**
@@ -87,6 +99,8 @@ export interface FileViewerProps {
scope: SessionScope
path: string
title: string
+ /** The matching descriptor's id (`'code'`, `'my-plugin:csv'`). */
+ viewerId: string
/** fsRead text content (fetchStrategy='fsRead'). */
content?: string
truncated?: boolean
@@ -106,8 +120,8 @@ export interface FileViewerDescriptor {
priority?: number
fetchStrategy: FileFetchStrategy
/**
- * Content sniff (overrides exts when `head` bytes are available).
- * The first descriptor (priority desc) whose `detect` returns true wins.
+ * Content sniff: when `head` bytes are available the descriptor's `detect`
+ * is consulted before its `exts` (per-descriptor, in priority order).
*/
detect?: (path: string, head: Uint8Array) => boolean
/** fetchStrategy='custom' loader. */
@@ -123,10 +137,15 @@ export interface BetterSidebarService {
getFileViewers(): readonly FileViewerDescriptor[]
/** Find a tab descriptor by id (undefined if not registered). */
getTab(id: string): TabDescriptor | undefined
- /** Find a file viewer for a path (priority desc → detect → exts). */
+ /** Find a file viewer for a path (priority desc; detect first, then exts). */
matchFileViewer(path: string, head?: Uint8Array): FileViewerDescriptor | undefined
- /** Open a tab (used by external tabs and the + menu). */
- openTab(seed: { type: string; title: string; path?: string; diff?: SidebarTab['diff']; id?: string }): void
+ /**
+ * Open a tab (used by external tabs and the + menu). `title` overrides
+ * the descriptor's title when given (the editor tab shows the file name);
+ * when the descriptor provides `createTab` it mints the tab itself and
+ * `title`/`path`/`id` are ignored.
+ */
+ openTab(seed: { type: string; title?: string; path?: string; diff?: SidebarTab['diff']; id?: string }): void
/** Close a tab by id. */
closeTab(tabId: string): void
/** Subscribe to registry changes (register/dispose). */
@@ -194,29 +213,34 @@ export function createBetterSidebarService(store: SidebarStore): BetterSidebarSe
const matchFileViewer = (path: string, head?: Uint8Array): FileViewerDescriptor | undefined => {
const ext = extOfPath(path)
- // Priority descending; stable order for equal priorities (insertion order).
- const sorted = Array.from(viewers.values()).sort(
+ // Single pass in priority order (descending; stable for equal
+ // priorities — insertion order). Each descriptor gets first refusal in
+ // its own turn: `detect` (when head bytes are available) beats its own
+ // `exts`, and `exts: []` is a catch-all matching any path — so the
+ // catch-all `code` viewer (-100) only sees paths no higher-priority
+ // descriptor claimed.
+ for (const v of Array.from(viewers.values()).sort(
(a, b) => (b.priority ?? 0) - (a.priority ?? 0),
- )
- // Pass 1: content sniff (detect overrides exts when head bytes are available).
- if (head !== undefined) {
- for (const v of sorted) {
- if (v.detect !== undefined && v.detect(path, head)) return v
+ )) {
+ // Content sniff first (only when head bytes are available).
+ if (head !== undefined && v.detect !== undefined) {
+ if (v.detect(path, head)) return v
+ // A catch-all with detect is SNIFF-ONLY: it must not blind-claim
+ // paths it never sniffed (a magic-number viewer must not swallow
+ // every file before the real viewers get their turn).
+ if (v.exts.length === 0) continue
+ } else if (v.exts.length === 0) {
+ // Blind catch-all (no detect) claims anything; a sniff-only
+ // catch-all (detect defined, no head yet) yields this round.
+ if (v.detect === undefined) return v
+ continue
}
- }
- // Pass 2: extension match ([] is catch-all, skipped here).
- for (const v of sorted) {
- if (v.exts.length === 0) continue
if (v.exts.includes(ext)) return v
}
- // Pass 3: catch-all (exts === []).
- for (const v of sorted) {
- if (v.exts.length === 0) return v
- }
return undefined
}
- const openTab = (seed: { type: string; title: string; path?: string; diff?: SidebarTab['diff']; id?: string }): void => {
+ const openTab = (seed: { type: string; title?: string; path?: string; diff?: SidebarTab['diff']; id?: string }): void => {
store.reduce((state) => {
const descriptor = tabs.get(seed.type)
if (descriptor === undefined) return state
@@ -230,7 +254,9 @@ export function createBetterSidebarService(store: SidebarStore): BetterSidebarSe
const tab: SidebarTab = {
id: seed.id ?? seed.type,
type: seed.type,
- title: typeof descriptor.title === 'function' ? descriptor.title() : descriptor.title,
+ // A caller-provided title wins (the editor shows the file name);
+ // otherwise the descriptor's (possibly i18n) title is the default.
+ title: seed.title ?? (typeof descriptor.title === 'function' ? descriptor.title() : descriptor.title),
...(seed.path !== undefined ? { path: seed.path } : {}),
...(seed.diff !== undefined ? { diff: seed.diff } : {}),
}
@@ -260,29 +286,22 @@ export function createBetterSidebarService(store: SidebarStore): BetterSidebarSe
}
/**
- * Apply dedup: if a tab with the same dedupeKey exists, focus it instead.
- * Mirrors the three branches the old `openTab` hardcoded (single/editor/diff).
+ * Apply dedup: if a tab whose `dedupeKey` matches an existing tab of the
+ * same type exists, focus it; otherwise land the tab through
+ * `openTabInActivePane` (the id safety net + active-pane landing are that
+ * reducer's job — not re-implemented here).
+ * `single: true` resolves to the id-key sugar when no explicit key is given.
*/
function applyDedupe(state: SidebarState, tab: SidebarTab, descriptor: TabDescriptor): SidebarState {
- const key = descriptor.dedupeKey?.(tab)
+ const dedupeKey = descriptor.dedupeKey ?? (descriptor.single === true ? () => descriptor.id : undefined)
+ const key = dedupeKey?.(tab)
if (key !== undefined) {
for (const leaf of allLeaves(state.splits)) {
- const existing = leaf.tabs.find(t => t.type === tab.type && descriptor.dedupeKey!(t) === key)
+ const existing = leaf.tabs.find(t => t.type === tab.type && dedupeKey!(t) === key)
if (existing !== undefined) return activateTab(state, leaf.id, existing.id)
}
}
- let targetId = state.activePane ?? firstLeaf(state.splits).id
- if (!allLeaves(state.splits).some(leaf => leaf.id === targetId)) {
- targetId = firstLeaf(state.splits).id
- }
- return {
- ...state,
- activePane: targetId,
- splits: mapLeaf(state.splits, targetId, (leaf) => {
- leaf.tabs = [...leaf.tabs, tab]
- leaf.active = tab.id
- }),
- }
+ return openTabInActivePane(state, tab)
}
/** Find which pane hosts a tab id ('' if none). */
diff --git a/src/client/sidebar.module.css b/src/client/sidebar.module.css
index 3ed2a10..afd0f01 100644
--- a/src/client/sidebar.module.css
+++ b/src/client/sidebar.module.css
@@ -640,6 +640,15 @@
text-align: center;
}
+/* The unregistered tab type shown by the orphaned-tab placeholder. */
+.orphanedType {
+ display: block;
+ margin-top: 8px;
+ font-size: 12px;
+ opacity: 0.7;
+ overflow-wrap: anywhere;
+}
+
/* Binary / download-only files (pptx, OLE .doc/.xls/.ppt, unknown binaries):
a centered notice plus a download link — the user always gets the file. */
.editorBinary {
diff --git a/src/client/state.ts b/src/client/state.ts
index c6ce084..93ec300 100644
--- a/src/client/state.ts
+++ b/src/client/state.ts
@@ -12,18 +12,13 @@
import { SIDEBAR_PREFS_DEFAULTS, type SidebarPrefs } from '../prefs-shared.ts'
/**
- * Tab type identifier. Builtins use the strings below; external plugins
- * register their own ids (e.g. `'my-plugin:db'`) through the sidebar
- * service. Kept as `string` so the registry is open; {@link SIDEBAR_BUILTIN_TAB_TYPES}
- * lists the builtins for back-compat checks.
+ * Tab type identifier. Builtins register their ids (explorer / git / editor
+ * / terminal / subagent / diff) through the sidebar service; external
+ * plugins register their own (e.g. `'my-plugin:db'`). Kept as `string` so
+ * the registry stays open.
*/
export type TabType = string
-/** The tab type ids the plugin itself registers (see {@link ./builtins.ts}). */
-export const SIDEBAR_BUILTIN_TAB_TYPES = [
- 'explorer', 'git', 'editor', 'terminal', 'subagent', 'diff',
-] as readonly string[]
-
/** What a diff tab shows: a worktree/index change of one path, or one commit's full patch. */
export type SidebarDiffRef =
| { kind: 'worktree'; path: string; staged: boolean; untracked?: boolean }
@@ -75,7 +70,6 @@ export const PANEL_MIN = 280
export const PANEL_MAX = 640
export const PANEL_DEFAULT = 400
export const TAB_MAX_WIDTH = 160
-export const TERMINAL_LIMIT = 3
let nextIdCounter = 0
/** Unique pane/tab id within one state instance. */
@@ -310,14 +304,15 @@ export function activateTab(state: SidebarState, paneId: string, tabId: string):
}
/**
- * Open a tab (or focus its existing instance by id). Dedup strategies
- * (single-instance, per-path, per-change) are owned by the tab descriptor
- * through {@link BetterSidebarService.openTab} / `dedupeKey`; this reducer
- * only handles the id-based safety net (reconcile/openDiffTab already
- * check existence before calling) and lands the tab in the active pane
- * (or the first pane when the active one is gone).
+ * Land a tab in the active pane (or focus its existing instance by id).
+ * Dedup strategies (single-instance, per-path, per-change) are owned by the
+ * tab descriptor through {@link BetterSidebarService.openTab} / `dedupeKey`;
+ * this reducer only handles the id-based safety net (reconcile and
+ * openDiffTab already check existence before calling) and the landing
+ * itself — the service's dedupe path delegates here after its dedupeKey
+ * check misses.
*/
-export function openTab(state: SidebarState, tab: SidebarTab): SidebarState {
+export function openTabInActivePane(state: SidebarState, tab: SidebarTab): SidebarState {
let targetId = state.activePane ?? firstLeaf(state.splits).id
// A stale activePane (its pane was closed since) must not swallow the
// open: fall back to the first pane instead of dropping the tab.
@@ -373,6 +368,12 @@ export function splitPane(state: SidebarState, dir: 'row' | 'col'): SidebarState
* already holds diff tabs (diff panes are sticky — repeated clicks stack
* there); on the FIRST diff of a layout the source pane splits vertically so
* the diff lands in a fresh pane below it ("默认在下半栏新增一个").
+ *
+ * This is split-tree placement surgery, not registry dispatch: the diff tab
+ * descriptor's `dedupeKey` is `(tab) => tab.id`, and the existing-instance
+ * check below is exactly that rule — the two agree by construction (asserted
+ * in tests). Diff tabs minted by the Git view carry change-derived ids, so
+ * the id check is the per-change dedupe.
* @returns the new state, with the diff pane active.
*/
export function openDiffTab(state: SidebarState, sourcePaneId: string, tab: SidebarTab): SidebarState {
@@ -393,7 +394,7 @@ export function openDiffTab(state: SidebarState, sourcePaneId: string, tab: Side
// (A stale sourcePaneId — its pane closed meanwhile — degrades to the
// regular open path instead of dropping the tab into an orphaned leaf.)
if (!allLeaves(state.splits).some(leaf => leaf.id === sourcePaneId)) {
- return openTab(state, tab)
+ return openTabInActivePane(state, tab)
}
const result = insertLeafAt(state.splits, sourcePaneId, 'col', tab, false)
return { ...state, splits: result.node, activePane: result.leafId }
@@ -488,7 +489,7 @@ export function reconcileAgentTerminals(
}
}
// Add tabs for new uuids (the agent created a terminal). They land in the
- // active pane via openTab; the next reconcile is a no-op for them.
+ // active pane via openTabInActivePane; the next reconcile is a no-op for them.
let next: SidebarState = { ...state, splits }
for (const terminal of toAdd) {
const tab: SidebarTab = {
@@ -496,7 +497,7 @@ export function reconcileAgentTerminals(
type: 'terminal',
title: terminal.title,
}
- next = openTab(next, tab)
+ next = openTabInActivePane(next, tab)
}
return next
}
diff --git a/src/index.ts b/src/index.ts
index 274720c..747455c 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -123,8 +123,19 @@ async function resolveGitPath(cwd: string, raw: string): Promise {
return requireAbsolute(join(root, raw))
}
-/** Text read of a file with the size cap; binary detection via NUL probe. */
-async function readText(path: string, readLimit: number): Promise<{ content: string; truncated: boolean; binary: boolean; size: number }> {
+/** How many leading bytes a binary read returns for client-side detect sniffing. */
+const READ_HEAD_LIMIT = 4096
+
+/** Text read of a file with the size cap; binary detection via NUL probe.
+ * Binary reads also return the first {@link READ_HEAD_LIMIT} bytes (base64)
+ * so the client can re-match viewers by content (`detect`). */
+async function readText(path: string, readLimit: number): Promise<{
+ content: string
+ truncated: boolean
+ binary: boolean
+ size: number
+ head?: string
+}> {
const info = await stat(path).catch((error: unknown) => {
throw new SidebarError('fs-error', `cannot read "${path}": ${error instanceof Error ? error.message : String(error)}`, 400)
})
@@ -141,7 +152,10 @@ async function readText(path: string, readLimit: number): Promise<{ content: str
const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0)
const slice = buffer.subarray(0, bytesRead)
const binary = slice.includes(0)
- return { content: binary ? '' : slice.toString('utf8'), truncated, binary, size }
+ const head = binary
+ ? slice.subarray(0, Math.min(slice.length, READ_HEAD_LIMIT)).toString('base64')
+ : undefined
+ return { content: binary ? '' : slice.toString('utf8'), truncated, binary, size, head }
} finally {
await handle.close()
}
@@ -194,8 +208,8 @@ function buildApi(
// Relative paths are git-derived (status/diff report repo-root-relative
// names; the untracked diff view reads the file through this route).
const path = await resolveGitPath(cwd, requireString(payload, 'path'))
- const { content, truncated, binary, size } = await readText(path, resolved.readLimit)
- if (binary) return { kind: 'binary', size, truncated }
+ const { content, truncated, binary, size, head } = await readText(path, resolved.readLimit)
+ if (binary) return { kind: 'binary', size, truncated, head }
return { kind: 'text', content, truncated }
},
'fs.write': async (payload) => {
diff --git a/tests/browser-globals.ts b/tests/browser-globals.ts
new file mode 100644
index 0000000..d636a90
--- /dev/null
+++ b/tests/browser-globals.ts
@@ -0,0 +1,59 @@
+/**
+ * Browser globals for specs that pull browser-bound modules. Import this
+ * FIRST in a spec file: unlike statements after imports (which vitest
+ * hoists above the module body), an import statement evaluates in order,
+ * so this runs before any later import's module graph (xterm's UMD wrapper
+ * checks `self` and its color defaults probe `document` at evaluation time;
+ * window/localStorage are only touched at runtime by the store).
+ */
+const g = globalThis as Record
+
+if (g.self === undefined) g.self = globalThis
+
+const elementStub = (): Record => ({
+ style: {},
+ classList: { add: () => {}, remove: () => {}, contains: () => false },
+ setAttribute: () => {},
+ getAttribute: () => null,
+ appendChild: () => {},
+ addEventListener: () => {},
+ removeEventListener: () => {},
+ getBoundingClientRect: () => ({ left: 0, top: 0, width: 0, height: 0 }),
+ // xterm's color palette probe measures a canvas context at module load.
+ getContext: () => null,
+})
+
+if (g.document === undefined) {
+ g.document = {
+ createElement: () => elementStub(),
+ createDocumentFragment: () => elementStub(),
+ addEventListener: () => {},
+ removeEventListener: () => {},
+ defaultView: globalThis,
+ body: elementStub(),
+ // CodeMirror's view module probes the UA and injects styles at load.
+ documentElement: elementStub(),
+ head: elementStub(),
+ styleSheets: [],
+ }
+}
+
+if (g.navigator === undefined) {
+ g.navigator = { userAgent: 'node', platform: 'node', vendor: '', maxTouchPoints: 0 }
+}
+
+if (g.window === undefined) {
+ g.window = {
+ clearTimeout: () => {},
+ setTimeout: (_fn: () => void) => 0,
+ innerWidth: 1024,
+ getComputedStyle: () => ({ getPropertyValue: () => '' }),
+ }
+}
+
+if (g.localStorage === undefined) {
+ g.localStorage = {
+ getItem: () => null,
+ setItem: () => {},
+ }
+}
diff --git a/tests/builtins.spec.ts b/tests/builtins.spec.ts
new file mode 100644
index 0000000..87c335f
--- /dev/null
+++ b/tests/builtins.spec.ts
@@ -0,0 +1,102 @@
+/**
+ * Built-in registration tests: the plugin registers 6 tabs and 8 file
+ * viewers through the same service external plugins use (dogfooding);
+ * the catch-all `code` viewer and the NUL-sniffing `binary-download`
+ * viewer pin the registry's matching behavior.
+ */
+import { describe, expect, it } from 'vitest'
+// First import: browser globals before the xterm-carrying builtin graph loads.
+import './browser-globals.ts'
+
+import type { Context } from '../src/context-types.ts'
+import { createBetterSidebarService } from '../src/client/service.ts'
+import { createSidebarStore } from '../src/client/state.ts'
+import { registerBuiltins } from '../src/client/builtins/index.ts'
+
+function setup(): { service: ReturnType; dispose: () => void } {
+ const store = createSidebarStore()
+ const service = createBetterSidebarService(store)
+ const dispose = registerBuiltins({} as Context, service)
+ return { service, dispose }
+}
+
+describe('built-in tab registrations', () => {
+ it('registers the 6 built-in tabs', () => {
+ const { service } = setup()
+ expect(service.getTabs().map(t => t.id).sort()).toEqual(
+ ['diff', 'editor', 'explorer', 'git', 'subagent', 'terminal'],
+ )
+ })
+
+ it('editor and diff are hidden from the + menu (opened by file-open / git view)', () => {
+ const { service } = setup()
+ expect(service.getTabs().filter(t => t.hidden).map(t => t.id).sort()).toEqual(['diff', 'editor'])
+ })
+
+ it('single-instance tabs use the single sugar', () => {
+ const { service } = setup()
+ for (const id of ['explorer', 'git', 'subagent']) {
+ expect(service.getTab(id)?.single).toBe(true)
+ }
+ })
+})
+
+describe('built-in file viewer registrations', () => {
+ it('registers the 8 built-in file viewers', () => {
+ const { service } = setup()
+ expect(service.getFileViewers().map(v => v.id).sort()).toEqual(
+ ['binary-download', 'code', 'docx', 'image', 'markdown', 'pdf', 'pptx', 'xlsx'],
+ )
+ })
+
+ it('code is the catch-all at the lowest priority', () => {
+ const { service } = setup()
+ const code = service.getFileViewers().find(v => v.id === 'code')
+ expect(code?.exts).toEqual([])
+ expect(code?.priority).toBe(-100)
+ expect(code?.fetchStrategy).toBe('fsRead')
+ expect(service.matchFileViewer('anything.zzz')?.id).toBe('code')
+ })
+
+ it('markdown claims md/markdown before the catch-all', () => {
+ const { service } = setup()
+ expect(service.matchFileViewer('readme.md')?.id).toBe('markdown')
+ expect(service.matchFileViewer('readme.markdown')?.id).toBe('markdown')
+ expect(service.matchFileViewer('readme.md', new Uint8Array([0x61]))?.id).toBe('markdown')
+ })
+
+ it('binary-download claims legacy office by extension', () => {
+ const { service } = setup()
+ expect(service.matchFileViewer('old.doc')?.id).toBe('binary-download')
+ expect(service.matchFileViewer('old.xls')?.id).toBe('binary-download')
+ expect(service.matchFileViewer('old.ppt')?.id).toBe('binary-download')
+ })
+
+ it('binary-download NUL detect claims unknown-extension binaries over code', () => {
+ const { service } = setup()
+ // First match (no head) falls to the catch-all code viewer...
+ expect(service.matchFileViewer('blob.zzz')?.id).toBe('code')
+ // ...but the head re-match (NUL probe) routes it to binary-download.
+ expect(service.matchFileViewer('blob.zzz', new Uint8Array([0x01, 0x00, 0x02]))?.id).toBe('binary-download')
+ // A NUL-free blob stays with code.
+ expect(service.matchFileViewer('blob.zzz', new Uint8Array([0x61, 0x62]))?.id).toBe('code')
+ })
+
+ it('office mediaUrl viewers beat the binary sniffers for their own extensions', () => {
+ const { service } = setup()
+ // A .docx is a zip (no NUL in its head): the docx viewer (priority 0)
+ // claims it before binary-download (-50) is consulted.
+ expect(service.matchFileViewer('book.docx', new Uint8Array([0x50, 0x4b, 0x03, 0x04]))?.id).toBe('docx')
+ })
+})
+
+describe('built-in disposer', () => {
+ it('unregisters everything (HMR-safe)', () => {
+ const { service, dispose } = setup()
+ dispose()
+ expect(service.getTabs()).toHaveLength(0)
+ expect(service.getFileViewers()).toHaveLength(0)
+ // The disposer is idempotent.
+ dispose()
+ })
+})
diff --git a/tests/editor-load.spec.ts b/tests/editor-load.spec.ts
new file mode 100644
index 0000000..c4afb2e
--- /dev/null
+++ b/tests/editor-load.spec.ts
@@ -0,0 +1,100 @@
+/**
+ * Tests for the editor-load planning: the pure strategy dispatch the
+ * editor host runs (planFirstMatch / planFsReadOutcome / decodeHead).
+ */
+import { describe, expect, it } from 'vitest'
+import { decodeHead, planFirstMatch, planFsReadOutcome } from '../src/client/editor-load.ts'
+import type { FileViewerDescriptor } from '../src/client/service.ts'
+
+const viewer = (over: Partial): FileViewerDescriptor => ({
+ id: 'v',
+ exts: [],
+ fetchStrategy: 'fsRead',
+ component: () => null,
+ ...over,
+})
+
+describe('planFirstMatch', () => {
+ it('no viewer → binary (download UI)', () => {
+ expect(planFirstMatch(undefined, () => '/m')).toEqual({ kind: 'binary' })
+ })
+
+ it('binary-download strategy → binary', () => {
+ const v = viewer({ id: 'dl', fetchStrategy: 'binary-download' })
+ expect(planFirstMatch(v, () => '/m')).toEqual({ kind: 'binary' })
+ })
+
+ it('mediaUrl / none → render with the media URL', () => {
+ const v = viewer({ id: 'img', fetchStrategy: 'mediaUrl' })
+ expect(planFirstMatch(v, () => '/media')).toEqual({ kind: 'render', viewer: v, mediaUrl: '/media' })
+ expect(planFirstMatch(viewer({ id: 'none', fetchStrategy: 'none' }), () => '/m').kind).toBe('render')
+ })
+
+ it('custom → customLoad (the viewer loads its own bytes)', () => {
+ const v = viewer({ id: 'csv', fetchStrategy: 'custom', load: async () => [] })
+ expect(planFirstMatch(v, () => '/m')).toEqual({ kind: 'customLoad', viewer: v })
+ })
+
+ it('fsRead → fetchFsRead', () => {
+ const v = viewer({ id: 'code', fetchStrategy: 'fsRead' })
+ expect(planFirstMatch(v, () => '/m')).toEqual({ kind: 'fetchFsRead', viewer: v })
+ })
+})
+
+describe('planFsReadOutcome', () => {
+ const rematch = (head: Uint8Array): FileViewerDescriptor | undefined => {
+ // The builtin binary-download NUL probe shape.
+ if (head.includes(0)) return viewer({ id: 'binary-download', fetchStrategy: 'binary-download' })
+ return undefined
+ }
+
+ it('text result renders with content, same viewer', () => {
+ const v = viewer({ id: 'code' })
+ const action = planFsReadOutcome(v, { binary: false, content: 'hello', truncated: true }, rematch, () => '/m')
+ expect(action).toEqual({ kind: 'render', viewer: v, content: 'hello', truncated: true })
+ })
+
+ it('binary without head bytes → binary', () => {
+ expect(planFsReadOutcome(viewer({}), { binary: true, content: '', truncated: false }, rematch, () => '/m')).toEqual({ kind: 'binary' })
+ })
+
+ it('binary whose NUL head re-matches nothing renderable → binary', () => {
+ const action = planFsReadOutcome(
+ viewer({}),
+ { binary: true, content: '', truncated: false, head: 'AAAAAA==' }, // 0x00 bytes
+ rematch,
+ () => '/m',
+ )
+ // binary-download claims it — still the download UI.
+ expect(action).toEqual({ kind: 'binary' })
+ })
+
+ it('binary re-matched to a custom viewer → customLoad (external sniffer)', () => {
+ const sniffer = viewer({ id: 'my:raw', fetchStrategy: 'custom', load: async () => ({}) })
+ const action = planFsReadOutcome(
+ viewer({}),
+ { binary: true, content: '', truncated: false, head: 'AAAAAA==' },
+ () => sniffer,
+ () => '/m',
+ )
+ expect(action).toEqual({ kind: 'customLoad', viewer: sniffer })
+ })
+
+ it('binary re-matched to a mediaUrl viewer → render with the media URL', () => {
+ const media = viewer({ id: 'my:binimg', fetchStrategy: 'mediaUrl' })
+ const action = planFsReadOutcome(
+ viewer({}),
+ { binary: true, content: '', truncated: false, head: 'AAAAAA==' },
+ () => media,
+ () => '/m?x=1',
+ )
+ expect(action).toEqual({ kind: 'render', viewer: media, mediaUrl: '/m?x=1' })
+ })
+})
+
+describe('decodeHead', () => {
+ it('decodes base64 to the exact bytes', () => {
+ const head = decodeHead('AP//AA==')
+ expect(Array.from(head)).toEqual([0x00, 0xff, 0xff, 0x00])
+ })
+})
diff --git a/tests/orphaned-tab.spec.tsx b/tests/orphaned-tab.spec.tsx
new file mode 100644
index 0000000..64d092f
--- /dev/null
+++ b/tests/orphaned-tab.spec.tsx
@@ -0,0 +1,87 @@
+/**
+ * Orphaned-tab tests: a persisted tab whose type is not registered must
+ * survive sanitize (title/path kept for recovery) and render the graceful
+ * placeholder instead of crashing — the degradation path of the open
+ * tab-type set (a contributing plugin not installed / not yet loaded).
+ */
+import { describe, expect, it } from 'vitest'
+import { renderToString } from 'react-dom/server'
+import { OrphanedTab } from '../src/client/OrphanedTab.tsx'
+import { sanitizeState } from '../src/client/state.ts'
+
+/** Collect every tab type in a sanitized tree (leaf/split recursive). */
+function typesOf(node: unknown): string[] {
+ if (node === null || typeof node !== 'object') return []
+ const record = node as { kind?: unknown; tabs?: unknown; children?: unknown }
+ if (record.kind === 'leaf' && Array.isArray(record.tabs)) {
+ return (record.tabs as Array<{ type: string }>).map(tab => tab.type)
+ }
+ if (Array.isArray(record.children)) return record.children.flatMap(typesOf)
+ return []
+}
+
+describe('sanitize keeps unregistered tab types', () => {
+ it('preserves a persisted tab of an unknown type with its title/path', () => {
+ const raw = {
+ panelOpen: true,
+ width: 400,
+ nextTerminal: 1,
+ activePane: null,
+ expanded: [],
+ splits: {
+ kind: 'leaf',
+ id: 'pane:1',
+ tabs: [
+ { id: 'tab:1', type: 'my-plugin:db', title: 'Database', path: '/data.sqlite' },
+ { id: 'tab:2', type: 'explorer', title: 'Explorer' },
+ ],
+ active: 'tab:1',
+ },
+ }
+ const clean = sanitizeState(raw)
+ expect(clean).toBeDefined()
+ expect(typesOf(clean!.splits)).toContain('my-plugin:db')
+ // The kept tab keeps its payload so a later registration can reuse it.
+ const leaf = clean!.splits as unknown as { kind: 'leaf'; tabs: Array> }
+ const kept = leaf.tabs.find(tab => tab.type === 'my-plugin:db')
+ expect(kept).toMatchObject({ title: 'Database', path: '/data.sqlite' })
+ })
+
+ it('an unknown type alone in a pane still sanitizes cleanly', () => {
+ const raw = {
+ panelOpen: true,
+ width: 400,
+ nextTerminal: 1,
+ activePane: null,
+ expanded: [],
+ splits: {
+ kind: 'leaf',
+ id: 'pane:1',
+ tabs: [{ id: 'tab:1', type: 'some-plugin:page', title: 'Page' }],
+ active: 'tab:1',
+ },
+ }
+ const clean = sanitizeState(raw)
+ expect(clean).toBeDefined()
+ expect(typesOf(clean!.splits)).toEqual(['some-plugin:page'])
+ })
+})
+
+describe('OrphanedTab placeholder', () => {
+ const tab = { id: 'tab:1', type: 'my-plugin:db', title: 'Database' }
+
+ it('renders the unregistered type and keeps the title', () => {
+ const html = renderToString((
+
// paneB 现在是 split(row) [旧leaf, 新leaf(tabId)]；其父 split 仍存在。
@@ -401,7 +401,7 @@ describe('sidebar state', () => {
it('dragging a tab back onto its own pane center reorders it', () => {
let s = state()
- s = openTab(s, { id: 't2', type: 'terminal', title: 'T2' })
+ s = openTabInActivePane(s, { id: 't2', type: 'terminal', title: 'T2' })
const leaf = s.splits as { id: string; tabs: { id: string }[] }
const first = leaf.tabs[0]!.id
s = moveTabToEdge(s, leaf.id, first, leaf.id, 'center')
@@ -419,7 +419,7 @@ describe('sidebar state', () => {
const explorerId = paneA.tabs[0]!.id
// paneA gets a terminal; the explorer moves to paneB; closing the
// terminal empties paneA, which is removed, promoting paneB.
- s = openTab(s, { id: 't', type: 'terminal', title: 'Terminal 1' })
+ s = openTabInActivePane(s, { id: 't', type: 'terminal', title: 'Terminal 1' })
s = moveTab(s, paneA.id, explorerId, paneB.id)
s = activateTab(s, paneA.id, 't')
s = closeTab(s, paneA.id, 't')
@@ -468,7 +468,7 @@ describe('sidebar state', () => {
s = closeTab(s, target.id, explorerId)
expect(tabOpenIn(s, explorerId)).toBe(false)
// A terminal tab added later is open too.
- s = openTab(s, { id: 'terminal:9', type: 'terminal', title: 'Terminal 9' })
+ s = openTabInActivePane(s, { id: 'terminal:9', type: 'terminal', title: 'Terminal 9' })
expect(tabOpenIn(s, 'terminal:9')).toBe(true)
})
})
@@ -511,7 +511,7 @@ describe('agent terminal reconciliation', () => {
it('does not touch non-agent terminal tabs', () => {
let s = makeDefaultState(400, true)
- s = openTab(s, { id: 'terminal:1', type: 'terminal', title: 'UI Tab' })
+ s = openTabInActivePane(s, { id: 'terminal:1', type: 'terminal', title: 'UI Tab' })
s = reconcileAgentTerminals(s, [{ uuid: 'aaa-111', title: 'agent' }])
expect(tabOpenIn(s, 'terminal:1')).toBe(true)
expect(tabOpenIn(s, 'agent:aaa-111')).toBe(true)
@@ -688,7 +688,7 @@ describe('persisted state sanitization', () => {
expect(new Set(leaves.map(leaf => leaf.id)).size).toBe(2)
expect(clean!.activePane).toBe(leaves[1]!.id)
// And an open must land in exactly one pane of the healed tree.
- const opened = openTab(clean!, { id: 'editor:/a.ts', type: 'editor', title: 'a.ts', path: '/a.ts' })
+ const opened = openTabInActivePane(clean!, { id: 'editor:/a.ts', type: 'editor', title: 'a.ts', path: '/a.ts' })
const owners = allLeaves(opened.splits).filter(leaf => leaf.tabs.some(tab => tab.path === '/a.ts'))
expect(owners).toHaveLength(1)
})
@@ -698,13 +698,13 @@ describe('persisted state sanitization', () => {
const paneA = allLeaves(s.splits)[0]!.id
const explorerTab = allLeaves(s.splits)[0]!.tabs.find(tab => tab.type === 'explorer')!.id
s = closeTab(s, paneA, explorerTab)
- s = openTab(s, { id: 'editor:/a.ts', type: 'editor', title: 'a.ts', path: '/a.ts' })
+ s = openTabInActivePane(s, { id: 'editor:/a.ts', type: 'editor', title: 'a.ts', path: '/a.ts' })
const split = insertLeafAt(s.splits, paneA, 'col', { id: 'terminal:1', type: 'terminal', title: 'Terminal 1' }, false)
s = { ...s, splits: split.node, activePane: paneA }
// Closing the editor empties paneA; the pane is removed but activePane
// still points at it. The next open must land in the surviving pane.
s = closeTab(s, paneA, 'editor:/a.ts')
- s = openTab(s, { id: 'editor:/b.ts', type: 'editor', title: 'b.ts', path: '/b.ts' })
+ s = openTabInActivePane(s, { id: 'editor:/b.ts', type: 'editor', title: 'b.ts', path: '/b.ts' })
const owners = allLeaves(s.splits).filter(leaf => leaf.tabs.some(tab => tab.path === '/b.ts'))
expect(owners).toHaveLength(1)
expect(owners[0]!.tabs.some(tab => tab.type === 'terminal')).toBe(true)
- {title}
- {previewable && (
+ {markdown && (
- {load.status === 'loading' &&
+
)
}
-
-/** The lowercased file extension of a path ('' when none). */
-function extOfPath(path: string): string {
- const at = path.lastIndexOf('.')
- if (at === -1) return ''
- const base = path.slice(at).toLowerCase()
- return base.includes('/') || base.includes('\\') ? '' : base
-}
diff --git a/src/client/api.ts b/src/client/api.ts
index 5583565..8fd943c 100644
--- a/src/client/api.ts
+++ b/src/client/api.ts
@@ -54,8 +54,9 @@ export interface GitLogEntry {
/** Text read result. */
export interface FsTextResult { kind: 'text'; content: string; truncated: boolean }
-/** Binary read result (no content; images load through the media route). */
-export interface FsBinaryResult { kind: 'binary'; size: number; truncated: boolean }
+/** Binary read result (no content; images load through the media route).
+ * `head` carries the first bytes (base64) for viewer detect sniffing. */
+export interface FsBinaryResult { kind: 'binary'; size: number; truncated: boolean; head: string }
async function call{t('loading')}
}
- {load.status === 'error' && {load.message}
}
- {load.status === 'binary' && (
-
- {t('binaryNoPreview')}
-
- {t('downloadToView')}
-
-
- )}
{editable && (
<>
- {load.truncated && mode === 'edit' && {t('truncation')}
}
+ {truncated === true && mode === 'edit' && {t('truncation')}
}
)}
- {load.status === 'ready' && load.viewer !== undefined && createElement(load.viewer.component, {
- ctx, store, scope, path, title,
- content: load.content,
- truncated: load.truncated,
- mediaUrl: load.mediaUrl,
- customData: load.customData,
- })}
- {previewable && mode === 'preview' && (
+ {markdown && mode === 'preview' && (
-
)}
-
+ {t('binaryNoPreview')}
+
+ {t('downloadToView')}
+
+
+ )
+}
diff --git a/src/client/builtins.tsx b/src/client/builtins.tsx
deleted file mode 100644
index 52b71e6..0000000
--- a/src/client/builtins.tsx
+++ /dev/null
@@ -1,214 +0,0 @@
-/**
- * Built-in tab types and file viewers: the plugin registers its own
- * built-in pages (explorer / git / terminal / subagent / editor / diff)
- * and file previewers (image / pdf / docx / xlsx / pptx / binary-download)
- * through the same {@link BetterSidebarService} external plugins use —
- * eating its own dogfood. Code/Markdown editing stays inlined in
- * {@link EditorView} as the catch-all fallback (no matching viewer →
- * fsRead + CodeMirror/MarkdownText).
- */
-import {
- IconBranchOutline16, IconCodeOutline16, IconFolderOpen16, IconThinkOutline16,
-} from '@deepseek-ai/dsh-client-ui-primitives'
-import type { Context } from '../context-types.ts'
-import { TERMINAL_LIMIT, allLeaves, isAgentTabId, type SidebarState } from './state.ts'
-import { downloadUrl, mediaUrl } from './api.ts'
-import { t } from './locales.ts'
-import { openSidebarFile } from './intercept.tsx'
-import { ExplorerView } from './ExplorerView.tsx'
-import { EditorView } from './EditorView.tsx'
-import { TerminalView } from './TerminalView.tsx'
-import { GitView } from './GitView.tsx'
-import { DiffTab } from './DiffTab.tsx'
-import { SubagentView } from './SubagentView.tsx'
-import { DocxView, XlsxView } from './office-view.tsx'
-import { PdfView } from './PdfView.tsx'
-import { PptxView } from './PptxView.tsx'
-import { IconTerminalOutline16, IconDiffOutline16 } from './icons.tsx'
-import type { BetterSidebarService, FileViewerDescriptor, TabDescriptor } from './service.ts'
-import css from './sidebar.module.css'
-
-/** Count UI-owned terminals (agent:` tabs excluded — they are the model's). */
-function uiTerminalCount(state: SidebarState): number {
- return allLeaves(state.splits)
- .flatMap(leaf => leaf.tabs)
- .filter(tab => tab.type === 'terminal' && !isAgentTabId(tab.id)).length
-}
-
-/** The 6 built-in tab descriptors. */
-function builtinTabs(ctx: Context): readonly TabDescriptor[] {
- return [
- {
- id: 'editor',
- title: () => t('editor'),
- icon: (size: number) =>
- 
-
- ),
- },
- {
- id: 'pdf',
- exts: ['pdf'],
- fetchStrategy: 'mediaUrl',
- component: ({ scope, path, title }) => (
-
- {t('binaryNoPreview')}
-
- {t('downloadToView')}
-
-
- ),
- },
-]
-
-/**
- * Register all built-in tabs and viewers with the service. Returns a
- * disposer that unregisters everything (cordis auto-invokes it on fiber
- * disposal). The `ctx` is threaded into tab descriptors that need it
- * (EditorView reads `ctx.betterSidebar` for file-viewer matching).
- */
-export function registerBuiltins(ctx: Context, service: BetterSidebarService): () => void {
- const disposers: (() => void)[] = []
- for (const tab of builtinTabs(ctx)) {
- disposers.push(service.registerTab(tab))
- }
- for (const viewer of builtinViewers) {
- disposers.push(service.registerFileViewer(viewer))
- }
- return () => {
- for (const d of disposers) {
- try { d() } catch { /* already disposed */ }
- }
- }
-}
diff --git a/src/client/builtins/index.ts b/src/client/builtins/index.ts
new file mode 100644
index 0000000..bad5352
--- /dev/null
+++ b/src/client/builtins/index.ts
@@ -0,0 +1,33 @@
+/**
+ * Built-in registration: the plugin registers its own tab pages and file
+ * previewers through the same {@link BetterSidebarService} external plugins
+ * use — eating its own dogfood. The descriptors live next to their feature
+ * modules (tabs.tsx / viewers.tsx); this module only aggregates them and
+ * owns the disposer lifecycle (cordis auto-invokes it on fiber disposal,
+ * HMR-safe).
+ */
+import type { Context } from '../../context-types.ts'
+import type { BetterSidebarService } from '../service.ts'
+import { builtinTabs } from './tabs.tsx'
+import { builtinViewers } from './viewers.tsx'
+
+/**
+ * Register all built-in tabs and viewers with the service. Returns a
+ * disposer that unregisters everything (cordis auto-invokes it on fiber
+ * disposal). The `ctx` is threaded into tab descriptors that need it
+ * (EditorHost reads `ctx.betterSidebar` for file-viewer matching).
+ */
+export function registerBuiltins(ctx: Context, service: BetterSidebarService): () => void {
+ const disposers: (() => void)[] = []
+ for (const tab of builtinTabs(ctx)) {
+ disposers.push(service.registerTab(tab))
+ }
+ for (const viewer of builtinViewers()) {
+ disposers.push(service.registerFileViewer(viewer))
+ }
+ return () => {
+ for (const d of disposers) {
+ try { d() } catch { /* already disposed */ }
+ }
+ }
+}
diff --git a/src/client/builtins/tabs.tsx b/src/client/builtins/tabs.tsx
new file mode 100644
index 0000000..874ac4d
--- /dev/null
+++ b/src/client/builtins/tabs.tsx
@@ -0,0 +1,127 @@
+/**
+ * The 6 built-in tab descriptors: the plugin registers its own pages
+ * (explorer / git / terminal / subagent / editor / diff) through the same
+ * {@link BetterSidebarService} external plugins use — eating its own
+ * dogfood. The terminal descriptor owns its quota (`TERMINAL_LIMIT`) and
+ * mints `terminal:
+
+
+ ),
+ },
+ {
+ id: 'pdf',
+ exts: ['pdf'],
+ fetchStrategy: 'mediaUrl',
+ component: ({ scope, path, title }) => (
+