@qwen-code/web-shell 0.24.1-preview.0

package/dist/types/components/sidebar/WorkspaceSection.d.ts

@@ -0,0 +1,112 @@
+import { type ReactNode } from 'react';
+import type { DaemonClient, DaemonSessionGroupCatalog } from '@qwen-code/sdk/daemon';
+import type { DaemonSessionGroup, DaemonSessionSummary, DaemonWorkspaceCapability } from '@qwen-code/sdk/daemon';
+import { type WorkspaceOverviewItem, type WorkspaceOverviewSnapshot, type WorkspaceSessionStats } from './workspaceOverviewModel';
+export declare function isAbsolutePath(cwd: string): boolean;
+export interface WorkspaceHeaderActionsContext {
+    overview: WorkspaceOverviewSnapshot | undefined;
+    /** Current branch from the git poll; null/undefined when not a git repo or not polled. */
+    gitBranch: string | null | undefined;
+}
+interface WorkspaceSectionProps {
+    workspace: DaemonWorkspaceCapability;
+    renderHeader?: (expanded: boolean) => ReactNode;
+    client: DaemonClient;
+    reloadToken: number;
+    untrustedLabel: string;
+    readOnlyLabel: string;
+    trustToOpenLabel: string;
+    noSessionsLabel: string;
+    loadErrorLabel: string;
+    organizationEnabled: boolean;
+    sessionCatalogRequestsEnabled?: boolean;
+    sessionGroupCatalog?: DaemonSessionGroupCatalog;
+    sessionLiveStateEnabled?: boolean;
+    sourceType?: string;
+    channelGroupingEnabled?: boolean;
+    ungroupedLabel: string;
+    searchQuery?: string;
+    expanded?: boolean;
+    autoExpandKey?: string;
+    onExpandedChange?: (expanded: boolean) => void;
+    renderSessions?: boolean;
+    /**
+     * Render one session row. The sidebar passes its shared `renderSessionRow`
+     * so per-workspace sessions match the single-workspace list exactly — same
+     * type scale, hover actions (pin, archive, export, more…), and states —
+     * instead of a bespoke, feature-poor row. `options.searchSnippet` carries
+     * the content-search excerpt for sessions matched on message text.
+     */
+    renderSession: (session: DaemonSessionSummary, options?: {
+        searchSnippet?: string | undefined;
+    }) => ReactNode;
+    mapSession?: (session: DaemonSessionSummary) => DaemonSessionSummary;
+    showSessionDetails?: boolean;
+    /**
+     * Hover-revealed actions at the right edge of the folder header. Receives
+     * the workspace's overview snapshot — undefined until the first fetch or
+     * when the overview is disabled; the last fetched one while its consumers
+     * are closed — so a menu can show counts, and the polled git branch
+     * so git-only actions can be withheld from non-git workspaces.
+     */
+    headerActions?: (visible: boolean, context: WorkspaceHeaderActionsContext) => ReactNode;
+    /**
+     * Show a details popover on hover with the full path, git branch, session
+     * counts and facet counts (MCP, skills, …). Off by default so embedders
+     * that render their own header keep today's layout. Facets are fetched
+     * only while the details or header menu is open and the workspace is trusted.
+     */
+    overviewEnabled?: boolean;
+    overviewItems?: readonly WorkspaceOverviewItem[];
+    /** Whether the header menu is consuming workspace metadata. */
+    overviewMenuOpen?: boolean;
+    /**
+     * A header action reads the polled git branch (the worktree entry), so the
+     * poll runs while the menu is open. Off when no consumer
+     * of `gitBranch` is wired.
+     */
+    gitBranchWanted?: boolean;
+    /**
+     * Session counts for the hover popover. The primary workspace's sessions
+     * are listed by the sidebar itself, so it passes them in; other workspaces
+     * count their own catalog page. `null` means the parent owns the counts
+     * but has no page yet (a source switch in flight): show none rather than
+     * the previous source's numbers.
+     */
+    sessionStats?: WorkspaceSessionStats | null;
+    onRenameGroup?: (group: DaemonSessionGroup, workspaceCwd: string) => void;
+    onDeleteGroup?: (group: DaemonSessionGroup, workspaceCwd: string) => void;
+    renameGroupLabel?: string;
+    deleteGroupLabel?: string;
+    groupActionsDisabled?: boolean;
+    excludePinned?: boolean;
+    limitSessions?: boolean;
+    /**
+     * Whether the sidebar-level Pinned section renders this session. Pinned
+     * rows have one owner: a pinned content-search ghost is kept in this
+     * list only when the Pinned section does not carry it.
+     */
+    isPinnedSectionMember?: (session: DaemonSessionSummary) => boolean;
+    /**
+     * Open the workspace folder in the daemon host's file manager. Wired only
+     * when the daemon advertises `workspace_local_open` and the client is on
+     * the same machine; the hover popover's path row shows the button then.
+     */
+    onOpenPathLocally?: (cwd: string) => Promise<void>;
+    /**
+     * Open a terminal at the workspace path on the daemon host. Wired only
+     * when the daemon advertises `workspace_local_terminal` and the client is
+     * on the same machine.
+     */
+    onOpenTerminalLocally?: (cwd: string) => Promise<void>;
+    /**
+     * Open the working-tree Changes dialog for this workspace. When wired, the
+     * hover popover's branch row becomes the trigger for that workspace's Git
+     * picker; without it the row stays a plain-text summary.
+     */
+    onOpenGitDiff?: (workspaceCwd: string) => void;
+    /** Commit entry for the same picker; the row still opens without it. */
+    onOpenCommit?: (workspaceCwd: string) => void;
+}
+export declare function WorkspaceSection({ workspace, renderHeader, client, reloadToken, untrustedLabel, readOnlyLabel, trustToOpenLabel, noSessionsLabel, loadErrorLabel, organizationEnabled, sessionCatalogRequestsEnabled, sessionGroupCatalog, sessionLiveStateEnabled, sourceType, channelGroupingEnabled, ungroupedLabel, searchQuery, expanded: controlledExpanded, autoExpandKey, onExpandedChange, renderSessions, renderSession, mapSession, showSessionDetails, headerActions, overviewEnabled, overviewMenuOpen, overviewItems, gitBranchWanted, sessionStats, onRenameGroup, onDeleteGroup, renameGroupLabel, deleteGroupLabel, groupActionsDisabled, excludePinned, limitSessions, isPinnedSectionMember, onOpenPathLocally, onOpenTerminalLocally, onOpenGitDiff, onOpenCommit, }: WorkspaceSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/sidebar/channelSessionGroups.d.ts

@@ -0,0 +1,7 @@
+import type { DaemonChannelInstanceSnapshot, DaemonChannelTypeCatalog, DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+export interface ChannelSessionGroup {
+    id: string;
+    label: string;
+    sessions: DaemonSessionSummary[];
+}
+export declare function groupSessionsByChannelType(sessions: readonly DaemonSessionSummary[], catalog: DaemonChannelTypeCatalog, instances: Readonly<Record<string, DaemonChannelInstanceSnapshot>>, otherLabel: string): ChannelSessionGroup[];

package/dist/types/components/sidebar/collapsedSessionSections.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared localStorage helpers for Web Shell session-organization collapse
+ * state. Primary sidebar and per-workspace sections both write into one app
+ * key so preferences survive reload without competing overwrites.
+ *
+ * Id conventions:
+ * - Primary catalog: `group:<id>`, `recent`, `color:<name>`,
+ *   `scheduled-task:<taskId>`, `channel-type:<type>`
+ * - Workspace-scoped: `ws:<workspaceId>|group:<id>` (including automatic
+ *   scheduled-task ids), `ws:<workspaceId>|ungrouped`
+ */
+export declare const COLLAPSED_SESSION_SECTIONS_STORAGE_KEY = "qwen-code-web-shell-collapsed-session-groups";
+export declare function isPrimaryCollapsedSectionId(id: string): boolean;
+export declare function workspaceGroupSectionId(workspaceId: string, groupId: string): string;
+export declare function workspaceUngroupedSectionId(workspaceId: string): string;
+export declare function isWorkspaceCollapsedSectionId(workspaceId: string, id: string): boolean;
+export declare function readCollapsedSessionSectionIds(): Set<string>;
+export declare function writeCollapsedSessionSectionIds(ids: ReadonlySet<string>): void;
+/**
+ * Replace one owner's subset of collapsed ids while preserving other owners
+ * (primary vs per-workspace), so parallel writers do not clobber each other.
+ */
+export declare function replaceOwnedCollapsedSessionSectionIds(ownedIds: ReadonlySet<string>, isOwned: (id: string) => boolean): void;
+export declare function readWorkspaceCollapsedGroupIds(workspaceId: string): Set<string>;
+export declare function writeWorkspaceCollapsedGroupIds(workspaceId: string, localIds: ReadonlySet<string>): void;

package/dist/types/components/sidebar/scheduled-task-session-groups.d.ts

@@ -0,0 +1,12 @@
+import type { DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+export interface ScheduledTaskSessionGroupIdentity {
+    id: string;
+    label: string;
+}
+export interface ScheduledTaskSessionSection {
+    id: string;
+    label: string;
+    sessions: DaemonSessionSummary[];
+}
+export declare function getScheduledTaskSessionGroup(session: DaemonSessionSummary): ScheduledTaskSessionGroupIdentity | undefined;
+export declare function collectScheduledTaskSession(sections: Map<string, ScheduledTaskSessionSection>, session: DaemonSessionSummary): boolean;

package/dist/types/components/sidebar/sessionDetailsCollisionBoundary.d.ts

@@ -0,0 +1 @@
+export declare function resolveSessionDetailsCollisionBoundary(anchor: HTMLElement | null): HTMLElement | null;

package/dist/types/components/sidebar/sessionSearch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+export declare function sessionMatchesGitQuery(session: DaemonSessionSummary, query: string): boolean;
+/**
+ * The sidebar's session-source scope: the "channel" tab lists only
+ * channel-source sessions, the "default" tab lists unattributed (legacy)
+ * and default/Qwen Live tasks, and no filter lists everything.
+ */
+export declare function sessionMatchesSource(session: DaemonSessionSummary, source: string | undefined): boolean;
+/**
+ * Merges daemon transcript-content search hits into the local title/id/git
+ * matches, in place of the previously duplicated inline merges in
+ * WebShellSidebar and WorkspaceSection. Local matches come first (catalog
+ * order), then content hits in server (recency) order. Hits the loaded
+ * catalog carries keep their catalog entry — it holds the live state the
+ * persisted-only search summary lacks; `seen` dedupes sessions matched by
+ * both paths; uncatalogued ("ghost") hits are dropped when they fall
+ * outside the `source` scope, and pass through `mapSession` (the
+ * optimistic-pin overlay) like every other rendered session.
+ */
+export declare function mergeSessionContentHits(scopedSessions: readonly DaemonSessionSummary[], localMatches: readonly DaemonSessionSummary[], hits: ReadonlyMap<string, {
+    session: DaemonSessionSummary;
+    snippet: string;
+}>, source: string | undefined, mapSession?: (session: DaemonSessionSummary) => DaemonSessionSummary): DaemonSessionSummary[];

package/dist/types/components/sidebar/sessionTitleScroll.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Measures the title inside `row` and refreshes the hover-scroll CSS
+ * variables plus the overflow flag that gates the right-edge fade mask.
+ * Rows call this on every pointer entry so a renamed or resized label never
+ * animates with a stale distance.
+ */
+export declare function measureSessionTitleScroll(row: HTMLElement): void;

package/dist/types/components/sidebar/sidebarToggleShortcut.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Cmd+B (macOS) / Ctrl+B toggles the session sidebar (#5074), mirroring the
+ * convention editors like VS Code use. Plain modifier+B only: Shift/Alt
+ * variants stay available to the browser and other bindings, and
+ * Cmd+Ctrl combined presses are rejected as ambiguous.
+ */
+export declare function isSidebarToggleShortcut(event: {
+    key: string;
+    metaKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+}): boolean;

package/dist/types/components/sidebar/useSessionContentSearch.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonClient, DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+export interface SessionContentSearchHit {
+    session: DaemonSessionSummary;
+    snippet: string;
+}
+/**
+ * Debounced conversation-content search behind the sidebar session search
+ * box. Local title/id/git matching stays the client-side fast path; this
+ * hook asks the daemon to scan persisted transcripts and returns the hits —
+ * including sessions not yet loaded into the catalog, with a snippet of the
+ * matched message — keyed by session id in server (recency) order. Any
+ * request failure (including a 404 from a daemon too old to serve the
+ * route) degrades to local-only filtering.
+ */
+export declare function useSessionContentSearch(client: DaemonClient | undefined, workspaceCwd: string | undefined, query: string, invalidationKey?: number | string): ReadonlyMap<string, SessionContentSearchHit>;

package/dist/types/components/sidebar/useWorkspaceOverview.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonClient } from '@qwen-code/sdk/daemon';
+import { type WorkspaceOverviewItem, type WorkspaceOverviewSnapshot } from './workspaceOverviewModel';
+/**
+ * Overview facets change on the order of minutes (a server reconnects, a
+ * skill is installed); the git chip already polls at 60s. 30s keeps a
+ * reconnect visible within one glance without turning N expanded workspaces
+ * into a request storm.
+ */
+export declare const WORKSPACE_OVERVIEW_POLL_MS = 30000;
+/**
+ * A facet keeps its last known value across this many consecutive rounds
+ * that did not answer for it, then reads as unavailable. Three rounds is a
+ * blip's worth (about 90 s at the default cadence), not a rollback's.
+ */
+export declare const WORKSPACE_OVERVIEW_MAX_MISSES = 3;
+export interface UseWorkspaceOverviewOptions {
+    /** Fetch only while true; false clears the snapshot and stops polling. */
+    enabled: boolean;
+    items?: readonly WorkspaceOverviewItem[];
+    /** Bump to force a refetch (the sidebar's reload token). */
+    reloadToken?: number;
+    pollIntervalMs?: number;
+}
+export interface WorkspaceOverviewResult {
+    overview: WorkspaceOverviewSnapshot | undefined;
+}
+/**
+ * Fetch every requested facet for one workspace. Facets fail independently:
+ * a daemon that predates one of the routes, or a transient error on one call,
+ * leaves that facet `undefined` and the others intact. Calls are deferred to
+ * a microtask so a client whose handle lacks a method (older SDK, test
+ * double) rejects instead of throwing synchronously out of the hook.
+ */
+export declare function fetchWorkspaceOverview(client: DaemonClient, workspaceCwd: string, items: ReadonlySet<WorkspaceOverviewItem>): Promise<WorkspaceOverviewSnapshot>;
+export declare function useWorkspaceOverview(client: DaemonClient, workspaceCwd: string | undefined, { enabled, items, reloadToken, pollIntervalMs, }: UseWorkspaceOverviewOptions): WorkspaceOverviewResult;

package/dist/types/components/sidebar/workspaceExpansion.d.ts

@@ -0,0 +1,4 @@
+export declare function hasWorkspaceExpansionPreference(id: string): boolean;
+export declare function readWorkspaceExpanded(id: string): boolean;
+export declare function writeWorkspaceExpanded(id: string, expanded: boolean): void;
+export declare function migrateWorkspaceExpansionPreference(previousId: string, nextId: string): void;

package/dist/types/components/sidebar/workspaceOverviewModel.d.ts

@@ -0,0 +1,123 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonChannelsSnapshot, DaemonMcpDiscoveryState, DaemonSessionSummary, DaemonWorkspaceHooksStatus, DaemonWorkspaceMcpStatus, DaemonWorkspaceMemoryStatus, DaemonWorkspaceSkillsStatus, WorkspaceExtensionProjection } from '@qwen-code/sdk/daemon';
+import type { useI18n } from '../../i18n';
+type Translate = ReturnType<typeof useI18n>['t'];
+/**
+ * Facets the sidebar can summarize per workspace. Each maps to one
+ * workspace-qualified daemon route; the order here is the chip order.
+ */
+export declare const WORKSPACE_OVERVIEW_ITEMS: readonly ["mcp", "skills", "extensions", "channels", "context", "hooks"];
+export type WorkspaceOverviewItem = (typeof WORKSPACE_OVERVIEW_ITEMS)[number];
+/** Hooks are opt-in: most workspaces have none and the chip would only add noise. */
+export declare const DEFAULT_WORKSPACE_OVERVIEW_ITEMS: readonly WorkspaceOverviewItem[];
+/** Management pages a workspace row can open for itself. */
+export type WorkspaceManagementTarget = 'mcp' | 'skills' | 'extensions' | 'channels' | 'settings';
+export interface WorkspaceSessionStats {
+    /** Sessions in the list the stats were computed from. */
+    total: number;
+    /** Sessions with a prompt in flight. */
+    running: number;
+    /** Sessions blocked on the user (permission, question, other interaction). */
+    attention: number;
+    /** The list was one page of a longer catalog, so `total` is a lower bound. */
+    truncated: boolean;
+}
+export declare function summarizeSessions(sessions: readonly DaemonSessionSummary[], truncated?: boolean): WorkspaceSessionStats;
+/**
+ * MCP, skills, context files and hooks are discovered by the workspace's ACP
+ * child. While no child is live the daemon answers with an idle placeholder
+ * (`initialized: false`, empty lists); that placeholder must render as
+ * "unknown", never as zero.
+ */
+export interface WorkspaceMcpSummary {
+    initialized: boolean;
+    discoveryState?: DaemonMcpDiscoveryState;
+    configured: number;
+    connected: number;
+    /** Enabled servers the runtime reports as errored. */
+    failed: number;
+    disabled: number;
+}
+export declare function summarizeMcp(status: DaemonWorkspaceMcpStatus): WorkspaceMcpSummary;
+export interface WorkspaceSkillsSummary {
+    initialized: boolean;
+    total: number;
+    enabled: number;
+}
+export declare function summarizeSkills(status: DaemonWorkspaceSkillsStatus): WorkspaceSkillsSummary;
+export interface WorkspaceExtensionsSummary {
+    total: number;
+    active: number;
+}
+export declare function summarizeExtensions(projection: WorkspaceExtensionProjection): WorkspaceExtensionsSummary;
+export interface WorkspaceChannelsSummary {
+    configured: number;
+    /** Instances whose worker is connected (fully or partially). */
+    connected: number;
+    failed: number;
+}
+export declare function summarizeChannels(snapshot: DaemonChannelsSnapshot): WorkspaceChannelsSummary;
+/**
+ * Context files are read from disk by the daemon itself (no ACP child), so
+ * the route always answers definitively: `initialized: false` is its way of
+ * saying no context file exists, and renders as a count of 0.
+ */
+export interface WorkspaceContextSummary {
+    initialized: boolean;
+    fileCount: number;
+    ruleCount: number;
+}
+export declare function summarizeContext(status: DaemonWorkspaceMemoryStatus): WorkspaceContextSummary;
+export interface WorkspaceHooksSummary {
+    initialized: boolean;
+    count: number;
+    disabled: boolean;
+}
+export declare function summarizeHooks(status: DaemonWorkspaceHooksStatus): WorkspaceHooksSummary;
+/**
+ * One workspace's facet summaries. A facet is `undefined` when it was not
+ * requested or its fetch failed (older daemon without the route, network
+ * blip); the hook keeps the previous value of a facet across a transient
+ * failure so a chip does not blank for a whole poll interval.
+ */
+export interface WorkspaceOverviewSnapshot {
+    mcp?: WorkspaceMcpSummary;
+    skills?: WorkspaceSkillsSummary;
+    extensions?: WorkspaceExtensionsSummary;
+    channels?: WorkspaceChannelsSummary;
+    context?: WorkspaceContextSummary;
+    hooks?: WorkspaceHooksSummary;
+    fetchedAt: number;
+}
+/**
+ * Facets the workspace's ACP child discovers, which stay unknown until it
+ * reports; extensions, channels and context files are answered by the daemon
+ * itself and are known as soon as the route responds.
+ */
+export declare function isRuntimeDiscoveredFacet(item: WorkspaceOverviewItem): boolean;
+/**
+ * Whether a facet carries a countable value. Runtime-discovered facets are
+ * unknown until the ACP child reports `initialized`; the rest are known as
+ * soon as the daemon answers.
+ */
+export declare function isOverviewFacetKnown(snapshot: WorkspaceOverviewSnapshot | undefined, item: WorkspaceOverviewItem): boolean;
+/** Facets that warrant the warning tone on their chip. */
+export declare function overviewFacetHasIssue(snapshot: WorkspaceOverviewSnapshot | undefined, item: WorkspaceOverviewItem): boolean;
+/** Remove facets whose carry-over has expired, keeping everything else. */
+export declare function dropExpiredFacets(snapshot: WorkspaceOverviewSnapshot, expired: ReadonlySet<WorkspaceOverviewItem>): WorkspaceOverviewSnapshot;
+/**
+ * Merge a fresh snapshot over the previous one, keeping a facet's last known
+ * value when the new round did not answer for it — unless the facet is in
+ * `expired`: a route that keeps failing (an older daemon after a rollback)
+ * must eventually show as unavailable instead of a frozen count.
+ */
+export declare function mergeOverviewSnapshots(previous: WorkspaceOverviewSnapshot | undefined, next: WorkspaceOverviewSnapshot, requested: ReadonlySet<WorkspaceOverviewItem>, expired?: ReadonlySet<WorkspaceOverviewItem>): WorkspaceOverviewSnapshot;
+/** The short value printed for a facet, or `undefined` while it is unknown. */
+export declare function formatOverviewValue(snapshot: WorkspaceOverviewSnapshot | undefined, item: WorkspaceOverviewItem): string | undefined;
+/** The long form of a facet's value, used as the tooltip row's title. */
+export declare function overviewDetail(t: Translate, snapshot: WorkspaceOverviewSnapshot, item: WorkspaceOverviewItem): string;
+export {};

package/dist/types/components/skills/SkillInstallDialog.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonSkillInstallRequest } from '@qwen-code/sdk/daemon';
+interface SkillInstallDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onInstall: (request: DaemonSkillInstallRequest) => Promise<void>;
+}
+export declare function SkillInstallDialog({ open, onOpenChange, onInstall, }: SkillInstallDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/skills/SkillsManagerPage.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+import type { EmbeddedManagerPage } from '../plugins/manager-page';
+interface SkillsManagerPageProps {
+    onClose: () => void;
+    onUseSkill: (name: string) => void;
+    embedded?: EmbeddedManagerPage;
+    workspaceCwd?: string;
+    workspaceControl?: ReactNode;
+}
+export declare function SkillsManagerPage({ onClose, onUseSkill, embedded, workspaceCwd, workspaceControl, }: SkillsManagerPageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/skills/skills-manager-logic.d.ts

@@ -0,0 +1,6 @@
+import type { DaemonWorkspaceSkillStatus } from '@qwen-code/web-shell/daemon-react-sdk';
+export type SkillLevelFilter = 'all' | DaemonWorkspaceSkillStatus['level'];
+export type SkillStatusFilter = 'all' | 'enabled' | 'disabled';
+export declare function skillExtensionLabel(skill: DaemonWorkspaceSkillStatus): string;
+export declare function filterSkills(skills: readonly DaemonWorkspaceSkillStatus[], query: string, level?: SkillLevelFilter, status?: SkillStatusFilter): DaemonWorkspaceSkillStatus[];
+export declare function preserveSkillSelection(name: string | null, skills: readonly DaemonWorkspaceSkillStatus[]): string | null;

package/dist/types/components/sources/SourceList.d.ts

@@ -0,0 +1,5 @@
+import type { WebShellSource } from '../../customization';
+export declare function SourceList({ entries, onOpen, }: {
+    entries: readonly WebShellSource[];
+    onOpen?: (entry: WebShellSource) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/sources/TurnSources.d.ts

@@ -0,0 +1,5 @@
+import { type WebShellSource } from '../../customization';
+export declare function TurnSources({ sources, onOpen, }: {
+    sources: readonly WebShellSource[];
+    onOpen?: (source: WebShellSource) => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/sources/sourceEntries.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonSessionAttachmentReference, SessionSource } from '@qwen-code/sdk/daemon';
+import type { WebShellSource, WebShellSourceReference } from '../../customization';
+import type { Message } from '../../adapters/types';
+export declare function sourceKey(entry: WebShellSource): string;
+export declare function sourceTitle(entry: WebShellSource): string;
+export declare function sourceLocation(entry: WebShellSource): string;
+export declare function getSourceEntries(sources: readonly SessionSource[], attachments: readonly DaemonSessionAttachmentReference[]): WebShellSource[];
+export declare function getSourcesByTurn(messages: readonly Message[], entries: readonly WebShellSource[], workspaceCwd: string | undefined, sessionId: string | undefined, references?: readonly WebShellSourceReference[]): ReadonlyMap<string, readonly WebShellSource[]>;

package/dist/types/components/summaryRunId.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Synthetic ids for compact-mode aggregated tool runs.
+ * `mergeCompactToolGroups` builds them via `summaryRunId`; render paths detect
+ * them through the shared predicate so the prefix scheme lives in one place.
+ */
+export declare const SUMMARY_RUN_ID_PREFIX = "summary-";
+export declare const summaryRunId: (firstMemberId: string) => string;
+export declare const isSummaryRunId: (id: string) => boolean;
+export declare const summaryRunFirstMemberId: (id: string) => string | undefined;

package/dist/types/components/terminal/TerminalPanel.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import '@xterm/xterm/css/xterm.css';
+interface TerminalPanelProps {
+    /** Stable id shared with the backend PTY session; reconnects reuse it. */
+    terminalId: string;
+    cwd?: string;
+    active?: boolean;
+    enabled?: boolean;
+}
+export declare function releaseWebTerminal(terminalId: string): void;
+export declare function releaseDetachedWebTerminal(baseUrl: string, terminalId: string, cwd?: string): void;
+export declare function TerminalPanel({ terminalId, cwd, active, enabled, }: TerminalPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/toolbarDropdown.d.ts

@@ -0,0 +1,39 @@
+export interface ToolbarDropdownItem {
+    id: string;
+    label: string;
+    searchText?: string;
+}
+export declare function filterToolbarDropdownItems<T extends ToolbarDropdownItem>(items: readonly T[], query: string): T[];
+export declare function getToolbarItemVisibility({ availableWidth, items, }: {
+    availableWidth: number;
+    items: ReadonlyArray<{
+        id: string;
+        expansionWidth: number;
+        ready?: boolean;
+    }>;
+}): Record<string, boolean>;
+export declare function getToolbarItemVisibilityWithHysteresis({ availableWidth, items, currentVisibility, expansionMargin, }: {
+    availableWidth: number;
+    items: ReadonlyArray<{
+        id: string;
+        expansionWidth: number;
+        ready?: boolean;
+    }>;
+    currentVisibility: Readonly<Record<string, boolean>>;
+    expansionMargin: number;
+}): Record<string, boolean>;
+export declare function getToolbarExpansionBudget({ toolbarWidth, leadingWidth, rightWidth, currentExpansionWidth, gap, }: {
+    toolbarWidth: number;
+    leadingWidth: number;
+    rightWidth: number;
+    currentExpansionWidth: number;
+    gap: number;
+}): number;
+export declare function resolveToolbarModelLabel({ currentModelLabel, lastConfirmedModelLabel, }: {
+    currentModelLabel: string;
+    lastConfirmedModelLabel: string;
+}): {
+    modelLabel: string;
+    modelLabelReady: boolean;
+    nextConfirmedModelLabel: string;
+};

package/dist/types/components/ui/alert-dialog.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { AlertDialog as AlertDialogPrimitive } from 'radix-ui';
+import { Button } from '@/components/ui/button';
+declare function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogPortal({ container, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type AlertDialogContentProps = React.ComponentProps<typeof AlertDialogPrimitive.Content> & {
+    size?: 'default' | 'sm' | 'middle';
+};
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogMedia({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogAction({ className, variant, size, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Action> & Pick<React.ComponentProps<typeof Button>, 'variant' | 'size'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogCancel({ className, variant, size, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Cancel> & Pick<React.ComponentProps<typeof Button>, 'variant' | 'size'>): import("react/jsx-runtime").JSX.Element;
+export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogMedia, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, };

package/dist/types/components/ui/alert.d.ts

@@ -0,0 +1,10 @@
+import type * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | "success" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Alert({ className, variant, ...props }: React.ComponentProps<'div'> & VariantProps<typeof alertVariants>): import("react/jsx-runtime").JSX.Element;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertAction({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Alert, AlertTitle, AlertDescription, AlertAction };

package/dist/types/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import type * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "link" | "outline" | "secondary" | "ghost" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<'span'> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/types/components/ui/breadcrumb.d.ts

@@ -0,0 +1,11 @@
+import type * as React from 'react';
+declare function Breadcrumb({ className, ...props }: React.ComponentProps<'nav'>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbList({ className, ...props }: React.ComponentProps<'ol'>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbItem({ className, ...props }: React.ComponentProps<'li'>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbLink({ asChild, className, ...props }: React.ComponentProps<'a'> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbPage({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbSeparator({ children, className, ...props }: React.ComponentProps<'li'>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbEllipsis({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

package/dist/types/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "link" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "xs" | "sm" | "lg" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ButtonProps = React.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+};
+declare const Button: React.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/types/components/ui/card.d.ts

@@ -0,0 +1,11 @@
+import type * as React from 'react';
+declare function Card({ className, size, ...props }: React.ComponentProps<'div'> & {
+    size?: 'default' | 'sm';
+}): import("react/jsx-runtime").JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };

package/dist/types/components/ui/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { Checkbox as CheckboxPrimitive } from 'radix-ui';
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };