@cjwddz/mirror 0.0.18-alpha → 1.2.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC"}

package/dist/index.js

@@ -1,11 +1,7 @@
 /**
- * Mirror 包入口
+ * Mirror 包入口 - HTTP 隧道工具
  */
-export * from './core/protocol.js';
-export * from './core/state-machine.js';
-export * from './core/workspace.js';
-export * from './core/process-manager.js';
-export * from './core/file-sync.js';
-export * from './transport/websocket.js';
-export * from './transport/pty.js';
+export * from './core/http-tunnel-protocol.js';
+export * from './core/http-tunnel-server.js';
+export * from './core/http-tunnel-client.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC"}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cjwddz/mirror",
-  "version": "0.0.18-alpha",
+  "version": "1.2.0",
   "type": "module",
-  "description": "开发态远程工作空间镜像工具",
+  "description": "HTTP 隧道工具 - 将本地服务暴露到公网",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
@@ -18,23 +18,25 @@
   },
   "keywords": [
     "mirror",
-    "remote",
-    "workspace",
-    "development"
+    "tunnel",
+    "http",
+    "websocket",
+    "localhost",
+    "expose"
   ],
   "author": "",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LeeLejia/npm-packages-hub.git",
+    "directory": "packages/mirror"
+  },
   "dependencies": {
-    "chokidar": "^3.6.0",
     "commander": "^12.0.0",
-    "ink": "^6.6.0",
-    "node-pty": "^1.0.0",
-    "react": "^19.2.4",
     "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "@types/react": "^19.2.11",
     "@types/ws": "^8.5.13",
     "@typescript-eslint/eslint-plugin": "^6.0.0",
     "@typescript-eslint/parser": "^6.0.0",

package/dist/cli/host-impl.d.ts

@@ -1,58 +0,0 @@
-/**
- * Host 实现类
- */
-interface HostOptions {
-    port: number;
-    workspaceDir: string;
-    token?: string;
-    metadataDir?: string;
-}
-export declare class Host {
-    private transport;
-    private stateMachine;
-    private workspace;
-    private processManager;
-    private currentClientId;
-    private currentClientWorkspacePath;
-    private sessionToken;
-    private options;
-    private snapshotFiles;
-    private isSnapshotInProgress;
-    private serverVersion;
-    private hasProgressLine;
-    private isCommandRunning;
-    constructor(options: HostOptions, serverVersion: string);
-    private generateToken;
-    /**
-     * 辅助日志方法：在输出日志前清除进度条
-     */
-    private log;
-    /**
-     * 辅助错误日志方法：在输出错误日志前清除进度条
-     */
-    private logError;
-    start(): Promise<void>;
-    private getHostname;
-    private handleConnection;
-    private handleMessage;
-    private handleHello;
-    private handleSnapshotStart;
-    private fileCount;
-    private snapshotFileCount;
-    private incrementalSyncCount;
-    private receivedFileCount;
-    private writtenFileCount;
-    private skippedFileCount;
-    private pendingFileDiffs;
-    private handleFile;
-    private handleSnapshotEnd;
-    private handleFileDiff;
-    private handleExec;
-    private handleExecSignal;
-    private sendError;
-    private cleanup;
-    private disconnect;
-    stop(): Promise<void>;
-}
-export {};
-//# sourceMappingURL=host-impl.d.ts.map

package/dist/cli/host-impl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"host-impl.d.ts","sourceRoot":"","sources":["../../src/cli/host-impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAqBH,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,IAAI;IACf,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,0BAA0B,CAAuB;IACzD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,aAAa,CAA6D;IAClF,OAAO,CAAC,oBAAoB,CAAkB;IAC9C,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,gBAAgB,CAAkB;gBAE9B,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM;IAUvD,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,GAAG;IASX;;OAEG;IACH,OAAO,CAAC,QAAQ;IAaV,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB5B,OAAO,CAAC,WAAW;YAoBL,gBAAgB;YA8DhB,aAAa;YA4Bb,WAAW;YAqDX,mBAAmB;IAsCjC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,gBAAgB,CAA0B;YAEpC,UAAU;YAuDV,iBAAiB;YA2HjB,cAAc;YAiEd,UAAU;YAoEV,gBAAgB;IAmB9B,OAAO,CAAC,SAAS;YAUH,OAAO;YA0BP,UAAU;IAuBlB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAI5B"}

package/dist/cli/host-impl.js

@@ -1,547 +0,0 @@
-/**
- * Host 实现类
- */
-import { randomBytes } from 'crypto';
-import { networkInterfaces } from 'os';
-import { WebSocketTransport } from '../transport/websocket.js';
-import { StateMachine, HostState } from '../core/state-machine.js';
-import { Workspace } from '../core/workspace.js';
-import { ProcessManager } from '../core/process-manager.js';
-import { computeHash, decompressContent } from '../core/file-sync.js';
-export class Host {
-    transport;
-    stateMachine;
-    workspace = null;
-    processManager;
-    currentClientId = null;
-    currentClientWorkspacePath = null;
-    sessionToken;
-    options;
-    snapshotFiles = new Map();
-    isSnapshotInProgress = false;
-    serverVersion;
-    hasProgressLine = false; // 标记是否有进度条在显示
-    isCommandRunning = false; // 独立的命令执行标志位
-    constructor(options, serverVersion) {
-        this.transport = new WebSocketTransport();
-        this.stateMachine = new StateMachine();
-        this.processManager = new ProcessManager();
-        this.options = options;
-        this.serverVersion = serverVersion;
-        // 如果提供了 token 就使用，否则自动生成
-        this.sessionToken = options.token || this.generateToken();
-    }
-    generateToken() {
-        return randomBytes(32).toString('base64url');
-    }
-    /**
-     * 辅助日志方法：在输出日志前清除进度条
-     */
-    log(message) {
-        if (this.hasProgressLine) {
-            // 清除进度条并换行
-            process.stdout.write('\r\x1b[K');
-            this.hasProgressLine = false;
-        }
-        console.log(message);
-    }
-    /**
-     * 辅助错误日志方法：在输出错误日志前清除进度条
-     */
-    logError(message, error) {
-        if (this.hasProgressLine) {
-            // 清除进度条并换行
-            process.stdout.write('\r\x1b[K');
-            this.hasProgressLine = false;
-        }
-        if (error !== undefined) {
-            console.error(message, error);
-        }
-        else {
-            console.error(message);
-        }
-    }
-    async start() {
-        const port = this.options.port;
-        await this.transport.createServer(port, (ws) => {
-            this.handleConnection(ws);
-        });
-        const hostname = this.getHostname();
-        console.log('Mirror host started');
-        console.log(`Listening on :${port}`);
-        console.log('链接指令: ');
-        console.log(`mirror link "${hostname}:${port}?token=${this.sessionToken}"`);
-        console.log(`mirror link "wss://mirror.tri-bank.online?token=${this.sessionToken}" (如果部署在服务端)`);
-    }
-    getHostname() {
-        // 尝试获取本机 IP
-        const interfaces = networkInterfaces();
-        for (const name of Object.keys(interfaces)) {
-            const ifaces = interfaces[name];
-            if (!ifaces)
-                continue;
-            for (const iface of ifaces) {
-                // 跳过内部（即 127.0.0.1）和非 IPv4 地址
-                if (iface.family === 'IPv4' && !iface.internal) {
-                    return iface.address;
-                }
-            }
-        }
-        // 如果没有找到外部 IP，返回 localhost
-        return 'localhost';
-    }
-    async handleConnection(ws) {
-        // 获取客户端地址信息，类型安全地访问 _socket
-        const socket = Object.getOwnPropertyDescriptor(ws, '_socket')?.value;
-        const clientAddress = socket?.remoteAddress ?? 'unknown';
-        const clientPort = socket?.remotePort ?? 'unknown';
-        this.log(`[${new Date().toISOString()}] 客户端连接: ${clientAddress}:${clientPort}`);
-        // 清理旧连接（如果有活跃连接）
-        if (this.currentClientId && this.stateMachine.getState() !== HostState.EMPTY) {
-            this.log(`[${new Date().toISOString()}] 检测到旧连接，断开旧连接: ${this.currentClientId}`);
-            // 断开旧连接时保留工作区
-            await this.disconnect();
-        }
-        ws.on('message', async (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                // 只记录关键消息，FILE 消息太多不记录
-                if (message.type !== 'FILE') {
-                    if (message.type === 'FILE_DIFF') {
-                        const diffMsg = message;
-                        this.log(`[${new Date().toISOString()}] 收到消息: ${message.type} (${diffMsg.op}: ${diffMsg.path})`);
-                    }
-                    else {
-                        this.log(`[${new Date().toISOString()}] 收到消息: ${message.type}`);
-                    }
-                }
-                await this.handleMessage(ws, message);
-            }
-            catch (error) {
-                this.logError(`[${new Date().toISOString()}] 处理消息失败:`, error);
-                this.sendError(ws, 'Failed to handle message');
-            }
-        });
-        ws.on('close', async () => {
-            this.log(`[${new Date().toISOString()}] 客户端断开连接: ${this.currentClientId || 'unknown'}`);
-            // 断开连接时保留工作区
-            await this.disconnect();
-            // 清除 currentClientId 和 currentClientWorkspacePath，以便下次连接时判断
-            this.currentClientId = null;
-            this.currentClientWorkspacePath = null;
-        });
-        ws.on('error', async (error) => {
-            // 清除进度条后输出错误
-            if (this.hasProgressLine) {
-                process.stdout.write('\r\x1b[K');
-                this.hasProgressLine = false;
-            }
-            console.error(`[${new Date().toISOString()}] WebSocket 错误:`, error);
-            // 错误时也保留工作区
-            await this.disconnect();
-            this.currentClientId = null;
-            this.currentClientWorkspacePath = null;
-        });
-    }
-    async handleMessage(ws, message) {
-        switch (message.type) {
-            case 'HELLO':
-                await this.handleHello(ws, message);
-                break;
-            case 'SNAPSHOT_START':
-                await this.handleSnapshotStart(ws, message);
-                break;
-            case 'FILE':
-                await this.handleFile(ws, message);
-                break;
-            case 'SNAPSHOT_END':
-                await this.handleSnapshotEnd(ws, message);
-                break;
-            case 'FILE_DIFF':
-                await this.handleFileDiff(ws, message);
-                break;
-            case 'EXEC':
-                await this.handleExec(ws, message);
-                break;
-            case 'EXEC_SIGNAL':
-                await this.handleExecSignal(ws, message);
-                break;
-            default:
-                this.sendError(ws, `Unknown message type: ${message.type}`);
-        }
-    }
-    async handleHello(ws, message) {
-        // 验证 token
-        if (message.token !== this.sessionToken) {
-            this.logError(`[${new Date().toISOString()}] Token 验证失败`);
-            this.sendError(ws, 'Invalid token');
-            ws.close();
-            return;
-        }
-        // 验证版本
-        const clientVersion = message.clientVersion || 'unknown';
-        if (clientVersion !== this.serverVersion) {
-            this.logError(`[${new Date().toISOString()}] 版本不匹配: 客户端版本=${clientVersion}, 服务端版本=${this.serverVersion}`);
-            this.sendError(ws, `Version mismatch: client version (${clientVersion}) != server version (${this.serverVersion}). Please update your mirror client.`);
-            ws.close();
-            return;
-        }
-        const newClientId = message.clientId;
-        const newClientWorkspacePath = message.workspacePath || null;
-        // 检查工作区元数据中的工作目录路径（用于判断是否为同一工作目录）
-        const workspacePath = this.workspace?.getWorkspacePath();
-        // 如果是不同工作目录连接，清理旧工作区
-        if (this.workspace && workspacePath !== newClientWorkspacePath) {
-            console.log(`[${new Date().toISOString()}] 检测到不同工作目录，清理旧工作区 (旧: ${workspacePath || 'unknown'}, 新: ${newClientWorkspacePath || 'unknown'})`);
-            await this.cleanup();
-        }
-        else if (this.workspace && workspacePath === newClientWorkspacePath) {
-            // 同一个工作目录重连，复用工作区
-            this.log(`[${new Date().toISOString()}] 检测到同一工作目录重连，复用工作区 (${newClientWorkspacePath || 'unknown'})`);
-            // 断开连接时已经保存了元数据，这里不需要额外操作
-        }
-        this.currentClientId = newClientId;
-        this.currentClientWorkspacePath = newClientWorkspacePath;
-        this.log(`[${new Date().toISOString()}] HELLO 成功，客户端 ID: ${newClientId}, 工作目录: ${newClientWorkspacePath || 'unknown'}, 版本: ${message.clientVersion || 'unknown'}`);
-        this.stateMachine.transitionTo(HostState.SYNCING);
-        this.snapshotFiles.clear();
-        this.isSnapshotInProgress = false;
-    }
-    async handleSnapshotStart(ws, message) {
-        if (this.stateMachine.getState() !== HostState.SYNCING) {
-            this.sendError(ws, 'Invalid state for SNAPSHOT_START');
-            return;
-        }
-        const totalFiles = message.totalFiles || 0;
-        this.log(`[${new Date().toISOString()}] 开始接收快照，版本: ${message.version}${totalFiles > 0 ? `，预计文件数: ${totalFiles}` : ''}`);
-        // 创建或复用 workspace（传入 clientId 和工作目录路径以便复用）
-        // 元数据文件保存在工作区目录之外，避免污染同步目录
-        if (!this.workspace) {
-            this.workspace = await Workspace.create(this.options.workspaceDir, false, this.currentClientId || null, this.currentClientWorkspacePath || null, this.options.metadataDir // 传递元数据目录
-            );
-            if (this.currentClientId) {
-                await this.workspace.setClientInfo(this.currentClientId, this.currentClientWorkspacePath || null);
-            }
-        }
-        this.log(`[${new Date().toISOString()}] 工作空间路径: ${this.workspace.getPath()}`);
-        this.isSnapshotInProgress = true;
-        this.snapshotFiles.clear();
-        this.fileCount = totalFiles; // 设置文件总数
-        this.receivedFileCount = 0; // 重置接收计数
-        this.writtenFileCount = 0; // 重置写入计数
-        this.skippedFileCount = 0; // 重置跳过计数
-    }
-    fileCount = 0; // 文件计数器（用于显示总文件数）
-    snapshotFileCount = 0; // 快照文件总数（初始同步的文件数）
-    incrementalSyncCount = 0; // 增量同步计数器（FILE_DIFF 同步的文件数）
-    receivedFileCount = 0; // 已接收文件数
-    writtenFileCount = 0; // 已写入文件数
-    skippedFileCount = 0; // 已跳过文件数（hash相同）
-    pendingFileDiffs = new Set(); // 待同步文件集合（用于跟踪 pending 状态）
-    async handleFile(ws, message) {
-        if (!this.workspace) {
-            this.sendError(ws, 'Workspace not initialized');
-            return;
-        }
-        if (!this.isSnapshotInProgress) {
-            // 忽略快照完成后收到的 FILE 消息（可能是网络延迟或客户端时序问题）
-            this.log(`[${new Date().toISOString()}] 忽略快照完成后的 FILE 消息: ${message.path}`);
-            return;
-        }
-        let content = Buffer.from(message.content, 'base64');
-        // 如果是压缩的，先解压
-        if (message.compressed) {
-            try {
-                content = Buffer.from(await decompressContent(content));
-            }
-            catch (error) {
-                this.logError(`[${new Date().toISOString()}] 解压失败: ${message.path}`, error);
-                this.sendError(ws, `Failed to decompress ${message.path}`);
-                return;
-            }
-        }
-        const hash = computeHash(content);
-        // 验证 hash
-        if (hash !== message.hash) {
-            this.logError(`[${new Date().toISOString()}] Hash 验证失败: ${message.path}`);
-            this.sendError(ws, `Hash mismatch for ${message.path}`);
-            return;
-        }
-        // 检查文件是否已存在且 hash 相同（增量同步）
-        const isSkipped = this.workspace.hasFile(message.path, message.hash);
-        if (isSkipped) {
-            this.skippedFileCount++;
-        }
-        // 记录到快照中（无论是否需要写入）
-        this.snapshotFiles.set(message.path, { hash, content });
-        this.receivedFileCount++;
-        // 每 10 个文件显示一次接收进度
-        if (this.receivedFileCount % 10 === 0 || this.receivedFileCount === this.fileCount) {
-            const skippedInfo = this.skippedFileCount > 0 ? ` (跳过 ${this.skippedFileCount})` : '';
-            const totalInfo = this.fileCount > 0 ? `/${this.fileCount}` : '';
-            process.stdout.write(`\r[${new Date().toISOString()}] 已接收 ${this.receivedFileCount}${totalInfo} 个文件${skippedInfo}...`);
-            this.hasProgressLine = true; // 标记有进度条在显示
-        }
-    }
-    async handleSnapshotEnd(ws, message) {
-        if (!this.workspace) {
-            this.sendError(ws, 'Workspace not initialized');
-            return;
-        }
-        if (!this.isSnapshotInProgress) {
-            this.sendError(ws, 'SNAPSHOT not in progress');
-            return;
-        }
-        // 清除接收进度显示（使用 ANSI 转义序列清除整行）
-        process.stdout.write('\r\x1b[K');
-        this.hasProgressLine = false; // 清除标记
-        console.log(`[${new Date().toISOString()}] 快照接收完成，版本: ${message.version}，文件数: ${this.snapshotFiles.size}`);
-        // 准备写入文件
-        const filesToWrite = [];
-        const fileHashes = {};
-        // 获取旧的文件列表（用于删除已移除的文件）
-        const oldFiles = this.workspace.getOldFiles();
-        const newFilePaths = new Set();
-        for (const [path, { hash, content }] of this.snapshotFiles) {
-            fileHashes[path] = hash;
-            newFilePaths.add(path);
-            // 只写入需要更新的文件（hash 不同的）
-            if (!this.workspace.hasFile(path, hash)) {
-                filesToWrite.push([path, content]);
-            }
-        }
-        // 找出需要删除的文件（在旧文件中但不在新快照中）
-        const filesToDelete = [];
-        for (const oldPath of Object.keys(oldFiles)) {
-            if (!newFilePaths.has(oldPath)) {
-                filesToDelete.push(oldPath);
-            }
-        }
-        const totalFiles = this.snapshotFiles.size;
-        const needWriteCount = filesToWrite.length;
-        const actualSkippedCount = totalFiles - needWriteCount;
-        // 删除已移除的文件
-        if (filesToDelete.length > 0) {
-            this.log(`[${new Date().toISOString()}] 检测到 ${filesToDelete.length} 个文件已移除，开始删除...`);
-            for (const path of filesToDelete) {
-                await this.workspace.deleteFile(path);
-            }
-            this.log(`[${new Date().toISOString()}] 已删除 ${filesToDelete.length} 个文件`);
-        }
-        if (needWriteCount > 0) {
-            this.log(`[${new Date().toISOString()}] 开始写入文件: ${needWriteCount}/${totalFiles} 需要更新...`);
-            // 写入文件并显示进度
-            for (let i = 0; i < filesToWrite.length; i++) {
-                const [path, content] = filesToWrite[i];
-                await this.workspace.writeFile(path, content);
-                this.writtenFileCount++;
-                // 每写入 10 个文件或最后一个文件时显示进度
-                if ((i + 1) % 10 === 0 || i === filesToWrite.length - 1) {
-                    process.stdout.write(`\r[${new Date().toISOString()}] 已写入 ${this.writtenFileCount}/${needWriteCount} 个文件...`);
-                    this.hasProgressLine = true; // 标记有进度条在显示
-                }
-            }
-            // 清除写入进度显示（使用 ANSI 转义序列清除整行）
-            process.stdout.write('\r\x1b[K');
-            this.hasProgressLine = false; // 清除标记
-        }
-        // 更新文件列表元数据
-        await this.workspace.updateFileList(fileHashes);
-        this.workspace.setVersion(message.version);
-        this.stateMachine.transitionTo(HostState.READY);
-        this.isSnapshotInProgress = false;
-        const skippedInfo = actualSkippedCount > 0 ? ` (跳过 ${actualSkippedCount} 个未变更文件)` : '';
-        this.log(`[${new Date().toISOString()}] 工作空间已就绪，可以执行命令${skippedInfo}`);
-        // 记录快照文件数（用于后续的 totalSynced 计算）
-        this.snapshotFileCount = this.snapshotFiles.size;
-        // 发送文件同步状态消息（初始同步完成）
-        ws.send(JSON.stringify({
-            type: 'FILE_SYNC_STATUS',
-            status: 'synced',
-            totalSynced: this.snapshotFileCount,
-            pendingCount: 0,
-        }));
-        // 发送 READY 消息通知客户端
-        ws.send(JSON.stringify({
-            type: 'READY',
-            message: '工作空间已就绪',
-        }));
-        // 重置计数器（保留 snapshotFileCount 用于后续增量同步计数）
-        this.snapshotFiles.clear();
-        this.fileCount = 0;
-        this.receivedFileCount = 0;
-        this.writtenFileCount = 0;
-        this.skippedFileCount = 0;
-        this.incrementalSyncCount = 0; // 重置增量同步计数器
-        this.pendingFileDiffs.clear(); // 清空待同步文件集合
-    }
-    async handleFileDiff(ws, message) {
-        if (!this.workspace) {
-            this.sendError(ws, 'Workspace not initialized');
-            return;
-        }
-        const state = this.stateMachine.getState();
-        // 只要状态是 READY，就可以同步文件（不管是否有命令在执行）
-        if (state === HostState.READY) {
-            // 通知客户端正在同步
-            ws.send(JSON.stringify({
-                type: 'FILE_SYNC_STATUS',
-                status: 'syncing',
-                path: message.path,
-                op: message.op,
-            }));
-            // 立即应用文件变更
-            if (message.op === 'update' && message.content) {
-                let content = Buffer.from(message.content, 'base64');
-                // 如果是压缩的，先解压
-                if (message.compressed) {
-                    try {
-                        content = Buffer.from(await decompressContent(content));
-                    }
-                    catch (error) {
-                        this.logError(`[${new Date().toISOString()}] 解压失败: ${message.path}`, error);
-                        this.sendError(ws, `Failed to decompress ${message.path}`);
-                        return;
-                    }
-                }
-                const hash = computeHash(content);
-                if (hash !== message.hash) {
-                    this.sendError(ws, `Hash mismatch for ${message.path}`);
-                    return;
-                }
-                await this.workspace.writeFile(message.path, content);
-            }
-            else if (message.op === 'delete') {
-                await this.workspace.deleteFile(message.path);
-            }
-            this.workspace.setVersion(message.version);
-            // 递增增量同步计数
-            this.incrementalSyncCount++;
-            // 通知客户端同步完成，包含统计信息
-            ws.send(JSON.stringify({
-                type: 'FILE_SYNC_STATUS',
-                status: 'synced',
-                path: message.path,
-                op: message.op,
-                totalSynced: this.snapshotFileCount + this.incrementalSyncCount, // 总同步数 = snapshot文件数 + 增量同步数
-                pendingCount: 0, // 实时同步，无待同步文件
-            }));
-        }
-        else {
-            this.sendError(ws, `Invalid state for FILE_DIFF: ${state}`);
-        }
-    }
-    async handleExec(ws, message) {
-        if (!this.workspace) {
-            this.sendError(ws, 'Workspace not initialized');
-            return;
-        }
-        // 验证状态
-        if (!this.stateMachine.canExec()) {
-            this.sendError(ws, `Cannot exec in state: ${this.stateMachine.getState()}`);
-            return;
-        }
-        // 验证版本
-        if (message.version !== this.workspace.getCurrentVersion()) {
-            this.sendError(ws, `Version mismatch: expected ${this.workspace.getCurrentVersion()}, got ${message.version}`);
-            return;
-        }
-        console.log(`[${new Date().toISOString()}] 执行命令: ${message.command} (execId: ${message.execId})`);
-        // 标记命令正在执行
-        this.isCommandRunning = true;
-        // 启动进程
-        const ptyProcess = await this.processManager.spawn(message.execId, message.command, this.workspace.getPath());
-        // 监听输出
-        ptyProcess.onData((data) => {
-            ws.send(JSON.stringify({
-                type: 'EXEC_OUTPUT',
-                execId: message.execId,
-                stream: 'stdout',
-                data,
-            }));
-        });
-        // 监听退出
-        ptyProcess.onExit(async (exit) => {
-            console.log(`[${new Date().toISOString()}] 命令执行完成: ${message.command} (execId: ${message.execId}, exitCode: ${exit.exitCode})`);
-            ws.send(JSON.stringify({
-                type: 'EXEC_EXIT',
-                execId: message.execId,
-                code: exit.exitCode,
-            }));
-            // 清理进程
-            this.processManager.removeProcess(message.execId);
-            // 标记命令执行完成
-            this.isCommandRunning = false;
-        });
-    }
-    async handleExecSignal(ws, message) {
-        const processInfo = this.processManager.getProcess(message.execId);
-        if (!processInfo) {
-            this.sendError(ws, `Process not found: ${message.execId}`);
-            return;
-        }
-        this.log(`[${new Date().toISOString()}] 向进程发送信号: ${message.signal} (execId: ${message.execId})`);
-        try {
-            processInfo.process.kill(message.signal);
-        }
-        catch (error) {
-            this.logError(`[${new Date().toISOString()}] 发送信号失败:`, error);
-            this.sendError(ws, `Failed to send signal to process: ${message.execId}`);
-        }
-    }
-    sendError(ws, message, code) {
-        ws.send(JSON.stringify({
-            type: 'ERROR',
-            message,
-            code,
-        }));
-    }
-    async cleanup() {
-        // 清理进程
-        await this.processManager.killAll();
-        // 清理 workspace（完全删除）
-        if (this.workspace) {
-            await this.workspace.cleanup();
-            this.workspace = null;
-        }
-        // 重置状态
-        this.stateMachine.reset();
-        this.currentClientId = null;
-        this.currentClientWorkspacePath = null;
-        this.snapshotFiles.clear();
-        this.isSnapshotInProgress = false;
-        this.isCommandRunning = false;
-        this.fileCount = 0;
-        this.snapshotFileCount = 0;
-        this.incrementalSyncCount = 0;
-        this.receivedFileCount = 0;
-        this.writtenFileCount = 0;
-        this.skippedFileCount = 0;
-        this.pendingFileDiffs.clear();
-    }
-    async disconnect() {
-        // 断开连接时保留工作区
-        // 清理进程
-        await this.processManager.killAll();
-        // 保存工作区元数据，但不删除工作区
-        if (this.workspace) {
-            await this.workspace.disconnect();
-            // 不设置为 null，以便重连时复用
-        }
-        // 重置状态（但保留 workspace、currentClientId 和 currentClientWorkspacePath，以便识别重连）
-        this.stateMachine.reset();
-        this.snapshotFiles.clear();
-        this.isSnapshotInProgress = false;
-        this.isCommandRunning = false;
-        this.fileCount = 0;
-        this.receivedFileCount = 0;
-        this.writtenFileCount = 0;
-        this.skippedFileCount = 0;
-        // 注意：不断开连接时不清除 currentClientId 和 currentClientWorkspacePath
-    }
-    async stop() {
-        await this.cleanup();
-        this.transport.close();
-    }
-}
-//# sourceMappingURL=host-impl.js.map