@hachej/boring-workspace 0.1.70 → 0.1.72

package/dist/src/front/charts/index.d.ts

@@ -0,0 +1,92 @@
+import { ReactNode } from 'react';
+export interface BoringChartTheme {
+    background: string;
+    foreground: string;
+    mutedForeground: string;
+    border: string;
+    grid: string;
+    tooltipBackground: string;
+    tooltipBorder: string;
+    tooltipForeground: string;
+    palette: readonly string[];
+}
+export declare const boringChartPalette: readonly string[];
+export declare const boringChartTheme: BoringChartTheme;
+export declare function getBoringChartColor(index: number, theme?: BoringChartTheme): string;
+export declare function defaultBoringChartValueFormatter(value: unknown): string;
+export type BoringChartValueFormatter = (value: unknown) => string;
+export interface BoringTooltipPayloadItem {
+    color?: string;
+    dataKey?: string | number;
+    name?: string | number;
+    value?: unknown;
+}
+export interface BoringTooltipProps {
+    active?: boolean;
+    payload?: BoringTooltipPayloadItem[];
+    label?: unknown;
+    valueFormatter?: BoringChartValueFormatter;
+}
+export declare function BoringTooltip({ active, payload, label, valueFormatter, }: BoringTooltipProps): import("react").JSX.Element | null;
+export interface BoringChartFrameProps {
+    title?: string;
+    subtitle?: string;
+    source?: string;
+    height?: number | string;
+    className?: string;
+    children: ReactNode;
+}
+export declare function BoringChartFrame({ title, subtitle, source, height, className, children, }: BoringChartFrameProps): import("react").JSX.Element;
+export declare const boringCartesianAxisProps: {
+    readonly tick: {
+        readonly fill: string;
+        readonly fontSize: 11;
+    };
+    readonly axisLine: {
+        readonly stroke: string;
+    };
+    readonly tickLine: {
+        readonly stroke: string;
+    };
+};
+export declare const boringCartesianGridProps: {
+    readonly stroke: string;
+    readonly strokeDasharray: "3 3";
+    readonly vertical: false;
+};
+export declare const boringLegendProps: {
+    readonly wrapperStyle: {
+        readonly color: string;
+        readonly fontSize: 12;
+    };
+};
+export declare const boringLineProps: {
+    readonly type: "monotone";
+    readonly strokeWidth: 2;
+    readonly dot: false;
+    readonly activeDot: {
+        readonly r: 4;
+    };
+    readonly connectNulls: true;
+    readonly isAnimationActive: false;
+};
+export declare const boringAreaProps: {
+    readonly type: "monotone";
+    readonly strokeWidth: 2;
+    readonly dot: false;
+    readonly connectNulls: true;
+    readonly isAnimationActive: false;
+};
+export declare const boringBarProps: {
+    readonly radius: [number, number, number, number];
+    readonly isAnimationActive: false;
+};
+export declare const boringPieProps: {
+    readonly innerRadius: "58%";
+    readonly outerRadius: "82%";
+    readonly paddingAngle: 2;
+    readonly isAnimationActive: false;
+};
+export declare const boringReferenceAreaProps: {
+    readonly fill: "oklch(from var(--accent) l c h / 0.20)";
+};

package/dist/src/front/chrome/artifact-surface/ArtifactSurfacePane.d.ts

@@ -0,0 +1,18 @@
+import { DockviewApi } from 'dockview-react';
+import { SerializedLayout } from '../../dock';
+export interface ArtifactSurfacePaneProps {
+    visible?: boolean;
+    storageKey?: string;
+    allowedPanels?: string[];
+    persistedLayout?: SerializedLayout;
+    onLayoutChange?: (layout: SerializedLayout) => void;
+    onReady?: (api: DockviewApi) => void;
+    prefixHeaderActions?: React.FunctionComponent<unknown>;
+    rightHeaderActions?: React.FunctionComponent<unknown>;
+    watermarkComponent?: React.FunctionComponent<unknown>;
+    className?: string;
+}
+export declare function ArtifactSurfacePane({ visible, storageKey, allowedPanels, persistedLayout, onLayoutChange, onReady, prefixHeaderActions, rightHeaderActions, watermarkComponent, className, }: ArtifactSurfacePaneProps): import("react").JSX.Element | null;
+export declare namespace ArtifactSurfacePane {
+    var defaultAllowedPanels: string[];
+}

package/dist/src/front/chrome/artifact-surface/SurfaceShell.d.ts

@@ -0,0 +1,84 @@
+import { FilesystemId } from '../../../shared/types/filesystem';
+import { SurfaceOpenRequest } from '../../../shared/types/surface';
+export { normalizeSurfaceOpenRequest, resolvePanelForPath } from './surfaceShellHelpers';
+export interface SurfaceShellTab {
+    id: string;
+    /** Registered panel component id for this tab. May differ from the tab instance id. */
+    component?: string;
+    title: string;
+    params?: Record<string, unknown>;
+}
+export interface SurfaceShellSnapshot {
+    openTabs: SurfaceShellTab[];
+    activeTab: string | null;
+}
+export interface OpenPanelConfig {
+    /** Panel instance id. If a panel with this id is already open, it's re-activated instead of duplicated. */
+    id: string;
+    /** Registered component id (must match a `PanelConfig.id` in WorkspaceProvider's panel registry). */
+    component: string;
+    /** Tab title. Defaults to `id`. */
+    title?: string;
+    /** Arbitrary params passed to the pane component. */
+    params?: Record<string, unknown>;
+}
+export interface SurfaceShellOpenFileOptions {
+    filesystem?: FilesystemId;
+    mode?: "view" | "edit" | "diff";
+}
+export interface SurfaceShellApi {
+    /** Open a file in the workbench. Idempotent — re-activates an existing pane for the same filesystem/path. */
+    openFile: (path: string, options?: SurfaceShellOpenFileOptions) => void;
+    /** Open a plugin-defined surface target through the registered surface resolvers. */
+    openSurface: (request: SurfaceOpenRequest) => void;
+    /**
+     * Open a non-file pane in the workbench. Idempotent on `id` —
+     * re-activates an existing panel with the same id rather than duplicating.
+     * Use this for app-specific panes (charts, dashboards, log viewers, …) that
+     * aren't anchored to a filesystem path.
+     */
+    openPanel: (config: OpenPanelConfig) => void;
+    /** Hide the workbench's left sources/files pane while leaving the workbench open. */
+    closeWorkbenchLeftPane: () => void;
+    /** Reveal/select a file-tree path without opening an editor pane. */
+    expandToFile: (path: string) => void;
+    /** Current snapshot of open tabs + active tab. */
+    getSnapshot: () => SurfaceShellSnapshot;
+}
+export interface SurfaceShellProps {
+    rootDir?: string;
+    sidebarDefaultWidth?: number;
+    sidebarMinWidth?: number;
+    sidebarMaxWidth?: number;
+    storageKey?: string;
+    /** Called once when the surface dockview becomes ready, with an imperative handle. */
+    onReady?: (api: SurfaceShellApi) => void;
+    /** Called on every panel add/remove/active-change with the current snapshot. */
+    onChange?: (snapshot: SurfaceShellSnapshot) => void;
+    /** Optional close action for hosts that model the workbench as collapsible. */
+    onClose?: () => void;
+    /** Render the built-in top-right close affordance. Hosts can set false when they provide their own chrome. */
+    showCloseAction?: boolean;
+    /**
+     * Extra panel ids (registered via WorkspaceProvider's `panels` prop) that
+     * this workbench is allowed to render. Defaults to the built-in
+     * editor/viewer panels only. Pass app-specific pane ids here so calls
+     * like `surface.openPanel({ component: "chart-canvas" })` actually
+     * instantiate — without this, dockview's components map filters them
+     * out and you get an empty tab. Two-layer defense: SurfaceShell.openPanel
+     * validates against the registry (loud throw on unknown), AND the
+     * dockview allowlist below filters which registered panels can mount
+     * inside THIS surface (so a host can gate panels per shell instance).
+     */
+    extraPanels?: string[];
+    defaultLeftTab?: string;
+    onReloadAgentPlugins?: () => void | Promise<unknown>;
+    initialPanels?: Array<{
+        id: string;
+        component: string;
+        title?: string;
+        params?: Record<string, unknown>;
+    }>;
+    className?: string;
+}
+export declare function SurfaceShell({ rootDir, sidebarDefaultWidth, sidebarMinWidth, sidebarMaxWidth, storageKey, onReady, onChange, onClose, showCloseAction, extraPanels, defaultLeftTab, onReloadAgentPlugins, initialPanels, className, }: SurfaceShellProps): import("react").JSX.Element;

package/dist/src/front/chrome/artifact-surface/__tests__/ArtifactSurfacePane.persistence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/chrome/artifact-surface/__tests__/ArtifactSurfacePane.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/chrome/artifact-surface/__tests__/SurfaceShell.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/chrome/artifact-surface/__tests__/resolvePanelForPath.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/chrome/artifact-surface/definition.d.ts

@@ -0,0 +1,12 @@
+import { PaneProps } from '../../registry/types';
+import { SurfaceShellProps } from './SurfaceShell';
+import { FunctionComponentElement } from 'react';
+declare function ArtifactSurfacePanel({ params }: PaneProps<SurfaceShellProps | undefined>): FunctionComponentElement<SurfaceShellProps>;
+export declare const artifactSurfacePanel: {
+    id: string;
+    title: string;
+    component: typeof ArtifactSurfacePanel;
+    placement: string;
+    source: string;
+};
+export {};

package/dist/src/front/chrome/artifact-surface/surfaceShellHelpers.d.ts

@@ -0,0 +1,10 @@
+import { DockviewApi, IDockviewPanel } from 'dockview-react';
+import { SurfaceOpenRequest, SurfacePanelResolution, SurfaceResolverConfig } from '../../../shared/types/surface';
+import { FilesystemId } from '../../../shared';
+export declare function resolvePanelForPath(path: string, registry: {
+    resolve: SurfaceResolverConfig["resolve"];
+}): SurfacePanelResolution | undefined;
+export declare function normalizeWorkbenchPath(path: string): string;
+export declare function findOpenFilePanel(api: DockviewApi, path: string, filesystem?: FilesystemId): IDockviewPanel | undefined;
+export declare function normalizeSurfaceOpenRequest(request: SurfaceOpenRequest): SurfaceOpenRequest;
+export declare function surfacePanelId(request: SurfaceOpenRequest, resolved: SurfacePanelResolution): string;

package/dist/src/front/chrome/chat/ChatPanelHost.d.ts

@@ -0,0 +1,16 @@
+import { DispatchContext } from '../../bridge';
+import { WorkspaceChatPanelProps } from './types';
+export interface ChatPanelHostShellProps {
+    /** Headers forwarded to the embedded ChatPanel's agent API requests. */
+    requestHeaders?: Record<string, string>;
+    /** Endpoint base for agent → UI commands. Empty string = same origin. */
+    bridgeEndpoint?: string | null;
+    /**
+     * Agent → UI command dispatch context (surface handle, open/close workbench,
+     * and the pending-op queue). Built once by the host and shared by every
+     * dispatch site here. Absent when the workbench surface isn't available.
+     */
+    surfaceDispatch?: DispatchContext;
+}
+export type ChatPanelHostProps = WorkspaceChatPanelProps & ChatPanelHostShellProps;
+export declare function ChatPanelHost(props: ChatPanelHostProps): import("react").JSX.Element;

package/dist/src/front/chrome/chat/DetachedChatPopover.d.ts

@@ -0,0 +1,11 @@
+import { DetachedPanelPosition } from '../../detached/detachedPanelTypes';
+import { ChatPanelHostProps } from './ChatPanelHost';
+export declare function DetachedChatPopover({ sessionId, title, chatParams, initialPosition, onClose, onDock, composingEnabled, }: {
+    sessionId: string;
+    title: string;
+    chatParams: ChatPanelHostProps;
+    initialPosition: DetachedPanelPosition;
+    onClose: () => void;
+    onDock: () => void;
+    composingEnabled?: boolean;
+}): import("react").JSX.Element;

package/dist/src/front/chrome/chat/__tests__/ChatPanelHost.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/chrome/chat/composerStop.d.ts

@@ -0,0 +1,19 @@
+export declare const WORKSPACE_COMPOSER_STOP_EVENT: "boring:workspace-composer-stop";
+export declare const WORKSPACE_COMPOSER_STOP_REASONS: {
+    readonly sessionSwitch: "session-switch";
+    readonly userStop: "user-stop";
+};
+export type WorkspaceComposerStopReason = typeof WORKSPACE_COMPOSER_STOP_REASONS[keyof typeof WORKSPACE_COMPOSER_STOP_REASONS];
+export type WorkspaceComposerStopDetail = {
+    sessionId?: string;
+    reason: WorkspaceComposerStopReason;
+};
+export declare function emitWorkspaceComposerStop(detail: WorkspaceComposerStopDetail): void;
+export declare function isWorkspaceComposerStopDetail(value: unknown): value is WorkspaceComposerStopDetail;
+export declare function isWorkspaceComposerStopReason(value: unknown): value is WorkspaceComposerStopReason;
+export type WorkspaceComposerStopMatchOptions = {
+    fallbackSessionId?: string | null;
+    ignoredReasons?: readonly WorkspaceComposerStopReason[];
+};
+export declare function workspaceComposerStopTargetSessionId(detail: unknown, fallbackSessionId?: string | null): string | undefined;
+export declare function workspaceComposerStopAppliesToSession(detail: unknown, sessionId: string, options?: WorkspaceComposerStopMatchOptions): boolean;

package/dist/src/front/chrome/chat/definition.d.ts

@@ -0,0 +1,16 @@
+import { PaneProps } from '../../registry/types';
+import { ChatPanelHostShellProps, ChatPanelHostProps } from './ChatPanelHost';
+import { WorkspaceChatPanelProps } from './types';
+import { FunctionComponentElement } from 'react';
+type ChatPaneParams = (Partial<WorkspaceChatPanelProps> & ChatPanelHostShellProps & {
+    debug?: boolean;
+}) | undefined;
+declare function ChatPane({ params }: PaneProps<ChatPaneParams>): FunctionComponentElement<ChatPanelHostProps>;
+export declare const chatPanel: {
+    id: string;
+    title: string;
+    component: typeof ChatPane;
+    placement: string;
+    source: string;
+};
+export {};

package/dist/src/front/chrome/chat/types.d.ts

@@ -0,0 +1,30 @@
+import { PiChatPanelProps } from '@hachej/boring-agent/front';
+import { FilesystemId } from '../../../shared/types/filesystem';
+import { ComponentType } from 'react';
+import { WorkspaceAttentionBlocker } from '../../provider';
+import { SurfaceShellApi } from '../artifact-surface/SurfaceShell';
+export type OpenArtifactHandler = (path: string, options?: {
+    filesystem?: FilesystemId;
+}) => void;
+export interface WorkspaceChatPanelProps extends Omit<PiChatPanelProps<WorkspaceAttentionBlocker>, "onOpenArtifact"> {
+    sessionId: string;
+    onOpenArtifact?: OpenArtifactHandler;
+    /** Endpoint base for agent → visible-workbench UI commands. */
+    bridgeEndpoint?: string | null;
+    /** Imperative handle getter for the visible workbench surface. */
+    getSurface?: () => SurfaceShellApi | null;
+    /** Reads whether the visible workbench surface should be open. */
+    isWorkbenchOpen?: () => boolean;
+    /** Opens the visible workbench surface before dispatching a command. */
+    openWorkbench?: () => void;
+    /** Opens the visible workbench sources/file-tree pane before dispatching a reveal. */
+    openWorkbenchSources?: () => void;
+    /** Closes the visible workbench surface after an ephemeral command finishes. */
+    closeWorkbench?: () => void;
+    /** Host-injected composer blockers (for shell policies such as detached read-only chat). */
+    composerBlockers?: WorkspaceAttentionBlocker[];
+    onComposerStop?: () => void;
+    onComposerBlockerAction?: (blocker: WorkspaceAttentionBlocker, action: string) => void;
+    onData?: (part: unknown) => void;
+}
+export type WorkspaceChatPanelComponent = ComponentType<any>;

package/dist/src/front/chrome/empty-pane/EmptyPane.d.ts

@@ -0,0 +1,5 @@
+export interface EmptyPaneProps {
+    className?: string;
+    onOpenFile?: () => void;
+}
+export declare function EmptyPane({ className, onOpenFile }: EmptyPaneProps): import("react").JSX.Element;

package/dist/src/front/chrome/empty-pane/__tests__/EmptyPane.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/chrome/management/ManagementOverlaySurface.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+export interface ManagementOverlaySurfaceProps {
+    part: string;
+    icon: ReactNode;
+    title: string;
+    description: string;
+    actions?: ReactNode;
+    headerInsetStart?: boolean;
+    headerInsetEnd?: boolean;
+    children: ReactNode;
+}
+/**
+ * Shared shell for app-left management overlays (Skills, Plugins, and host/
+ * plugin-provided tools) so they use one header/content surface contract.
+ */
+export declare function ManagementOverlaySurface({ part, icon, title, description, actions, headerInsetStart, headerInsetEnd, children, }: ManagementOverlaySurfaceProps): import("react").JSX.Element;

package/dist/src/front/chrome/plugins/PluginsOverlay.d.ts

@@ -0,0 +1,16 @@
+export interface PluginsOverlayProps {
+    onClose: () => void;
+    /** Reload external/runtime plugins. The host owns the exact session-aware
+     *  reload payload; this overlay owns only the chrome. */
+    onReloadExternalPlugins?: () => Promise<string | undefined> | string | undefined;
+    /** Reserve room for shell-level chrome that floats over collapsed app nav. */
+    headerInsetStart?: boolean;
+    /** Reserve room for shell-level top-right controls floating over the overlay. */
+    headerInsetEnd?: boolean;
+}
+/**
+ * External plugins overlay — hosted as a chat overlay, not as a workbench panel.
+ * Lists only runtime/external plugins; statically bundled app plugins (Deck,
+ * Questions, etc.) are intentionally hidden here.
+ */
+export declare function PluginsOverlay({ onClose, onReloadExternalPlugins, headerInsetStart, headerInsetEnd }: PluginsOverlayProps): import("react").JSX.Element;

package/dist/src/front/chrome/session-list/SessionBrowser.d.ts

@@ -0,0 +1,20 @@
+import { SessionItem } from '../../components/SessionList';
+export interface SessionBrowserProps {
+    sessions: SessionItem[];
+    activeId?: string | null;
+    /** Session ids currently open as chat panes, in pane order. */
+    openIds?: string[];
+    /** Session ids the user pinned; surfaced in a Pinned section on top. */
+    pinnedIds?: string[];
+    onTogglePin?: (id: string) => void;
+    onSwitch?: (id: string) => void;
+    onOpenAsTab?: (id: string) => void;
+    onCreate?: () => void;
+    onDelete?: (id: string) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    loadingMore?: boolean;
+    onClose?: () => void;
+    className?: string;
+}
+export declare function SessionBrowser({ sessions, activeId, openIds, pinnedIds, onTogglePin, onSwitch, onOpenAsTab, onCreate, onDelete, onLoadMore, hasMore, loadingMore, onClose, className, }: SessionBrowserProps): import("react").JSX.Element;

package/dist/src/front/chrome/session-list/__tests__/SessionBrowser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/chrome/session-list/definition.d.ts

@@ -0,0 +1,28 @@
+import { PaneProps } from '../../registry/types';
+import { SessionItem } from '../../components/SessionList';
+import { FunctionComponentElement } from 'react';
+import { SessionBrowserProps } from './SessionBrowser';
+interface SessionListPaneParams {
+    sessions?: SessionItem[];
+    activeId?: string | null;
+    openIds?: string[];
+    pinnedIds?: string[];
+    onTogglePin?: (id: string) => void;
+    onSwitch?: (id: string) => void;
+    onOpenAsTab?: (id: string) => void;
+    onCreate?: () => void;
+    onDelete?: (id: string) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    loadingMore?: boolean;
+    onClose?: () => void;
+}
+declare function SessionListPane({ params }: PaneProps<SessionListPaneParams | undefined>): FunctionComponentElement<SessionBrowserProps>;
+export declare const sessionListPanel: {
+    id: string;
+    title: string;
+    component: typeof SessionListPane;
+    placement: string;
+    source: string;
+};
+export {};

package/dist/src/front/chrome/skills/SkillsPage.d.ts

@@ -0,0 +1,11 @@
+import { PaneProps } from '../../registry/types';
+export type SkillsPageProps = Partial<PaneProps> & {
+    /** When provided, renders a close control in the header — used when Skills
+     *  is hosted as a chat left overlay rather than a workspace panel. */
+    onClose?: () => void;
+    /** Reserve room for shell-level chrome that floats over collapsed app nav. */
+    headerInsetStart?: boolean;
+    /** Reserve room for shell-level top-right controls floating over the overlay. */
+    headerInsetEnd?: boolean;
+};
+export declare function SkillsPage({ onClose, headerInsetStart, headerInsetEnd }: SkillsPageProps): import("react").JSX.Element;

package/dist/src/front/chrome/skills/definition.d.ts

@@ -0,0 +1,3 @@
+import { PanelConfig } from '../../registry/types';
+export declare const WORKSPACE_SKILLS_PANEL_ID = "workspace:skills";
+export declare const workspaceSkillsPanel: PanelConfig;

package/dist/src/front/chrome/workbench-left/WorkbenchLeftPane.d.ts

@@ -0,0 +1,28 @@
+import { FileTreeBridge } from '../../bridge/types';
+import { WorkbenchLeftTabId, WorkspaceLeftPaneOpenPanelConfig as WorkbenchLeftPaneOpenPanelConfig } from './useWorkspaceLeftPaneActions';
+export type { WorkbenchLeftTabId, WorkspaceLeftPaneOpenPanelConfig as WorkbenchLeftPaneOpenPanelConfig } from './useWorkspaceLeftPaneActions';
+export interface WorkbenchLeftPaneProps {
+    rootDir?: string;
+    bridge?: FileTreeBridge;
+    defaultTab?: WorkbenchLeftTabId;
+    activeTab?: WorkbenchLeftTabId;
+    /**
+     * Id of the currently-focused surface tab (dockview's active panel). Drives the
+     * accent for "workspace-page" rail icons so a page only glows while it's the open
+     * tab — `activeTab` is the rail's own click state and goes stale on tab switches.
+     */
+    activePanelId?: string | null;
+    onActiveTabChange?: (tab: WorkbenchLeftTabId) => void;
+    revealFileTreeRequest?: {
+        path: string;
+        seq: number;
+    } | null;
+    onOpenPanel?: (config: WorkbenchLeftPaneOpenPanelConfig) => void;
+    onReloadAgentPlugins?: () => void | Promise<unknown>;
+    onCollapse?: () => void;
+    onExpand?: (tab?: WorkbenchLeftTabId) => void;
+    onCloseSourcePane?: () => void;
+    railOnly?: boolean;
+    className?: string;
+}
+export declare function WorkbenchLeftPane({ rootDir, bridge, defaultTab, activeTab: controlledActiveTab, activePanelId, onActiveTabChange, revealFileTreeRequest, onOpenPanel, onReloadAgentPlugins, onCollapse, onExpand, onCloseSourcePane, railOnly, className, }: WorkbenchLeftPaneProps): import("react").JSX.Element;

package/dist/src/front/chrome/workbench-left/__tests__/WorkbenchLeftPane.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/chrome/workbench-left/definition.d.ts

@@ -0,0 +1,12 @@
+import { PaneProps } from '../../registry/types';
+import { WorkbenchLeftPaneProps } from './WorkbenchLeftPane';
+import { FunctionComponentElement } from 'react';
+declare function WorkbenchLeftPanel({ params }: PaneProps<WorkbenchLeftPaneProps | undefined>): FunctionComponentElement<WorkbenchLeftPaneProps>;
+export declare const workbenchLeftPanel: {
+    id: string;
+    title: string;
+    component: typeof WorkbenchLeftPanel;
+    placement: string;
+    source: string;
+};
+export {};

package/dist/src/front/chrome/workbench-left/useWorkspaceLeftPaneActions.d.ts

@@ -0,0 +1,48 @@
+import { ReactNode } from 'react';
+import { PanelConfig, WorkspaceSourceConfig } from '../../registry/types';
+export type WorkbenchLeftTabId = string;
+export interface WorkspaceLeftPaneOpenPanelConfig {
+    id: string;
+    component: string;
+    title?: string;
+    params?: Record<string, unknown>;
+}
+export interface UseWorkspaceLeftPaneActionsOptions {
+    defaultTab?: WorkbenchLeftTabId;
+    activeTab?: WorkbenchLeftTabId;
+    activePanelId?: string | null;
+    onActiveTabChange?: (tab: WorkbenchLeftTabId) => void;
+    revealFileTreeRequest?: {
+        path: string;
+        seq: number;
+    } | null;
+    onOpenPanel?: (config: WorkspaceLeftPaneOpenPanelConfig) => void;
+    onReloadAgentPlugins?: () => void | Promise<unknown>;
+    onExpand?: (tab?: WorkbenchLeftTabId) => void;
+    onCloseSourcePane?: () => void;
+    railOnly?: boolean;
+}
+export interface WorkspaceLeftPaneAction {
+    id: WorkbenchLeftTabId;
+    title: string;
+    icon: ReactNode;
+    kind: "source" | "workspace-page";
+    active: boolean;
+    select: () => void;
+    reloadAgentPlugins?: () => void | Promise<unknown>;
+}
+interface WorkbenchLeftPaneActionModel extends WorkspaceLeftPaneAction {
+    source?: WorkspaceSourceConfig;
+    panel?: PanelConfig;
+    focused: boolean;
+}
+interface WorkbenchLeftPaneModel {
+    actions: WorkbenchLeftPaneActionModel[];
+    publicActions: WorkspaceLeftPaneAction[];
+    activeTab: WorkbenchLeftTabId;
+    activeAction?: WorkbenchLeftPaneActionModel;
+    activeSource?: WorkspaceSourceConfig;
+}
+export declare function useWorkspaceLeftPaneActions(options?: UseWorkspaceLeftPaneActionsOptions): WorkspaceLeftPaneAction[];
+export declare function useWorkbenchLeftPaneModel({ defaultTab, activeTab: controlledActiveTab, activePanelId, onActiveTabChange, revealFileTreeRequest, onOpenPanel, onReloadAgentPlugins, onExpand, onCloseSourcePane, railOnly, }?: UseWorkspaceLeftPaneActionsOptions): WorkbenchLeftPaneModel;
+export {};

package/dist/src/front/components/CommandPalette.d.ts

@@ -0,0 +1,21 @@
+export interface CommandPaletteSessionItem {
+    id: string;
+    title?: string | null;
+    updatedAt?: string | number;
+    turnCount?: number;
+}
+export interface CommandPaletteSessionSearchConfig {
+    sessions: CommandPaletteSessionItem[];
+    activeId?: string | null;
+    openIds?: readonly string[];
+    search?: (sessions: readonly CommandPaletteSessionItem[], query: string) => CommandPaletteSessionItem[];
+    onSwitch: (id: string) => void;
+    onOpenAsTab: (id: string) => void;
+}
+export interface CommandPaletteProps {
+    sessionSearch?: CommandPaletteSessionSearchConfig;
+    apiBaseUrl?: string;
+    authHeaders?: Record<string, string>;
+}
+export declare function CommandPalette({ sessionSearch, apiBaseUrl, authHeaders }?: CommandPaletteProps): import("react").JSX.Element;
+export { formatShortcut } from '../hooks/useKeyboardShortcuts';

package/dist/src/front/components/ControlTooltip.d.ts

@@ -0,0 +1,12 @@
+import { ReactElement, ReactNode } from 'react';
+/**
+ * Instant tooltip for icon-only chrome controls — no OS hover delay, with
+ * an optional keyboard hint rendered after the label. Wrap the control and
+ * drop its native `title` (the two together double up).
+ */
+export declare function ControlTooltip({ label, hint, side, children, }: {
+    label: ReactNode;
+    hint?: string;
+    side?: "top" | "bottom" | "left" | "right";
+    children: ReactElement;
+}): import("react").JSX.Element;

package/dist/src/front/components/ErrorChip.d.ts

@@ -0,0 +1,6 @@
+export interface ErrorChipProps {
+    pluginId: string;
+    message: string;
+    kind: "panel" | "workspace-source" | "catalog-row" | "chat-suggestion" | "app-left-action";
+}
+export declare function ErrorChip({ pluginId, message, kind }: ErrorChipProps): import("react").JSX.Element;

package/dist/src/front/components/PanelErrorBoundary.d.ts

@@ -0,0 +1,22 @@
+import { Component, ErrorInfo, ReactNode, ReactPortal, ReactElement, JSXElementConstructor } from 'react';
+export interface PanelErrorBoundaryProps {
+    panelId: string;
+    onError?: (data: {
+        panelId: string;
+        error: string;
+        stack?: string;
+    }) => void;
+    children: ReactNode;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+}
+export declare class PanelErrorBoundary extends Component<PanelErrorBoundaryProps, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    handleRetry: () => void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+export {};

package/dist/src/front/components/SessionList.d.ts

@@ -0,0 +1,15 @@
+export interface SessionItem {
+    id: string;
+    title: string;
+    updatedAt?: string | number;
+}
+export interface SessionListProps {
+    sessions: SessionItem[];
+    activeId?: string | null;
+    onSwitch?: (id: string) => void;
+    onCreate?: () => void;
+    onDelete?: (id: string) => void;
+    onRename?: (id: string, newTitle: string) => void;
+    className?: string;
+}
+export declare function SessionList({ sessions, activeId, onSwitch, onCreate, onDelete, className, }: SessionListProps): import("react").JSX.Element;

package/dist/src/front/components/WorkspaceLoadingState.d.ts

@@ -0,0 +1,8 @@
+export interface WorkspaceLoadingStateProps {
+    title?: string;
+    description?: string;
+    status?: string;
+    fullscreen?: boolean;
+    className?: string;
+}
+export declare function WorkspaceLoadingState({ title, description, status, fullscreen, className, }: WorkspaceLoadingStateProps): import("react").JSX.Element;

package/dist/src/front/components/__tests__/CommandPalette.test.d.ts

@@ -0,0 +1 @@
+export {};