@khorsheed/dsh-local-agent 0.1.0-rc.6

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

@@ -0,0 +1,59 @@
+import type { ReactNode } from 'react';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { SessionListState } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { LocalAgentStatus } from '@khorsheed/dsh-local-agent/types';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { NS } from './locales.ts';
+import type { LocalAgentHarnessView } from './LocalAgentRecordsAction.tsx';
+/** Known harnesses the family plans to support; unregistered ones render as pending. */
+export declare const KNOWN_HARNESSES: readonly LocalAgentHarnessView[];
+/** How often a pending login's status is re-probed after the prompt surfaces. */
+export declare const LOGIN_POLL_MS = 4000;
+/** How long a pending login keeps being polled before the section gives up. */
+export declare const LOGIN_POLL_LIMIT_MS: number;
+/** The first http(s) URL in a login prompt, if any. */
+export declare function parseLoginUrl(text: string): string | undefined;
+/**
+ * Injected business face of the shared auth block — the subset of the
+ * settings section's injected face one harness row consumes.
+ */
+export interface ProviderAuthInjected {
+    /** One harness's auth status. */
+    status: (name: string) => Promise<LocalAgentStatus | undefined>;
+    /**
+     * Run one user-initiated slash-command line (login/logout) against the
+     * session's agent and return the command result text, or undefined when
+     * unavailable.
+     * @param sessionId - the target session.
+     * @param line - the full command line.
+     */
+    runCommand: (sessionId: SessionId, line: string) => Promise<string | undefined>;
+}
+/** Full props for the shared per-harness auth block. */
+export interface ProviderAuthBlockProps extends ProviderAuthInjected, PropsLocale<typeof NS> {
+    /** The harness this block manages. */
+    harness: LocalAgentHarnessView;
+    /** Global sessions hook (the slot runtime share, delivered to every slot). */
+    useSessions: <T>(select: (state: SessionListState) => T) => T;
+    /**
+     * Extra actions rendered at the end of the action row — the settings
+     * section passes its `local-agent.settings.row-action` seat here.
+     */
+    actions?: ReactNode;
+}
+/**
+ * One harness's auth interactions, shared between the per-provider settings
+ * cards (the alpha.2 `plugins.bundle.config` pages and the 0.1.5
+ * `settings.plugin.item` tab): auth status through
+ * the read-only Remote channel and a web-login action that runs
+ * `/<harness> login`, surfaces the device-code prompt, and offers a link to
+ * the authorization page. The login command returns at prompt time while the
+ * CLI polls in the background, so a pending login's status keeps being
+ * re-probed until credentials land or the poll window expires. Status polls
+ * ride the Remote channel and emit no session events; only the user-initiated
+ * login/logout commands leave command nodes in the log.
+ * @param props - the harness, the injected query/command faces, and copy.
+ * @returns the block content (head row, prompts, and the login toast).
+ */
+export declare function ProviderAuthBlock({ harness, useSessions, status, runCommand, actions, t }: ProviderAuthBlockProps): import("react").JSX.Element;
+//# sourceMappingURL=ProviderAuthBlock.d.ts.map

package/lib/types/client/ProviderAuthBlock.js

@@ -0,0 +1,164 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Toast } from '@deepseek-ai/dsh-client-ui-primitives';
+import { IconCheckOutlineMedium } from './icons.js';
+import { publishAuthStatus } from './auth-status.js';
+import css from './ProviderAuthBlock.module.css';
+/** Known harnesses the family plans to support; unregistered ones render as pending. */
+export const KNOWN_HARNESSES = [
+    { id: 'kimi', label: 'Kimi Code' },
+    { id: 'codex', label: 'Codex' },
+    { id: 'claude-code', label: 'Claude Code' },
+];
+/** How often a pending login's status is re-probed after the prompt surfaces. */
+export const LOGIN_POLL_MS = 4_000;
+/** How long a pending login keeps being polled before the section gives up. */
+export const LOGIN_POLL_LIMIT_MS = 5 * 60_000;
+/** The first http(s) URL in a login prompt, if any. */
+export function parseLoginUrl(text) {
+    return /https?:\/\/\S+/.exec(text)?.[0];
+}
+/** Resolve a harness id to its display label for toast text. */
+function harnessLabel(id) {
+    return KNOWN_HARNESSES.find(harness => harness.id === id)?.label ?? id;
+}
+/**
+ * The main-view session: host 0.1.6-alpha.2 dropped SessionListState.current
+ * for the retainedBy.mainView count on each summary (the label is ui-session's
+ * declaration merge, read here as a plain duck-typed count so this package
+ * needs no ui-session edge), with the legacy field as the older-host fallback.
+ */
+const mainSessionId = (list) => Object.values(list.byId ?? {}).find(session => (session.retainedBy?.mainView ?? 0) > 0)?.id
+    ?? list.current;
+/**
+ * One harness's auth interactions, shared between the per-provider settings
+ * cards (the alpha.2 `plugins.bundle.config` pages and the 0.1.5
+ * `settings.plugin.item` tab): auth status through
+ * the read-only Remote channel and a web-login action that runs
+ * `/<harness> login`, surfaces the device-code prompt, and offers a link to
+ * the authorization page. The login command returns at prompt time while the
+ * CLI polls in the background, so a pending login's status keeps being
+ * re-probed until credentials land or the poll window expires. Status polls
+ * ride the Remote channel and emit no session events; only the user-initiated
+ * login/logout commands leave command nodes in the log.
+ * @param props - the harness, the injected query/command faces, and copy.
+ * @returns the block content (head row, prompts, and the login toast).
+ */
+export function ProviderAuthBlock({ harness, useSessions, status, runCommand, actions, t }) {
+    const sessionId = useSessions((state) => mainSessionId(state));
+    const [view, setView] = useState({ status: 'checking' });
+    /** The login start time while the device-code login is still pending. */
+    const [pendingSince, setPendingSince] = useState(undefined);
+    /** A login-completion toast awaiting mount; seq forces a re-show for repeats. */
+    const [loginToast, setLoginToast] = useState(null);
+    const toastSeq = useRef(0);
+    /** OAuth code draft for a pty login awaiting a paste. */
+    const [codeDraft, setCodeDraft] = useState('');
+    const refresh = () => {
+        const id = harness.id;
+        setView(prev => ({ ...prev, status: 'checking' }));
+        void status(id).then((probe) => {
+            const statusKind = probe === undefined ? 'unavailable'
+                : probe.authenticated ? 'authenticated' : 'anonymous';
+            // Card headers read the same probe through the status bus (the dot
+            // flips the moment a login/logout lands, in every mounted card).
+            publishAuthStatus(id, statusKind);
+            const capabilities = probe === undefined
+                ? {}
+                : {
+                    loginable: probe.loginable ?? true,
+                    logoutable: probe.logoutable ?? true,
+                    ...probe.loginAwaitingCode === true ? { loginAwaitingCode: true } : {},
+                };
+            setView(prev => 
+            // A completed login drops the stale device prompt.
+            statusKind === 'authenticated'
+                ? { status: statusKind, ...capabilities }
+                : { ...prev, status: statusKind, ...capabilities });
+            if (statusKind === 'authenticated') {
+                setPendingSince((prev) => {
+                    // A pending→authenticated transition (a start time was tracked) is
+                    // the authorization-complete moment; surface it as a success toast.
+                    if (prev !== undefined) {
+                        toastSeq.current += 1;
+                        setLoginToast({ seq: toastSeq.current });
+                    }
+                    return undefined;
+                });
+            }
+        }).catch(() => {
+            publishAuthStatus(id, 'unavailable');
+            setView(prev => ({ ...prev, status: 'unavailable' }));
+        });
+    };
+    useEffect(() => {
+        refresh();
+    }, [harness.id, status, sessionId]);
+    useEffect(() => {
+        if (sessionId === undefined || pendingSince === undefined)
+            return;
+        const timer = window.setInterval(() => {
+            if (Date.now() - pendingSince > LOGIN_POLL_LIMIT_MS) {
+                setPendingSince(undefined);
+                return;
+            }
+            refresh();
+        }, LOGIN_POLL_MS);
+        return () => { window.clearInterval(timer); };
+    }, [pendingSince, status, sessionId, harness.id]);
+    const startLogin = () => {
+        if (sessionId === undefined)
+            return;
+        void runCommand(sessionId, `/${harness.id} login`).then((text) => {
+            const text2 = text ?? '';
+            const loginUrl = parseLoginUrl(text2);
+            setView({
+                status: 'checking',
+                loginText: text2,
+                ...loginUrl !== undefined && { loginUrl },
+            });
+            setPendingSince(Date.now());
+        }).catch(() => {
+            setView({ status: 'unavailable' });
+        });
+    };
+    const signOut = () => {
+        if (sessionId === undefined)
+            return;
+        void runCommand(sessionId, `/${harness.id} logout`).then((text) => {
+            // Show the sign-out reply where the device prompt renders (a missing
+            // logout path is visible as its error text), then re-probe so the row
+            // flips to not authenticated.
+            setView({
+                status: 'checking',
+                loginText: text !== undefined && text.trim() !== '' ? text : t('settings.loggedOut'),
+            });
+            refresh();
+        }).catch(() => {
+            setView({ status: 'unavailable' });
+        });
+    };
+    const statusKind = view.status;
+    const authenticated = statusKind === 'authenticated';
+    const loginPending = pendingSince !== undefined;
+    // A harness without a login/logout flow (dsh authenticates through the host
+    // credentials) must not offer the actions its command family would answer
+    // with an error.
+    const loginable = view.loginable ?? true;
+    const logoutable = view.logoutable ?? true;
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: css.rowHead, children: [_jsxs("span", { className: css.rowIdentity, children: [_jsx("span", { className: css.rowName, children: harness.label }), _jsx("span", { className: `${css.credentialDot} ${authenticated ? css.dotOn : css.dotOff}`, role: "img", "aria-label": t(authenticated ? 'settings.authenticated' : 'settings.notAuthenticated') }), _jsx("span", { className: css.rowTag, children: harness.id })] }), _jsxs("span", { className: css.status, children: [statusKind === 'checking' && t('loading'), statusKind === 'authenticated' && t('settings.authenticated'), statusKind === 'anonymous' && t('settings.notAuthenticated'), statusKind === 'unavailable' && t('error')] }), _jsxs("span", { className: css.rowActions, children: [authenticated && logoutable && (_jsx("button", { type: "button", className: css.logoutButton, onClick: () => { signOut(); }, children: t('settings.logout') })), loginable && (_jsx("button", { type: "button", className: css.loginButton, disabled: loginPending || sessionId === undefined, onClick: () => { startLogin(); }, children: authenticated ? t('settings.reauthorize') : t('settings.login') })), actions] })] }), view.loginText !== undefined && (_jsxs("div", { className: css.loginPrompt, children: [_jsx("span", { className: css.promptText, children: view.loginText }), view.loginUrl !== undefined && (_jsx("a", { className: css.openPage, href: view.loginUrl, target: "_blank", rel: "noreferrer", children: t('settings.openPage') }))] })), view.loginAwaitingCode === true && (_jsxs("div", { className: css.loginPrompt, children: [_jsx("input", { className: css.codeInput, value: codeDraft, placeholder: t('settings.pasteCode'), onChange: (event) => {
+                            setCodeDraft(event.currentTarget.value);
+                        } }), _jsx("button", { type: "button", className: css.loginButton, disabled: codeDraft.trim() === '', onClick: () => {
+                            const code = codeDraft.trim();
+                            if (code === '' || sessionId === undefined)
+                                return;
+                            void runCommand(sessionId, `/${harness.id} code ${code}`).then((text) => {
+                                setView((prev) => {
+                                    // Drop the awaiting flag; the command reply becomes the prompt text.
+                                    const { loginAwaitingCode: _cleared, ...rest } = prev;
+                                    return { ...rest, loginText: text ?? '' };
+                                });
+                                setCodeDraft('');
+                            });
+                        }, children: t('settings.submitCode') })] })), loginToast !== null && (_jsx(Toast, { text: t('settings.loginSuccess', { harness: harnessLabel(harness.id) }), icon: _jsx(IconCheckOutlineMedium, {}), onDone: () => { setLoginToast(null); } }, loginToast.seq))] }));
+}

package/lib/types/client/auth-status.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Harness auth-status bus for the settings cards: the ProviderAuthBlock
+ * publishes every probe result, and card headers subscribe for the at-a-glance
+ * credential dot — one probe feeds both the block and the header, a login or
+ * logout inside any card flips every dot immediately, and every header mount
+ * re-probes so a mid-session credential loss cannot leave a stale green dot.
+ * @module @khorsheed/dsh-local-agent/client — auth status bus
+ */
+import type { LocalAgentStatus } from '@khorsheed/dsh-local-agent/types';
+/** The probe-result kinds the credential dot distinguishes. */
+export type HarnessAuthStatusKind = 'checking' | 'authenticated' | 'anonymous' | 'unavailable';
+/** Record one harness's latest probe result and notify subscribers. */
+export declare function publishAuthStatus(harnessId: string, status: HarnessAuthStatusKind): void;
+/** Test hook: clear every published status so specs start with an empty bus. */
+export declare function resetAuthStatuses(): void;
+/** Read one harness's latest published status without subscribing (tests, non-React callers). */
+export declare function readAuthStatus(harnessId: string): HarnessAuthStatusKind | undefined;
+/**
+ * Read one harness's latest known auth status. Every mount probes once and
+ * publishes — a published value only snapshots the past (a credential expiring
+ * mid-session must flip the dot at the next view, not stay green forever);
+ * the bus dedupes identical values, so repeat probes never re-render.
+ * @param harnessId - the harness to read.
+ * @param probe - the card's injected status face (read-only Remote channel).
+ * @returns the latest known status kind.
+ */
+export declare function useHarnessAuthStatus(harnessId: string, probe: (name: string) => Promise<LocalAgentStatus | undefined>): HarnessAuthStatusKind;
+//# sourceMappingURL=auth-status.d.ts.map

package/lib/types/client/auth-status.js

@@ -0,0 +1,56 @@
+/**
+ * Harness auth-status bus for the settings cards: the ProviderAuthBlock
+ * publishes every probe result, and card headers subscribe for the at-a-glance
+ * credential dot — one probe feeds both the block and the header, a login or
+ * logout inside any card flips every dot immediately, and every header mount
+ * re-probes so a mid-session credential loss cannot leave a stale green dot.
+ * @module @khorsheed/dsh-local-agent/client — auth status bus
+ */
+import { useEffect, useSyncExternalStore } from 'react';
+const statuses = new Map();
+const listeners = new Set();
+/** Record one harness's latest probe result and notify subscribers. */
+export function publishAuthStatus(harnessId, status) {
+    if (statuses.get(harnessId) === status)
+        return;
+    statuses.set(harnessId, status);
+    for (const listener of listeners)
+        listener();
+}
+function subscribe(listener) {
+    listeners.add(listener);
+    return () => { listeners.delete(listener); };
+}
+/** Test hook: clear every published status so specs start with an empty bus. */
+export function resetAuthStatuses() {
+    statuses.clear();
+}
+/** Read one harness's latest published status without subscribing (tests, non-React callers). */
+export function readAuthStatus(harnessId) {
+    return statuses.get(harnessId);
+}
+/**
+ * Read one harness's latest known auth status. Every mount probes once and
+ * publishes — a published value only snapshots the past (a credential expiring
+ * mid-session must flip the dot at the next view, not stay green forever);
+ * the bus dedupes identical values, so repeat probes never re-render.
+ * @param harnessId - the harness to read.
+ * @param probe - the card's injected status face (read-only Remote channel).
+ * @returns the latest known status kind.
+ */
+export function useHarnessAuthStatus(harnessId, probe) {
+    const status = useSyncExternalStore(subscribe, () => statuses.get(harnessId) ?? 'checking');
+    useEffect(() => {
+        let cancelled = false;
+        void probe(harnessId).then((result) => {
+            if (cancelled)
+                return;
+            publishAuthStatus(harnessId, result === undefined ? 'unavailable' : result.authenticated ? 'authenticated' : 'anonymous');
+        }).catch(() => {
+            if (!cancelled)
+                publishAuthStatus(harnessId, 'unavailable');
+        });
+        return () => { cancelled = true; };
+    }, [harnessId, probe]);
+    return status;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Generated by scripts/sync-icon-artwork.mts from @deepseek-ai/dsh-client-ui-primitives
+ * (v0.1.7-rc.1, harness 46a7f68b09) — do not edit by hand. The 0.1.5 and rc.1 host lines
+ * share no icon export name, so the rc.1 artwork is inlined here: pure SVG,
+ * no host runtime identity, identical on every line. Re-run the generator
+ * after adding an icon import or bumping the harness checkout.
+ *
+ * @module @khorsheed/dsh-local-agent/client
+ */
+/** Shared props for every product icon component (mirrors the upstream IconProps). */
+export interface IconProps {
+    /** Square edge in px; defaults to the glyph's own drawn size. */
+    size?: number | undefined;
+    /** Extra class for layout placement; color rides currentColor. */
+    className?: string | undefined;
+}
+export declare const IconCheckOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+export declare const IconChevronDownOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+export declare const IconChevronUpOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+export declare const IconQueueOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+export declare const IconTrashOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+//# sourceMappingURL=icons.d.ts.map

package/lib/types/client/icons.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const IconCheckOutlineMedium = ({ size = 16, className }) => (_jsx("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.3, children: _jsx("path", { d: "M2.25 8.5L5.49732 11.7473C5.90519 12.1552 6.57263 12.1344 6.95426 11.7018L13.75 4", stroke: "currentColor" }) }));
+export const IconChevronDownOutlineMedium = ({ size = 14, className }) => (_jsx("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.3, children: _jsx("path", { d: "M4 6L7.29289 9.29289C7.68342 9.68342 8.31658 9.68342 8.70711 9.29289L12 6", stroke: "currentColor" }) }));
+export const IconChevronUpOutlineMedium = ({ size = 14, className }) => (_jsx("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.3, children: _jsx("path", { d: "M12 10L8.70711 6.70711C8.31658 6.31658 7.68342 6.31658 7.29289 6.70711L4 10", stroke: "currentColor" }) }));
+export const IconQueueOutlineMedium = ({ size = 14, className }) => (_jsxs("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.3, children: [_jsx("path", { d: "M5 6.75H11", stroke: "currentColor" }), _jsx("path", { d: "M5 9H8", stroke: "currentColor" }), _jsx("path", { d: "M2.37067 11.2497C1.5872 9.89252 1.32042 8.29798 1.61945 6.7597C1.91847 5.22141 2.76317 3.84293 3.99801 2.87809C5.23285 1.91325 6.7747 1.427 8.33964 1.50888C9.90458 1.59076 11.3873 2.23526 12.5147 3.32369C13.6422 4.41232 14.3384 5.8717 14.4751 7.43304C14.6118 8.99438 14.1797 10.5525 13.2585 11.8205C12.3372 13.0885 10.9889 13.9809 9.4617 14.3334C8.18666 14.6277 6.8587 14.529 5.64964 14.0601C5.17095 13.8745 4.76937 13.4929 4.26509 13.3963C3.67389 13.2832 2.95232 13.5595 2.0377 14.3334", stroke: "currentColor" })] }));
+export const IconTrashOutlineMedium = ({ size = 16, className }) => (_jsxs("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.3, children: [_jsx("path", { d: "M1.28149 3.88831H14.7187", stroke: "currentColor" }), _jsx("path", { d: "M5.41602 3.88833V2.47962C5.41602 2.29282 5.52492 2.11366 5.71876 1.98157C5.9126 1.84948 6.17551 1.77527 6.44964 1.77527H9.55053C9.82466 1.77527 10.0876 1.84948 10.2814 1.98157C10.4753 2.11366 10.5842 2.29282 10.5842 2.47962V3.88833", stroke: "currentColor" }), _jsx("path", { d: "M2.57349 3.88831L3.19366 13.2943C3.21937 13.5502 3.33952 13.7872 3.53065 13.9593C3.72178 14.1313 3.97016 14.2259 4.22729 14.2246H11.7728C12.0299 14.2259 12.2783 14.1313 12.4694 13.9593C12.6605 13.7872 12.7807 13.5502 12.8064 13.2943L13.4266 3.88831", stroke: "currentColor" }), _jsx("path", { d: "M6.44946 6.98926V11.1238", stroke: "currentColor" }), _jsx("path", { d: "M9.55054 6.98926V11.1238", stroke: "currentColor" })] }));

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

@@ -0,0 +1,62 @@
+/**
+ * Local-agent records plugin, browser half: the member composer for delegated
+ * CLI sessions, plus the shared settings-card building blocks the provider
+ * packages compose (ProviderAuthBlock, the auth-status bus, AuthStatusDot).
+ * The per-harness auth/live settings live in each provider's own settings
+ * card — on alpha.2 the bundle's configuration on its Plugins-page detail
+ * view (`plugins.bundle.config`), on 0.1.5 the `settings.plugin.item` card
+ * (Plugins → 可配置插件); the standalone「本地 Agent」section was retired
+ * once the cards carried auth (the live-settings proposal's M3). Roster and status ride the read-only local-agent Remote
+ * channel (no session events); only the user-initiated login/logout/preset
+ * commands go through the commands Remote, whose visible command node is the
+ * expected feedback. Delegation records live with the shared subagent
+ * surface — there is no separate header dropdown, so kimi delegations appear
+ * under the standard 子代理 list like every other subagent. The plugin holds
+ * no host data — every open pulls fresh.
+ */
+import { type ReactNode } from 'react';
+import { type HarnessModelPickerProps } from './HarnessModelPicker.tsx';
+import type { Context } from '@deepseek-ai/cordis';
+import type { TypertRemoteNamespaceMap } from '@deepseek-ai/dsh-typert-protocol';
+import { type LocalAgentKey } from './locales.ts';
+export type { LocalAgentHarnessView } from './LocalAgentRecordsAction.tsx';
+export { ProviderAuthBlock } from './ProviderAuthBlock.tsx';
+export type { ProviderAuthBlockProps, ProviderAuthInjected } from './ProviderAuthBlock.tsx';
+export { AuthStatusDot } from './AuthStatusDot.tsx';
+export type { AuthStatusDotProps } from './AuthStatusDot.tsx';
+export { publishAuthStatus, useHarnessAuthStatus, resetAuthStatuses, readAuthStatus } from './auth-status.ts';
+export type { HarnessAuthStatusKind } from './auth-status.ts';
+export type { MemberComposerInjected, MemberComposerMatch, MemberComposerProps } from './MemberComposer.tsx';
+export { selectCliMember } from './MemberComposer.tsx';
+/** The mounted local-agent gateway namespace, read back from the global store. */
+export type LocalAgentGatewayRemote = TypertRemoteNamespaceMap['localAgentGateway'];
+/** Optional companion-facing renderer; consumers probe the service at gesture time. */
+export type HarnessModelPickerInput = Omit<HarnessModelPickerProps, 'face' | 't'>;
+export interface LocalAgentUi {
+    renderMemberOutput(childSessionId: string, startedAt: number): ReactNode;
+    renderMemberInbox(childSessionId: string): ReactNode;
+    renderHarnessModelPicker(name: string, props: HarnessModelPickerInput): ReactNode;
+    renderMemberConfiguration(childSessionId: string): ReactNode;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        localAgentUi: LocalAgentUi;
+    }
+}
+export { ModelConfigurationFields } from './ModelConfigurationFields.tsx';
+export type { ConfigurationTranslate } from './ModelConfigurationFields.tsx';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The local-agent settings section copy. */
+        'local-agent': LocalAgentKey;
+    }
+}
+/** Required services: slot registry, the Remote channel, and locale registry. */
+export declare const inject: string[];
+/**
+ * Client plugin body: mount the local-agent Remote channel, register the
+ * dictionaries, and put the member composer on the conversation chain.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: Context): Promise<() => Promise<void>>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.js

@@ -0,0 +1,135 @@
+import { MemberFeeds } from './member-feed.js';
+/**
+ * Local-agent records plugin, browser half: the member composer for delegated
+ * CLI sessions, plus the shared settings-card building blocks the provider
+ * packages compose (ProviderAuthBlock, the auth-status bus, AuthStatusDot).
+ * The per-harness auth/live settings live in each provider's own settings
+ * card — on alpha.2 the bundle's configuration on its Plugins-page detail
+ * view (`plugins.bundle.config`), on 0.1.5 the `settings.plugin.item` card
+ * (Plugins → 可配置插件); the standalone「本地 Agent」section was retired
+ * once the cards carried auth (the live-settings proposal's M3). Roster and status ride the read-only local-agent Remote
+ * channel (no session events); only the user-initiated login/logout/preset
+ * commands go through the commands Remote, whose visible command node is the
+ * expected feedback. Delegation records live with the shared subagent
+ * surface — there is no separate header dropdown, so kimi delegations appear
+ * under the standard 子代理 list like every other subagent. The plugin holds
+ * no host data — every open pulls fresh.
+ */
+import { createElement } from 'react';
+import { HarnessModelPicker } from './HarnessModelPicker.js';
+import { MemberConfiguration } from './MemberConfiguration.js';
+import { MemberConfigurationStores } from './member-configuration.js';
+import localAgentRemote from '@khorsheed/dsh-local-agent/remote';
+import { MemberComposer, selectCliMember } from './MemberComposer.js';
+import { en, NS, zh } from './locales.js';
+import { memberLiveDefinition } from './live-node.js';
+import { MemberLiveNode, MemberLiveOutputView } from './MemberLiveNode.js';
+import { MemberLiveOutputs } from './live-output.js';
+export { ProviderAuthBlock } from './ProviderAuthBlock.js';
+export { AuthStatusDot } from './AuthStatusDot.js';
+export { publishAuthStatus, useHarnessAuthStatus, resetAuthStatuses, readAuthStatus } from './auth-status.js';
+export { selectCliMember } from './MemberComposer.js';
+import { MemberInboxView } from './MemberInboxView.js';
+export { ModelConfigurationFields } from './ModelConfigurationFields.js';
+/** Required services: slot registry, the Remote channel, and locale registry. */
+export const inject = ['slots', 'remote', 'remote.commands', 'locale'];
+/**
+ * Client plugin body: mount the local-agent Remote channel, register the
+ * dictionaries, and put the member composer on the conversation chain.
+ * @param ctx - client root context.
+ */
+export async function apply(ctx) {
+    const disposers = [];
+    try {
+        // The namespace is registered by $mount; `ctx.remote.localAgentGateway`
+        // cannot see it (the property proxy walks the fiber chain, and the
+        // namespace lives in the sibling fiber $mount spawned), so read it from
+        // the global store once the mount has settled.
+        disposers.push(await ctx.remote.$mount(localAgentRemote));
+    }
+    catch (error) {
+        // A Remote already mounted by another composition fails loud at boot; the
+        // rest of the plugin still registers (callers would answer an unmounted
+        // namespace with a typed RPC error, which the surfaces render).
+        /* v8 ignore next -- double-mount is a composition error, not a runtime path */
+        ctx.logger.error(error);
+    }
+    const gateway = ctx.get('remote.localAgentGateway');
+    const unwrap = (result) => {
+        if (!result.ok)
+            throw new Error('Configuration request failed');
+        return result.value;
+    };
+    const feeds = new MemberFeeds((requests, signal) => gateway.followMembers(requests, signal));
+    ctx.effect(() => () => feeds.dispose(), 'local-agent: shared member feed');
+    const configurations = new MemberConfigurationStores({
+        read: async (id) => unwrap(await gateway.memberConfiguration(id)),
+        follow: (id, signal) => feeds.follow(id, 'configuration', signal),
+        directory: async (id, refresh) => unwrap(await gateway.memberDirectory(id, refresh)),
+        followDirectory: (id, signal) => feeds.follow(id, 'directory', signal),
+        select: async (id, request, revision, selection) => unwrap(await gateway.selectMemberConfiguration(id, request, revision, selection)),
+        cancel: async (id, request, revision) => unwrap(await gateway.cancelMemberConfiguration(id, request, revision)),
+        retry: async (id, revision) => { unwrap(await gateway.retryMemberConfiguration(id, revision)); },
+    });
+    const directoryFaces = new Map();
+    const directoryFace = (name) => {
+        let face = directoryFaces.get(name);
+        if (face === undefined)
+            directoryFaces.set(name, face = {
+                read: async (refresh) => unwrap(await gateway.modelDirectory(name, undefined, refresh)),
+                follow: signal => gateway.followModelDirectory(name, undefined, signal),
+            });
+        return face;
+    };
+    const inboxFaces = new Map();
+    const inboxFace = (id) => {
+        let face = inboxFaces.get(id);
+        if (face === undefined)
+            inboxFaces.set(id, face = {
+                read: async () => unwrap(await gateway.memberInbox(id)),
+                control: async (action, requestId, outcome, evidence) => unwrap(await gateway.controlMemberInbox(id, action, requestId, outcome, evidence)),
+            });
+        return face;
+    };
+    const outputs = new MemberLiveOutputs((id, signal) => feeds.follow(id, 'output', signal));
+    const configurationUi = {
+        renderMemberOutput: (id, startedAt) => createElement(MemberLiveOutputView, { key: `${id}:${startedAt}`, sessionId: id, startedAt, outputs, t: ctx.locale.bind(NS) }),
+        renderMemberInbox: id => createElement(MemberInboxView, { key: id, face: inboxFace(id), t: ctx.locale.bind(NS) }),
+        renderHarnessModelPicker: (name, props) => createElement(HarnessModelPicker, { ...props, key: name, face: directoryFace(name), t: ctx.locale.bind(NS) }),
+        renderMemberConfiguration: id => createElement(MemberConfiguration, { key: id, store: configurations.get(id), diagnostics: outputs.diagnostics, t: ctx.locale.bind(NS) }),
+    };
+    ctx.provide('localAgentUi', configurationUi);
+    ctx.inject(['uiConversation'], lctx => { lctx.uiConversation.events.register(memberLiveDefinition); });
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node', key: 'local-agent-stream', locale: NS,
+        inject: () => ({ outputs }),
+    }, MemberLiveNode));
+    ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'ui-local-agent: dictionaries');
+    // The member composer: a one-shot subagent session that the family delegated
+    // gets a writable box (send = facade resume via the promptMember Remote);
+    // any other one-shot session gets the same read-only panel the official
+    // takeover would render. Priority -20 runs the selector before ui-subagent's
+    // read-only takeover (-10) — chain election is ascending, first non-null
+    // wins — and the degraded branch makes the takeover a strict subset of this
+    // entry, so electing first never changes a non-member session's UX.
+    ctx.slots.inject('conversation.composer', () => ctx.slots.register({
+        name: 'conversation.composer',
+        priority: -20,
+        locale: NS,
+        select: selectCliMember,
+        inject: () => ({
+            renderMemberConfiguration: configurationUi.renderMemberConfiguration,
+            renderMemberInbox: configurationUi.renderMemberInbox,
+            memberOf: childSessionId => gateway.memberOf(childSessionId).then(result => (result.ok ? result.value : undefined)),
+            promptMember: (childSessionId, text, requestId) => gateway.promptMember(childSessionId, text, requestId).then(result => (result.ok ? result.value : undefined)),
+            stopMember: childSessionId => gateway.stopMember(childSessionId).then(result => (result.ok ? result.value : undefined)),
+            activeDelegations: () => gateway.activeDelegations().then(result => (result.ok ? result.value : undefined)),
+            memberModel: childSessionId => gateway.memberModel(childSessionId).then(result => (result.ok ? result.value : undefined)),
+            setMemberModel: (childSessionId, model) => gateway.setMemberModel(childSessionId, model).then(result => (result.ok ? result.value : undefined)),
+        }),
+    }, MemberComposer));
+    return async () => {
+        for (const dispose of disposers.reverse())
+            await dispose();
+    };
+}

package/lib/types/client/live-node.d.ts

@@ -0,0 +1,14 @@
+/** Public Conversation definition: transient presentation yields to the native final message. */
+import type { ConversationNodeDefinition } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { LocalAgentStreamCheckpoint } from '../types.ts';
+export interface MemberLiveNodeData extends LocalAgentStreamCheckpoint {
+    readonly seq: number;
+    readonly settled: boolean;
+}
+declare module '@deepseek-ai/dsh-client-ui-chat/client' {
+    interface ChatNodeDataMap {
+        'local-agent-stream': MemberLiveNodeData;
+    }
+}
+export declare const memberLiveDefinition: ConversationNodeDefinition<MemberLiveNodeData>;
+//# sourceMappingURL=live-node.d.ts.map

package/lib/types/client/live-node.js

@@ -0,0 +1,34 @@
+export const memberLiveDefinition = {
+    kind: 'local-agent-stream',
+    target: 'chat',
+    match(event) {
+        if (event.type === 'local-agent/stream')
+            return { id: event.data.id, role: event.data.opening ? 'start' : 'update' };
+        if (event.type === 'assistant/message')
+            return { id: `${event.data.turn}:${event.data.step}`, role: 'update' };
+        return null;
+    },
+    start(_context, match) {
+        if (match.event.type !== 'local-agent/stream')
+            throw new Error('stream anchor required');
+        return { ...match.event.data, seq: match.event.seq, settled: match.event.data.closed === true };
+    },
+    update(context, match) {
+        if (match.event.type === 'assistant/message')
+            return { ...context.state, settled: true };
+        if (match.event.type !== 'local-agent/stream')
+            return context.state;
+        const checkpoint = match.event.data;
+        return { ...context.state, ...checkpoint, settled: context.state.settled || checkpoint.closed === true, text: checkpoint.append ? context.state.text + checkpoint.text : checkpoint.text };
+    },
+    buildViewNode(context) {
+        if (context.state === undefined)
+            return null;
+        const node = {
+            key: context.key, kind: 'local-agent-stream', id: context.id, target: 'chat',
+            anchorSeq: context.state.seq, location: context.start?.location ?? { kind: 'unresolved' },
+            visibility: context.state.settled ? 'hidden' : 'visible', data: context.state,
+        };
+        return node;
+    },
+};

package/lib/types/client/live-output.d.ts

@@ -0,0 +1,34 @@
+/** One shared Remote subscription per viewed member, independent of session history. */
+import type { LocalAgentStreamFrame, LocalAgentStreamItem } from '../types.ts';
+import { LivePaintDiagnostics } from './live-paint.ts';
+export type FollowMemberOutput = (id: string, signal: AbortSignal) => AsyncIterable<LocalAgentStreamFrame>;
+export interface LiveOutputItem extends LocalAgentStreamItem {
+    baseline: boolean;
+}
+export interface LiveOutputSnapshot {
+    readonly items: ReadonlyMap<string, LiveOutputItem>;
+    readonly connected: boolean;
+}
+export declare class MemberLiveOutput {
+    private readonly id;
+    private readonly follow;
+    private readonly onIdle;
+    private readonly diagnostics;
+    private readonly listeners;
+    private snapshot;
+    private controller;
+    constructor(id: string, follow: FollowMemberOutput, onIdle: () => void, diagnostics: LivePaintDiagnostics);
+    readonly getSnapshot: () => LiveOutputSnapshot;
+    readonly subscribe: (listener: () => void) => (() => void);
+    private publish;
+    private run;
+}
+/** Cached only while rendered: historical sessions do not retain text or connections. */
+export declare class MemberLiveOutputs {
+    private readonly follow;
+    readonly diagnostics: LivePaintDiagnostics;
+    private readonly stores;
+    constructor(follow: FollowMemberOutput);
+    get(id: string): MemberLiveOutput;
+}
+//# sourceMappingURL=live-output.d.ts.map