syncast-cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,57 +1,887 @@
+import { WebSocketServer } from "ws";
+import { mkdir, readFile, readdir, stat as promises_stat, writeFile } from "node:fs/promises";
+import { dirname as external_node_path_dirname, join } from "node:path";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { watch } from "chokidar";
 import { Command } from "commander";
-async function createServer(options = {}) {
-    const { port = 3456, host = "localhost" } = options;
+const DEFAULT_HOST = "localhost";
+const CHUNK_SIZE = 1048576;
+const FILE_CONFIG_SUFFIX = ".config.json";
+const FOLDER_CONFIG_SUFFIX = ".folder.config.json";
+const SUPPORTED_EXTENSIONS = [
+    "jpg",
+    "jpeg",
+    "png",
+    "webp",
+    "gif",
+    "mp4",
+    "mov",
+    "m4v",
+    "webm",
+    "mp3",
+    "wav",
+    "ogg",
+    "m4a"
+];
+function createFileConfig(assetId, originalFilename, md5) {
     return {
-        async start () {
-            console.log(`🚀 Syncast server starting on ${host}:${port}`);
-        },
-        async stop () {
-            console.log("🛑 Syncast server stopped");
+        assetId,
+        syncedAt: new Date().toISOString(),
+        originalFilename,
+        md5
+    };
+}
+function createFolderConfig(folderId) {
+    return {
+        folderId,
+        syncedAt: new Date().toISOString()
+    };
+}
+function parseFileConfig(content) {
+    try {
+        const config = JSON.parse(content);
+        if (!config.assetId || "string" != typeof config.assetId) {
+            console.warn("Invalid config.json: missing or invalid assetId");
+            return null;
+        }
+        if (!config.originalFilename || "string" != typeof config.originalFilename) {
+            console.warn("Invalid config.json: missing or invalid originalFilename");
+            return null;
+        }
+        return config;
+    } catch (e) {
+        console.warn("Failed to parse config.json:", e);
+        return null;
+    }
+}
+function parseFolderConfig(content) {
+    try {
+        const config = JSON.parse(content);
+        if (!config.folderId || "string" != typeof config.folderId) {
+            console.warn("Invalid folder config.json: missing or invalid folderId");
+            return null;
         }
+        return config;
+    } catch (e) {
+        console.warn("Failed to parse folder config.json:", e);
+        return null;
+    }
+}
+function getFileConfigPath(filePath) {
+    return `${filePath}${FILE_CONFIG_SUFFIX}`;
+}
+function getFolderConfigPath(folderPath) {
+    const normalizedPath = folderPath.replace(/\/+$/, "");
+    return `${normalizedPath}${FOLDER_CONFIG_SUFFIX}`;
+}
+function isConfigFile(path) {
+    return path.endsWith(FOLDER_CONFIG_SUFFIX) || path.endsWith(FILE_CONFIG_SUFFIX);
+}
+function getFileExtension(filename) {
+    const lastDot = filename.lastIndexOf(".");
+    if (-1 === lastDot || lastDot === filename.length - 1) return "";
+    return filename.slice(lastDot + 1).toLowerCase();
+}
+function isSupportedFile(filename) {
+    const ext = getFileExtension(filename);
+    return ext ? SUPPORTED_EXTENSIONS.includes(ext) : false;
+}
+function getFilename(path) {
+    const normalized = path.replace(/\\/g, "/");
+    const parts = normalized.split("/");
+    return parts[parts.length - 1] || "";
+}
+function normalizePath(path) {
+    return path.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function toRelativePath(absolutePath, basePath) {
+    const normalizedAbs = normalizePath(absolutePath);
+    const normalizedBase = normalizePath(basePath);
+    if (!normalizedAbs.startsWith(normalizedBase)) return normalizedAbs;
+    let relative = normalizedAbs.slice(normalizedBase.length);
+    if (relative.startsWith("/")) relative = relative.slice(1);
+    return relative;
+}
+function createConnectedMessage(cwd) {
+    return {
+        type: "connected",
+        cwd,
+        version: "1.0.0"
+    };
+}
+function createErrorMessage(code, message, requestId) {
+    return {
+        type: "error",
+        code,
+        message,
+        requestId
     };
 }
+const ErrorCodes = {
+    FILE_NOT_FOUND: "FILE_NOT_FOUND",
+    FOLDER_NOT_FOUND: "FOLDER_NOT_FOUND",
+    PERMISSION_DENIED: "PERMISSION_DENIED",
+    FILE_IN_USE: "FILE_IN_USE",
+    TRANSFER_CANCELLED: "TRANSFER_CANCELLED",
+    INVALID_REQUEST_ID: "INVALID_REQUEST_ID",
+    VERSION_MISMATCH: "VERSION_MISMATCH",
+    PROJECT_ALREADY_CONNECTED: "PROJECT_ALREADY_CONNECTED",
+    UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+var __webpack_exports__DEFAULT_PORT = 23456;
+var __webpack_exports__FILE_CHANGE_DEBOUNCE_MS = 300;
+var __webpack_exports__FILE_STABLE_CHECK_INTERVAL_MS = 500;
+var __webpack_exports__PROTOCOL_VERSION = "1.0.0";
+class FileTransferManager {
+    rootPath;
+    events;
+    pendingReceives = new Map();
+    activeSends = new Set();
+    constructor(rootPath, events){
+        this.rootPath = rootPath;
+        this.events = events;
+    }
+    async sendFile(requestId, relativePath) {
+        const absolutePath = join(this.rootPath, relativePath);
+        if (this.activeSends.has(requestId)) return;
+        this.activeSends.add(requestId);
+        try {
+            const stat = await promises_stat(absolutePath);
+            if (!stat.isFile()) return void this.events.onError(requestId, ErrorCodes.FILE_NOT_FOUND, `Not a file: ${relativePath}`);
+            const fileBuffer = await readFile(absolutePath);
+            const totalChunks = Math.ceil(fileBuffer.length / CHUNK_SIZE);
+            console.log(`[FileTransfer] Sending file: ${relativePath} (${fileBuffer.length} bytes, ${totalChunks} chunks)`);
+            for(let i = 0; i < totalChunks; i++){
+                if (!this.activeSends.has(requestId)) return void console.log(`[FileTransfer] Send cancelled: ${relativePath}`);
+                const start = i * CHUNK_SIZE;
+                const end = Math.min(start + CHUNK_SIZE, fileBuffer.length);
+                const chunk = fileBuffer.subarray(start, end);
+                const base64Data = chunk.toString("base64");
+                this.events.onChunk(requestId, i, totalChunks, base64Data);
+                if (i < totalChunks - 1) await sleep(1);
+            }
+            this.events.onComplete(requestId, relativePath);
+            console.log(`[FileTransfer] File sent: ${relativePath}`);
+        } catch (error) {
+            console.error(`[FileTransfer] Failed to send file: ${relativePath}`, error);
+            this.events.onError(requestId, ErrorCodes.FILE_NOT_FOUND, `Failed to read file: ${relativePath}`);
+        } finally{
+            this.activeSends.delete(requestId);
+        }
+    }
+    async receiveFile(requestId, relativePath, totalChunks, fileSize) {
+        const absolutePath = join(this.rootPath, relativePath);
+        const folderPath = relativePath.includes("/") ? relativePath.substring(0, relativePath.lastIndexOf("/")) : null;
+        if (folderPath) this.events.onReceiveStart?.(folderPath);
+        const dir = external_node_path_dirname(absolutePath);
+        await mkdir(dir, {
+            recursive: true
+        });
+        this.pendingReceives.set(requestId, {
+            path: relativePath,
+            absolutePath,
+            totalChunks,
+            fileSize,
+            receivedChunks: new Map(),
+            receivedSize: 0,
+            isSaving: false
+        });
+        this.events.onReceiveStart?.(relativePath);
+        console.log(`[FileTransfer] Ready to receive: ${relativePath} (${fileSize} bytes, ${totalChunks} chunks)`);
+    }
+    async handleChunk(requestId, index, base64Data) {
+        const pending = this.pendingReceives.get(requestId);
+        if (!pending) return void console.warn(`[FileTransfer] Unknown requestId: ${requestId}`);
+        const chunk = Buffer.from(base64Data, "base64");
+        pending.receivedChunks.set(index, chunk);
+        pending.receivedSize += chunk.length;
+        if (pending.receivedChunks.size === pending.totalChunks && !pending.isSaving) {
+            pending.isSaving = true;
+            await this.assembleAndSave(requestId, pending);
+        }
+    }
+    async handleTransferComplete(requestId) {
+        const pending = this.pendingReceives.get(requestId);
+        if (!pending) return;
+        if (pending.receivedChunks.size !== pending.totalChunks || pending.isSaving) {
+            if (pending.receivedChunks.size < pending.totalChunks) console.warn(`[FileTransfer] Transfer complete but missing chunks: ${pending.receivedChunks.size}/${pending.totalChunks}`);
+        } else {
+            pending.isSaving = true;
+            await this.assembleAndSave(requestId, pending);
+        }
+    }
+    async assembleAndSave(requestId, pending) {
+        try {
+            const chunks = [];
+            for(let i = 0; i < pending.totalChunks; i++){
+                const chunk = pending.receivedChunks.get(i);
+                if (!chunk) throw new Error(`Missing chunk ${i}`);
+                chunks.push(chunk);
+            }
+            const fileBuffer = Buffer.concat(chunks);
+            await writeFile(pending.absolutePath, fileBuffer);
+            console.log(`[FileTransfer] File saved: ${pending.path} (${fileBuffer.length} bytes)`);
+            this.events.onFileSaved(requestId, pending.path);
+            this.pendingReceives.delete(requestId);
+        } catch (error) {
+            console.error(`[FileTransfer] Failed to save file: ${pending.path}`, error);
+            this.events.onError(requestId, ErrorCodes.PERMISSION_DENIED, `Failed to save file: ${pending.path}`);
+            this.pendingReceives.delete(requestId);
+        }
+    }
+    async cancelTransfer(requestId) {
+        this.activeSends.delete(requestId);
+        const pending = this.pendingReceives.get(requestId);
+        if (pending) {
+            console.log(`[FileTransfer] Transfer cancelled: ${pending.path}`);
+            this.pendingReceives.delete(requestId);
+        }
+    }
+    getPendingCount() {
+        return this.pendingReceives.size + this.activeSends.size;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+const execAsync = promisify(exec);
+class FileChangeCollector {
+    pending = new Map();
+    timer = null;
+    onFlush;
+    constructor(onFlush){
+        this.onFlush = onFlush;
+    }
+    add(file) {
+        this.pending.set(file.path, file);
+        this.scheduleFlush();
+    }
+    scheduleFlush() {
+        if (this.timer) return;
+        this.timer = setTimeout(()=>{
+            this.flush();
+            this.timer = null;
+        }, __webpack_exports__FILE_CHANGE_DEBOUNCE_MS);
+    }
+    flush() {
+        if (0 === this.pending.size) return;
+        const files = Array.from(this.pending.values());
+        this.pending.clear();
+        this.onFlush(files);
+    }
+    clear() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.pending.clear();
+    }
+}
+class FileWatcher {
+    rootPath;
+    watcher = null;
+    events;
+    fileCollector;
+    processingFiles = new Set();
+    constructor(rootPath, events){
+        this.rootPath = rootPath;
+        this.events = events;
+        this.fileCollector = new FileChangeCollector((files)=>{
+            if (1 === files.length) this.events.onFileAdded(files[0]);
+            else this.events.onFilesAdded(files);
+        });
+    }
+    async scan() {
+        const files = [];
+        const folders = [];
+        await this.scanDirectory(this.rootPath, "", files, folders);
+        return {
+            files,
+            folders
+        };
+    }
+    async scanDirectory(absolutePath, relativePath, files, folders) {
+        try {
+            const entries = await readdir(absolutePath, {
+                withFileTypes: true
+            });
+            for (const entry of entries){
+                const entryPath = join(absolutePath, entry.name);
+                const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    if (entry.name.startsWith(".")) continue;
+                    const folderInfo = await this.getFolderInfo(entryPath, entryRelativePath);
+                    folders.push(folderInfo);
+                    await this.scanDirectory(entryPath, entryRelativePath, files, folders);
+                } else if (entry.isFile()) {
+                    if (isConfigFile(entry.name)) continue;
+                    if (!isSupportedFile(entry.name)) continue;
+                    if (entry.name.startsWith(".")) continue;
+                    const fileInfo = await this.getFileInfo(entryPath, entryRelativePath);
+                    files.push(fileInfo);
+                }
+            }
+        } catch (error) {
+            console.error(`Failed to scan directory ${absolutePath}:`, error);
+        }
+    }
+    async getFileInfo(absolutePath, relativePath) {
+        const stat = await promises_stat(absolutePath);
+        const name = getFilename(absolutePath);
+        const configPath = getFileConfigPath(absolutePath);
+        let hasConfig = false;
+        let assetId;
+        try {
+            const configContent = await readFile(configPath, "utf-8");
+            const config = parseFileConfig(configContent);
+            if (config) {
+                hasConfig = true;
+                assetId = config.assetId;
+            }
+        } catch  {}
+        return {
+            path: relativePath,
+            name,
+            size: stat.size,
+            mtime: stat.mtimeMs,
+            hasConfig,
+            assetId
+        };
+    }
+    async getFolderInfo(absolutePath, relativePath) {
+        const name = getFilename(absolutePath);
+        const configPath = getFolderConfigPath(absolutePath);
+        let hasConfig = false;
+        let folderId;
+        try {
+            const configContent = await readFile(configPath, "utf-8");
+            const config = parseFolderConfig(configContent);
+            if (config) {
+                hasConfig = true;
+                folderId = config.folderId;
+            }
+        } catch  {}
+        return {
+            path: relativePath,
+            name,
+            hasConfig,
+            folderId
+        };
+    }
+    async start() {
+        this.watcher = watch(this.rootPath, {
+            ignored: [
+                /(^|[/\\])\.[^/\\]+$/,
+                /node_modules/
+            ],
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: __webpack_exports__FILE_STABLE_CHECK_INTERVAL_MS,
+                pollInterval: 100
+            }
+        });
+        this.watcher.on("add", (filePath)=>this.handleFileAdd(filePath));
+        this.watcher.on("unlink", (filePath)=>this.handleFileRemove(filePath));
+        this.watcher.on("addDir", (dirPath)=>this.handleDirAdd(dirPath));
+        this.watcher.on("unlinkDir", (dirPath)=>this.handleDirRemove(dirPath));
+        this.watcher.on("error", (error)=>console.error("Watcher error:", error));
+    }
+    async stop() {
+        this.fileCollector.clear();
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    async handleFileAdd(filePath) {
+        const relativePath = toRelativePath(filePath, this.rootPath);
+        const filename = getFilename(filePath);
+        if (isConfigFile(filename)) return;
+        if (!isSupportedFile(filename)) return;
+        if (filename.startsWith(".")) return;
+        if (this.processingFiles.has(relativePath)) return;
+        try {
+            const fileInfo = await this.getFileInfo(filePath, relativePath);
+            if (fileInfo.hasConfig) return void console.log(`[FileWatcher] Skipping already synced file: ${relativePath}`);
+            console.log(`[FileWatcher] File added: ${relativePath}`);
+            this.fileCollector.add(fileInfo);
+        } catch (error) {
+            console.error(`[FileWatcher] Failed to get file info: ${filePath}`, error);
+        }
+    }
+    handleFileRemove(filePath) {
+        const relativePath = toRelativePath(filePath, this.rootPath);
+        const filename = getFilename(filePath);
+        if (isConfigFile(filename)) return;
+        if (!isSupportedFile(filename)) return;
+        console.log(`[FileWatcher] File removed: ${relativePath}`);
+        this.events.onFileRemoved(relativePath);
+    }
+    async handleDirAdd(dirPath) {
+        const relativePath = toRelativePath(dirPath, this.rootPath);
+        const dirname = getFilename(dirPath);
+        if (!relativePath) return;
+        if (dirname.startsWith(".")) return;
+        if (this.processingFiles.has(relativePath)) return void console.log(`[FileWatcher] Skipping processing folder: ${relativePath}`);
+        try {
+            const folderInfo = await this.getFolderInfo(dirPath, relativePath);
+            if (folderInfo.hasConfig) return void console.log(`[FileWatcher] Skipping already synced folder: ${relativePath}`);
+            console.log(`[FileWatcher] Folder added: ${relativePath}`);
+            this.events.onFolderAdded(folderInfo);
+        } catch (error) {
+            console.error(`[FileWatcher] Failed to get folder info: ${dirPath}`, error);
+        }
+    }
+    handleDirRemove(dirPath) {
+        const relativePath = toRelativePath(dirPath, this.rootPath);
+        if (!relativePath) return;
+        console.log(`[FileWatcher] Folder removed: ${relativePath}`);
+        this.events.onFolderRemoved(relativePath);
+    }
+    async writeConfig(relativePath, assetId, folderId, originalFilename, md5) {
+        const absolutePath = join(this.rootPath, relativePath);
+        if (assetId && originalFilename) {
+            const configPath = getFileConfigPath(absolutePath);
+            const config = createFileConfig(assetId, originalFilename, md5);
+            await writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+            await this.setHiddenAttribute(configPath);
+            console.log(`[FileWatcher] Config written (hidden): ${configPath}`);
+        } else if (folderId) {
+            const configPath = getFolderConfigPath(absolutePath);
+            const config = createFolderConfig(folderId);
+            await writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+            await this.setHiddenAttribute(configPath);
+            console.log(`[FileWatcher] Folder config written (hidden): ${configPath}`);
+        }
+    }
+    async setHiddenAttribute(filePath) {
+        try {
+            if ("darwin" === process.platform) await execAsync(`chflags hidden "${filePath}"`);
+            else if ("win32" === process.platform) await execAsync(`attrib +h "${filePath}"`);
+        } catch (error) {
+            console.warn(`[FileWatcher] Failed to set hidden attribute: ${filePath}`, error);
+        }
+    }
+    markProcessing(relativePath) {
+        this.processingFiles.add(relativePath);
+    }
+    unmarkProcessing(relativePath) {
+        this.processingFiles.delete(relativePath);
+    }
+}
+class SyncServer {
+    wss = null;
+    client = null;
+    fileWatcher = null;
+    fileTransfer = null;
+    port;
+    host;
+    cwd;
+    syncFolder = null;
+    events;
+    messageQueue = [];
+    isProcessingQueue = false;
+    currentProjectId = null;
+    constructor(options = {}, events = {}){
+        this.port = options.port ?? __webpack_exports__DEFAULT_PORT;
+        this.host = options.host ?? DEFAULT_HOST;
+        this.cwd = process.cwd();
+        this.events = events;
+    }
+    async start() {
+        return new Promise((resolve, reject)=>{
+            try {
+                this.wss = new WebSocketServer({
+                    port: this.port,
+                    host: this.host
+                });
+                this.wss.on("listening", ()=>{
+                    console.log(`🌐 WebSocket server listening on ws://${this.host}:${this.port}`);
+                    resolve();
+                });
+                this.wss.on("connection", (ws)=>{
+                    this.handleConnection(ws);
+                });
+                this.wss.on("error", (error)=>{
+                    console.error("WebSocket server error:", error);
+                    this.events.onError?.(error);
+                    reject(error);
+                });
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async stop() {
+        if (this.fileWatcher) {
+            await this.fileWatcher.stop();
+            this.fileWatcher = null;
+        }
+        if (this.client) {
+            this.client.close();
+            this.client = null;
+        }
+        return new Promise((resolve)=>{
+            if (this.wss) this.wss.close(()=>{
+                console.log("🛑 WebSocket server stopped");
+                this.wss = null;
+                resolve();
+            });
+            else resolve();
+        });
+    }
+    handleConnection(ws) {
+        const pendingClient = ws;
+        console.log("📡 New connection attempt, waiting for project registration...");
+        pendingClient.send(JSON.stringify(createConnectedMessage(this.cwd)));
+        const registrationTimeout = setTimeout(()=>{
+            console.log("⚠️ Registration timeout, closing connection");
+            pendingClient.close(1008, "Registration timeout");
+        }, 5000);
+        const tempMessageHandler = (data)=>{
+            try {
+                const message = JSON.parse(data.toString());
+                if ("register_project" === message.type) {
+                    clearTimeout(registrationTimeout);
+                    pendingClient.removeListener("message", tempMessageHandler);
+                    this.handleProjectRegistration(pendingClient, message.projectId);
+                }
+            } catch (error) {
+                console.error("Failed to parse registration message:", error);
+            }
+        };
+        pendingClient.on("message", tempMessageHandler);
+        pendingClient.on("close", ()=>{
+            clearTimeout(registrationTimeout);
+            pendingClient.removeListener("message", tempMessageHandler);
+        });
+    }
+    handleProjectRegistration(ws, projectId) {
+        if (this.client && this.currentProjectId === projectId) {
+            console.log(`⚠️ Project ${projectId} is already connected, rejecting new connection`);
+            ws.send(JSON.stringify(createErrorMessage(ErrorCodes.PROJECT_ALREADY_CONNECTED, `Project ${projectId} is already connected from another client`)));
+            ws.close(1013, "Project already connected");
+            return;
+        }
+        if (this.client) {
+            console.log(`🔄 Switching from project ${this.currentProjectId} to ${projectId}`);
+            this.client.close(1000, "New project connected");
+            this.cleanupConnection();
+        }
+        this.client = ws;
+        this.currentProjectId = projectId;
+        console.log(`✅ Project ${projectId} registered`);
+        this.events.onClientConnected?.(ws);
+        ws.on("message", (data)=>{
+            try {
+                const message = JSON.parse(data.toString());
+                this.enqueueMessage(message);
+            } catch (error) {
+                console.error("Failed to parse message:", error);
+                this.send(createErrorMessage(ErrorCodes.UNKNOWN_ERROR, "Failed to parse message"));
+            }
+        });
+        ws.on("close", ()=>{
+            console.log("📴 Client disconnected");
+            this.cleanupConnection();
+            this.events.onClientDisconnected?.(ws);
+        });
+        ws.on("error", (error)=>{
+            console.error("WebSocket error:", error);
+            this.events.onError?.(error);
+        });
+    }
+    cleanupConnection() {
+        this.client = null;
+        this.currentProjectId = null;
+        if (this.fileWatcher) {
+            this.fileWatcher.stop();
+            this.fileWatcher = null;
+        }
+        this.syncFolder = null;
+    }
+    async handleMessage(message) {
+        switch(message.type){
+            case "list_directory":
+                await this.handleListDirectory(message.path);
+                break;
+            case "select_folder":
+                await this.handleSelectFolder(message.path);
+                break;
+            case "request_file":
+                await this.handleRequestFile(message.requestId, message.path);
+                break;
+            case "send_file":
+                await this.handleSendFile(message.requestId, message.path, message.totalChunks, message.fileSize);
+                break;
+            case "file_chunk":
+                await this.handleFileChunk(message.requestId, message.index, message.data);
+                break;
+            case "file_transfer_complete":
+                await this.handleFileTransferComplete(message.requestId);
+                break;
+            case "write_config":
+                await this.handleWriteConfig(message.path, message.assetId, message.folderId, message.originalFilename, message.md5);
+                break;
+            case "cancel_transfer":
+                await this.handleCancelTransfer(message.requestId);
+                break;
+            default:
+                console.warn("Unknown message type:", message.type);
+        }
+    }
+    async handleListDirectory(path) {
+        const fs = await import("node:fs/promises");
+        const nodePath = await import("node:path");
+        const targetPath = path ? nodePath.resolve(this.cwd, path) : this.cwd;
+        try {
+            const entries = await fs.readdir(targetPath, {
+                withFileTypes: true
+            });
+            const directories = entries.filter((entry)=>entry.isDirectory() && !entry.name.startsWith(".")).map((entry)=>entry.name).sort();
+            const listing = {
+                path: targetPath,
+                directories,
+                isRoot: targetPath === this.cwd
+            };
+            this.send({
+                type: "directory_listing",
+                listing
+            });
+        } catch (error) {
+            this.send(createErrorMessage(ErrorCodes.FOLDER_NOT_FOUND, `Failed to list directory: ${targetPath}`));
+        }
+    }
+    async handleSelectFolder(path) {
+        const fs = await import("node:fs/promises");
+        const nodePath = await import("node:path");
+        const absolutePath = nodePath.resolve(this.cwd, path);
+        try {
+            const stat = await fs.stat(absolutePath);
+            if (!stat.isDirectory()) return void this.send(createErrorMessage(ErrorCodes.FOLDER_NOT_FOUND, `Not a directory: ${absolutePath}`));
+        } catch  {
+            this.send(createErrorMessage(ErrorCodes.FOLDER_NOT_FOUND, `Folder not found: ${absolutePath}`));
+            return;
+        }
+        if (this.fileWatcher) await this.fileWatcher.stop();
+        this.syncFolder = absolutePath;
+        this.fileWatcher = new FileWatcher(absolutePath, {
+            onFileAdded: (file)=>this.send({
+                    type: "file_added",
+                    file
+                }),
+            onFilesAdded: (files)=>this.send({
+                    type: "files_added",
+                    files
+                }),
+            onFileRemoved: (path)=>this.send({
+                    type: "file_removed",
+                    path
+                }),
+            onFolderAdded: (folder)=>this.send({
+                    type: "folder_added",
+                    folder
+                }),
+            onFolderRemoved: (path)=>this.send({
+                    type: "folder_removed",
+                    path
+                })
+        });
+        this.fileTransfer = new FileTransferManager(absolutePath, {
+            onChunk: (requestId, index, total, data)=>{
+                this.send({
+                    type: "file_chunk",
+                    requestId,
+                    index,
+                    total,
+                    data
+                });
+            },
+            onComplete: (requestId, path)=>{
+                this.send({
+                    type: "file_transfer_complete",
+                    requestId,
+                    path
+                });
+            },
+            onFileSaved: (requestId, path)=>{
+                this.send({
+                    type: "file_saved",
+                    requestId,
+                    path
+                });
+            },
+            onError: (requestId, code, message)=>{
+                this.send(createErrorMessage(code, message, requestId));
+            },
+            onReceiveStart: (relativePath)=>{
+                this.fileWatcher?.markProcessing(relativePath);
+            },
+            onReceiveEnd: (relativePath)=>{}
+        });
+        const snapshot = await this.fileWatcher.scan();
+        this.send({
+            type: "folder_selected",
+            path: absolutePath,
+            snapshot
+        });
+        await this.fileWatcher.start();
+        console.log(`📂 Syncing folder: ${absolutePath}`);
+    }
+    async handleRequestFile(requestId, path) {
+        if (!this.fileTransfer) return void this.send(createErrorMessage(ErrorCodes.FOLDER_NOT_FOUND, "No folder selected", requestId));
+        await this.fileTransfer.sendFile(requestId, path);
+    }
+    async handleSendFile(requestId, path, totalChunks, fileSize) {
+        if (!this.fileTransfer) return void this.send(createErrorMessage(ErrorCodes.FOLDER_NOT_FOUND, "No folder selected", requestId));
+        await this.fileTransfer.receiveFile(requestId, path, totalChunks, fileSize);
+    }
+    async handleFileChunk(requestId, index, data) {
+        if (!this.fileTransfer) return void this.send(createErrorMessage(ErrorCodes.FOLDER_NOT_FOUND, "No folder selected", requestId));
+        await this.fileTransfer.handleChunk(requestId, index, data);
+    }
+    async handleFileTransferComplete(requestId) {
+        if (!this.fileTransfer) return;
+        await this.fileTransfer.handleTransferComplete(requestId);
+    }
+    async handleWriteConfig(path, assetId, folderId, originalFilename, md5) {
+        if (!this.fileWatcher) return void this.send(createErrorMessage(ErrorCodes.FOLDER_NOT_FOUND, "No folder selected"));
+        try {
+            await this.fileWatcher.writeConfig(path, assetId, folderId, originalFilename, md5);
+            this.fileWatcher.unmarkProcessing(path);
+            if (assetId && path.includes("/")) {
+                const folderPath = path.substring(0, path.lastIndexOf("/"));
+                this.fileWatcher.unmarkProcessing(folderPath);
+            }
+            this.send({
+                type: "config_written",
+                path,
+                assetId,
+                folderId
+            });
+        } catch (error) {
+            this.fileWatcher.unmarkProcessing(path);
+            if (assetId && path.includes("/")) {
+                const folderPath = path.substring(0, path.lastIndexOf("/"));
+                this.fileWatcher.unmarkProcessing(folderPath);
+            }
+            this.send(createErrorMessage(ErrorCodes.PERMISSION_DENIED, `Failed to write config: ${error}`));
+        }
+    }
+    async handleCancelTransfer(requestId) {
+        if (!this.fileTransfer) return;
+        await this.fileTransfer.cancelTransfer(requestId);
+    }
+    send(message) {
+        if (this.client && 1 === this.client.readyState) this.client.send(JSON.stringify(message));
+    }
+    getAddress() {
+        return `ws://${this.host}:${this.port}`;
+    }
+    isClientConnected() {
+        return null !== this.client && 1 === this.client.readyState;
+    }
+    enqueueMessage(message) {
+        this.messageQueue.push(message);
+        this.processQueue();
+    }
+    async processQueue() {
+        if (this.isProcessingQueue) return;
+        this.isProcessingQueue = true;
+        while(this.messageQueue.length > 0){
+            const message = this.messageQueue.shift();
+            try {
+                await this.handleMessage(message);
+            } catch (error) {
+                console.error("Error handling message:", error);
+            }
+        }
+        this.isProcessingQueue = false;
+    }
+}
 const program = new Command();
-program.name("syncast-cli").description("Syncast CLI tool").version("0.1.0");
-program.command("start").description("Start the Syncast server").option("-p, --port <port>", "Port to listen on", "3456").option("-h, --host <host>", "Host to bind to", "localhost").action(async (options)=>{
+program.name("syncast-cli").description("Syncast CLI tool for local file sync").version("0.1.0");
+program.command("sync").description("Start the local sync server").option("-p, --port <port>", "Port to listen on", String(__webpack_exports__DEFAULT_PORT)).option("-H, --host <host>", "Host to bind to", DEFAULT_HOST).action(startSyncServer);
+async function startSyncServer(options) {
     const port = Number.parseInt(options.port, 10);
     const host = options.host;
-    console.log("🔧 Syncast CLI");
+    console.log("");
+    console.log("🔧 Syncast Local Sync");
     console.log("   Version: 0.1.0");
     console.log(`   Port: ${port}`);
     console.log(`   Host: ${host}`);
+    console.log(`   Working Directory: ${process.cwd()}`);
     console.log("");
-    const server = await createServer({
+    const server = new SyncServer({
         port,
         host
+    }, {
+        onClientConnected: ()=>{
+            console.log("📱 Frontend connected");
+        },
+        onClientDisconnected: ()=>{
+            console.log("📴 Frontend disconnected");
+        },
+        onError: (error)=>{
+            console.error("❌ Server error:", error.message);
+        }
     });
-    await server.start();
-    process.on("SIGINT", async ()=>{
+    try {
+        await server.start();
+        console.log("");
+        console.log("✨ Ready to sync! Connect from Syncast frontend.");
+        console.log(`   Address: ${server.getAddress()}`);
+        console.log("");
+        console.log("Press Ctrl+C to stop.");
+        console.log("");
+    } catch (error) {
+        console.error("Failed to start server:", error);
+        process.exit(1);
+    }
+    const shutdown = async ()=>{
         console.log("\n");
+        console.log("🛑 Shutting down...");
         await server.stop();
         process.exit(0);
-    });
-    process.on("SIGTERM", async ()=>{
-        await server.stop();
-        process.exit(0);
-    });
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
     await new Promise(()=>{});
-});
-program.command("status").description("Check the status of Syncast server").action(()=>{
-    console.log("📊 Checking Syncast server status...");
+}
+program.command("start").description("Alias for 'sync' command - Start the local sync server").option("-p, --port <port>", "Port to listen on", String(__webpack_exports__DEFAULT_PORT)).option("-H, --host <host>", "Host to bind to", DEFAULT_HOST).action(startSyncServer);
+program.command("status").description("Check if a sync server is running").option("-p, --port <port>", "Port to check", String(__webpack_exports__DEFAULT_PORT)).option("-H, --host <host>", "Host to check", DEFAULT_HOST).action(async (options)=>{
+    const port = Number.parseInt(options.port, 10);
+    const host = options.host;
+    const address = `ws://${host}:${port}`;
+    console.log(`📊 Checking sync server at ${address}...`);
+    try {
+        const { WebSocket } = await import("ws");
+        const ws = new WebSocket(address);
+        const timeout = setTimeout(()=>{
+            ws.close();
+            console.log("❌ No server running (timeout)");
+            process.exit(1);
+        }, 3000);
+        ws.on("open", ()=>{
+            clearTimeout(timeout);
+            console.log("✅ Server is running");
+            ws.close();
+            process.exit(0);
+        });
+        ws.on("error", ()=>{
+            clearTimeout(timeout);
+            console.log("❌ No server running");
+            process.exit(1);
+        });
+    } catch  {
+        console.log("❌ Failed to check server status");
+        process.exit(1);
+    }
 });
 async function runCli(args = process.argv) {
     await program.parseAsync(args);
 }
 runCli();
-async function src_createServer(options = {}) {
-    const { port = 3456, host = "localhost" } = options;
-    return {
-        async start () {
-            console.log(`🚀 Syncast server starting on ${host}:${port}`);
-        },
-        async stop () {
-            console.log("🛑 Syncast server stopped");
-        }
-    };
-}
-export { src_createServer as createServer, runCli };
+export { DEFAULT_HOST, __webpack_exports__DEFAULT_PORT as DEFAULT_PORT, FileTransferManager, FileWatcher, __webpack_exports__PROTOCOL_VERSION as PROTOCOL_VERSION, SyncServer, runCli };