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

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

@@ -0,0 +1,93 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ReactNode } from 'react';
+import { type DaemonSessionActions } from '@qwen-code/web-shell/daemon-react-sdk';
+import { type DaemonSessionArtifact, type DaemonSessionMonitorTaskStatus, type DaemonSessionSummary, type DaemonWorkspaceCapability } from '@qwen-code/sdk/daemon';
+import { type RegisterContextUsageControls } from '../hooks/useContextUsageControls';
+import type { WebShellSlashCommandHandler } from '../App';
+import type { TurnOutputKind, TurnOutputOpenRequest } from './artifacts/TurnOutputs';
+export interface PaneHeaderActionsInfo {
+    sessionId: string;
+    workspaceCwd?: string;
+    /** The pane's own session actions; lets an action drive session data. */
+    sessionActions?: DaemonSessionActions;
+}
+export type PaneHeaderActionsRenderer = (info: PaneHeaderActionsInfo) => ReactNode;
+export interface ChatPaneProps {
+    /** Header label; falls back to the session's own display name / id. */
+    title?: string;
+    /** Session-list metadata for the shared title details. */
+    sessionSummary?: DaemonSessionSummary;
+    /** Last interacted pane, independent of whether its session is running. */
+    isActive?: boolean;
+    /** Must be referentially stable; reports pending state and unmount cleanup. */
+    onApprovalChange?: (sessionId: string, pending: boolean) => void;
+    /**
+     * The workspace this pane's session lives in. Passed explicitly by the split
+     * view (which knows it per session) and shown as a composer-toolbar chip on a
+     * multi-workspace daemon; falls back to the connection's own workspace.
+     */
+    workspaceCwd?: string;
+    /**
+     * Extra actions rendered in the pane header, before the built-in
+     * maximize/close buttons. Receives this pane's session id (and workspace
+     * when known) so the host can scope each control to the right session. When
+     * the actions no longer fit beside the title they collapse into a `…`
+     * overflow menu.
+     *
+     * Each child should be a single interactive element (button or link). When
+     * collapsed, the overflow menu lists the actions and proxies a click to that
+     * element, labelling each item from its accessible name (decorative
+     * `aria-hidden` glyphs are ignored). The action instance stays mounted in a
+     * hidden, off-pane slot across collapse so its state survives; because that
+     * slot is `visibility: hidden`, an action that opens a popover anchored to
+     * itself must render the popover through a portal — one rendered as a
+     * descendant of the action (or anchored to its bounding box) would be
+     * invisible or mispositioned while collapsed.
+     */
+    renderHeaderActions?: PaneHeaderActionsRenderer;
+    onClose?: () => void;
+    /**
+     * Toggle this pane between maximized (solo, filling the whole split) and the
+     * tiled layout. Omitted when only one pane is open — there's nothing to
+     * maximize against.
+     */
+    onToggleMaximize?: () => void;
+    /** Whether this pane is currently the maximized (solo) one. */
+    isMaximized?: boolean;
+    onError?: (error: unknown, fallback: string) => void;
+    onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
+    /** Host slash-command callback shared with the main chat composer. */
+    onSlashCommand?: WebShellSlashCommandHandler;
+    onOpenGoals?: () => void;
+    onRightPanelOpen?: (request: TurnOutputOpenRequest) => void;
+    onOpenMonitor?: (task: DaemonSessionMonitorTaskStatus, sessionId: string, sessionActions: DaemonSessionActions) => void;
+    registerContextUsageControls?: RegisterContextUsageControls;
+    onBeforeContextCompress?: (sessionId: string) => void;
+    onOpenContextUsage?: (sessionId: string, sessionActions: DaemonSessionActions) => void;
+    onPaneArtifactsChange?: (sessionId: string, artifacts: readonly DaemonSessionArtifact[]) => void;
+    messageTurnOutputs?: readonly TurnOutputKind[];
+    /** Render inside a parent surface that already provides its own frame. */
+    embedded?: boolean;
+    onFirstPromptAdmitted?: (text: string) => void;
+    /** Whether this pane owns Session Catalog turn-completion reconciliation. */
+    reportCatalogTurnCompletion?: boolean;
+    hidden?: boolean;
+    voiceUserRevision?: number;
+    voiceWorkspaceRevisions?: Readonly<Record<string, number>>;
+    voiceWorkspaces?: readonly DaemonWorkspaceCapability[];
+    /** Enable the app-scoped experimental Session Workflow presentation. */
+    sessionWorkflowEnabled?: boolean;
+    planControlVisible?: boolean;
+}
+/**
+ * A self-contained interactive chat, scoped to whichever `DaemonSessionProvider`
+ * it is nested under. Rendering N of these (each under its own provider) inside
+ * one window is the split view: every pane has its own transcript, streaming
+ * state, approvals, and composer, and the browser scopes keyboard focus to the
+ * pane the user clicks into — so there is no cross-pane approval arbitration.
+ */
+export declare function ChatPane({ title, sessionSummary, isActive, onApprovalChange, workspaceCwd, renderHeaderActions, onClose, onToggleMaximize, isMaximized, onError, onImageIngestionNotice, onSlashCommand, onOpenGoals, onRightPanelOpen, onOpenMonitor, onPaneArtifactsChange, registerContextUsageControls, onBeforeContextCompress, onOpenContextUsage, messageTurnOutputs, embedded, onFirstPromptAdmitted, reportCatalogTurnCompletion, hidden, voiceUserRevision, voiceWorkspaceRevisions, voiceWorkspaces, sessionWorkflowEnabled, planControlVisible, }: ChatPaneProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+import type { ContextUsageControls } from '../hooks/useContextUsageControls';
+export declare function ContextCompressionFeedback({ controls, className, }: {
+    controls?: Pick<ContextUsageControls, 'compressing' | 'result'>;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,10 @@
+import { type ReactElement } from 'react';
+import type { ContextUsageControls } from '../hooks/useContextUsageControls';
+export declare function ContextUsagePopover({ tokenCount, contextWindow, controls, onOpenDetails, showSnapshotHint, children, }: {
+    tokenCount: number;
+    contextWindow: number;
+    controls?: Pick<ContextUsageControls, 'canCompress' | 'compressing' | 'result' | 'compress'>;
+    onOpenDetails?: () => void;
+    showSnapshotHint: boolean;
+    children: ReactElement;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,40 @@
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+type FallbackRender = (error: Error, reset: () => void) => ReactNode;
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    /**
+     * Rendered in place of the children once one of them throws. A function form
+     * receives the captured error and a `reset` callback that clears the error
+     * and re-mounts the children (for an explicit "try again" affordance).
+     */
+    fallback: ReactNode | FallbackRender;
+    /**
+     * When any value here changes between renders, the boundary clears its error
+     * state and retries. Pass the rendered content's identity (e.g. a message
+     * object) so an edited/retried/streamed update recovers on its own instead of
+     * staying stuck on the fallback. A stable broken child keeps the fallback and
+     * never loops, since unchanged keys never trigger a reset.
+     */
+    resetKeys?: ReadonlyArray<unknown>;
+    /** Identifies the boundary in console diagnostics. */
+    label?: string;
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+    resetKeys: ReadonlyArray<unknown>;
+}
+/**
+ * Generic React error boundary. web-shell ships as an embeddable component, so
+ * a throw in any one subtree (Markdown, KaTeX, Mermaid, a tool panel) must not
+ * white-screen the host page. Wrap risky subtrees with this and supply a
+ * graceful fallback.
+ */
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
+    static getDerivedStateFromProps(props: ErrorBoundaryProps, state: ErrorBoundaryState): Partial<ErrorBoundaryState> | null;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    private readonly reset;
+    render(): ReactNode;
+}
+export {};

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

@@ -0,0 +1,4 @@
+export declare function FileAttachmentContent({ name, mimeType, }: {
+    name: string;
+    mimeType?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,6 @@
+import { type LucideIcon } from 'lucide-react';
+import type { ComponentProps } from 'react';
+export declare function FileTypeIcon({ name, mimeType, size, absoluteStrokeWidth, ...props }: ComponentProps<LucideIcon> & {
+    name: string;
+    mimeType?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonWorkspaceGitStatus } from '@qwen-code/sdk/daemon';
+import { useI18n } from '../i18n';
+/** Tone of the compact badge dot, by descending severity. */
+type BadgeTone = 'error' | 'warning' | 'accent';
+export interface DerivedStatus {
+    detached: boolean;
+    staged: number;
+    unstaged: number;
+    untracked: number;
+    conflicted: number;
+    ahead: number;
+    behind: number;
+    stashCount: number;
+    operation?: DaemonWorkspaceGitStatus['operation'];
+    dirty: boolean;
+}
+/**
+ * Normalise a (possibly v1, possibly absent) status into zero-defaulted
+ * counters. Shared with the branch picker so both surfaces read the same
+ * numbers from the same object.
+ */
+export declare function deriveStatus(status?: DaemonWorkspaceGitStatus): DerivedStatus;
+/**
+ * True once the daemon has actually computed the enriched (v2) fields;
+ * `computedAt` is stamped only on that path, so its absence means the counters
+ * above are defaults rather than a clean tree.
+ */
+export declare function hasComputedTreeSummary(status?: DaemonWorkspaceGitStatus): boolean;
+/**
+ * Severity tone for a status dot. The compact chip's badge and the sidebar
+ * details row both read it; null when there is nothing to flag.
+ */
+export declare function gitBranchBadgeTone(s: DerivedStatus): BadgeTone | null;
+type TranslateFn = ReturnType<typeof useI18n>['t'];
+export declare function gitStatusPhrases(s: DerivedStatus, t: TranslateFn): string[];
+/**
+ * Composed accessible label for a git branch chip, e.g.
+ * "Current branch: main — 3 staged, 2 ahead". Shared by the indicator and any
+ * wrapper button so the accessible name never drifts from the tooltip phrases.
+ */
+export declare function gitBranchAriaLabel(branch: string, status: DaemonWorkspaceGitStatus | undefined, t: TranslateFn): string;
+/**
+ * The chip's inner content (icon + branch + status indicators), shared by the
+ * interactive {@link GitBranchIndicator} and the toolbar's hidden measurement
+ * replica. The replica must render the same indicators or it under-measures the
+ * expanded chip, which makes the responsive compact/expanded toggle oscillate.
+ */
+export declare function GitBranchChipContent({ branch, status, compact, worktree, }: {
+    branch: string;
+    status?: DaemonWorkspaceGitStatus;
+    compact: boolean;
+    worktree?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function GitBranchIndicator({ branch, status, compact, onOpenDiff, worktree, }: {
+    branch: string;
+    status?: DaemonWorkspaceGitStatus;
+    compact?: boolean;
+    onOpenDiff?: () => void;
+    worktree?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export type SessionGitIntent = {
+    mode: 'current';
+} | {
+    mode: 'branch';
+    name: string;
+} | {
+    mode: 'worktree';
+    slug?: string;
+};
+export declare function validateBranchName(name: string): boolean;
+interface GitModePopoverProps {
+    branch: string;
+    compact?: boolean;
+    intent: SessionGitIntent;
+    onIntentChange: (intent: SessionGitIntent) => void;
+}
+export declare function GitModePopover({ branch, compact, intent, onIntentChange, }: GitModePopoverProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonTurnNavigationSnapshot, DaemonTurnNavigationStore } from '../daemon/session/turn-navigation-store';
+export declare function GlobalTurnNavigation({ state, store, follow, onSelect, }: {
+    state: DaemonTurnNavigationSnapshot;
+    store: DaemonTurnNavigationStore;
+    follow?: {
+        start: number;
+        end: number;
+        current: number;
+    };
+    onSelect: (ordinal: number) => void;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,13 @@
+import type { GoalSnapshotV2 } from '@qwen-code/sdk/daemon';
+import { useI18n } from '../i18n';
+export interface GoalStatusStripProps {
+    snapshot: GoalSnapshotV2;
+    busy?: boolean;
+    onEdit: () => void;
+    onPause: () => void;
+    onResume: () => void;
+    onClear: () => void;
+}
+export declare function getGoalActiveTimeMs(snapshot: GoalSnapshotV2, now: number): number;
+export declare function getGoalTokenLabel(goal: NonNullable<GoalSnapshotV2['goal']>, t: ReturnType<typeof useI18n>['t']): string | undefined;
+export declare function GoalStatusStrip({ snapshot, busy, onEdit, onPause, onResume, onClear, }: GoalStatusStripProps): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,12 @@
+export interface InsightProgressData {
+    stage: string;
+    progress: number;
+    detail?: string;
+    isComplete?: boolean;
+    error?: string;
+}
+interface InsightProgressProps {
+    progress: InsightProgressData;
+}
+export declare function InsightProgress({ progress }: InsightProgressProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+interface InsightReadyProps {
+    path: string;
+    onInsightReportOpen?: (path: string) => void;
+}
+export declare function InsightReady({ path, onInsightReportOpen }: InsightReadyProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+interface LocalControlQrButtonProps {
+    onOpenSettings: () => void;
+    /** Extra classes for the trigger, e.g. to match a host header's action style. */
+    className?: string;
+}
+export declare function LocalControlQrButton({ onOpenSettings, className, }: LocalControlQrButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonCapabilities, DaemonClient, DaemonWorkspaceCapability } from '@qwen-code/sdk/daemon';
+import type { AcpWorkspaceSelector } from '../local-files/bridge-client';
+import { type LocalFilesStatus } from '../local-files/useLocalFilesBridge';
+export interface LocalFilesPanelProps {
+    status: LocalFilesStatus;
+    onConnect: () => void;
+    onDisconnect: () => void;
+    onOpenInNewTab: () => void;
+}
+/**
+ * The popover body, kept prop-driven and free of hooks/portals so the phase →
+ * affordance mapping is testable without a Radix portal or a daemon provider.
+ */
+export declare function LocalFilesPanel({ status, onConnect, onDisconnect, onOpenInNewTab, }: LocalFilesPanelProps): import("react/jsx-runtime").JSX.Element;
+interface LocalFilesControlProps {
+    /**
+     * Class for the trigger button. Required, and supplied by the host surface
+     * (the sidebar passes its own footer-button class) so the entry matches its
+     * neighbours instead of inventing a second button style.
+     */
+    triggerClassName: string;
+    /**
+     * The merged workspace list (capabilities snapshot plus a locked workspace
+     * registered before the snapshot). The sidebar already holds it; resolving
+     * on the bare snapshot alone would collapse a locked workspace's session
+     * onto the primary mount.
+     */
+    workspaces?: readonly DaemonWorkspaceCapability[];
+}
+/**
+ * Resolve how a session's bridge must dial, with the same rules voice uses
+ * for the eligible cases (primary → legacy `/acp`, trusted secondary →
+ * workspace-qualified route). Unlike voice, this surface also needs an
+ * explicit "no bridge" outcome: an untrusted or live workspace must withhold
+ * the entry instead of collapsing onto the primary mount, and
+ * `{ kind: 'pending' }` is reserved for "cannot tell yet" (capabilities
+ * snapshot or registry entry not landed). The resolver never returns
+ * `undefined`; whether a resolved route may actually be offered also depends
+ * on the daemon's client_mcp_over_ws feature gate, which the caller applies
+ * separately.
+ */
+export type LocalFilesWorkspaceRoute = {
+    kind: 'legacy';
+} | {
+    kind: 'qualified';
+    selector: AcpWorkspaceSelector;
+} | {
+    kind: 'none';
+} | {
+    kind: 'pending';
+};
+export declare function resolveLocalFilesWorkspaceRoute(options: {
+    capabilities: DaemonCapabilities | undefined;
+    workspaces?: readonly DaemonWorkspaceCapability[];
+    workspaceCwd: string | undefined;
+    sessionId: string | undefined;
+}): LocalFilesWorkspaceRoute;
+/**
+ * Registration retries must warm the runtime that owns the session: the
+ * legacy preheat route is bound to the primary workspace, so a secondary
+ * session's cold child would never warm and every attempt would fail.
+ */
+export declare function createLocalFilesRewarm(options: {
+    client: DaemonClient;
+    selector: AcpWorkspaceSelector | undefined;
+    preheat: () => Promise<unknown>;
+}): () => Promise<void>;
+export declare function LocalFilesControl({ triggerClassName, workspaces, }: LocalFilesControlProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,43 @@
+import type { Message, PermissionRequest } from '../adapters/types';
+import type { WebShellAssistantTurnFooterRenderInfo, WebShellSource } from '../customization';
+import { type SessionContentGenerator } from './messages/AssistantMessage';
+import type { TurnOutputOpenRequest } from './artifacts/TurnOutputs';
+import type { AttachmentPreviewRequest } from '../adapters/messageTypes';
+interface MessageItemProps {
+    message: Message;
+    pendingApproval?: PermissionRequest | null;
+    /** Run /context detail, exactly like typing it (context-usage panels). */
+    onShowContextDetail?: () => void;
+    onLocateBackgroundSource?: (messageId: string, callId?: string) => boolean;
+    /** Click an uploaded image in a user message to preview it in the right panel. */
+    onImagePreview?: (src: string, alt?: string) => void;
+    onAttachmentPreview?: (file: AttachmentPreviewRequest) => void;
+    onTurnOutputOpen?: (request: TurnOutputOpenRequest) => void;
+    onInsightReportOpen?: (path: string) => void;
+    workspaceCwd?: string;
+    showRetryHint?: boolean;
+    onRetryClick?: () => void;
+    sendFailed?: boolean;
+    onRetrySend?: () => void;
+    /**
+     * Open the in-place editor for this user message. Return `true` when a host
+     * owns the edit lifecycle — then the inline editor stays closed.
+     */
+    onEditUserMessage?: () => boolean | void;
+    /**
+     * Send the text the user confirmed in the inline editor. Resolves `false`
+     * when the resend was refused or failed; the editor stays open then.
+     */
+    onSubmitUserMessageEdit?: (content: string) => boolean | void | Promise<boolean | void>;
+    onBranchSession?: (branchRecordId?: string) => void | Promise<void>;
+    branchRecordId?: string;
+    showAssistantActions?: boolean;
+    showAssistantBranch?: boolean;
+    isLocateFlashing?: boolean;
+    assistantTurnFooterInfo?: WebShellAssistantTurnFooterRenderInfo;
+    turnSources?: readonly WebShellSource[];
+    onSourceOpen?: (source: WebShellSource) => void;
+    generateContent?: SessionContentGenerator;
+}
+export declare const MessageItem: import("react").NamedExoticComponent<MessageItemProps>;
+export {};