@dyyz1993/agent-browser 0.13.2 → 0.24.0

package/dist/daemon.js

@@ -4,10 +4,8 @@ import * as path from 'path';
 import * as os from 'os';
 import { randomUUID } from 'crypto';
 import { BrowserManager } from './browser.js';
-import { IOSManager } from './ios-manager.js';
 import { parseCommand, serializeResponse, errorResponse, successResponse } from './protocol.js';
 import { executeCommand } from './actions.js';
-import { executeIOSCommand } from './ios-actions.js';
 import { getExecutablePath } from './rc-config.js';
 import { StreamServerProxy, getStreamServerIpcPath } from './stream-server.js';
 const isWindows = process.platform === 'win32';
@@ -15,6 +13,7 @@ let currentSession = process.env.AGENT_BROWSER_SESSION || 'default';
 let currentInstanceId = randomUUID().substring(0, 8);
 let streamServerProxy = null;
 let lastUrl = null;
+let lastActivityAt = Date.now();
 const STREAM_SERVER_PID_FILE = 'stream-server.pid';
 const INPUT_FILL_DEBOUNCE_MS = 60;
 const inputFillDebounceMap = new Map();
@@ -59,17 +58,19 @@ export function getSession() {
 export function getInstanceId() {
     return currentInstanceId;
 }
+export function getLastActivityAt() {
+    return lastActivityAt;
+}
 /**
  * Get port number for TCP mode (Windows)
  * Uses a hash of the session name to get a consistent port
  */
 function getPortForSession(session) {
-    let hash = 0;
+    let hash = 2166136261;
     for (let i = 0; i < session.length; i++) {
-        hash = (hash << 5) - hash + session.charCodeAt(i);
-        hash |= 0;
+        hash ^= session.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
     }
-    // Port range 49152-65535 (dynamic/private ports)
     return 49152 + (Math.abs(hash) % 16383);
 }
 /**
@@ -78,8 +79,9 @@ function getPortForSession(session) {
  */
 export function getAppDir() {
     // 1. XDG_RUNTIME_DIR (Linux standard)
-    if (process.env.XDG_RUNTIME_DIR) {
-        return path.join(process.env.XDG_RUNTIME_DIR, 'agent-browser');
+    const runtimeDir = process.env.XDG_RUNTIME_DIR;
+    if (runtimeDir) {
+        return path.join(runtimeDir, 'agent-browser');
     }
     // 2. Home directory fallback (like Docker Desktop's ~/.docker/run/)
     const homeDir = os.homedir();
@@ -203,19 +205,36 @@ export function cleanupSocket(session) {
     const pidFile = getPidFile(session);
     const streamPortFile = getStreamPortFile(session);
     try {
-        if (fs.existsSync(pidFile))
+        // Remove stale files, ignoring ENOENT (avoid TOCTOU race)
+        try {
             fs.unlinkSync(pidFile);
-        if (fs.existsSync(streamPortFile))
+        }
+        catch (_e) {
+            /* not found */
+        }
+        try {
             fs.unlinkSync(streamPortFile);
+        }
+        catch (_e) {
+            /* not found */
+        }
         if (isWindows) {
             const portFile = getPortFile(session);
-            if (fs.existsSync(portFile))
+            try {
                 fs.unlinkSync(portFile);
+            }
+            catch (_e) {
+                /* not found */
+            }
         }
         else {
             const socketPath = getSocketPath(session);
-            if (fs.existsSync(socketPath))
+            try {
                 fs.unlinkSync(socketPath);
+            }
+            catch (_e) {
+                /* not found */
+            }
         }
     }
     catch {
@@ -236,10 +255,9 @@ export async function startDaemon(options) {
     }
     cleanupSocket();
     const provider = options?.provider ?? process.env.AGENT_BROWSER_PROVIDER;
-    const isIOS = provider === 'ios';
-    const manager = isIOS ? new IOSManager() : new BrowserManager();
+    const manager = new BrowserManager();
     let shuttingDown = false;
-    if (!isIOS && manager instanceof BrowserManager) {
+    {
         const ipcPath = getStreamServerIpcPath();
         if (fs.existsSync(ipcPath)) {
             streamServerProxy = new StreamServerProxy(manager);
@@ -259,287 +277,296 @@ export async function startDaemon(options) {
     const server = net.createServer((socket) => {
         let buffer = '';
         let httpChecked = false;
-        socket.on('data', async (data) => {
-            buffer += data.toString();
-            // Security: Detect and reject HTTP requests to prevent cross-origin attacks.
-            // Browsers using fetch() must send HTTP headers (e.g., "POST / HTTP/1.1"),
-            // while legitimate clients send raw JSON starting with "{".
-            if (!httpChecked) {
-                httpChecked = true;
-                const trimmed = buffer.trimStart();
-                if (/^(GET|POST|PUT|DELETE|HEAD|OPTIONS|PATCH|CONNECT|TRACE)\s/i.test(trimmed)) {
-                    socket.destroy();
-                    return;
-                }
-            }
-            // Process complete lines
-            while (buffer.includes('\n')) {
-                const newlineIdx = buffer.indexOf('\n');
-                const line = buffer.substring(0, newlineIdx);
-                buffer = buffer.substring(newlineIdx + 1);
-                if (!line.trim())
-                    continue;
-                // Handle custom actions before schema validation (not in standard Zod union)
-                // Viewer sends messages with 'type' field, standalone commands use 'action' field.
-                // Normalize to support both.
-                if (line.trim()) {
-                    try {
-                        const quickParse = JSON.parse(line);
-                        const action = quickParse.action || quickParse.type;
-                        if (quickParse &&
-                            action === 'inject_focus_listener' &&
-                            manager instanceof BrowserManager) {
-                            try {
-                                await manager.injectFocusListener((data) => {
-                                    try {
-                                        socket.write(JSON.stringify(data) + '\n');
-                                    }
-                                    catch (_) { }
-                                });
-                                socket.write(serializeResponse(successResponse(quickParse.id, { injected: true })) + '\n');
-                            }
-                            catch (err) {
-                                const message = err instanceof Error ? err.message : String(err);
-                                socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+        let processing = false;
+        async function processBuffer() {
+            if (processing)
+                return;
+            processing = true;
+            try {
+                while (buffer.includes('\n')) {
+                    const newlineIdx = buffer.indexOf('\n');
+                    const line = buffer.substring(0, newlineIdx);
+                    buffer = buffer.substring(newlineIdx + 1);
+                    if (!line.trim())
+                        continue;
+                    // Handle custom actions before schema validation (not in standard Zod union)
+                    // Viewer sends messages with 'type' field, standalone commands use 'action' field.
+                    // Normalize to support both.
+                    if (line.trim()) {
+                        try {
+                            const quickParse = JSON.parse(line);
+                            const action = quickParse.action || quickParse.type;
+                            if (quickParse &&
+                                action === 'inject_focus_listener' &&
+                                manager instanceof BrowserManager) {
+                                try {
+                                    await manager.injectFocusListener((data) => {
+                                        try {
+                                            socket.write(JSON.stringify(data) + '\n');
+                                        }
+                                        catch (_e) {
+                                            // Socket write to disconnected client, non-fatal
+                                        }
+                                    });
+                                    socket.write(serializeResponse(successResponse(quickParse.id, { injected: true })) + '\n');
+                                }
+                                catch (err) {
+                                    const message = err instanceof Error ? err.message : String(err);
+                                    socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                                }
+                                continue;
                             }
-                            continue;
-                        }
-                        if (quickParse && action === 'input_fill' && manager instanceof BrowserManager) {
-                            const selector = quickParse.selector || '';
-                            const text = quickParse.text || '';
-                            debounceInputFill(socket, manager, String(quickParse.id), selector, text);
-                            continue;
-                        }
-                        if (quickParse &&
-                            (action === 'blur_element' || action === 'input_blur_element') &&
-                            manager instanceof BrowserManager) {
-                            try {
+                            if (quickParse && action === 'input_fill' && manager instanceof BrowserManager) {
                                 const selector = quickParse.selector || '';
-                                await manager.blurElement(selector);
-                                socket.write(serializeResponse(successResponse(quickParse.id, { blurred: true, selector })) +
-                                    '\n');
+                                const text = quickParse.text || '';
+                                debounceInputFill(socket, manager, String(quickParse.id), selector, text);
+                                continue;
                             }
-                            catch (err) {
-                                const message = err instanceof Error ? err.message : String(err);
-                                socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                            if (quickParse &&
+                                (action === 'blur_element' || action === 'input_blur_element') &&
+                                manager instanceof BrowserManager) {
+                                try {
+                                    const selector = quickParse.selector || '';
+                                    await manager.blurElement(selector);
+                                    socket.write(serializeResponse(successResponse(quickParse.id, { blurred: true, selector })) +
+                                        '\n');
+                                }
+                                catch (err) {
+                                    const message = err instanceof Error ? err.message : String(err);
+                                    socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                                }
+                                continue;
                             }
-                            continue;
-                        }
-                        if (quickParse && action === 'input_mouse' && manager instanceof BrowserManager) {
-                            try {
-                                await manager.injectMouseEvent({
-                                    type: quickParse.eventType,
-                                    x: quickParse.x ?? 0,
-                                    y: quickParse.y ?? 0,
-                                    button: quickParse.button,
-                                    clickCount: quickParse.clickCount,
-                                    deltaX: quickParse.deltaX,
-                                    deltaY: quickParse.deltaY,
-                                    modifiers: quickParse.modifiers,
-                                });
-                                socket.write(serializeResponse(successResponse(quickParse.id, { injected: true })) + '\n');
+                            if (quickParse && action === 'input_mouse' && manager instanceof BrowserManager) {
+                                try {
+                                    await manager.injectMouseEvent({
+                                        type: quickParse.eventType,
+                                        x: quickParse.x ?? 0,
+                                        y: quickParse.y ?? 0,
+                                        button: quickParse.button,
+                                        clickCount: quickParse.clickCount,
+                                        deltaX: quickParse.deltaX,
+                                        deltaY: quickParse.deltaY,
+                                        modifiers: quickParse.modifiers,
+                                    });
+                                    socket.write(serializeResponse(successResponse(quickParse.id, { injected: true })) + '\n');
+                                }
+                                catch (err) {
+                                    const message = err instanceof Error ? err.message : String(err);
+                                    socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                                }
+                                continue;
                             }
-                            catch (err) {
-                                const message = err instanceof Error ? err.message : String(err);
-                                socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                            if (quickParse && action === 'input_keyboard' && manager instanceof BrowserManager) {
+                                try {
+                                    await manager.injectKeyboardEvent({
+                                        type: quickParse.eventType,
+                                        key: quickParse.key,
+                                        code: quickParse.code,
+                                        text: quickParse.text,
+                                        modifiers: quickParse.modifiers,
+                                    });
+                                    socket.write(serializeResponse(successResponse(quickParse.id, { injected: true })) + '\n');
+                                }
+                                catch (err) {
+                                    const message = err instanceof Error ? err.message : String(err);
+                                    socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                                }
+                                continue;
                             }
+                            if (quickParse &&
+                                action === 'keyboard_insert_text' &&
+                                manager instanceof BrowserManager) {
+                                try {
+                                    const text = quickParse.text || '';
+                                    await manager.insertText(text);
+                                    socket.write(serializeResponse(successResponse(quickParse.id, { inserted: true })) + '\n');
+                                }
+                                catch (err) {
+                                    const message = err instanceof Error ? err.message : String(err);
+                                    socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                                }
+                                continue;
+                            }
+                            if (quickParse && action === '_ping') {
+                                try {
+                                    const tabList = manager instanceof BrowserManager && manager.isLaunched()
+                                        ? await manager.listTabs()
+                                        : [];
+                                    socket.write(serializeResponse(successResponse(quickParse.id, {
+                                        session: currentSession,
+                                        lastActivityAt,
+                                        tabs: tabList,
+                                    })) + '\n');
+                                }
+                                catch (err) {
+                                    const message = err instanceof Error ? err.message : String(err);
+                                    socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                                }
+                                continue;
+                            }
+                        }
+                        catch (_) {
+                            /* not JSON, fall through to normal parsing */
+                        }
+                    }
+                    try {
+                        const parseResult = parseCommand(line);
+                        if (!parseResult.success) {
+                            const resp = errorResponse(parseResult.id ?? 'unknown', parseResult.error);
+                            socket.write(serializeResponse(resp) + '\n');
                             continue;
                         }
-                        if (quickParse && action === 'input_keyboard' && manager instanceof BrowserManager) {
-                            try {
-                                await manager.injectKeyboardEvent({
-                                    type: quickParse.eventType,
-                                    key: quickParse.key,
-                                    code: quickParse.code,
-                                    text: quickParse.text,
-                                    modifiers: quickParse.modifiers,
+                        // Auto-launch if not already launched and this isn't a launch/close command
+                        if (!manager.isLaunched() &&
+                            parseResult.command.action !== 'launch' &&
+                            parseResult.command.action !== 'close') {
+                            if (manager instanceof BrowserManager) {
+                                // Auto-launch desktop browser
+                                const extensions = process.env.AGENT_BROWSER_EXTENSIONS
+                                    ? (process.env.AGENT_BROWSER_EXTENSIONS || '')
+                                        .split(',')
+                                        .map((p) => p.trim())
+                                        .filter(Boolean)
+                                    : undefined;
+                                // Parse args from env (comma or newline separated)
+                                const argsEnv = process.env.AGENT_BROWSER_ARGS;
+                                const args = argsEnv
+                                    ? argsEnv
+                                        .split(/[,\n]/)
+                                        .map((a) => a.trim())
+                                        .filter((a) => a.length > 0)
+                                    : undefined;
+                                // Parse proxy from env
+                                const proxyServer = process.env.AGENT_BROWSER_PROXY;
+                                const proxyBypass = process.env.AGENT_BROWSER_PROXY_BYPASS;
+                                const proxy = proxyServer
+                                    ? {
+                                        server: proxyServer,
+                                        ...(proxyBypass && { bypass: proxyBypass }),
+                                    }
+                                    : undefined;
+                                const ignoreHTTPSErrors = process.env.AGENT_BROWSER_IGNORE_HTTPS_ERRORS === '1';
+                                const allowFileAccess = process.env.AGENT_BROWSER_ALLOW_FILE_ACCESS === '1';
+                                await manager.launch({
+                                    id: 'auto',
+                                    action: 'launch',
+                                    headless: process.env.AGENT_BROWSER_HEADED !== '1',
+                                    executablePath: process.env.AGENT_BROWSER_EXECUTABLE_PATH || getExecutablePath(),
+                                    extensions: extensions,
+                                    profile: process.env.AGENT_BROWSER_PROFILE,
+                                    storageState: process.env.AGENT_BROWSER_STATE,
+                                    args,
+                                    userAgent: process.env.AGENT_BROWSER_USER_AGENT,
+                                    proxy,
+                                    ignoreHTTPSErrors: ignoreHTTPSErrors,
+                                    allowFileAccess: allowFileAccess,
                                 });
-                                socket.write(serializeResponse(successResponse(quickParse.id, { injected: true })) + '\n');
                             }
-                            catch (err) {
-                                const message = err instanceof Error ? err.message : String(err);
-                                socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                        }
+                        // Handle close command specially - shuts down daemon
+                        if (parseResult.command.action === 'close') {
+                            const response = await executeCommand(parseResult.command, manager);
+                            socket.write(serializeResponse(response) + '\n');
+                            if (!shuttingDown) {
+                                shuttingDown = true;
+                                // 先断开 StreamServer 连接，发送 unregister 消息
+                                if (streamServerProxy) {
+                                    await streamServerProxy.disconnect();
+                                    streamServerProxy = null;
+                                }
+                                setTimeout(() => {
+                                    server.close();
+                                    cleanupSocket();
+                                    process.exit(0);
+                                }, 100);
                             }
-                            continue;
+                            return;
                         }
-                        if (quickParse &&
-                            action === 'keyboard_insert_text' &&
+                        // Handle inject_focus_listener: set up focus event bridge to stream-server
+                        if (parseResult.command.action === 'inject_focus_listener' &&
                             manager instanceof BrowserManager) {
                             try {
-                                const text = quickParse.text || '';
-                                await manager.insertText(text);
-                                socket.write(serializeResponse(successResponse(quickParse.id, { inserted: true })) + '\n');
+                                await manager.injectFocusListener((data) => {
+                                    try {
+                                        socket.write(JSON.stringify(data) + '\n');
+                                    }
+                                    catch (_e) {
+                                        // Socket write to disconnected client, non-fatal
+                                    }
+                                });
+                                socket.write(serializeResponse(successResponse(parseResult.command.id, { injected: true })) +
+                                    '\n');
                             }
                             catch (err) {
                                 const message = err instanceof Error ? err.message : String(err);
-                                socket.write(serializeResponse(errorResponse(quickParse.id, message)) + '\n');
+                                socket.write(serializeResponse(errorResponse(parseResult.command.id, message)) + '\n');
                             }
                             continue;
                         }
-                    }
-                    catch (_) {
-                        /* not JSON, fall through to normal parsing */
-                    }
-                }
-                try {
-                    const parseResult = parseCommand(line);
-                    if (!parseResult.success) {
-                        const resp = errorResponse(parseResult.id ?? 'unknown', parseResult.error);
-                        socket.write(serializeResponse(resp) + '\n');
-                        continue;
-                    }
-                    // Handle device_list specially - it works without a session and always uses IOSManager
-                    if (parseResult.command.action === 'device_list') {
-                        const iosManager = new IOSManager();
-                        try {
-                            const devices = await iosManager.listAllDevices();
-                            const response = {
-                                id: parseResult.command.id,
-                                success: true,
-                                data: { devices },
-                            };
-                            socket.write(serializeResponse(response) + '\n');
-                        }
-                        catch (err) {
-                            const message = err instanceof Error ? err.message : String(err);
-                            socket.write(serializeResponse(errorResponse(parseResult.command.id, message)) + '\n');
-                        }
-                        continue;
-                    }
-                    // Auto-launch if not already launched and this isn't a launch/close command
-                    if (!manager.isLaunched() &&
-                        parseResult.command.action !== 'launch' &&
-                        parseResult.command.action !== 'close') {
-                        if (isIOS && manager instanceof IOSManager) {
-                            // Auto-launch iOS Safari
-                            // Check for device in command first (for reused daemons), then fall back to env vars
-                            const cmd = parseResult.command;
-                            const iosDevice = cmd.iosDevice || process.env.AGENT_BROWSER_IOS_DEVICE;
-                            await manager.launch({
-                                device: iosDevice,
-                                udid: process.env.AGENT_BROWSER_IOS_UDID,
-                            });
-                        }
-                        else if (manager instanceof BrowserManager) {
-                            // Auto-launch desktop browser
-                            const extensions = process.env.AGENT_BROWSER_EXTENSIONS
-                                ? process.env.AGENT_BROWSER_EXTENSIONS.split(',')
-                                    .map((p) => p.trim())
-                                    .filter(Boolean)
-                                : undefined;
-                            // Parse args from env (comma or newline separated)
-                            const argsEnv = process.env.AGENT_BROWSER_ARGS;
-                            const args = argsEnv
-                                ? argsEnv
-                                    .split(/[,\n]/)
-                                    .map((a) => a.trim())
-                                    .filter((a) => a.length > 0)
-                                : undefined;
-                            // Parse proxy from env
-                            const proxyServer = process.env.AGENT_BROWSER_PROXY;
-                            const proxyBypass = process.env.AGENT_BROWSER_PROXY_BYPASS;
-                            const proxy = proxyServer
-                                ? {
-                                    server: proxyServer,
-                                    ...(proxyBypass && { bypass: proxyBypass }),
+                        lastActivityAt = Date.now();
+                        // Execute command with appropriate handler
+                        let response = await executeCommand(parseResult.command, manager);
+                        if (response.success && manager instanceof BrowserManager && manager.isLaunched()) {
+                            try {
+                                const currentUrl = manager.getPage().url();
+                                if (lastUrl !== null && currentUrl !== lastUrl) {
+                                    const urlTip = `URL changed: ${lastUrl} -> ${currentUrl}`;
+                                    const existingTips = response.tips;
+                                    if (existingTips) {
+                                        const tipsArray = Array.isArray(existingTips) ? existingTips : [existingTips];
+                                        response.tips = [urlTip, ...tipsArray];
+                                    }
+                                    else {
+                                        response.tips = [urlTip];
+                                    }
                                 }
-                                : undefined;
-                            const ignoreHTTPSErrors = process.env.AGENT_BROWSER_IGNORE_HTTPS_ERRORS === '1';
-                            const allowFileAccess = process.env.AGENT_BROWSER_ALLOW_FILE_ACCESS === '1';
-                            await manager.launch({
-                                id: 'auto',
-                                action: 'launch',
-                                headless: process.env.AGENT_BROWSER_HEADED !== '1',
-                                executablePath: process.env.AGENT_BROWSER_EXECUTABLE_PATH || getExecutablePath(),
-                                extensions: extensions,
-                                profile: process.env.AGENT_BROWSER_PROFILE,
-                                storageState: process.env.AGENT_BROWSER_STATE,
-                                args,
-                                userAgent: process.env.AGENT_BROWSER_USER_AGENT,
-                                proxy,
-                                ignoreHTTPSErrors: ignoreHTTPSErrors,
-                                allowFileAccess: allowFileAccess,
-                            });
-                        }
-                    }
-                    // Handle close command specially - shuts down daemon
-                    if (parseResult.command.action === 'close') {
-                        const response = isIOS && manager instanceof IOSManager
-                            ? await executeIOSCommand(parseResult.command, manager)
-                            : await executeCommand(parseResult.command, manager);
-                        socket.write(serializeResponse(response) + '\n');
-                        if (!shuttingDown) {
-                            shuttingDown = true;
-                            // 先断开 StreamServer 连接，发送 unregister 消息
-                            if (streamServerProxy) {
-                                await streamServerProxy.disconnect();
-                                streamServerProxy = null;
+                                lastUrl = currentUrl;
                             }
-                            setTimeout(() => {
-                                server.close();
-                                cleanupSocket();
-                                process.exit(0);
-                            }, 100);
-                        }
-                        return;
-                    }
-                    // Handle inject_focus_listener: set up focus event bridge to stream-server
-                    if (parseResult.command.action === 'inject_focus_listener' &&
-                        manager instanceof BrowserManager) {
-                        try {
-                            await manager.injectFocusListener((data) => {
-                                try {
-                                    socket.write(JSON.stringify(data) + '\n');
-                                }
-                                catch (_) { }
-                            });
-                            socket.write(serializeResponse(successResponse(parseResult.command.id, { injected: true })) +
-                                '\n');
-                        }
-                        catch (err) {
-                            const message = err instanceof Error ? err.message : String(err);
-                            socket.write(serializeResponse(errorResponse(parseResult.command.id, message)) + '\n');
-                        }
-                        continue;
-                    }
-                    // Execute command with appropriate handler
-                    let response = isIOS && manager instanceof IOSManager
-                        ? await executeIOSCommand(parseResult.command, manager)
-                        : await executeCommand(parseResult.command, manager);
-                    if (response.success &&
-                        !isIOS &&
-                        manager instanceof BrowserManager &&
-                        manager.isLaunched()) {
-                        try {
-                            const currentUrl = manager.getPage().url();
-                            if (lastUrl !== null && currentUrl !== lastUrl) {
-                                const urlTip = `URL changed: ${lastUrl} -> ${currentUrl}`;
-                                const existingTips = response.tips;
-                                if (existingTips) {
-                                    const tipsArray = Array.isArray(existingTips) ? existingTips : [existingTips];
-                                    response.tips = [urlTip, ...tipsArray];
-                                }
-                                else {
-                                    response.tips = [urlTip];
-                                }
+                            catch {
+                                // Page may not be available (e.g., after close)
                             }
-                            lastUrl = currentUrl;
-                        }
-                        catch {
-                            // Page may not be available (e.g., after close)
                         }
+                        socket.write(serializeResponse(response) + '\n');
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        socket.write(serializeResponse(errorResponse('error', message)) + '\n');
                     }
-                    socket.write(serializeResponse(response) + '\n');
                 }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    socket.write(serializeResponse(errorResponse('error', message)) + '\n');
+            }
+            finally {
+                processing = false;
+                if (buffer.includes('\n')) {
+                    processBuffer();
+                }
+            }
+        }
+        socket.on('data', (data) => {
+            buffer += data.toString();
+            // Security: Detect and reject HTTP requests to prevent cross-origin attacks.
+            // Browsers using fetch() must send HTTP headers (e.g., "POST / HTTP/1.1"),
+            // while legitimate clients send raw JSON starting with "{".
+            if (!httpChecked) {
+                httpChecked = true;
+                const trimmed = buffer.trimStart();
+                if (/^(GET|POST|PUT|DELETE|HEAD|OPTIONS|PATCH|CONNECT|TRACE)\s/i.test(trimmed)) {
+                    socket.destroy();
+                    return;
                 }
             }
+            processBuffer();
         });
         socket.on('error', () => {
             // Client disconnected, ignore
         });
+        socket.on('close', () => {
+            // Clear any pending debounce timers to prevent writes to closed socket
+            for (const [key, entry] of inputFillDebounceMap.entries()) {
+                clearTimeout(entry.timer);
+                inputFillDebounceMap.delete(key);
+            }
+        });
     });
     const pidFile = getPidFile();
     // Write PID file before listening