dsh-ntr 0.1.5 → 0.2.0

package/lib/client/permission-dock.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Pending ACP permission asks for the staged DSH conversation, rendered as
+ * composer-width entries above the composer card (`conversation.input.dock`).
+ * The slot itself spans the conversation column; the dock mirrors the host's
+ * InputBar width formula so the cards line up with the input box.
+ *
+ * The host broadcasts every ask as `permission/request`, carrying the DSH chat
+ * session id when the ask belongs to a conversation. This dock is the primary
+ * answer surface: it renders exactly the asks whose `dshSessionId` is the
+ * conversation it was mounted for, and nothing otherwise. There is no
+ * ACP-mode gate — the frame set itself is the gate, so an ordinary
+ * conversation shows this card if and only if it actually has an ask.
+ *
+ * The ask's description and options are the agent's own: buttons appear in the
+ * agent's order with the agent's names (including "Always Allow"), and
+ * `kind` is not rendered. A separate cancel button answers with no option,
+ * which the host forwards as `cancelled`. No Enter/Escape handlers: the
+ * composer owns its keyboard, and these are ordinary focusable buttons.
+ *
+ * Multiple asks stack in ARRIVAL order, oldest first: the question ignored
+ * longest stays at the top. The list is capped in height by CSS and scrolls.
+ * Asks without a chat identity never appear here — they stay in the
+ * settings-panel ledger, the cross-session mirror.
+ */
+import { useEffect, useState } from 'react';
+import { ensureAcpStyle, useUi } from "./acp-ui.js";
+import { deadlineRemainingLabel, PERMISSION_DEADLINE_EXPIRED, permissionsForSession, } from "./store.js";
+/** Tick interval for the countdown (seconds are all the label shows). */
+const COUNTDOWN_TICK_MS = 1000;
+export function PermissionDock({ acp, sessionId }) {
+    ensureAcpStyle();
+    const ui = useUi(acp);
+    const dshSessionId = String(sessionId);
+    const pending = permissionsForSession(ui.permissions, dshSessionId);
+    const counting = pending.some(ask => ask.timeoutMode !== 'wait' && ask.deadlineAt !== undefined);
+    const [now, setNow] = useState(() => Date.now());
+    useEffect(() => {
+        if (!counting)
+            return;
+        setNow(Date.now());
+        const timer = setInterval(() => { setNow(Date.now()); }, COUNTDOWN_TICK_MS);
+        return () => { clearInterval(timer); };
+    }, [counting]);
+    if (pending.length === 0)
+        return null;
+    return (_jsx("div", { className: "ntr-permission-dock", role: "region", "aria-label": acp.label('待处理的权限请求', 'Pending permission requests'), children: pending.map(permission => (_jsx(PermissionAskCard, { acp: acp, permission: permission, now: now }, permission.requestId))) }));
+}
+function PermissionAskCard(props) {
+    const { acp, permission, now } = props;
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState();
+    const remaining = deadlineRemainingLabel(permission.deadlineAt, now, permission.timeoutMode);
+    const expired = remaining === PERMISSION_DEADLINE_EXPIRED;
+    const respond = (optionId) => {
+        if (busy)
+            return;
+        setBusy(true);
+        setError(undefined);
+        void acp.respondPermission(permission.requestId, optionId)
+            // `respondPermission` reports to the store's notice too, but that notice
+            // lives on the settings page; this card pins the failure where the user
+            // is looking.
+            .catch((failure) => {
+            setError(failure instanceof Error ? failure.message : String(failure));
+        })
+            .finally(() => { setBusy(false); });
+    };
+    return (_jsxs("div", { className: "ntr-permission-card", children: [_jsxs("div", { className: "ntr-permission-head", children: [_jsx("span", { className: "ntr-permission-tool", children: permission.toolName }), permission.reason !== undefined && (_jsx("span", { className: "ntr-permission-reason", title: permission.reason, children: permission.reason })), remaining !== undefined && (_jsx("span", { className: `ntr-permission-deadline${expired ? ' is-expired' : ''}`, children: expired
+                            ? acp.label('已超时', 'expired')
+                            : acp.label(`剩余 ${remaining}`, `${remaining} left`) }))] }), _jsxs("div", { className: "ntr-permission-actions", children: [permission.options.map(option => (_jsx("button", { type: "button", className: "ntr-permission-option", disabled: busy, title: option.name, onClick: () => { respond(option.optionId); }, children: option.name }, option.optionId))), _jsx("button", { type: "button", className: "ntr-permission-cancel", disabled: busy, title: acp.label('取消这次询问（不选择任何选项）', 'Cancel this ask without choosing an option'), onClick: () => { respond(); }, children: acp.label('取消', 'Cancel') })] }), error !== undefined && (_jsx("div", { className: "ntr-permission-error", role: "alert", children: error }))] }));
+}

package/lib/client/session-controls.js

@@ -61,10 +61,10 @@ import { useEffect, useState } from 'react';
 import { AcpChip, AcpMenu, AcpShatterParts, buildAcpModelId, closeAcpMenu, ensureAcpStyle, openAcpMenu, openAcpSettingsDialog, setAcpMenuError, splitAcpModelId, useAcpMenu, useUi, } from "./acp-ui.js";
 import { playAgentLockAnim, useAgentLockPhase } from "./agent-lock-anim.js";
 const STATE_COLORS = {
-    ready: '#22c55e',
-    starting: '#eab308',
-    error: '#ef4444',
-    stopped: '#9ca3af',
+    ready: 'var(--dsw-alias-state-success-primary, #22c55e)',
+    starting: 'var(--dsw-alias-state-warn-primary, #eab308)',
+    error: 'var(--dsw-alias-state-error-primary, #ef4444)',
+    stopped: 'var(--dsw-alias-state-idle-primary, #9ca3af)',
 };
 function agentStateText(acp, state) {
     switch (state) {

package/lib/client/store.js

@@ -6,6 +6,39 @@
  * Deliberately framework-free: React binds through `useSyncExternalStore`.
  */
 import { DEFAULT_TAG_HALO } from "../protocol.js";
+/** Returned by {@link deadlineRemainingLabel} once the deadline has passed. */
+export const PERMISSION_DEADLINE_EXPIRED = 'expired';
+/**
+ * The asks that belong to one DSH chat conversation. An ask without a
+ * `dshSessionId` belongs to no conversation (an `/acp` RPC-only session), so it
+ * is deliberately absent from every conversation's dock and stays in the
+ * settings-panel ledger.
+ */
+export function permissionsForSession(permissions, dshSessionId) {
+    return permissions.filter(permission => permission.dshSessionId === dshSessionId);
+}
+/**
+ * Compact countdown for one ask, or `undefined` when there is nothing to count
+ * down (`wait` mode, or a frame without a deadline). Pure so the formatting is
+ * testable without a clock: the dock passes `Date.now()` on its tick.
+ *
+ * Past the deadline the answer is {@link PERMISSION_DEADLINE_EXPIRED} rather
+ * than a negative number — the host has already armed the expiry, and a card
+ * counting backwards would claim a deadline that no longer exists.
+ */
+export function deadlineRemainingLabel(deadlineAt, now, mode) {
+    if (mode === 'wait' || deadlineAt === undefined)
+        return undefined;
+    const remainingMs = deadlineAt - now;
+    if (remainingMs <= 0)
+        return PERMISSION_DEADLINE_EXPIRED;
+    const seconds = Math.ceil(remainingMs / 1000);
+    if (seconds < 60)
+        return `${String(seconds)}s`;
+    const minutes = Math.floor(seconds / 60);
+    const rest = seconds % 60;
+    return rest === 0 ? `${String(minutes)}m` : `${String(minutes)}m ${String(rest)}s`;
+}
 const MAX_BLOCKS = 400;
 /** How many observed ACP transcripts stay live at once (insertion-ordered eviction). */
 const MAX_WATCHED = 6;
@@ -298,7 +331,6 @@ export class AcpStore {
         seatCatalogs: {},
         probingModels: {},
         probeErrors: {},
-        approvalRouted: false,
         chatSessions: [],
         tagHalo: { ...DEFAULT_TAG_HALO },
         approvalDeadlines: undefined,
@@ -501,7 +533,7 @@ export class AcpStore {
     /** Snapshot refresh used on panel open and after a stream outage. */
     async resync() {
         try {
-            const [{ agents, approvalRouted }, { sessions }, defaultAgentInfo, detectResult, presetResult, tagHaloResult, deadlinesResult] = await Promise.all([
+            const [{ agents }, { sessions }, defaultAgentInfo, detectResult, presetResult, tagHaloResult, deadlinesResult] = await Promise.all([
                 this.call('agents/list'),
                 this.call('sessions/list'),
                 // The plugin's OWN default ACP agent — a plugin-private id, not a DSH
@@ -526,7 +558,6 @@ export class AcpStore {
                 sessions,
                 defaultAgent: defaultAgentInfo?.agentId,
                 detectedAgents,
-                approvalRouted: approvalRouted === true,
                 preset: presetResult?.preset ?? undefined,
                 tagHalo: tagHaloResult?.halo ?? { ...DEFAULT_TAG_HALO },
                 approvalDeadlines: deadlinesResult.deadlines,
@@ -790,12 +821,23 @@ export class AcpStore {
     async loadTranscript(sessionId) {
         try {
             const { session, entries } = await this.call('transcript/get', { sessionId });
+            // An answer BEHIND what this page already folded must not replace it.
+            //
+            // The host fills its transcript from the notification pipeline, which the
+            // SDK paces independently of the `session/prompt` response, so a read
+            // taken right after a turn can still be missing the agent's last chunk.
+            // `lastSeq` already refuses to go backwards; the blocks must not either,
+            // or switching away and back inside that window truncates a turn the user
+            // just watched finish. A resumed session replays as fresh updates, but
+            // only after `session/reset` zeroes the watermark — so this cannot swallow
+            // a legitimate replay.
+            const seen = this.lastSeq.get(sessionId) ?? 0;
+            if ((entries.at(-1)?.seq ?? 0) < seen)
+                return;
             const blocks = [];
             for (const entry of entries) {
-                const before = blocks.length;
                 foldUpdate(blocks, entry.update);
                 this.lastSeq.set(sessionId, Math.max(this.lastSeq.get(sessionId) ?? 0, entry.seq));
-                void before;
             }
             const sessions = this.state.sessions.some(s => s.sessionId === sessionId)
                 ? this.state.sessions.map(s => (s.sessionId === sessionId ? session : s))
@@ -1233,12 +1275,21 @@ export class AcpStore {
             this.flashError(error);
         }
     }
+    /**
+     * Answer one ask (`optionId` absent = cancel it). A failure is reported
+     * through the store's notice — the settings panel renders that — AND
+     * rethrown, so the conversation dock can pin the message next to the card
+     * that failed instead of leaving it on a settings page the user may not
+     * have open. Callers that cannot show it (the settings panel) swallow it
+     * after the notice.
+     */
     async respondPermission(requestId, optionId) {
         try {
             await this.call('permission/respond', { requestId, ...(optionId === undefined ? {} : { optionId }) });
         }
         catch (error) {
             this.flashError(error);
+            throw error;
         }
     }
     async stopAgent(agentId) {
@@ -1282,7 +1333,7 @@ export class AcpStore {
         }
     }
     /**
-     * Write one approval deadline (settings card), or drop the persisted override
+     * Write the approval deadline (settings card), or drop the persisted override
      * with `reset` so the `cordis.patch.yml` baseline applies again.
      *
      * The host answer — the same route returns the deadlines now in force — is the
@@ -1290,8 +1341,17 @@ export class AcpStore {
      * merged with a value this browser did not know about) self-corrects instead
      * of drifting from what runs.
      */
-    async setApprovalDeadline(key, ms) {
-        await this.writeApprovalDeadlines({ [key]: ms });
+    async setApprovalDeadline(ms) {
+        await this.writeApprovalDeadlines({ permissionTimeoutMs: ms });
+    }
+    /**
+     * Write the mode: what an expired deadline DOES (`abort` refuses, `auto`
+     * answers with the option the agent's own kinds imply, `wait` never
+     * expires). Same write path as the window, so the host answer stays
+     * the authority.
+     */
+    async setApprovalTimeoutMode(mode) {
+        await this.writeApprovalDeadlines({ mode });
     }
     /** Drop the persisted override: the config file (or the built-in default) decides again. */
     async resetApprovalDeadlines() {
@@ -1299,15 +1359,15 @@ export class AcpStore {
     }
     async writeApprovalDeadlines(payload) {
         const previous = this.state.approvalDeadlines;
-        // Optimistic only where it is safe: the effective numbers move now, and the
-        // override facts (`configured`) stay as the host last reported them. A
-        // failure restores the whole view.
+        // Optimistic only where it is safe: the effective numbers and the mode move
+        // now, and the override facts (`configured`) stay as the host last reported
+        // them. A failure restores the whole view.
         if (previous !== undefined) {
             this.mutate({
                 approvalDeadlines: {
                     ...previous,
-                    ...(payload.nativeApprovalTimeoutMs === undefined ? {} : { nativeApprovalTimeoutMs: payload.nativeApprovalTimeoutMs }),
-                    ...(payload.permissionFallbackTimeoutMs === undefined ? {} : { permissionFallbackTimeoutMs: payload.permissionFallbackTimeoutMs }),
+                    ...(payload.permissionTimeoutMs === undefined ? {} : { permissionTimeoutMs: payload.permissionTimeoutMs }),
+                    ...(payload.mode === undefined ? {} : { mode: payload.mode }),
                 },
             });
         }
@@ -1581,16 +1641,22 @@ export class AcpStore {
                 return this.loadAgentCatalog(event.agentId);
             }
             case 'permission/request': {
-                const title = typeof event.toolCall?.title === 'string'
-                    ? String(event.toolCall.title)
-                    : this.locale('工具调用', 'tool call');
+                // Verbatim copy of the host's frame. The host decides what the ask is
+                // called (`toolName` / `reason`) and which options exist; deriving a
+                // title from `toolCall` here used to make the card say something the
+                // host never said.
+                const permission = {
+                    requestId: event.requestId,
+                    sessionId: event.sessionId,
+                    ...(event.dshSessionId === undefined ? {} : { dshSessionId: event.dshSessionId }),
+                    toolName: event.toolName,
+                    ...(event.reason === undefined ? {} : { reason: event.reason }),
+                    options: event.options,
+                    timeoutMode: event.timeoutMode,
+                    ...(event.deadlineAt === undefined ? {} : { deadlineAt: event.deadlineAt }),
+                };
                 this.mutate({
-                    permissions: [...this.state.permissions.filter(p => p.requestId !== event.requestId), {
-                            requestId: event.requestId,
-                            sessionId: event.sessionId,
-                            title,
-                            options: event.options,
-                        }],
+                    permissions: [...this.state.permissions.filter(p => p.requestId !== event.requestId), permission],
                 });
                 return Promise.resolve();
             }