@hunterzhu/pulse-cli 0.1.4 → 0.1.5

package/dist/components/SessionList.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { useState } from 'react';
+import { theme } from '../theme.js';
+import path from 'node:path';
+export function SessionList({ sessions, notice, onSelect, onDelete, onBack }) {
+    const [highlightedId, setHighlightedId] = useState(sessions[0]?.id ?? null);
+    const [pendingDelete, setPendingDelete] = useState(null);
+    useInput((input) => {
+        if (pendingDelete) {
+            if (input === 'd' && highlightedId === pendingDelete && onDelete) {
+                void Promise.resolve(onDelete(pendingDelete));
+                setPendingDelete(null);
+            }
+            else if (input === 'n' || input === 'q' || input === 'd') {
+                setPendingDelete(null);
+            }
+            return;
+        }
+        if (input === 'q') {
+            onBack();
+        }
+        else if (input === 'd' && highlightedId && onDelete) {
+            setPendingDelete(highlightedId);
+        }
+    });
+    const items = sessions.map(s => ({
+        label: `${s.title.length > 30 ? s.title.slice(0, 30) + '...' : s.title} (${s.updatedAt}) - ${path.basename(s.cwd)}`,
+        value: s.id
+    }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.primary, bold: true, children: "\u4F1A\u8BDD\u5217\u8868 (\u2191\u2193 \u9009\u62E9, Enter \u7EE7\u7EED, d \u5220\u9664, q \u8FD4\u56DE)" }) }), notice && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.error, children: notice }) })), pendingDelete && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.warning, children: "\u518D\u6309 d \u786E\u8BA4\u5220\u9664\uFF0C\u6309 n \u53D6\u6D88\u3002" }) })), items.length === 0 ? (_jsx(Text, { color: theme.dim, children: "\u6682\u65E0\u5386\u53F2\u4F1A\u8BDD\u3002\u6309 q \u8FD4\u56DE\u3002" })) : (_jsx(SelectInput, { items: items, onSelect: (item) => onSelect(item.value), onHighlight: (item) => setHighlightedId(item.value) }))] }));
+}

package/dist/components/Spinner.d.ts

@@ -0,0 +1,4 @@
+export interface SpinnerProps {
+    label?: string;
+}
+export declare function Spinner({ label }: SpinnerProps): import("react").JSX.Element;

package/dist/components/Spinner.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import InkSpinner from 'ink-spinner';
+import { theme } from '../theme.js';
+export function Spinner({ label }) {
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: theme.primary, children: _jsx(InkSpinner, { type: "dots" }) }), label && _jsx(Text, { color: theme.dim, children: label })] }));
+}

package/dist/components/ThinkingBlock.d.ts

@@ -0,0 +1,5 @@
+export interface ThinkingBlockProps {
+    content: string;
+    visible?: boolean;
+}
+export declare function ThinkingBlock({ content, visible }: ThinkingBlockProps): import("react").JSX.Element | null;

package/dist/components/ThinkingBlock.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+export function ThinkingBlock({ content, visible }) {
+    if (!visible)
+        return null;
+    return (_jsx(Box, { borderStyle: "single", borderLeft: true, borderTop: false, borderRight: false, borderBottom: false, borderColor: theme.thinking, paddingLeft: 1, marginY: 1, children: _jsx(Text, { color: theme.thinking, dimColor: true, children: content }) }));
+}

package/dist/components/TokenStats.d.ts

@@ -0,0 +1,7 @@
+export interface TokenStatsProps {
+    inputTokens: number;
+    outputTokens: number;
+    durationMs: number;
+    estimatedCost?: number | undefined;
+}
+export declare function TokenStats({ inputTokens, outputTokens, durationMs, estimatedCost }: TokenStatsProps): import("react").JSX.Element;

package/dist/components/TokenStats.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+import { formatDuration, formatTokenCount, formatCost } from '../utils/format.js';
+export function TokenStats({ inputTokens, outputTokens, durationMs, estimatedCost }) {
+    const duration = formatDuration(durationMs);
+    const totalTokens = formatTokenCount(inputTokens + outputTokens);
+    const inT = formatTokenCount(inputTokens);
+    const outT = formatTokenCount(outputTokens);
+    let text = `⏱ ${duration} · 📊 ${totalTokens} tokens (in: ${inT} · out: ${outT})`;
+    if (estimatedCost !== undefined) {
+        text += ` · 💰 ~${formatCost(estimatedCost)}`;
+    }
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.stats, dimColor: true, children: text }) }));
+}

package/dist/components/ToolCallCard.d.ts

@@ -0,0 +1,8 @@
+import type { ToolCallDisplay } from '../types.js';
+interface Props {
+    call: ToolCallDisplay;
+    expanded?: boolean;
+    onToggle?: () => void;
+}
+export declare function ToolCallCard({ call, expanded: defaultExpanded, onToggle }: Props): import("react").JSX.Element;
+export {};

package/dist/components/ToolCallCard.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useFocus, useInput } from 'ink';
+import { useState } from 'react';
+import { theme } from '../theme.js';
+export function ToolCallCard({ call, expanded: defaultExpanded = false, onToggle }) {
+    const [internalExpanded, setInternalExpanded] = useState(defaultExpanded);
+    const { isFocused } = useFocus({ autoFocus: false });
+    const isExpanded = onToggle ? defaultExpanded : internalExpanded;
+    useInput((input, key) => {
+        if (isFocused && (key.return || input === ' ')) {
+            if (onToggle) {
+                onToggle();
+            }
+            else {
+                setInternalExpanded(!isExpanded);
+            }
+        }
+    });
+    const getStatusIcon = () => {
+        switch (call.status) {
+            case 'running': return _jsx(Text, { color: theme.warning, children: "\u23F3" });
+            case 'succeeded': return _jsx(Text, { color: theme.success, children: "\u2713" });
+            case 'failed': return _jsx(Text, { color: theme.error, children: "\u2717" });
+            default: return _jsx(Text, { children: "?" });
+        }
+    };
+    const argsJson = call.arguments ? JSON.stringify(call.arguments, null, 2) : '{}';
+    const resultJson = call.result ? JSON.stringify(call.result) : '';
+    const resultSummary = resultJson.length > 500 ? resultJson.slice(0, 500) + '...' : resultJson;
+    return (_jsxs(Box, { borderStyle: "round", borderColor: isFocused ? theme.tool : theme.border, flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { children: "\uD83D\uDD27" }), _jsx(Text, { color: theme.tool, bold: true, children: call.name }), getStatusIcon(), call.durationMs && _jsxs(Text, { color: theme.dim, children: [call.durationMs, "ms"] })] }), isExpanded && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: theme.dim, children: "\u53C2\u6570:" }), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: theme.codeLang, children: argsJson }) }), call.result !== undefined && call.result !== null ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: theme.dim, children: "\u7ED3\u679C:" }), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: theme.codeLang, children: resultSummary }) })] })) : null] }))] }));
+}

package/dist/components/UserMessage.d.ts

@@ -0,0 +1,5 @@
+export interface UserMessageProps {
+    text: string;
+    timestamp?: string;
+}
+export declare function UserMessage({ text, timestamp }: UserMessageProps): import("react").JSX.Element;

package/dist/components/UserMessage.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+import { stripTerminalControls } from '../utils/ansi.js';
+export function UserMessage({ text, timestamp }) {
+    return (_jsxs(Box, { marginY: 1, gap: 1, children: [_jsx(Text, { color: theme.user, children: "\u203A" }), _jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: stripTerminalControls(text) }) }), timestamp && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: theme.dim, dimColor: true, children: timestamp }) }))] }));
+}

package/dist/components/Welcome.d.ts

@@ -0,0 +1,6 @@
+export interface WelcomeProps {
+    cwd: string;
+    model: string;
+    version: string;
+}
+export declare function Welcome({ cwd, model, version }: WelcomeProps): import("react").JSX.Element;

package/dist/components/Welcome.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+export function Welcome({ cwd, model, version }) {
+    return (_jsxs(Box, { borderStyle: "round", borderColor: theme.border, paddingX: 2, paddingY: 1, flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: theme.primary, bold: true, children: "Pulse" }), _jsxs(Text, { color: theme.dim, children: ["v", version] })] }), _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.dim, children: "Workspace: " }), _jsx(Text, { children: cwd })] }), _jsxs(Text, { children: [_jsx(Text, { color: theme.dim, children: "Model: " }), _jsx(Text, { children: model })] })] }), _jsx(Text, { color: theme.dim, children: "Type /help for commands." })] }));
+}

package/dist/hooks/useConversation.d.ts

@@ -0,0 +1,15 @@
+import type { LocalHost, ConversationHandle } from '@hunterzhu/pulse-server';
+import type { DisplayMessage } from '../types.js';
+export declare function useConversation({ host, conversationId, }: {
+    host: LocalHost | null;
+    conversationId?: string | undefined;
+}): {
+    conversation: ConversationHandle | null;
+    messages: DisplayMessage[];
+    error: string | null;
+    addUserMessage: (text: string) => void;
+    addAssistantMessage: (msg: DisplayMessage) => void;
+    clearMessages: () => void;
+    switchConversation: (id: string) => Promise<void>;
+    newConversation: () => Promise<void>;
+};

package/dist/hooks/useConversation.js

@@ -0,0 +1,115 @@
+import { useState, useEffect, useCallback } from 'react';
+export function useConversation({ host, conversationId, }) {
+    const [conversation, setConversation] = useState(null);
+    const [messages, setMessages] = useState([]);
+    const [error, setError] = useState(null);
+    const loadMessages = useCallback(async (convId) => {
+        if (!host)
+            return;
+        try {
+            const existing = await host.getConversationMessages(convId);
+            setMessages(existing.map((m) => ({
+                id: m.id,
+                role: m.role,
+                text: m.text,
+                createdAt: m.createdAt,
+                runId: m.runId,
+            })));
+            setError(null);
+        }
+        catch (e) {
+            setError(e instanceof Error ? e.message : String(e));
+        }
+    }, [host]);
+    useEffect(() => {
+        if (!host)
+            return;
+        const currentHost = host;
+        let mounted = true;
+        async function setupConversation() {
+            try {
+                if (conversationId) {
+                    const conv = await currentHost.getConversation(conversationId);
+                    if (mounted && conv) {
+                        setConversation(conv);
+                        await loadMessages(conversationId);
+                    }
+                }
+                else {
+                    const conv = await currentHost.createConversation();
+                    if (mounted && conv) {
+                        setConversation(conv);
+                        setMessages([]);
+                    }
+                }
+            }
+            catch (err) {
+                if (mounted)
+                    setError(err instanceof Error ? err.message : String(err));
+            }
+        }
+        setupConversation();
+        return () => {
+            mounted = false;
+        };
+    }, [host, conversationId, loadMessages]);
+    const addUserMessage = useCallback((text) => {
+        const newMessage = {
+            id: Date.now().toString(),
+            role: 'user',
+            text,
+            createdAt: new Date().toISOString(),
+        };
+        setMessages((prev) => [...prev, newMessage]);
+    }, []);
+    const addAssistantMessage = useCallback((msg) => {
+        setMessages((prev) => {
+            const index = prev.findIndex((m) => m.id === msg.id);
+            if (index >= 0) {
+                const next = [...prev];
+                next[index] = msg;
+                return next;
+            }
+            return [...prev, msg];
+        });
+    }, []);
+    const clearMessages = useCallback(() => setMessages([]), []);
+    const switchConversation = useCallback(async (id) => {
+        if (!host)
+            return;
+        try {
+            const conv = await host.getConversation(id);
+            if (conv) {
+                setConversation(conv);
+                await loadMessages(id);
+            }
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+        }
+    }, [host, loadMessages]);
+    const newConversation = useCallback(async () => {
+        if (!host)
+            return;
+        try {
+            const conv = await host.createConversation();
+            setConversation(conv);
+            setMessages([]);
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+        }
+    }, [host]);
+    return {
+        conversation,
+        messages,
+        error,
+        addUserMessage,
+        addAssistantMessage,
+        clearMessages,
+        switchConversation,
+        newConversation,
+    };
+}

package/dist/hooks/useHost.d.ts

@@ -0,0 +1,7 @@
+import { LocalHost, LocalHostOptions } from '@hunterzhu/pulse-server';
+export declare function closePendingHosts(): Promise<void>;
+export declare function useHost(options: LocalHostOptions): {
+    host: LocalHost | null;
+    error: string | null;
+    ready: boolean;
+};

package/dist/hooks/useHost.js

@@ -0,0 +1,44 @@
+import { useState, useEffect } from 'react';
+import { createLocalHost } from '@hunterzhu/pulse-server';
+const pendingHostCloses = [];
+export function closePendingHosts() {
+    const pending = pendingHostCloses.splice(0, pendingHostCloses.length);
+    return Promise.all(pending).then(() => undefined);
+}
+export function useHost(options) {
+    const [host, setHost] = useState(null);
+    const [error, setError] = useState(null);
+    const [ready, setReady] = useState(false);
+    useEffect(() => {
+        let isMounted = true;
+        let localHost = null;
+        async function initHost() {
+            try {
+                // 创建本地服务器实例
+                localHost = createLocalHost(options);
+                await localHost.init();
+                if (isMounted) {
+                    setHost(localHost);
+                    setReady(true);
+                }
+            }
+            catch (err) {
+                if (isMounted) {
+                    setError(err instanceof Error ? err.message : String(err));
+                }
+            }
+        }
+        initHost();
+        return () => {
+            isMounted = false;
+            if (localHost) {
+                const closing = localHost;
+                localHost = null;
+                pendingHostCloses.push(closing.close().catch((error) => {
+                    console.error(error);
+                }));
+            }
+        };
+    }, []); // 仅在组件挂载时初始化一次
+    return { host, error, ready };
+}

package/dist/hooks/useMultilineInput.d.ts

@@ -0,0 +1,11 @@
+export declare function useMultilineInput(): {
+    currentLine: string;
+    setCurrentLine: import("react").Dispatch<import("react").SetStateAction<string>>;
+    accumulatedLines: string[];
+    isContinuation: boolean;
+    handleSubmit: (line: string) => string | null;
+    history: string[];
+    historyIndex: number;
+    navigateHistory: (direction: "up" | "down") => string | undefined;
+    addToHistory: (text: string) => void;
+};

package/dist/hooks/useMultilineInput.js

@@ -0,0 +1,58 @@
+import { useState, useCallback } from 'react';
+export function useMultilineInput() {
+    const [currentLine, setCurrentLine] = useState('');
+    const [accumulatedLines, setAccumulatedLines] = useState([]);
+    const [history, setHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const isContinuation = currentLine.endsWith('\\');
+    const handleSubmit = useCallback((line) => {
+        const trimmedLine = line.trimEnd();
+        // 如果以反斜杠结尾，视为多行输入的续行
+        if (trimmedLine.endsWith('\\')) {
+            const newLine = trimmedLine.slice(0, -1);
+            setAccumulatedLines(prev => [...prev, newLine]);
+            setCurrentLine('');
+            return null;
+        }
+        // 否则结束多行输入
+        const finalLines = [...accumulatedLines, line];
+        const fullText = finalLines.join('\n');
+        setAccumulatedLines([]);
+        setCurrentLine('');
+        return fullText;
+    }, [accumulatedLines]);
+    const addToHistory = useCallback((text) => {
+        if (!text.trim())
+            return;
+        setHistory(prev => {
+            // 保持最多 50 条历史记录
+            const next = [text, ...prev.filter(h => h !== text)].slice(0, 50);
+            return next;
+        });
+        setHistoryIndex(-1);
+    }, []);
+    const navigateHistory = useCallback((direction) => {
+        if (history.length === 0)
+            return undefined;
+        let nextIndex = historyIndex;
+        if (direction === 'up') {
+            nextIndex = Math.min(historyIndex + 1, history.length - 1);
+        }
+        else {
+            nextIndex = Math.max(historyIndex - 1, -1);
+        }
+        setHistoryIndex(nextIndex);
+        return nextIndex === -1 ? '' : history[nextIndex];
+    }, [history, historyIndex]);
+    return {
+        currentLine,
+        setCurrentLine,
+        accumulatedLines,
+        isContinuation,
+        handleSubmit,
+        history,
+        historyIndex,
+        navigateHistory,
+        addToHistory
+    };
+}

package/dist/hooks/useRun.d.ts

@@ -0,0 +1,16 @@
+import type { LocalHost } from '@hunterzhu/pulse-server';
+import type { ApprovalRequest, DisplayMessage } from '../types.js';
+export declare function useRun({ host, conversationId, addAssistantMessage, }: {
+    host: LocalHost | null;
+    conversationId: string | null;
+    addAssistantMessage: (msg: DisplayMessage) => void;
+}): {
+    isRunning: boolean;
+    currentStep: string | null;
+    error: string | null;
+    approvalRequest: ApprovalRequest | null;
+    sendMessage: (text: string) => Promise<void>;
+    resumeActive: () => Promise<void>;
+    approveAction: (effectId: string, approved: boolean, reason?: string) => Promise<void>;
+    cancelRun: () => Promise<void>;
+};

package/dist/hooks/useRun.js

@@ -0,0 +1,176 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+function toolStatus(value) {
+    if (value === 'succeeded' || value === 'failed' || value === 'running')
+        return value;
+    return 'running';
+}
+export function useRun({ host, conversationId, addAssistantMessage, }) {
+    const [isRunning, setIsRunning] = useState(false);
+    const [currentStep, setCurrentStep] = useState(null);
+    const [error, setError] = useState(null);
+    const [approvalRequest, setApprovalRequest] = useState(null);
+    const runRef = useRef(null);
+    const consumeRun = useCallback(async (run) => {
+        runRef.current = run;
+        const assistantMessage = {
+            id: run.id,
+            role: 'assistant',
+            text: '',
+            createdAt: new Date().toISOString(),
+            toolCalls: [],
+            runId: run.id,
+        };
+        addAssistantMessage({ ...assistantMessage, toolCalls: [] });
+        for await (const event of run.events) {
+            switch (event.type) {
+                case 'text':
+                    assistantMessage.text += String(event.data ?? '');
+                    addAssistantMessage({ ...assistantMessage, toolCalls: assistantMessage.toolCalls?.map((call) => ({ ...call })) });
+                    break;
+                case 'observation': {
+                    const obs = event.data;
+                    if (obs && typeof obs === 'object' && typeof obs.tool === 'string') {
+                        const id = String(obs.toolCallId ?? obs.tool);
+                        const nextCall = {
+                            id,
+                            name: obs.tool,
+                            arguments: obs.args && typeof obs.args === 'object' && !Array.isArray(obs.args)
+                                ? obs.args
+                                : {},
+                            status: toolStatus(obs.status),
+                            ...(obs.result === undefined ? {} : { result: obs.result }),
+                        };
+                        const calls = assistantMessage.toolCalls ?? [];
+                        const index = calls.findIndex((call) => call.id === id);
+                        assistantMessage.toolCalls = index >= 0
+                            ? calls.map((call, callIndex) => callIndex === index ? { ...call, ...nextCall } : call)
+                            : [...calls, nextCall];
+                        addAssistantMessage({ ...assistantMessage, toolCalls: assistantMessage.toolCalls.map((call) => ({ ...call })) });
+                    }
+                    break;
+                }
+                case 'waiting': {
+                    const payload = event.data && typeof event.data === 'object' && !Array.isArray(event.data)
+                        ? event.data
+                        : {};
+                    const effectId = typeof payload.effectId === 'string' ? payload.effectId : '';
+                    const input = payload.input && typeof payload.input === 'object' && !Array.isArray(payload.input)
+                        ? payload.input
+                        : {};
+                    const tools = Array.isArray(input.tools)
+                        ? input.tools.flatMap((tool) => {
+                            if (!tool || typeof tool !== 'object' || Array.isArray(tool))
+                                return [];
+                            const item = tool;
+                            return [{
+                                    name: String(item.toolName ?? item.name ?? '系统操作'),
+                                    ...(typeof item.toolCallId === 'string' ? { toolCallId: item.toolCallId } : {}),
+                                    input: item.input && typeof item.input === 'object' && !Array.isArray(item.input)
+                                        ? item.input
+                                        : {},
+                                }];
+                        })
+                        : [];
+                    const firstTool = tools[0];
+                    setApprovalRequest({
+                        effectId,
+                        toolName: tools.length === 1 ? firstTool.name : `${tools.length || 1} 个系统操作`,
+                        toolArgs: firstTool?.input ?? {},
+                        prompt: typeof input.prompt === 'string' ? input.prompt : '是否批准执行？',
+                        ...(typeof input.digest === 'string' ? { digest: input.digest } : {}),
+                        ...(tools.length ? { tools } : {}),
+                    });
+                    setCurrentStep('等待用户审批...');
+                    break;
+                }
+                case 'fact':
+                    if (typeof event.data === 'string') {
+                        setCurrentStep(event.data);
+                    }
+                    else if (event.data && typeof event.data === 'object') {
+                        setCurrentStep('正在执行...');
+                    }
+                    break;
+                case 'error':
+                    setError(String(event.data ?? '发生未知错误'));
+                    setIsRunning(false);
+                    setCurrentStep(null);
+                    setApprovalRequest(null);
+                    break;
+                case 'complete':
+                    setIsRunning(false);
+                    setCurrentStep(null);
+                    break;
+            }
+        }
+    }, [addAssistantMessage]);
+    const finishRun = useCallback(() => {
+        setIsRunning(false);
+        setCurrentStep(null);
+        setApprovalRequest(null);
+        runRef.current = null;
+    }, []);
+    const sendMessage = useCallback(async (text) => {
+        if (!host || !conversationId || runRef.current)
+            return;
+        setIsRunning(true);
+        setError(null);
+        setCurrentStep('思考中...');
+        try {
+            const run = await host.sendMessage(conversationId, { text });
+            await consumeRun(run);
+        }
+        catch (e) {
+            setError(e instanceof Error ? e.message : String(e));
+        }
+        finally {
+            finishRun();
+        }
+    }, [host, conversationId, consumeRun, finishRun]);
+    const resumeActive = useCallback(async () => {
+        if (!host || !conversationId || runRef.current)
+            return;
+        setIsRunning(true);
+        setError(null);
+        setCurrentStep('正在恢复未完成的运行...');
+        try {
+            const run = await host.resumeRun(conversationId);
+            await consumeRun(run);
+        }
+        catch (e) {
+            setError(e instanceof Error ? e.message : String(e));
+        }
+        finally {
+            finishRun();
+        }
+    }, [host, conversationId, consumeRun, finishRun]);
+    useEffect(() => () => {
+        const run = runRef.current;
+        if (run)
+            void run.cancel('USER_INTERRUPT');
+    }, []);
+    const approveAction = useCallback(async (effectId, approved, reason) => {
+        if (!effectId || !runRef.current)
+            return;
+        await runRef.current.reply(effectId, { approved, ...(approved ? {} : { reason: reason || '拒绝执行' }) });
+        setApprovalRequest(null);
+        setCurrentStep('审批已提交，正在继续...');
+    }, []);
+    const cancelRun = useCallback(async () => {
+        if (runRef.current) {
+            await runRef.current.cancel('USER_CANCELLED');
+            setIsRunning(false);
+            setCurrentStep('已取消');
+        }
+    }, []);
+    return {
+        isRunning,
+        currentStep,
+        error,
+        approvalRequest,
+        sendMessage,
+        resumeActive,
+        approveAction,
+        cancelRun,
+    };
+}

package/dist/hooks/useSlashCommands.d.ts

@@ -0,0 +1,25 @@
+import type { SlashCommand } from '../types.js';
+export interface SlashCommandDependencies {
+    onHelp?: () => void | Promise<void>;
+    onStatus?: () => void | Promise<void>;
+    onTools?: () => void | Promise<void>;
+    onArtifacts?: () => void | Promise<void>;
+    onExit?: () => void | Promise<void>;
+    onQuit?: () => void | Promise<void>;
+    onNew?: () => void | Promise<void>;
+    onSessions?: () => void | Promise<void>;
+    onDelete?: (args: string) => void | Promise<void>;
+    onExport?: (args: string) => void | Promise<void>;
+    onClear?: () => void | Promise<void>;
+    onConfig?: () => void | Promise<void>;
+    onModel?: (args: string) => void | Promise<void>;
+    onCompact?: () => void | Promise<void>;
+    onVerbose?: () => void | Promise<void>;
+    onQuiet?: () => void | Promise<void>;
+    onThinking?: (args: string) => void | Promise<void>;
+}
+export declare function useSlashCommands(deps: SlashCommandDependencies): {
+    commands: SlashCommand[];
+    isSlashCommand: (input: string) => boolean;
+    executeCommand: (input: string) => Promise<boolean>;
+};