@michengai/dsh-automation 0.1.0

package/lib/types/client/AutomationView.d.ts

@@ -0,0 +1,2 @@
+import type { AutomationViewProps } from './contracts.js';
+export declare function AutomationView({ t, runtime, closeSettings }: AutomationViewProps): JSX.Element;

package/lib/types/client/ScheduleRail.d.ts

@@ -0,0 +1,34 @@
+import { type ComponentType, type ReactNode } from 'react';
+import type { Translate } from './contracts.js';
+import type { AutomationRuntime } from './runtime.js';
+import { type NativeSessionLike, type NativeWorkspaceLike } from './schedule-rail-model.js';
+import type { NativeTabRegistry } from './native-tabs.js';
+type SessionSelector = <S>(select: (state: {
+    ids?: string[];
+    byId?: Record<string, NativeSessionLike>;
+    current?: string | null;
+}) => S) => S;
+type WorkspaceSelector = <S>(select: (state: {
+    items?: NativeWorkspaceLike[];
+    archivedSessionIds?: string[];
+}) => S) => S;
+export declare function ScheduleRail({ t, runtime, openSession, }: {
+    readonly t: Translate;
+    readonly runtime: AutomationRuntime;
+    readonly openSession?: (sessionId: string) => void;
+}): JSX.Element;
+export declare function NativeScheduleShell({ t, runtime, officialTree, hostProps, openSession, useSessions, useWorkspaces, renderSlot, hasChannels, subscribeChannels, tabRegistry, wide, }: {
+    readonly t: Translate;
+    readonly runtime: AutomationRuntime;
+    readonly officialTree?: ComponentType<any>;
+    readonly hostProps?: Record<string, unknown>;
+    readonly openSession?: (sessionId: string) => void;
+    readonly useSessions?: SessionSelector;
+    readonly useWorkspaces?: WorkspaceSelector;
+    readonly renderSlot?: (name: string, props?: Record<string, unknown>) => ReactNode;
+    readonly hasChannels?: () => boolean;
+    readonly subscribeChannels?: (listener: () => void) => () => void;
+    readonly tabRegistry?: NativeTabRegistry;
+    readonly wide?: boolean;
+}): JSX.Element | null;
+export {};

package/lib/types/client/contracts.d.ts

@@ -0,0 +1,57 @@
+import type { ComponentType, ReactNode } from 'react';
+import type { AutomationLocaleKey } from './locales.js';
+import type { AutomationRuntime } from './runtime.js';
+export type Translate = (key: AutomationLocaleKey, params?: Record<string, unknown>) => string;
+export interface AutomationViewProps {
+    readonly t: Translate;
+    readonly runtime: AutomationRuntime;
+    readonly closeSettings?: () => void;
+}
+export interface ClientRpc {
+    call(channel: string, endpoint: string, payload: unknown, signal?: AbortSignal): Promise<unknown>;
+}
+export interface SlotRegisterOptions {
+    readonly name: string;
+    readonly id?: string;
+    readonly order?: number;
+    readonly locale?: string;
+    readonly label?: () => string;
+    readonly icon?: string;
+    readonly priority?: number;
+    readonly children?: Record<string, {
+        readonly kind: string;
+        readonly scope: string;
+    }>;
+    readonly inject?: () => Record<string, unknown>;
+}
+export interface ClientContext {
+    effect(factory: () => void | (() => void), label?: string): void;
+    connection: {
+        readonly rpc: ClientRpc;
+    };
+    sessions?: {
+        open(id: string): void;
+    };
+    locale: {
+        register(namespace: string, dictionaries: {
+            readonly zh: Record<string, string>;
+            readonly en: Record<string, string>;
+        }): () => void;
+        bind(namespace: string): Translate;
+    };
+    slots: {
+        inject(name: string, register: () => void | (() => void)): void;
+        register(options: SlotRegisterOptions, component: ComponentType<any>): () => void;
+        entries?(name: string): readonly unknown[];
+        entriesOfSlot?(name: string): readonly unknown[];
+        subscribe?(name: string, listener: () => void): () => void;
+    };
+}
+export interface NativeSwitcherProps {
+    readonly wide?: boolean;
+    readonly openSession?: (sessionId: string) => void;
+    readonly open?: (sessionId: string) => void;
+    readonly useSessions?: (select: (state: any) => any) => any;
+    readonly useWorkspaces?: (select: (state: any) => any) => any;
+    readonly renderSlot?: (name: string, props?: Record<string, unknown>) => ReactNode;
+}

package/lib/types/client/create-modal.d.ts

@@ -0,0 +1,30 @@
+import type { Translate } from './contracts.js';
+import { type AutomationFormState } from './helpers.js';
+export declare function CreateModal({ t, busy, workspaces, models, defaultModel, skills, draft, editing, onClose, onSubmit, onAddWorkspace, }: {
+    readonly t: Translate;
+    readonly busy: boolean;
+    readonly workspaces: readonly {
+        id: string;
+        title: string;
+        path: string;
+    }[];
+    readonly models: readonly {
+        provider: string;
+        model: string;
+        label: string;
+    }[];
+    readonly defaultModel: {
+        provider: string;
+        model: string;
+        label: string;
+    } | null;
+    readonly skills: readonly {
+        id: string;
+        name: string;
+    }[];
+    readonly draft?: Partial<AutomationFormState>;
+    readonly editing?: boolean;
+    readonly onClose: () => void;
+    readonly onSubmit: (form: AutomationFormState) => Promise<void>;
+    readonly onAddWorkspace?: (path: string) => Promise<string>;
+}): JSX.Element;

package/lib/types/client/helpers.d.ts

@@ -0,0 +1,67 @@
+import type { Translate } from './contracts.js';
+import type { AutomationSchedule, AutomationSnapshot, CreateAutomationInput, ModelOption, WorkspaceOption } from './protocol.js';
+export type ScheduleKind = 'once' | 'interval' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'custom';
+export interface AutomationFormState {
+    readonly name: string;
+    readonly prompt: string;
+    readonly scheduleKind: ScheduleKind;
+    readonly onceAt: string;
+    readonly everyMinutes: string;
+    readonly time: string;
+    readonly weekdays: readonly number[];
+    readonly hourlyMinute: string;
+    readonly monthDay: string;
+    readonly customDays: string;
+    readonly timeZone: string;
+    readonly permission: CreateAutomationInput['permission'];
+    readonly workspaceId: string;
+    readonly modelKey: string;
+    readonly reasoningEffort: string;
+    readonly skills: readonly string[];
+}
+export type FormErrorKey = 'form.error.name' | 'form.error.prompt' | 'form.error.once' | 'form.error.interval' | 'form.error.weekdays' | 'form.error.workspace';
+export declare class AutomationFormError extends Error {
+    readonly key: FormErrorKey;
+    constructor(key: FormErrorKey);
+}
+/** Chat 点选技能后写入输入框的 `/name` 文本。优先用合法技能名，否则回退到目录 id。 */
+export declare function skillGestureToken(skill: {
+    readonly id: string;
+    readonly name: string;
+}): string;
+/** 在光标处插入技能手势；已存在相同 token 时不重复插入。 */
+export declare function insertSkillGesture(prompt: string, token: string, caret: number): {
+    readonly text: string;
+    readonly caret: number;
+};
+export declare function localDateTimeValue(date?: Date): string;
+export declare function defaultFormState(now?: Date, workspaces?: readonly WorkspaceOption[], defaultModel?: ModelOption | null): AutomationFormState;
+export declare function buildCreateInput(form: AutomationFormState, workspaces: readonly WorkspaceOption[], models: readonly ModelOption[], now?: Date, options?: {
+    readonly allowPastOnce?: boolean;
+}): CreateAutomationInput;
+export interface OverviewStats {
+    readonly total: number;
+    readonly active: number;
+    readonly attention: number;
+    readonly nextRunAt?: string;
+}
+export declare function deriveOverview(snapshot: AutomationSnapshot): OverviewStats;
+export declare function formatRelativeTime(iso: string, now: Date, t: Translate): string;
+export declare function shortSessionId(sessionId: string): string;
+export declare function formatSchedule(schedule: AutomationSchedule, t: Translate): string;
+export declare function workspaceLabel(item: {
+    readonly workspaceId?: string;
+    readonly cwd?: string;
+}, workspaces: readonly WorkspaceOption[]): string;
+export declare function formatWithin(iso: string, now: Date, t: Translate): string;
+export declare function formatDuration(startedAt?: string, finishedAt?: string): string | undefined;
+export declare function clockTime(iso: string): string;
+export type HistoryRange = 'day' | 'week' | 'month';
+export interface HistoryGroup {
+    readonly key: string;
+    readonly label: string;
+    readonly items: readonly import('./protocol.js').AutomationRunViewModel[];
+}
+export declare function groupHistory(runs: readonly import('./protocol.js').AutomationRunViewModel[], range: HistoryRange, now: Date, t: Translate): HistoryGroup[];
+export declare function formFromAutomation(item: import('./protocol.js').AutomationViewModel, workspaces?: readonly WorkspaceOption[], defaultModel?: ModelOption | null): AutomationFormState;
+export declare function prettyModelName(model: string): string;

package/lib/types/client/icons.d.ts

@@ -0,0 +1,28 @@
+import type { SVGProps } from 'react';
+type IconProps = SVGProps<SVGSVGElement>;
+export declare function AutomationIcon(props: IconProps): JSX.Element;
+export declare function PlusIcon(props: IconProps): JSX.Element;
+export declare function RefreshIcon(props: IconProps): JSX.Element;
+export declare function PlayIcon(props: IconProps): JSX.Element;
+export declare function PauseIcon(props: IconProps): JSX.Element;
+export declare function TrashIcon(props: IconProps): JSX.Element;
+export declare function ShieldIcon(props: IconProps): JSX.Element;
+export declare function CalendarIcon(props: IconProps): JSX.Element;
+export declare function CheckIcon(props: IconProps): JSX.Element;
+export declare function AlertIcon(props: IconProps): JSX.Element;
+export declare function MoreIcon(props: IconProps): JSX.Element;
+export declare function InfoIcon(props: IconProps): JSX.Element;
+export declare function ClockIcon(props: IconProps): JSX.Element;
+export declare function ChatIcon(props: IconProps): JSX.Element;
+export declare function FolderIcon(props: IconProps): JSX.Element;
+export declare function SparkleIcon(props: IconProps): JSX.Element;
+export declare function FolderClosedIcon(props: IconProps): JSX.Element;
+export declare function FolderOpenIcon(props: IconProps): JSX.Element;
+export declare function ChevronIcon(props: IconProps): JSX.Element;
+export declare function EllipsisIcon(props: IconProps): JSX.Element;
+export declare function PencilIcon(props: IconProps): JSX.Element;
+export declare function BranchIcon(props: IconProps): JSX.Element;
+export declare function ArchiveIcon(props: IconProps): JSX.Element;
+/** 复刻官方任务树 running StateDot：3x3 像素绕圈。 */
+export declare function RunningStateDot(): JSX.Element;
+export {};

package/lib/types/client/index.d.ts

@@ -0,0 +1,4 @@
+import type { ClientContext } from './contracts.js';
+export declare const name = "dsh-automation-client";
+export declare const inject: string[];
+export declare function apply(ctx: ClientContext): void;

package/lib/types/client/locales.d.ts

@@ -0,0 +1,187 @@
+export declare const NS = "dsh-automation";
+export declare const en: {
+    readonly tab: "Scheduled tasks";
+    readonly 'sidebar.tab': "Scheduled";
+    readonly 'sidebar.tabs': "Workspace views";
+    readonly 'sidebar.tasksTab': "Tasks";
+    readonly 'sidebar.channelsTab': "Channels";
+    readonly 'sidebar.empty': "No scheduled runs yet.";
+    readonly 'sidebar.tasksEmpty': "No web tasks yet.";
+    readonly 'sidebar.ungrouped': "Ungrouped";
+    readonly 'sidebar.section': "Scheduled";
+    readonly 'header.lead': "Plan automatic tasks, or trigger them by hand. Describe the recurring work in any chat to create it quickly.";
+    readonly 'examples.title': "Recommended examples";
+    readonly 'examples.1.title': "Daily regression check";
+    readonly 'examples.1.body': "Create a scheduled task that runs every day and inspects new test failures.";
+    readonly 'examples.1.chip': "Every day 09:00";
+    readonly 'examples.2.title': "Weekly dependency review";
+    readonly 'examples.2.body': "Create a scheduled task that runs every Monday and reports outdated or risky dependencies.";
+    readonly 'examples.2.chip': "Monday 10:00";
+    readonly 'examples.3.title': "Weekday morning briefing";
+    readonly 'examples.3.body': "Create a scheduled task that runs on weekdays and summarizes overnight changes.";
+    readonly 'examples.3.chip': "Weekdays 08:00";
+    readonly 'chat.hint': "In any conversation, describe the recurring work and ask the Agent to call automation_create.";
+    readonly 'chat.prompt': "I want to create a scheduled task that runs every [interval] and does [the actual task]";
+    readonly 'menu.run': "Run now";
+    readonly 'menu.delete': "Delete task";
+    readonly 'session.rename': "Rename";
+    readonly 'session.fork': "Fork session";
+    readonly 'session.archive': "Archive session";
+    readonly 'session.delete': "Delete session";
+    readonly 'session.deleteFolder': "Delete folder";
+    readonly 'history.range.day': "By day";
+    readonly 'history.range.week': "By week";
+    readonly 'history.range.month': "By month";
+    readonly 'history.allTasks': "All tasks";
+    readonly 'history.allStatus': "All statuses";
+    readonly 'history.today': "Today";
+    readonly 'history.yesterday': "Yesterday";
+    readonly 'history.date': "{date}";
+    readonly 'history.week': "Week of {date}";
+    readonly 'history.month': "{month}";
+    readonly 'history.trigger': "Scheduled";
+    readonly 'history.nextApprox': "Next run in about {when}";
+    readonly 'time.withinMinute': "about {count} minutes";
+    readonly 'time.withinHour': "about {count} hours";
+    readonly 'time.withinDay': "about {count} days";
+    readonly 'search.placeholder': "Search scheduled tasks...";
+    readonly 'action.chatCreate': "Create in chat";
+    readonly 'action.create': "New scheduled task";
+    readonly 'banner.wake': "Scheduled tasks run only while this computer stays awake.";
+    readonly 'tabs.mine': "My tasks";
+    readonly 'tabs.runs': "Run history";
+    readonly 'sort.created': "Newest first";
+    readonly 'form.workspace': "Workspace";
+    readonly 'form.addWorkspace': "Add workspace...";
+    readonly 'form.workspacePath': "Folder path";
+    readonly 'form.workspacePathPlaceholder': "D:\\work\\project";
+    readonly 'form.model': "Model";
+    readonly 'form.modelDefault': "Follow default model";
+    readonly 'form.effort': "Reasoning";
+    readonly 'form.effort.none': "Default";
+    readonly 'form.effort.low': "Low";
+    readonly 'form.effort.medium': "Medium";
+    readonly 'form.effort.high': "High";
+    readonly 'form.error.workspace': "Select a workspace.";
+    readonly 'modal.title': "New scheduled task";
+    readonly 'modal.edit': "Edit scheduled task";
+    readonly 'modal.save': "Save";
+    readonly 'header.eyebrow': "Unattended coding work";
+    readonly 'header.title': "Automations";
+    readonly 'header.subtitle': "Schedule standalone, auditable Agent runs for this workspace.";
+    readonly 'header.create': "New automation";
+    readonly 'header.closeCreate': "Hide form";
+    readonly 'scope.workspace': "Workspace";
+    readonly 'scope.folder': "Working directory";
+    readonly 'stats.total': "All";
+    readonly 'stats.active': "Active";
+    readonly 'stats.next': "Next run";
+    readonly 'stats.attention': "Needs attention";
+    readonly 'stats.noneScheduled': "None scheduled";
+    readonly 'stats.noAttention': "All clear";
+    readonly 'section.automations': "Workspace automations";
+    readonly 'section.automationsHint': "Each trigger starts a fresh DSH Session and keeps its own audit record.";
+    readonly 'section.runs': "Recent runs";
+    readonly 'section.runsHint': "Latest outcomes for this workspace.";
+    readonly 'section.refresh': "Refresh";
+    readonly 'empty.title': "Let recurring coding work run itself";
+    readonly 'empty.body': "Save a self-contained task, a schedule, and a permission boundary. Every run starts in a new Session.";
+    readonly 'empty.action': "Create the first automation";
+    readonly 'runs.empty': "No runs yet. Run one now, or wait for the next scheduled occurrence.";
+    readonly 'form.title': "Create automation";
+    readonly 'form.subtitle': "Write a complete, standalone task. Scheduled runs do not inherit this conversation.";
+    readonly 'form.name': "Name";
+    readonly 'form.namePlaceholder': "Daily regression triage";
+    readonly 'form.prompt': "Task prompt";
+    readonly 'form.promptPlaceholder': "Inspect new test failures, locate the regression, and propose a verified minimal fix…";
+    readonly 'form.schedule': "Schedule";
+    readonly 'form.planTime': "Schedule";
+    readonly 'form.hourly': "Hourly";
+    readonly 'form.monthly': "Monthly";
+    readonly 'form.custom': "Custom";
+    readonly 'form.minutesShort': "min";
+    readonly 'form.daysShort': "days";
+    readonly 'form.monthDay': "Day {day} of month";
+    readonly 'form.skills': "Skills";
+    readonly 'form.skillsEmpty': "No skills available";
+    readonly 'schedule.hourlyAt': "Every hour at :{minute}";
+    readonly 'schedule.monthlyAt': "Monthly on day {day} · {time}";
+    readonly 'schedule.customAt': "Every {count} days · {time}";
+    readonly 'form.once': "Does not repeat";
+    readonly 'form.interval': "Interval";
+    readonly 'form.daily': "Daily";
+    readonly 'form.weekly': "Weekly";
+    readonly 'form.runAt': "Run at";
+    readonly 'form.every': "Every";
+    readonly 'form.minutes': "minutes";
+    readonly 'form.time': "Time";
+    readonly 'form.days': "Weekdays";
+    readonly 'form.timeZone': "Time zone";
+    readonly 'form.permission': "Permission boundary";
+    readonly 'form.readOnly': "Read Only";
+    readonly 'form.readOnlyHint': "Inspect the workspace without changing files.";
+    readonly 'form.workspaceWrite': "Workspace Write";
+    readonly 'form.fullAccess': "Full access";
+    readonly 'form.workspaceWriteHint': "May change files in this workspace; past approvals are not reused.";
+    readonly 'form.cancel': "Cancel";
+    readonly 'form.submit': "Create automation";
+    readonly 'form.submitting': "Creating…";
+    readonly 'form.error.name': "Enter a name.";
+    readonly 'form.error.prompt': "Enter a complete, standalone task prompt.";
+    readonly 'form.error.once': "Choose a valid future date and time.";
+    readonly 'form.error.interval': "The interval must be between 5 and 43,200 minutes.";
+    readonly 'form.error.weekdays': "Select at least one weekday.";
+    readonly 'day.1': "Mon";
+    readonly 'day.2': "Tue";
+    readonly 'day.3': "Wed";
+    readonly 'day.4': "Thu";
+    readonly 'day.5': "Fri";
+    readonly 'day.6': "Sat";
+    readonly 'day.7': "Sun";
+    readonly 'status.active': "Active";
+    readonly 'status.paused': "Paused";
+    readonly 'status.queued': "Queued";
+    readonly 'status.running': "Running";
+    readonly 'status.succeeded': "Succeeded";
+    readonly 'status.failed': "Failed";
+    readonly 'status.skipped': "Skipped";
+    readonly 'status.cancelled': "Cancelled";
+    readonly 'status.interrupted': "Interrupted";
+    readonly 'card.nextRun': "Next";
+    readonly 'card.lastRun': "Last";
+    readonly 'card.never': "Not yet run";
+    readonly 'card.permission.read-only': "Read-only";
+    readonly 'card.permission.workspace-write': "Workspace write";
+    readonly 'card.permission.full-access': "Full access";
+    readonly 'schedule.onceAt': "Once · {time}";
+    readonly 'schedule.everyMinutes': "Every {count} minutes";
+    readonly 'schedule.dailyAt': "Daily · {time}";
+    readonly 'schedule.weeklyAt': "{days} · {time}";
+    readonly 'card.pause': "Pause";
+    readonly 'card.resume': "Resume";
+    readonly 'card.runNow': "Run now";
+    readonly 'card.delete': "Delete";
+    readonly 'card.confirmDelete': "Delete this automation?";
+    readonly 'card.confirmDeleteHint': "Run history is kept for audit.";
+    readonly 'card.confirm': "Delete";
+    readonly 'card.cancel': "Cancel";
+    readonly 'run.trigger.schedule': "Scheduled";
+    readonly 'run.trigger.manual': "Manual";
+    readonly 'run.trigger.catch-up': "Catch-up";
+    readonly 'run.openSession': "Session {id}";
+    readonly 'run.markRead': "Mark reviewed";
+    readonly loading: "Loading automations…";
+    readonly 'error.title': "Automations could not be loaded";
+    readonly 'error.retry': "Try again";
+    readonly 'error.action': "The action failed. Please try again.";
+    readonly 'error.offline': "Could not reach the local automation service. Check that DSH is still running and try again.";
+    readonly 'time.now': "now";
+    readonly 'time.minuteAgo': "{count}m ago";
+    readonly 'time.hourAgo': "{count}h ago";
+    readonly 'time.dayAgo': "{count}d ago";
+    readonly 'time.inMinute': "in {count}m";
+    readonly 'time.inHour': "in {count}h";
+    readonly 'time.inDay': "in {count}d";
+};
+export type AutomationLocaleKey = keyof typeof en;
+export declare const zh: Record<AutomationLocaleKey, string>;

package/lib/types/client/menu.d.ts

@@ -0,0 +1,53 @@
+import { type ReactNode, type RefObject } from 'react';
+export interface MenuOption<T extends string> {
+    readonly value: T;
+    readonly label: string;
+    readonly icon?: ReactNode;
+}
+declare function useMenuOpen(): {
+    readonly open: boolean;
+    readonly setOpen: (value: boolean | ((current: boolean) => boolean)) => void;
+    readonly root: React.RefObject<HTMLDivElement>;
+    readonly menu: React.RefObject<HTMLDivElement>;
+};
+export declare function MenuPopup({ open, anchor, menuRef, up, end, className, children, onClick, }: {
+    readonly open: boolean;
+    readonly anchor: RefObject<HTMLElement>;
+    readonly menuRef: RefObject<HTMLDivElement>;
+    readonly up?: boolean | undefined;
+    readonly end?: boolean | undefined;
+    readonly className: string;
+    readonly children: ReactNode;
+    readonly onClick?: () => void;
+}): JSX.Element | null;
+export declare function MenuHostProvider({ host, children, }: {
+    readonly host: HTMLElement | null;
+    readonly children: ReactNode;
+}): JSX.Element;
+export declare function MenuRow({ icon, label, hint, active, chevron, kv, onClick, }: {
+    readonly icon?: ReactNode;
+    readonly label: ReactNode;
+    readonly hint?: ReactNode;
+    readonly active?: boolean;
+    readonly chevron?: boolean;
+    readonly kv?: boolean;
+    readonly onClick: () => void;
+}): JSX.Element;
+export declare function MenuSelect<T extends string>({ value, options, onChange, wide, pill, up, icon, }: {
+    readonly value: T;
+    readonly options: readonly MenuOption<T>[];
+    readonly onChange: (value: T) => void;
+    readonly wide?: boolean;
+    readonly pill?: boolean;
+    readonly up?: boolean;
+    readonly icon?: ReactNode;
+}): JSX.Element;
+export declare function MenuPanel({ label, children, ghost, up, persist, }: {
+    readonly label: ReactNode;
+    readonly children: ReactNode;
+    readonly ghost?: boolean;
+    readonly up?: boolean;
+    readonly persist?: boolean;
+}): JSX.Element;
+export declare function useMenuState(): ReturnType<typeof useMenuOpen>;
+export {};

package/lib/types/client/native-session-list.d.ts

@@ -0,0 +1,14 @@
+import type { Translate } from './contracts.js';
+import type { AutomationRuntime } from './runtime.js';
+export declare function relativeTime(value: string): string;
+export declare function NativeScheduleSessionList(props: {
+    readonly t: Translate;
+    readonly runtime: AutomationRuntime;
+    readonly openSession?: (sessionId: string) => void;
+    readonly useSessions?: (select: (state: any) => any) => any;
+    readonly useWorkspaces?: (select: (state: any) => any) => any;
+    readonly renameSession?: (sessionId: string, title: string) => void | Promise<void>;
+    readonly archiveSession?: (sessionId: string) => void | Promise<void>;
+    readonly deleteSession?: (sessionId: string) => void | Promise<void>;
+    readonly forkSession?: (sessionId: string) => void | Promise<void>;
+}): JSX.Element;

package/lib/types/client/native-tabs.d.ts

@@ -0,0 +1,23 @@
+/** 原生侧栏页签协作协议。两套插件各自复制这份约定，不互相 import。 */
+export declare const NATIVE_TABS_KEY = "__dshNativeTabs";
+export interface NativeSidebarTab {
+    readonly id: string;
+    readonly label: string;
+    readonly order?: number;
+    matchSession?(sessionId: string): boolean;
+    render(props: Record<string, unknown>): unknown;
+}
+export interface NativeTabRegistry {
+    readonly version: 1;
+    officialTree: unknown;
+    readonly sessionFilters: Array<(id: string) => boolean>;
+    getTabs(): NativeSidebarTab[];
+    subscribe(listener: () => void): () => void;
+    insert(tab: NativeSidebarTab): () => void;
+    addSessionFilter(filter: (id: string) => boolean): () => void;
+}
+export declare function createNativeTabRegistry(officialTree: unknown): NativeTabRegistry;
+export declare function getNativeTabRegistry(target: unknown): NativeTabRegistry | undefined;
+export declare function attachNativeTabRegistry<T>(target: T, registry: NativeTabRegistry): NativeTabRegistry;
+export declare function findNativeTabRegistry(entry: unknown): NativeTabRegistry | undefined;
+export declare function isForeignSidebarHost(component: unknown): boolean;

package/lib/types/client/prefill.d.ts

@@ -0,0 +1,6 @@
+/** 设置页「通过对话创建」交给会话输入框的待填草稿。 */
+export declare function setChatPrefill(text: string): void;
+export declare function takeChatPrefill(): string | null;
+export declare function peekChatPrefill(): string | null;
+export declare function subscribeChatPrefill(listener: (text: string | null) => void): () => void;
+export declare function applyPrefillToDom(text: string): boolean;