@sstar/embedlink_agent 0.1.0

package/dist/board_uart/sessions.js

@@ -0,0 +1,559 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DefaultTimeouts, ErrorCodes, error } from '../core/errors.js';
+import { getSharedBoardUartManager } from './manager.js';
+import { appendBoardUartHistoryChunk } from './history.js';
+const manager = getSharedBoardUartManager();
+const sessions = new Map();
+let defaultSessionId = null;
+let boardUartPortHint;
+let boardUartBaudHint;
+const MAX_BUFFER_BYTES = 1024 * 1024;
+let hardwareSuspendedOwner = null;
+export function setBoardUartHardwareSuspended(owner) {
+    const v = (owner || '').trim();
+    hardwareSuspendedOwner = v ? v : null;
+}
+function assertHardwareNotSuspended() {
+    if (!hardwareSuspendedOwner)
+        return;
+    throw error(ErrorCodes.EL_BOARD_UART_SUSPENDED, `board-uart hardware suspended by ${hardwareSuspendedOwner}`);
+}
+function getTimestamp() {
+    const d = new Date();
+    const time = d.toLocaleTimeString('en-US', {
+        hour12: false,
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    });
+    const ms = d.getMilliseconds().toString().padStart(3, '0');
+    return `[${time}.${ms}] `;
+}
+export function setDefaultBoardUartHint(port, baud) {
+    const p = (port || '').trim();
+    // Avoid hanging on invalid default port hints.
+    // On non-Windows platforms we only accept /dev/* style paths.
+    if (p) {
+        if (process.platform !== 'win32' && !p.startsWith('/dev/')) {
+            boardUartPortHint = undefined;
+        }
+        else {
+            boardUartPortHint = p;
+        }
+    }
+    else {
+        boardUartPortHint = undefined;
+    }
+    boardUartBaudHint = baud;
+}
+async function pickDefaultPortAndBaud() {
+    const baud = boardUartBaudHint && boardUartBaudHint > 0 ? boardUartBaudHint : 115200;
+    if (boardUartPortHint) {
+        return { port: boardUartPortHint, baud };
+    }
+    const ports = await manager.list();
+    if (!ports.length) {
+        throw error(ErrorCodes.EL_BOARD_UART_NO_DEVICE, 'no board-uart device detected for default session');
+    }
+    return { port: ports[0].path, baud };
+}
+function makeSessionId(port, baud) {
+    return `sess-${port}-${baud}`;
+}
+export function buildSessionId(port, baud) {
+    return makeSessionId(port, baud);
+}
+function handleIncoming(state, chunk) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    appendBoardUartHistoryChunk(state.id, buf);
+    // Logging logic
+    if (state.recording && state.logStream) {
+        try {
+            const text = chunk.toString('utf8');
+            const lines = (state.logLineBuffer + text).split('\n');
+            state.logLineBuffer = lines.pop() || '';
+            for (const line of lines) {
+                // Remove \r for cleaner log file if desired, or keep it. keeping for now.
+                state.logStream.write(getTimestamp() + line + '\n');
+            }
+        }
+        catch {
+            // ignore log errors
+        }
+    }
+    state.buffer.push(buf);
+    state.bufferBytes += buf.length;
+    // 丢弃最旧的数据，防止无限增长
+    while (state.bufferBytes > MAX_BUFFER_BYTES && state.buffer.length > 0) {
+        const old = state.buffer.shift();
+        state.bufferBytes -= old.length;
+    }
+    // 通知等待的读取
+    const waiters = Array.from(state.waiters);
+    for (const fn of waiters) {
+        try {
+            fn();
+        }
+        catch {
+            // ignore waiter errors
+        }
+    }
+    // 广播给订阅者
+    for (const consumer of state.consumers.values()) {
+        try {
+            consumer.onData(buf);
+        }
+        catch {
+            // ignore consumer errors
+        }
+    }
+}
+function handleSessionError(state, e) {
+    for (const consumer of state.consumers.values()) {
+        try {
+            consumer.onError?.(e);
+        }
+        catch {
+            // ignore consumer errors
+        }
+    }
+}
+async function ensureSessionHardwareOpen(state) {
+    if (state.hardwareOpen)
+        return;
+    assertHardwareNotSuspended();
+    const stream = await manager.openStream({
+        port: state.port,
+        baud: state.baud,
+        onData(chunk) {
+            handleIncoming(state, chunk);
+        },
+        onError(e) {
+            handleSessionError(state, e);
+        },
+    });
+    state.write = stream.write;
+    state.close = stream.close;
+    state.hardwareOpen = true;
+}
+async function ensureSession(id, port, baud, opts) {
+    const existing = sessions.get(id);
+    if (existing)
+        return existing;
+    assertHardwareNotSuspended();
+    let state;
+    const stream = await manager.openStream({
+        port,
+        baud,
+        onData(chunk) {
+            handleIncoming(state, chunk);
+        },
+        onError(e) {
+            handleSessionError(state, e);
+        },
+    });
+    state = {
+        id,
+        label: opts.label || port,
+        role: opts.role || 'primary',
+        isDefault: opts.isDefault,
+        canWrite: opts.canWrite ?? true,
+        port,
+        baud,
+        recording: false,
+        logLineBuffer: '',
+        hardwareOpen: true,
+        buffer: [],
+        bufferBytes: 0,
+        reading: false,
+        waiters: new Set(),
+        consumers: new Map(),
+        write: stream.write,
+        close: stream.close,
+    };
+    sessions.set(id, state);
+    if (opts.isDefault) {
+        defaultSessionId = id;
+    }
+    return state;
+}
+async function getDefaultSession() {
+    if (defaultSessionId) {
+        const s = sessions.get(defaultSessionId);
+        if (s)
+            return s;
+    }
+    const { port, baud } = await pickDefaultPortAndBaud();
+    const id = makeSessionId(port, baud);
+    return ensureSession(id, port, baud, {
+        isDefault: true,
+        label: 'default',
+        role: 'primary',
+        canWrite: true,
+    });
+}
+function getSessionOrThrow(sessionId) {
+    const id = sessionId && sessionId.trim().length > 0 ? sessionId : defaultSessionId;
+    if (!id) {
+        throw error(ErrorCodes.EL_BOARD_UART_SESSION_NOT_FOUND, 'no default board-uart session available (no port configured)');
+    }
+    const s = sessions.get(id);
+    if (!s) {
+        // 如果是查找默认会话且会话不存在，返回临时不可用错误而不是永久性错误
+        if (!sessionId || sessionId === 'default') {
+            throw error(ErrorCodes.EL_BOARD_UART_SESSION_TEMPORARILY_UNAVAILABLE, `default session temporarily unavailable, please retry: ${id}`);
+        }
+        throw error(ErrorCodes.EL_BOARD_UART_SESSION_NOT_FOUND, `board-uart session not found: ${id}`);
+    }
+    return s;
+}
+function toSessionInfo(s) {
+    return {
+        id: s.id,
+        label: s.label,
+        role: s.role,
+        isDefault: s.isDefault,
+        canWrite: s.canWrite,
+        port: s.port,
+        baud: s.baud,
+        recording: s.recording,
+        logPath: s.logPath,
+    };
+}
+export function listExistingBoardUartSessions() {
+    const all = [];
+    for (const s of sessions.values()) {
+        all.push(toSessionInfo(s));
+    }
+    return all;
+}
+export async function listBoardUartSessions() {
+    const all = listExistingBoardUartSessions();
+    if (!all.length) {
+        try {
+            const s = await getDefaultSession();
+            all.push(toSessionInfo(s));
+        }
+        catch {
+            // 没有串口设备时返回空列表
+        }
+    }
+    return all;
+}
+export async function writeToSession(sessionId, data) {
+    let s;
+    try {
+        s = sessionId ? getSessionOrThrow(sessionId) : await getDefaultSession();
+    }
+    catch (e) {
+        // 如果是默认会话临时不可用，尝试重新创建
+        if (e.code === 'EL_BOARD_UART_SESSION_TEMPORARILY_UNAVAILABLE') {
+            s = await getDefaultSession();
+        }
+        else {
+            throw e;
+        }
+    }
+    await ensureSessionHardwareOpen(s);
+    if (!s.canWrite) {
+        throw error(ErrorCodes.EL_BOARD_UART_READONLY_SESSION, `board-uart session is read-only: ${s.id}`);
+    }
+    return s.write(data);
+}
+export async function readFromSession(params) {
+    let s;
+    try {
+        s = params.sessionId ? getSessionOrThrow(params.sessionId) : await getDefaultSession();
+    }
+    catch (e) {
+        // 如果是默认会话临时不可用，尝试重新创建
+        if (e.code === 'EL_BOARD_UART_SESSION_TEMPORARILY_UNAVAILABLE') {
+            s = await getDefaultSession();
+        }
+        else {
+            throw e;
+        }
+    }
+    await ensureSessionHardwareOpen(s);
+    if (s.reading) {
+        throw error(ErrorCodes.EL_BOARD_UART_READ_IN_PROGRESS, `board-uart session is already reading: ${s.id}`);
+    }
+    const maxBytes = params.maxBytes && params.maxBytes > 0 ? params.maxBytes : 8192;
+    const quietMs = params.quietMs && params.quietMs > 0 ? params.quietMs : 200;
+    const timeoutMs = params.timeoutMs && params.timeoutMs > 0 ? params.timeoutMs : DefaultTimeouts.boardUart.read;
+    s.reading = true;
+    try {
+        const chunks = [];
+        let bytes = 0;
+        let lastActivity = Date.now();
+        const drainFromBuffer = () => {
+            while (s.buffer.length && bytes < maxBytes) {
+                const chunk = s.buffer.shift();
+                s.bufferBytes -= chunk.length;
+                const remaining = maxBytes - bytes;
+                if (chunk.length <= remaining) {
+                    chunks.push(chunk);
+                    bytes += chunk.length;
+                }
+                else {
+                    const part = chunk.subarray(0, remaining);
+                    const rest = chunk.subarray(remaining);
+                    chunks.push(part);
+                    bytes += part.length;
+                    s.buffer.unshift(rest);
+                    s.bufferBytes += rest.length;
+                    break;
+                }
+            }
+        };
+        drainFromBuffer();
+        return await new Promise((resolve) => {
+            let finished = false;
+            const finish = (timedOut) => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(timeoutTimer);
+                clearInterval(quietTimer);
+                s.waiters.delete(onNewData);
+                drainFromBuffer();
+                const remains = s.bufferBytes; // 缓冲区剩余字节数
+                resolve({ data: Buffer.concat(chunks, bytes), bytes, timedOut, remains });
+            };
+            const onNewData = () => {
+                lastActivity = Date.now();
+                drainFromBuffer();
+                if (bytes >= maxBytes) {
+                    finish(false);
+                }
+            };
+            s.waiters.add(onNewData);
+            const quietTimer = setInterval(() => {
+                const now = Date.now();
+                if (now - lastActivity >= quietMs) {
+                    finish(false);
+                }
+            }, quietMs);
+            const timeoutTimer = setTimeout(() => {
+                finish(true);
+            }, timeoutMs);
+            // 如果初次 drain 已经拿到了足够的数据，尽快返回
+            if (bytes >= maxBytes) {
+                finish(false);
+            }
+            else if (bytes > 0) {
+                // 有数据但未满，等待 quietMs 结束
+            }
+        });
+    }
+    finally {
+        s.reading = false;
+    }
+}
+export async function openManualSession(params) {
+    if (!params.port || !params.baud) {
+        throw error(ErrorCodes.EL_INVALID_PARAMS, 'port/baud are required for manual session');
+    }
+    const id = makeSessionId(params.port, params.baud);
+    const s = await ensureSession(id, params.port, params.baud, {
+        isDefault: false,
+        label: params.port,
+        role: 'manual',
+        canWrite: true,
+    });
+    return {
+        id: s.id,
+        label: s.label,
+        role: s.role,
+        isDefault: s.isDefault,
+        canWrite: s.canWrite,
+        port: s.port,
+        baud: s.baud,
+        recording: s.recording,
+        logPath: s.logPath,
+    };
+}
+export async function closeSession(sessionId) {
+    const s = getSessionOrThrow(sessionId);
+    if (s.isDefault) {
+        throw error(ErrorCodes.EL_INVALID_PARAMS, `cannot close default board-uart session via closeSession: ${sessionId}`);
+    }
+    sessions.delete(sessionId);
+    if (defaultSessionId === sessionId) {
+        defaultSessionId = null;
+    }
+    if (s.recording) {
+        await stopRecording(sessionId).catch(() => { });
+    }
+    for (const consumer of s.consumers.values()) {
+        try {
+            consumer.onError?.(error(ErrorCodes.EL_BOARD_UART_OPEN_FAILED, 'board-uart session closed'));
+        }
+        catch {
+            // ignore consumer errors
+        }
+    }
+    s.consumers.clear();
+    try {
+        await s.close();
+    }
+    catch {
+        // ignore close errors
+    }
+    s.hardwareOpen = false;
+    return true;
+}
+export async function startRecording(sessionId, logDir) {
+    const s = getSessionOrThrow(sessionId);
+    if (s.recording)
+        return s.logPath || '';
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const filename = `serial-${s.port.replace(/[^a-zA-Z0-9]/g, '_')}-${timestamp}.log`;
+    const fullPath = path.join(logDir, filename);
+    await fs.promises.mkdir(logDir, { recursive: true });
+    const stream = fs.createWriteStream(fullPath, { flags: 'a' });
+    s.recording = true;
+    s.logPath = fullPath;
+    s.logStream = stream;
+    s.logLineBuffer = '';
+    return fullPath;
+}
+export async function stopRecording(sessionId) {
+    const s = getSessionOrThrow(sessionId);
+    if (!s.recording)
+        return;
+    if (s.logStream) {
+        // Flush buffer
+        if (s.logLineBuffer) {
+            try {
+                s.logStream.write(getTimestamp() + s.logLineBuffer + '\n');
+            }
+            catch { }
+        }
+        s.logStream.end();
+        s.logStream = undefined;
+    }
+    s.recording = false;
+    s.logPath = undefined;
+}
+export async function addSessionConsumer(params) {
+    if (!params.consumerId) {
+        throw error(ErrorCodes.EL_INVALID_PARAMS, 'consumerId is required');
+    }
+    let session;
+    if (params.sessionId) {
+        const s = sessions.get(params.sessionId);
+        if (s) {
+            session = s;
+        }
+        else if (params.port && params.baud) {
+            session = await ensureSession(params.sessionId, params.port, params.baud, {
+                isDefault: false,
+                label: params.port,
+                role: 'shared',
+                canWrite: true,
+            });
+        }
+        else {
+            // 对于不存在的session，如果是default，尝试重新创建
+            if (params.sessionId === 'default') {
+                session = await getDefaultSession();
+            }
+            else {
+                session = getSessionOrThrow(params.sessionId);
+            }
+        }
+    }
+    else if (params.port && params.baud) {
+        const id = makeSessionId(params.port, params.baud);
+        session = await ensureSession(id, params.port, params.baud, {
+            isDefault: false,
+            label: params.port,
+            role: 'shared',
+            canWrite: true,
+        });
+    }
+    else {
+        session = await getDefaultSession();
+    }
+    session.consumers.set(params.consumerId, {
+        id: params.consumerId,
+        onData: params.onData,
+        onError: params.onError,
+    });
+    return {
+        id: session.id,
+        label: session.label,
+        role: session.role,
+        isDefault: session.isDefault,
+        canWrite: session.canWrite,
+        port: session.port,
+        baud: session.baud,
+        recording: session.recording,
+        logPath: session.logPath,
+    };
+}
+export function removeSessionConsumer(sessionId, consumerId) {
+    const s = sessions.get(sessionId);
+    if (!s)
+        return;
+    s.consumers.delete(consumerId);
+}
+export async function forceCloseAllSessions() {
+    const all = Array.from(sessions.values());
+    sessions.clear();
+    defaultSessionId = null;
+    for (const s of all) {
+        if (s.recording)
+            await stopRecording(s.id).catch(() => { });
+        for (const consumer of s.consumers.values()) {
+            try {
+                consumer.onError?.(error(ErrorCodes.EL_BOARD_UART_OPEN_FAILED, 'board-uart session closed by forceClose'));
+            }
+            catch {
+                // ignore consumer errors
+            }
+        }
+        s.consumers.clear();
+        try {
+            await s.close();
+        }
+        catch {
+            // ignore close errors
+        }
+        s.hardwareOpen = false;
+    }
+}
+export async function closeAllSessionHardwarePreserveState() {
+    const closed = [];
+    for (const s of sessions.values()) {
+        if (!s.hardwareOpen)
+            continue;
+        try {
+            await s.close();
+        }
+        catch {
+            // ignore close errors
+        }
+        s.hardwareOpen = false;
+        closed.push(s.id);
+    }
+    return closed;
+}
+export async function reopenSessionHardwareByIds(sessionIds) {
+    for (const id of sessionIds) {
+        const s = sessions.get(id);
+        if (!s)
+            continue;
+        try {
+            await ensureSessionHardwareOpen(s);
+        }
+        catch {
+            // ignore open errors; status/read/write will surface later
+        }
+    }
+}
+export function hasSession(sessionId) {
+    return sessions.has(sessionId);
+}