@linxin666/dsh-client-ui-task-board 0.1.1

package/lib/index.js

@@ -0,0 +1,54 @@
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import z from "schemastery";
+//#region src/index.ts
+/** Order of the announcement section within the tool-guidance band. */
+const SECTION_ORDER = 200;
+const inject = ["systemPrompt"];
+/** Model-facing announcement: plugin presence, capabilities, and limits. */
+const TASK_BOARD_GUIDANCE = "本机已安装 dsh-task-board 插件（DSH Web GUI 的任务看板）：侧边栏「任务看板」入口；在 dsh-web-ui 插件全家桶仓库（packages/dsh-task-board）统一维护，经聚合包 web-ui-all 一键安装。能力：多列看板管理任务；任务可真实执行（驱动 agent 会话）；任务支持 5 段 cron 定时执行（如 0 23 * * *）；数据存浏览器 localStorage（键 dsh.taskBoard.v1）。限制：定时调度在浏览器端，需 GUI 标签页打开，错过即跳过；执行消耗 API 额度。用户提到「任务看板 / 看板 / 定时任务」时即指本插件，请据此协作。";
+/**
+* Settings namespace of the board's announcement capability — the section the
+* web settings surface edits. Spelled here rather than imported: the browser
+* half spells the same value and must not depend on a Host package.
+*/
+const TASK_BOARD_SETTINGS_NAMESPACE = settingsNamespace("task-board");
+const Config = z.object({
+	announceToAgent: z.boolean().default(true),
+	enabled: z.boolean().default(true)
+});
+/** Schema default, re-read for hand-built test contexts (the loader applies them normally). */
+const DEFAULT_ANNOUNCE = true;
+/**
+* Register the board's announcement section, gated on the composition entry's
+* `announceToAgent` (and the live settings value once the web settings
+* surface is served). The section is re-registered whenever the source
+* changes, so a settings edit takes effect without a restart.
+* @param ctx - the plugin context (systemPrompt injected).
+* @param config - resolved plugin config (schema defaults applied by the loader).
+*/
+function apply(ctx, config) {
+	let current = () => config ?? {};
+	let disposeSection;
+	const sync = () => {
+		if (disposeSection !== void 0) {
+			disposeSection();
+			disposeSection = void 0;
+		}
+		if ((current().enabled ?? true) === false) return;
+		if ((current().announceToAgent ?? DEFAULT_ANNOUNCE) === false) return;
+		disposeSection = ctx.systemPrompt.section({
+			name: "plugin:task-board",
+			order: SECTION_ORDER,
+			text: TASK_BOARD_GUIDANCE
+		});
+	};
+	installSettingsSection(ctx, TASK_BOARD_SETTINGS_NAMESPACE, Config, config ?? {}, {
+		setSource: (source) => {
+			current = source;
+		},
+		onChange: sync
+	});
+	sync();
+}
+//#endregion
+export { Config, TASK_BOARD_GUIDANCE, TASK_BOARD_SETTINGS_NAMESPACE, apply, inject };

package/lib/invariant.js

@@ -0,0 +1,6 @@
+//#region src/invariant.ts
+/** Invariant companion plugin (no assertions — nothing to check at runtime). */
+/** Provides no assertions: the board owns no cross-package runtime invariants. */
+function apply() {}
+//#endregion
+export { apply };

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

@@ -0,0 +1,77 @@
+/**
+ * Shared chrome for the plugin settings card: a disclosure header naming the
+ * plugin and what its settings govern, the controls inside, and the save that
+ * writes them. Renders nothing while the namespace is unavailable — a
+ * deployment that does not compose the owning plugin should show no trace of
+ * it. Mirrors the official ui-plugin-config PluginCard in a self-contained
+ * slice (this package must not depend on a sibling UI package).
+ */
+import { type ReactNode } from 'react';
+import type { CardShell } from './settings-form.ts';
+import type { SettingsCardKey } from './locales.ts';
+/** Card chrome shared by every plugin settings card. */
+export interface PluginSettingsCardProps {
+    /** Locale reader for this card's copy. */
+    t: (key: SettingsCardKey) => string;
+    /** Locale key of the plugin's name. */
+    titleKey: SettingsCardKey;
+    /** Locale key of the line describing what this plugin's settings govern. */
+    descriptionKey: SettingsCardKey;
+    /** The card's form state: availability, writability, and what a save would do. */
+    state: CardShell;
+    /** Write every staged edit. */
+    onSave: () => void;
+    /** Drop every staged edit. */
+    onDiscard: () => void;
+    /** The plugin's controls. */
+    children: ReactNode;
+}
+/**
+ * Render one plugin settings card.
+ * @param props - the plugin's copy keys, its form state, and its controls.
+ * @returns the card, or nothing when the namespace is unavailable.
+ */
+export declare function PluginSettingsCard(props: PluginSettingsCardProps): import("react").JSX.Element | null;
+/** Props every field control needs regardless of its value type. */
+export interface FieldProps {
+    /** Stable id associating the label with its control. */
+    id: string;
+    /** Visible label. */
+    label: string;
+    /** One-line explanation rendered under the control. */
+    hint: string;
+    /** Draft text this control renders. */
+    text: string;
+    /** True when saving would leave a user-layer entry for this field. */
+    overridden: boolean;
+    /** True when the draft is not a value this field accepts. */
+    invalid: boolean;
+    /** Copy for the overridden badge. */
+    overriddenLabel: string;
+    /** Copy for the reset control. */
+    resetLabel: string;
+    /** Copy shown in place of the hint while the draft is invalid. */
+    invalidLabel: string;
+    /** Disables every control (read-only document, or an unavailable namespace). */
+    disabled: boolean;
+    /** Stage draft text. */
+    onEdit: (text: string) => void;
+    /** Stage a clear so the field re-inherits the composition layer. */
+    onReset: () => void;
+}
+/** A staged value field. `numeric` only hints the keypad: which drafts a field accepts is decided by its spec. */
+export declare function ValueField(props: FieldProps & {
+    /** Hints a numeric keypad without narrowing what the control accepts. */
+    numeric?: boolean;
+    /** Placeholder shown while the draft is empty. */
+    placeholder?: string;
+}): import("react").JSX.Element;
+/** A staged boolean field: 继承 / 开 / 关. */
+export declare function BooleanField(props: FieldProps & {
+    /** Copy for the inherit option. */
+    inheritLabel: string;
+    /** Copy for the on option. */
+    onLabel: string;
+    /** Copy for the off option. */
+    offLabel: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,51 @@
+/**
+ * The task-board settings card: whether the board announces itself in every
+ * agent's system prompt. Registers into the `settings.plugin.item` slot the
+ * plugin-configuration section renders, bound to the `task-board` settings
+ * namespace.
+ */
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SettingsScope, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import { type CardActions, type CardShell, type FieldState as CardFieldState } from './settings-form.ts';
+/** The task-board fields this card edits (the namespace's full schema). */
+export interface TaskBoardSettings {
+    /** Master switch for the plugin. */
+    enabled?: boolean;
+    /** Whether the board announces itself in every agent's system prompt. */
+    announceToAgent?: boolean;
+}
+/** What the task-board card renders. */
+export interface TaskBoardSettingsCardState extends CardShell {
+    /** Master switch. */
+    enabled: CardFieldState;
+    /** System-prompt announcement flag. */
+    announceToAgent: CardFieldState;
+}
+/** The registration-side face the card's slot entry injects. */
+export interface TaskBoardSettingsCardFace extends CardActions {
+    hooks: {
+        /** Card snapshot bound by the renderer as useTaskBoardSettingsCard. */
+        taskBoardSettingsCard: SnapshotStore<TaskBoardSettingsCardState>;
+    };
+}
+/** Bridges the `task-board` scope onto the card's staged form. */
+export declare class TaskBoardSettingsCardController {
+    private readonly form;
+    private readonly store;
+    /** @param scope - the bound settings scope for the `task-board` namespace. */
+    constructor(scope: SettingsScope<TaskBoardSettings>);
+    private projection;
+    /**
+     * Build the face the card's slot registration injects.
+     * @returns the card's snapshot and its form actions.
+     */
+    inject(): TaskBoardSettingsCardFace;
+}
+/** Props the renderer binds for the task-board card. */
+export type TaskBoardSettingsCardProps = PropsRuntime<'web-ui.plugin.item'> & PropsLocale<'task-board'> & InjectFace<TaskBoardSettingsCardFace>;
+/**
+ * Render the task-board card.
+ * @param props - locale copy, the card snapshot, and its form actions.
+ * @returns the card.
+ */
+export declare function TaskBoardSettingsCard(props: TaskBoardSettingsCardProps): import("react").JSX.Element;

package/lib/types/client/board/ConfirmDialog.d.ts

@@ -0,0 +1,12 @@
+/** Confirm overlay props. */
+export interface ConfirmDialogProps {
+    title: string;
+    message: string;
+    confirmLabel: string;
+    /** Render the confirm button in the danger style. */
+    danger?: boolean;
+    onCancel: () => void;
+    onConfirm: () => void;
+}
+/** Small confirm overlay. */
+export declare function ConfirmDialog({ title, message, confirmLabel, danger, onCancel, onConfirm }: ConfirmDialogProps): import("react").JSX.Element;

package/lib/types/client/board/NewTaskModal.d.ts

@@ -0,0 +1,6 @@
+import type { BoardController } from '../../core/controller.ts';
+/** New-task form overlay. */
+export declare function NewTaskModal({ controller, onClose }: {
+    controller: BoardController;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/lib/types/client/board/TaskBoard.d.ts

@@ -0,0 +1,5 @@
+import { type BoardController } from '../../core/controller.ts';
+/** Board component; subscribes to the controller snapshot. */
+export declare function TaskBoard({ controller }: {
+    controller: BoardController;
+}): import("react").JSX.Element;

package/lib/types/client/board/TaskCard.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Task card: the board's column item. Clicking opens the task detail — it
+ * never executes anything directly (detail holds the Run button).
+ */
+import type { TaskRecord } from '../../core/tasks.ts';
+/** Compact relative/absolute time label. */
+export declare function formatTime(ms: number): string;
+/** One card in a column. */
+export declare function TaskCard({ task, onClick }: {
+    task: TaskRecord;
+    onClick: () => void;
+}): import("react").JSX.Element;

package/lib/types/client/board/TaskDetail.d.ts

@@ -0,0 +1,7 @@
+import type { BoardController } from '../../core/controller.ts';
+import { type TaskRecord } from '../../core/tasks.ts';
+/** Task detail overlay. */
+export declare function TaskDetail({ controller, task }: {
+    controller: BoardController;
+    task: TaskRecord;
+}): import("react").JSX.Element;

package/lib/types/client/board-mount.d.ts

@@ -0,0 +1,10 @@
+import type { BoardController } from '../core/controller.ts';
+/** The injected board container (kept in the DOM, hidden when inactive). */
+export declare const BOARD_VIEW_SELECTOR = "[data-dsh-taskboard-view]";
+/**
+ * Mount the board React tree into the center column and bind its visibility
+ * to the controller's boardOpen state.
+ * @param controller - the board controller driving the view.
+ * @returns disposer unmounting the tree and restoring the column.
+ */
+export declare function mountBoard(controller: BoardController): () => void;

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

@@ -0,0 +1,43 @@
+/**
+ * Task-board client plugin: wires the framework-free core (controller,
+ * execution service, store) to the real client runtime and mounts the two
+ * DOM surfaces — the sidebar entry row and the board view in the center
+ * column.
+ *
+ * Failure policy: DOM mounting problems are logged, never thrown — the web
+ * shell fails the whole boot when a plugin apply throws, and an external
+ * plugin must not take the GUI down.
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import { type TaskBoardKey } from './locales.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Task-board surface copy. */
+        'task-board': TaskBoardKey;
+    }
+    interface SlotMap {
+        /**
+         * The child slot the Web UI plugin group declares; this card registers
+         * into the group instead of the top-level `settings.plugin.item` list.
+         * Spelled here with the same shape so this package can register without
+         * depending on the sibling UI package.
+         */
+        'web-ui.plugin.item': {
+            kind: 'list';
+            scope: 'root';
+            owner: SettingsPluginItemOwnerProps;
+        };
+    }
+}
+/** Owner share of a plugin card (the section supplies nothing). */
+export interface SettingsPluginItemOwnerProps {
+    /** Marker field: card owner props are intentionally empty. */
+    children?: never;
+}
+/** Required services (fiber inject waiting — the runtime must be up first). */
+export declare const inject: string[];
+/**
+ * Mount the task board.
+ * @param ctx - client root context (services: sessions, workspaces).
+ */
+export declare function apply(ctx: ClientContext): void;

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

@@ -0,0 +1,105 @@
+/**
+ * Task-board copy: zh-first dictionaries with an English fallback, selected
+ * by the document language. Kept dependency-free (no dsh locale service) so
+ * the DOM-injected entry row and the standalone board tree share one tiny
+ * lookup.
+ */
+/** zh dictionary (key-set source of truth). */
+export declare const zh: {
+    'entry.label': string;
+    'board.title': string;
+    'board.close': string;
+    'board.new': string;
+    'board.search': string;
+    'board.empty': string;
+    'board.filterAll': string;
+    'board.status': string;
+    'board.status.backlog': string;
+    'board.status.todo': string;
+    'board.status.running': string;
+    'board.status.done': string;
+    'board.status.failed': string;
+    'board.runs': string;
+    'board.updated': string;
+    'board.created': string;
+    'new.title': string;
+    'new.titlePlaceholder': string;
+    'new.description': string;
+    'new.descriptionPlaceholder': string;
+    'new.prompt': string;
+    'new.promptPlaceholder': string;
+    'new.submit': string;
+    'new.cancel': string;
+    'new.required': string;
+    'detail.title': string;
+    'detail.close': string;
+    'detail.prompt': string;
+    'detail.description': string;
+    'detail.execution': string;
+    'detail.noExecution': string;
+    'detail.run': string;
+    'detail.rerun': string;
+    'detail.delete': string;
+    'detail.viewSession': string;
+    'detail.noSession': string;
+    'detail.executionStarted': string;
+    'detail.executionEnded': string;
+    'detail.result.succeeded': string;
+    'detail.result.failed': string;
+    'detail.result.cancelled': string;
+    'detail.result.running': string;
+    'delete.title': string;
+    'delete.confirm': string;
+    'delete.ok': string;
+    'delete.cancel': string;
+    'status.move.backlog': string;
+    'status.move.todo': string;
+    'exec.error.noWorkspace': string;
+    'exec.error.promptRejected': string;
+    'run.failed': string;
+    'time.justNow': string;
+    'detail.schedule': string;
+    'detail.schedule.enable': string;
+    'detail.schedule.cron': string;
+    'detail.schedule.presets': string;
+    'detail.schedule.preset.daily9': string;
+    'detail.schedule.preset.hourly': string;
+    'detail.schedule.preset.tenMin': string;
+    'detail.schedule.preset.weeklyMon9': string;
+    'detail.schedule.nextRun': string;
+    'detail.schedule.lastTriggered': string;
+    'detail.schedule.invalid': string;
+    'detail.schedule.notScheduled': string;
+    'detail.schedule.dueSoon': string;
+    'card.scheduled': string;
+    'settings.title': string;
+    'settings.description': string;
+    'settings.enabled': string;
+    'settings.enabledHint': string;
+    'settings.announceToAgent': string;
+    'settings.announceToAgentHint': string;
+    'settings.inherit': string;
+    'settings.on': string;
+    'settings.off': string;
+    'settings.overridden': string;
+    'settings.reset': string;
+    'settings.readOnly': string;
+    'settings.expand': string;
+    'settings.collapse': string;
+    'settings.save': string;
+    'settings.saving': string;
+    'settings.discard': string;
+    'settings.unsaved': string;
+    'settings.saveFailed': string;
+    'settings.invalidNumber': string;
+};
+/** en dictionary, complete against the zh key set. */
+export declare const en: Record<keyof typeof zh, string>;
+/** The dictionary key union. */
+export type TaskBoardKey = keyof typeof zh;
+/** The settings-card slice of the task-board dictionary. */
+export type SettingsCardKey = TaskBoardKey;
+/** Active dictionary, picked by the document language at call time. */
+export declare function dictionary(): Record<TaskBoardKey, string>;
+/** Translate a key with optional {name} template params. */
+export declare function t(key: TaskBoardKey, params?: Record<string, string>): string;

package/lib/types/client/settings-form.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Staged form model behind the plugin settings card. A card stages what the
+ * user types and writes it only when they save — the settings write is a
+ * durable, revision-fenced document mutation, so staging keeps what is on
+ * screen exactly what a save would store. Mirrors the official
+ * ui-plugin-config card-store pattern in a self-contained slice: this
+ * package must not depend on a sibling UI package.
+ */
+import type { SettingsScope, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+/** The write one field's staged text performs when the card is saved. */
+export type FieldWrite = {
+    kind: 'set';
+    value: unknown;
+} | {
+    kind: 'clear';
+};
+/** How one field converts between its stored value and its draft text. */
+export interface FieldSpec {
+    /** Field name inside the namespace section. */
+    field: string;
+    /** Render a stored value as draft text; the empty string when the section carries none. */
+    format: (value: unknown) => string;
+    /**
+     * The write this draft text stages, or undefined when the text is not a
+     * value this field accepts — which blocks the save rather than discarding it.
+     */
+    parse: (text: string) => FieldWrite | undefined;
+}
+/** One field as the card renders it. */
+export interface FieldState {
+    /** Draft text the control renders. */
+    text: string;
+    /** Whether saving would leave a user-layer entry for this field. */
+    overridden: boolean;
+    /** Whether the draft is not a value this field accepts, which blocks saving. */
+    invalid: boolean;
+}
+/** Form state every plugin settings card shares. */
+export interface CardShell {
+    /** False while the namespace is not served to this client; the card renders nothing. */
+    available: boolean;
+    /** Whether the Host document accepts writes. */
+    writable: boolean;
+    /** Whether the form holds edits that a save would write. */
+    dirty: boolean;
+    /** Whether any staged draft is invalid, which blocks the save. */
+    invalid: boolean;
+    /** Whether a save is crossing the wire. */
+    saving: boolean;
+    /** Whether the last save did not land as staged; cleared by the next edit or save. */
+    failed: boolean;
+}
+/** The write actions the card's slot entry injects. */
+export interface CardActions {
+    /** Stage draft text for one field. */
+    edit: (field: string, text: string) => void;
+    /** Stage a clear, so saving lets the field re-inherit the composition layer. */
+    resetField: (field: string) => void;
+    /** Write every staged edit, then re-seed from what the Host accepted. */
+    save: () => void;
+    /** Drop every staged edit. */
+    discard: () => void;
+}
+/** A whole-number field. An empty draft clears the field; any other draft that is not a finite number blocks the save. */
+export declare function numberField(field: string): FieldSpec;
+/** A free-text field. An empty draft clears the field. */
+export declare function textField(field: string): FieldSpec;
+/** A boolean field, edited through true/false draft text. */
+export declare function booleanField(field: string): FieldSpec;
+/**
+ * Stages one card's edits over one settings namespace and writes them on save.
+ *
+ * The Host is the only authority on whether a value was accepted — its
+ * validators own the constraints no schema can express — so the outcome is
+ * read back from the section rather than predicted here. A save that did not
+ * land keeps its drafts, so the user can correct them instead of retyping.
+ */
+export declare class CardForm<T> {
+    private readonly scope;
+    private readonly specs;
+    private readonly staged;
+    private readonly listeners;
+    private saving;
+    private failed;
+    /** @param scope - the bound settings scope for this card's namespace. */
+    constructor(scope: SettingsScope<T>, specs: FieldSpec[]);
+    /** Publish a projection of this form, rebuilt whenever the scope or a draft changes. */
+    bind<S>(project: () => S): SnapshotStore<S>;
+    /** Read the card-level state: what the Host serves, and what a save would do. */
+    shell(): CardShell;
+    /** Read one field's state from the effective section and its staged draft. */
+    field(field: string): FieldState;
+    /** The actions the card's slot registration injects. */
+    actions(): CardActions;
+    /**
+     * Write every staged edit, then re-seed from what the Host accepted.
+     * @returns settlement after every write and the read-back.
+     */
+    save(): Promise<void>;
+    /**
+     * Every staged edit a save would write. An entry whose draft is not a value
+     * its field accepts carries no write: the form is still dirty, and the save
+     * refuses rather than dropping the edit. A staged edit that matches the
+     * effective section is not a write at all.
+     * @returns the planned writes, in the order the fields were staged.
+     */
+    private plan;
+    private clear;
+    private store;
+    private stage;
+    private specOf;
+    private snapshotOf;
+    private sectionValue;
+    private baseValue;
+    private userLayer;
+    private stored;
+    private publish;
+}

package/lib/types/client/sidebar-entry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Sidebar entry injection.
+ *
+ * dsh's sidebar shell exposes no slot an external plugin can register into
+ * (`sidebar.workspaces` / `sidebar.settings` are single-occupant and already
+ * taken), so — following the skin precedent of DOM-level extension — the
+ * entry row is injected between the shell's New Session button and the
+ * workspace browser. The injection self-heals: a MutationObserver watches the
+ * sidebar root and re-inserts the row whenever a React re-render displaces it
+ * (re-insertion happens in the same frame, before paint, so no flicker).
+ *
+ * The row is plain DOM (no React tree) so it can never disturb the shell's
+ * reconciliation; the board view it toggles is a separate React root mounted
+ * in the center column (see board-mount.ts).
+ */
+import type { BoardController } from '../core/controller.ts';
+/** Stable data attribute identifying the injected entry row. */
+export declare const ENTRY_SELECTOR = "[data-dsh-taskboard-entry]";
+/**
+ * Mount the sidebar entry, waiting for the shell to render and self-healing
+ * on later React re-renders.
+ * @param controller - the board controller the entry toggles.
+ * @returns disposer removing the entry and its observers.
+ */
+export declare function mountSidebarEntry(controller: BoardController): () => void;