@lcap/wave-sandbox-sdk 0.0.1

package/dist/modules/agent.js

@@ -0,0 +1,251 @@
+import { createSocketHandler, onSocketEvent } from '../utils/socket.js';
+/**
+ * Agent 模块
+ */
+export class AgentModule {
+    constructor(socket, baseUrl, projectId) {
+        this.socket = socket;
+        this.baseUrl = baseUrl;
+        this.projectId = projectId;
+    }
+    /**
+     * 获取查询参数
+     */
+    getQueryParams() {
+        if (this.projectId) {
+            return `projectId=${encodeURIComponent(this.projectId)}`;
+        }
+        return '';
+    }
+    /**
+     * 发送消息
+     * @param options 发送消息选项
+     * @returns Promise<string> 返回 assistantMessageId
+     */
+    async sendMessage(options) {
+        const result = await createSocketHandler(this.socket, 'agent:sendMessage', () => options);
+        return result.assistantMessageId;
+    }
+    /**
+     * 中止消息
+     * @param messageId 消息 ID
+     */
+    async abortMessage(messageId) {
+        return createSocketHandler(this.socket, 'agent:abortMessage', () => ({
+            messageId,
+        }));
+    }
+    /**
+     * 删除 session，包括日志记录和 agent 对象
+     * @param sessionId 会话 ID
+     * @throws 如果当前正在处理该 session 的消息，则抛出错误
+     */
+    async removeSession(sessionId) {
+        return createSocketHandler(this.socket, 'agent:removeSession', () => ({
+            sessionId,
+        }));
+    }
+    /**
+     * 获取指定 session 的消息日志文件列表
+     * @param sessionId 会话 ID
+     * @returns Promise<string[] | null> 返回文件列表（倒序，最新的在前），如果没有文件则返回 null
+     */
+    async getSessionFiles(sessionId) {
+        const result = await createSocketHandler(this.socket, 'agent:getSessionFiles', () => ({ sessionId }));
+        return result ? result.files : null;
+    }
+    /**
+     * 获取当前 wave-agent 的完整状态
+     * @returns Promise<MessageQueueChangedEvent | null> 返回当前状态，如果没有活动状态则返回 null
+     */
+    async getCurrentState() {
+        const queryParams = this.getQueryParams();
+        const url = `${this.baseUrl}/api/agent/currentState${queryParams ? `?${queryParams}` : ''}`;
+        const response = await fetch(url);
+        const result = await response.json();
+        if (result.status === 'error') {
+            throw new Error(result.message);
+        }
+        return result.data;
+    }
+    /**
+     * 监听消息发送事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageSend(callback) {
+        return onSocketEvent(this.socket, 'agent:message-send', callback);
+    }
+    /**
+     * 监听消息运行事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageRunning(callback) {
+        return onSocketEvent(this.socket, 'agent:message-running', callback);
+    }
+    /**
+     * 监听消息完成事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageFinished(callback) {
+        return onSocketEvent(this.socket, 'agent:message-finished', callback);
+    }
+    /**
+     * 监听消息队列变化事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageQueueChanged(callback) {
+        return onSocketEvent(this.socket, 'agent:message-queue-changed', callback);
+    }
+    /**
+     * 监听初始化事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onInitializing(callback) {
+        return onSocketEvent(this.socket, 'agent:initializing', callback);
+    }
+    /**
+     * 监听初始化完成事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onInitialized(callback) {
+        return onSocketEvent(this.socket, 'agent:initialized', callback);
+    }
+    /**
+     * 监听消息块添加事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageBlockAdded(callback) {
+        return onSocketEvent(this.socket, 'agent:message-block-added', callback);
+    }
+    /**
+     * 监听消息块更新事件（用于流式内容更新）
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageBlockUpdated(callback) {
+        return onSocketEvent(this.socket, 'agent:message-block-updated', callback);
+    }
+    /**
+     * 监听工具块更新事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageToolBlockUpdated(callback) {
+        return onSocketEvent(this.socket, 'agent:message-tool-block-updated', callback);
+    }
+    /**
+     * 监听子代理块添加事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageSubagentBlockAdd(callback) {
+        return onSocketEvent(this.socket, 'agent:message-subagent-block-add', callback);
+    }
+    /**
+     * 监听子代理块状态更新事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageSubagentBlockStatusUpdated(callback) {
+        return onSocketEvent(this.socket, 'agent:message-subagent-block-status-updated', callback);
+    }
+    /**
+     * 监听子代理块内容更新事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageSubagentBlockContentUpdated(callback) {
+        return onSocketEvent(this.socket, 'agent:message-subagent-block-content-updated', callback);
+    }
+    /**
+     * 监听子代理工具块更新事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageSubagentToolBlockUpdated(callback) {
+        return onSocketEvent(this.socket, 'agent:message-subagent-tool-block-updated', callback);
+    }
+    /**
+     * 监听错误块添加事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageErrorBlockAdded(callback) {
+        return onSocketEvent(this.socket, 'agent:message-error-block-added', callback);
+    }
+    /**
+     * 监听命令输出消息添加事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageCommandOutputMessageAdded(callback) {
+        return onSocketEvent(this.socket, 'agent:message-command-output-message-added', callback);
+    }
+    /**
+     * 监听命令输出消息更新事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageCommandOutputMessageUpdated(callback) {
+        return onSocketEvent(this.socket, 'agent:message-command-output-message-updated', callback);
+    }
+    /**
+     * 监听命令输出消息完成事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMessageCommandOutputMessageCompleted(callback) {
+        return onSocketEvent(this.socket, 'agent:message-command-output-message-completed', callback);
+    }
+    /**
+     * 监听 MCP 服务器变化事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onMcpServersChange(callback) {
+        return onSocketEvent(this.socket, 'agent:mcp-servers-change', callback);
+    }
+    /**
+     * 监听文档解析开始事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onDocumentParseStart(callback) {
+        return onSocketEvent(this.socket, 'agent:document-parse-start', callback);
+    }
+    /**
+     * 监听文档解析完成事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onDocumentParseComplete(callback) {
+        return onSocketEvent(this.socket, 'agent:document-parse-complete', callback);
+    }
+    /**
+     * 监听文档解析错误事件
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    onDocumentParseError(callback) {
+        return onSocketEvent(this.socket, 'agent:document-parse-error', callback);
+    }
+    /**
+     * 通用事件监听方法，用于监听自定义事件
+     * @param eventName 事件名称（必须以 'agent:' 开头）
+     * @param callback 回调函数
+     * @returns 取消监听的函数
+     */
+    on(eventName, callback) {
+        if (!eventName.startsWith('agent:')) {
+            throw new Error(`事件名称必须以 'agent:' 开头，当前事件名称: ${eventName}`);
+        }
+        return onSocketEvent(this.socket, eventName, callback);
+    }
+}

package/dist/modules/exec.d.ts

@@ -0,0 +1,27 @@
+import type { Socket } from 'socket.io-client';
+/**
+ * 命令执行模块
+ */
+export declare class ExecModule {
+    private socket;
+    constructor(socket: Socket);
+    /**
+     * 执行命令
+     * @param sessionId 会话 ID
+     * @param command 要执行的命令
+     * @returns Promise<number> 命令退出码
+     */
+    exec(sessionId: string, command: string): Promise<number>;
+    /**
+     * 中止命令执行
+     * @param sessionId 会话 ID
+     */
+    abort(sessionId: string): Promise<void>;
+    /**
+     * 监听命令输出
+     * @param sessionId 会话 ID
+     * @param callback 输出回调函数，接收 Uint8Array 数据（浏览器环境）
+     * @returns 取消监听的函数
+     */
+    onOutput(sessionId: string, callback: (data: Uint8Array) => void): () => void;
+}

package/dist/modules/exec.js

@@ -0,0 +1,35 @@
+import { createSocketHandler, onSocketEvent } from '../utils/socket.js';
+/**
+ * 命令执行模块
+ */
+export class ExecModule {
+    constructor(socket) {
+        this.socket = socket;
+    }
+    /**
+     * 执行命令
+     * @param sessionId 会话 ID
+     * @param command 要执行的命令
+     * @returns Promise<number> 命令退出码
+     */
+    async exec(sessionId, command) {
+        return createSocketHandler(this.socket, 'cmd:exec', () => ({ sessionId, command }));
+    }
+    /**
+     * 中止命令执行
+     * @param sessionId 会话 ID
+     */
+    async abort(sessionId) {
+        return createSocketHandler(this.socket, 'cmd:abort', () => ({ sessionId }));
+    }
+    /**
+     * 监听命令输出
+     * @param sessionId 会话 ID
+     * @param callback 输出回调函数，接收 Uint8Array 数据（浏览器环境）
+     * @returns 取消监听的函数
+     */
+    onOutput(sessionId, callback) {
+        const eventName = `cmd:exec-output-${sessionId}`;
+        return onSocketEvent(this.socket, eventName, callback);
+    }
+}

package/dist/modules/file-system.d.ts

@@ -0,0 +1,64 @@
+import type { Socket } from 'socket.io-client';
+import type { FileStat, DirectoryItem, FileChangeEvent } from '../types/index.js';
+/**
+ * 文件系统模块
+ */
+export declare class FileSystemModule {
+    private socket;
+    private baseUrl;
+    private projectId?;
+    constructor(socket: Socket, baseUrl: string, projectId?: string | undefined);
+    /**
+     * 获取查询参数
+     */
+    private getQueryParams;
+    /**
+     * 获取文件状态
+     */
+    stat(filePath: string): Promise<FileStat>;
+    /**
+     * 读取文件
+     * @param filePath 文件路径
+     * @param asText 是否以文本形式读取，默认 false（返回 Blob）
+     * @returns Promise<string | Blob> 文件内容
+     */
+    read(filePath: string, asText: false): Promise<Blob>;
+    read(filePath: string, asText: true): Promise<string>;
+    /**
+     * 读取文件内容（文本形式）
+     * @param filePath 文件路径
+     * @returns Promise<string> 文件文本内容
+     */
+    readFile(filePath: string): Promise<string>;
+    /**
+     * 读取目录
+     */
+    readdir(filePath: string): Promise<DirectoryItem[]>;
+    /**
+     * 写入文件（流式）
+     * @param filePath 文件路径
+     * @param data 文件数据（可以是字符串、Blob、ArrayBuffer 或 Buffer）
+     * @param chunkSize 分块大小（字节），默认 64KB
+     */
+    writeFile(filePath: string, data: string | Blob | ArrayBuffer | Uint8Array, chunkSize?: number): Promise<void>;
+    /**
+     * 创建目录
+     */
+    mkdir(filePath: string): Promise<string | undefined>;
+    /**
+     * 重命名文件或目录
+     */
+    rename(oldPath: string, newPath: string): Promise<void>;
+    /**
+     * 删除文件或目录
+     */
+    rm(filePath: string): Promise<void>;
+    /**
+     * 监听文件变化
+     * @param paths 要监听的文件路径数组
+     * @param ignored 要忽略的文件路径数组
+     * @param callback 文件变化回调函数
+     * @returns 取消监听的函数
+     */
+    watch(paths: string[], ignored: string[] | undefined, callback: (event: FileChangeEvent) => void): () => void;
+}

package/dist/modules/file-system.js

@@ -0,0 +1,172 @@
+import { createSocketHandler, onSocketEvent } from '../utils/socket.js';
+/**
+ * 文件系统模块
+ */
+export class FileSystemModule {
+    constructor(socket, baseUrl, projectId) {
+        this.socket = socket;
+        this.baseUrl = baseUrl;
+        this.projectId = projectId;
+    }
+    /**
+     * 获取查询参数
+     */
+    getQueryParams(filePath) {
+        const params = new URLSearchParams({ filePath });
+        if (this.projectId) {
+            params.set('projectId', this.projectId);
+        }
+        return params.toString();
+    }
+    /**
+     * 获取文件状态
+     */
+    async stat(filePath) {
+        const url = `${this.baseUrl}/api/fs/stat?${this.getQueryParams(filePath)}`;
+        const response = await fetch(url);
+        const result = await response.json();
+        if (result.status === 'error') {
+            throw new Error(result.message);
+        }
+        return result.data;
+    }
+    async read(filePath, asText = false) {
+        if (asText) {
+            // 使用 readFile 端点获取文本内容
+            const url = `${this.baseUrl}/api/fs/readFile?${this.getQueryParams(filePath)}`;
+            const response = await fetch(url);
+            const result = await response.json();
+            if (result.status === 'error') {
+                throw new Error(result.message);
+            }
+            return result.data;
+        }
+        else {
+            // 使用 read 端点获取原始文件（支持二进制）
+            const url = `${this.baseUrl}/api/fs/read?${this.getQueryParams(filePath)}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to read file: ${response.statusText}`);
+            }
+            return response.blob();
+        }
+    }
+    /**
+     * 读取文件内容（文本形式）
+     * @param filePath 文件路径
+     * @returns Promise<string> 文件文本内容
+     */
+    async readFile(filePath) {
+        return this.read(filePath, true);
+    }
+    /**
+     * 读取目录
+     */
+    async readdir(filePath) {
+        const url = `${this.baseUrl}/api/fs/readdir?${this.getQueryParams(filePath)}`;
+        const response = await fetch(url);
+        const result = await response.json();
+        if (result.status === 'error') {
+            throw new Error(result.message);
+        }
+        return result.data;
+    }
+    /**
+     * 写入文件（流式）
+     * @param filePath 文件路径
+     * @param data 文件数据（可以是字符串、Blob、ArrayBuffer 或 Buffer）
+     * @param chunkSize 分块大小（字节），默认 64KB
+     */
+    async writeFile(filePath, data, chunkSize = 64 * 1024) {
+        // 开始写入
+        const { taskId } = await createSocketHandler(this.socket, 'fs:writeFileStart', () => ({ filePath }));
+        try {
+            // 将数据转换为 Uint8Array
+            let buffer;
+            if (typeof data === 'string') {
+                buffer = new TextEncoder().encode(data);
+            }
+            else if (data instanceof Blob) {
+                const arrayBuffer = await data.arrayBuffer();
+                buffer = new Uint8Array(arrayBuffer);
+            }
+            else if (data instanceof ArrayBuffer) {
+                buffer = new Uint8Array(data);
+            }
+            else {
+                buffer = data;
+            }
+            // 分块发送数据
+            for (let i = 0; i < buffer.length; i += chunkSize) {
+                const chunk = buffer.slice(i, i + chunkSize);
+                // 将 Uint8Array 转换为 ArrayBuffer，Socket.IO 会自动处理
+                await createSocketHandler(this.socket, 'fs:writeFileChunk', () => ({ taskId, chunk }));
+            }
+            // 结束写入
+            await createSocketHandler(this.socket, 'fs:writeFileEnd', () => ({ taskId }));
+        }
+        catch (error) {
+            // 如果出错，尝试结束写入以清理资源
+            try {
+                await createSocketHandler(this.socket, 'fs:writeFileEnd', () => ({ taskId }));
+            }
+            catch {
+                // 忽略清理错误
+            }
+            throw error;
+        }
+    }
+    /**
+     * 创建目录
+     */
+    async mkdir(filePath) {
+        return createSocketHandler(this.socket, 'fs:mkdir', () => ({ filePath }));
+    }
+    /**
+     * 重命名文件或目录
+     */
+    async rename(oldPath, newPath) {
+        return createSocketHandler(this.socket, 'fs:rename', () => ({
+            oldPath,
+            newPath,
+        }));
+    }
+    /**
+     * 删除文件或目录
+     */
+    async rm(filePath) {
+        return createSocketHandler(this.socket, 'fs:rm', () => ({ filePath }));
+    }
+    /**
+     * 监听文件变化
+     * @param paths 要监听的文件路径数组
+     * @param ignored 要忽略的文件路径数组
+     * @param callback 文件变化回调函数
+     * @returns 取消监听的函数
+     */
+    watch(paths, ignored = [], callback) {
+        let taskId = null;
+        // 启动监听
+        createSocketHandler(this.socket, 'fs:watch', () => ({
+            paths,
+            ignored,
+        }))
+            .then((result) => {
+            taskId = result.taskId;
+            // 监听文件变化事件
+            const eventName = `fs:file-change:${taskId}`;
+            onSocketEvent(this.socket, eventName, callback);
+        })
+            .catch((error) => {
+            console.error('Failed to start file watch:', error);
+        });
+        // 返回取消监听的函数
+        return () => {
+            if (taskId) {
+                createSocketHandler(this.socket, 'fs:unwatch', () => ({ taskId: taskId })).catch((error) => {
+                    console.error('Failed to stop file watch:', error);
+                });
+            }
+        };
+    }
+}

package/dist/modules/port.d.ts

@@ -0,0 +1,30 @@
+import type { Socket } from 'socket.io-client';
+import type { PortStatusChangedEvent } from '../types/index.js';
+/**
+ * 端口监听模块
+ */
+export declare class PortModule {
+    private socket;
+    constructor(socket: Socket);
+    /**
+     * 获取可用端口
+     * @param count 需要获取的端口数量，默认 2
+     * @returns Promise<number[]> 可用端口数组
+     */
+    getPorts(count?: number): Promise<number[]>;
+    /**
+     * 开始监听端口状态
+     * @param ports 要监听的端口数组
+     */
+    startWatch(ports: number[]): Promise<void>;
+    /**
+     * 停止监听端口状态
+     */
+    stopWatch(): Promise<void>;
+    /**
+     * 监听端口状态变化
+     * @param callback 端口状态变化回调函数
+     * @returns 取消监听的函数
+     */
+    onStatusChanged(callback: (event: PortStatusChangedEvent) => void): () => void;
+}

package/dist/modules/port.js

@@ -0,0 +1,41 @@
+import { createSocketHandler, onSocketEvent } from '../utils/socket.js';
+/**
+ * 端口监听模块
+ */
+export class PortModule {
+    constructor(socket) {
+        this.socket = socket;
+    }
+    /**
+     * 获取可用端口
+     * @param count 需要获取的端口数量，默认 2
+     * @returns Promise<number[]> 可用端口数组
+     */
+    async getPorts(count = 2) {
+        const result = await createSocketHandler(this.socket, 'port:find', () => ({
+            count,
+        }));
+        return result.ports;
+    }
+    /**
+     * 开始监听端口状态
+     * @param ports 要监听的端口数组
+     */
+    async startWatch(ports) {
+        return createSocketHandler(this.socket, 'port:watch', () => ({ ports }));
+    }
+    /**
+     * 停止监听端口状态
+     */
+    async stopWatch() {
+        return createSocketHandler(this.socket, 'port:unwatch', () => undefined);
+    }
+    /**
+     * 监听端口状态变化
+     * @param callback 端口状态变化回调函数
+     * @returns 取消监听的函数
+     */
+    onStatusChanged(callback) {
+        return onSocketEvent(this.socket, 'portStatusChanged', callback);
+    }
+}

package/dist/modules/project.d.ts

@@ -0,0 +1,37 @@
+import type { Socket } from 'socket.io-client';
+import type { ProjectInfo, ProjectFile, FileChangeEvent } from '../types/index.js';
+/**
+ * 项目模块
+ */
+export declare class ProjectModule {
+    private socket;
+    private baseUrl;
+    private projectId?;
+    constructor(socket: Socket, baseUrl: string, projectId?: string | undefined);
+    /**
+     * 获取查询参数
+     */
+    private getQueryParams;
+    /**
+     * 获取项目信息
+     */
+    getInfo(): Promise<ProjectInfo>;
+    /**
+     * 获取项目文件列表
+     */
+    getFiles(): Promise<ProjectFile[]>;
+    /**
+     * 开始监听项目变化
+     */
+    watch(): Promise<void>;
+    /**
+     * 停止监听项目变化
+     */
+    unwatch(): Promise<void>;
+    /**
+     * 监听项目文件变化
+     * @param callback 文件变化回调函数
+     * @returns 取消监听的函数
+     */
+    onFileChange(callback: (event: FileChangeEvent) => void): () => void;
+}