@sstar/embedlink_agent 0.1.0

package/dist/logger.js

@@ -0,0 +1,245 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { publishAgentLog } from './core/log_stream.js';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+})(LogLevel || (LogLevel = {}));
+export class AgentLogger {
+    constructor() {
+        this.logStream = null;
+        this.serviceName = 'agent';
+        this.config = this.loadConfig();
+        if (this.config.enabled) {
+            this.initializeLogFile();
+        }
+        this.currentLogFile = '';
+    }
+    loadConfig() {
+        return {
+            enabled: process.env.EMBEDLINK_DEBUG === '1' || true, // Agent默认开启日志
+            level: process.env.EMBEDLINK_LOG_LEVEL || LogLevel.INFO,
+            dir: process.env.EMBEDLINK_LOG_DIR || this.getDefaultLogDir(),
+            maxSize: this.parseSize(process.env.EMBEDLINK_LOG_MAX_SIZE) || 10 * 1024 * 1024, // 10MB
+            maxFiles: parseInt(process.env.EMBEDLINK_LOG_MAX_FILES || '20'),
+            maxAge: parseInt(process.env.EMBEDLINK_LOG_MAX_AGE || '7'), // days
+        };
+    }
+    getDefaultLogDir() {
+        return path.join(os.homedir(), '.config', 'embed_link', 'logs', 'agent');
+    }
+    parseSize(sizeStr) {
+        if (!sizeStr)
+            return 0;
+        const units = {
+            B: 1,
+            KB: 1024,
+            MB: 1024 * 1024,
+            GB: 1024 * 1024 * 1024,
+        };
+        const match = sizeStr.match(/^(\d+)(B|KB|MB|GB)?$/i);
+        if (!match)
+            return 0;
+        const value = parseInt(match[1]);
+        const unit = match[2]?.toUpperCase() || 'B';
+        return value * (units[unit] || 1);
+    }
+    async initializeLogFile() {
+        try {
+            // 确保日志目录存在
+            await fs.promises.mkdir(this.config.dir, { recursive: true });
+            // 生成基于启动时间的日志文件名（使用本地时间）
+            const now = new Date();
+            const year = now.getFullYear();
+            const month = String(now.getMonth() + 1).padStart(2, '0');
+            const day = String(now.getDate()).padStart(2, '0');
+            const hours = String(now.getHours()).padStart(2, '0');
+            const minutes = String(now.getMinutes()).padStart(2, '0');
+            const seconds = String(now.getSeconds()).padStart(2, '0');
+            const timestamp = `${year}-${month}-${day}T${hours}-${minutes}-${seconds}`;
+            this.currentLogFile = path.join(this.config.dir, `${this.serviceName}-${timestamp}.log`);
+            // 创建写入流
+            this.logStream = fs.createWriteStream(this.currentLogFile, { flags: 'a' });
+            // 写入启动标记
+            this.write(LogLevel.INFO, 'logger.initialized', {
+                pid: process.pid,
+                nodeVersion: process.version,
+                platform: os.platform(),
+                logFile: this.currentLogFile,
+            });
+            // 设置错误处理
+            this.logStream.on('error', (error) => {
+                console.error('[embedlink-agent] Logger write error:', error);
+            });
+        }
+        catch (error) {
+            console.error('[embedlink-agent] Failed to initialize logger:', error);
+            this.logStream = null;
+        }
+    }
+    write(level, event, data) {
+        if (!this.config.enabled) {
+            return;
+        }
+        // 检查日志级别
+        if (!this.shouldLog(level)) {
+            return;
+        }
+        const logEntry = {
+            ts: Date.now(),
+            level,
+            event,
+            data,
+            pid: process.pid,
+        };
+        // UI 实时日志：best-effort 内存缓冲 + WS 广播（由 web.ts 订阅）
+        publishAgentLog(logEntry);
+        if (!this.logStream) {
+            return;
+        }
+        const logLine = JSON.stringify(logEntry) + '\n';
+        try {
+            this.logStream.write(logLine);
+            // 检查是否需要轮转
+            this.checkRotation().catch((error) => {
+                console.error('[embedlink-agent] Log rotation error:', error);
+            });
+        }
+        catch (error) {
+            console.error('[embedlink-agent] Logger write error:', error);
+        }
+    }
+    shouldLog(level) {
+        const levels = [LogLevel.DEBUG, LogLevel.INFO, LogLevel.WARN, LogLevel.ERROR];
+        const currentLevelIndex = levels.indexOf(this.config.level);
+        const messageLevelIndex = levels.indexOf(level);
+        return messageLevelIndex >= currentLevelIndex;
+    }
+    async checkRotation() {
+        if (!this.currentLogFile || !this.logStream) {
+            return;
+        }
+        try {
+            const stats = await fs.promises.stat(this.currentLogFile);
+            if (stats.size > this.config.maxSize) {
+                await this.rotate();
+            }
+        }
+        catch (error) {
+            // 忽略文件不存在的错误
+        }
+    }
+    async rotate() {
+        if (!this.logStream)
+            return;
+        try {
+            // 关闭当前文件流
+            this.logStream.end();
+            // 创建新的日志文件
+            await this.initializeLogFile();
+            // 清理旧文件
+            await this.cleanupOldFiles();
+        }
+        catch (error) {
+            console.error('[embedlink-agent] Log rotation error:', error);
+        }
+    }
+    async cleanupOldFiles() {
+        try {
+            const files = await fs.promises.readdir(this.config.dir);
+            const logFiles = files
+                .filter((f) => f.startsWith(`${this.serviceName}-`) && f.endsWith('.log'))
+                .map((f) => ({ name: f, path: path.join(this.config.dir, f) }));
+            // 按修改时间排序
+            const fileStats = await Promise.all(logFiles.map(async (f) => ({
+                ...f,
+                mtime: (await fs.promises.stat(f.path)).mtime,
+            })));
+            fileStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+            // 删除超出数量��制的文件
+            const filesToDelete = fileStats.slice(this.config.maxFiles);
+            await Promise.all(filesToDelete.map((f) => fs.promises.unlink(f.path).catch(() => {
+                // 忽略删除错误
+            })));
+            // 删除超出时间限制的文件
+            const cutoffDate = new Date(Date.now() - this.config.maxAge * 24 * 60 * 60 * 1000);
+            const oldFiles = fileStats.filter((f) => f.mtime < cutoffDate);
+            await Promise.all(oldFiles.map((f) => fs.promises.unlink(f.path).catch(() => {
+                // 忽略删除错误
+            })));
+        }
+        catch (error) {
+            console.error('[embedlink-agent] Log cleanup error:', error);
+        }
+    }
+    close() {
+        if (this.logStream) {
+            this.write(LogLevel.INFO, 'logger.closed', { reason: 'shutdown' });
+            this.logStream.end();
+            this.logStream = null;
+        }
+    }
+    async getLogFiles() {
+        try {
+            const files = await fs.promises.readdir(this.config.dir);
+            return files
+                .filter((f) => f.startsWith(`${this.serviceName}-`) && f.endsWith('.log'))
+                .sort()
+                .reverse(); // Newest first
+        }
+        catch {
+            return [];
+        }
+    }
+    async readLogFile(filename, lines) {
+        try {
+            const p = path.join(this.config.dir, filename);
+            // Ensure path traversal protection
+            if (!p.startsWith(this.config.dir))
+                throw new Error('Invalid path');
+            const content = await fs.promises.readFile(p, 'utf8');
+            const allLines = content.trim().split('\n');
+            const targetLines = lines ? allLines.slice(-lines) : allLines;
+            return targetLines.map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return { message: line, ts: Date.now(), level: 'unknown' };
+                }
+            });
+        }
+        catch (e) {
+            console.error('Failed to read log file:', e);
+            return [];
+        }
+    }
+}
+// 单例实例
+let agentLogger = null;
+export function getAgentLogger() {
+    if (!agentLogger) {
+        agentLogger = new AgentLogger();
+    }
+    return agentLogger;
+}
+// 便捷函数
+export function logAgent(level, event, data) {
+    getAgentLogger().write(level, event, data);
+}
+export function logAgentDebug(event, data) {
+    logAgent(LogLevel.DEBUG, event, data);
+}
+export function logAgentInfo(event, data) {
+    logAgent(LogLevel.INFO, event, data);
+}
+export function logAgentWarn(event, data) {
+    logAgent(LogLevel.WARN, event, data);
+}
+export function logAgentError(event, data) {
+    logAgent(LogLevel.ERROR, event, data);
+}

package/dist/macro/index.js

@@ -0,0 +1,241 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+function sanitizeMacroStep(raw) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error('invalid macro step: expected object');
+    }
+    const kind = String(raw.kind || '').trim();
+    if (kind === 'send') {
+        const dataBase64 = String(raw.dataBase64 || '');
+        if (!dataBase64)
+            throw new Error('invalid send step: missing dataBase64');
+        const text = String(raw.text || '');
+        return { kind: 'send', dataBase64, text };
+    }
+    if (kind === 'delay') {
+        const delayMs = Number(raw.delayMs);
+        if (!Number.isFinite(delayMs) || delayMs < 0) {
+            throw new Error('invalid delay step: delayMs must be a non-negative number');
+        }
+        return { kind: 'delay', delayMs: Math.floor(delayMs) };
+    }
+    if (kind === 'expect') {
+        const waitFor = String(raw.waitFor || '');
+        if (!waitFor)
+            throw new Error('invalid expect step: missing waitFor');
+        const timeoutMsRaw = raw.timeoutMs;
+        const timeoutMs = typeof timeoutMsRaw === 'number' && Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0
+            ? Math.floor(timeoutMsRaw)
+            : undefined;
+        return { kind: 'expect', waitFor, timeoutMs };
+    }
+    throw new Error(`invalid macro step: unknown kind: ${kind}`);
+}
+function sanitizeMacroSteps(raw) {
+    if (!Array.isArray(raw))
+        throw new Error('invalid macro steps: steps must be an array');
+    return raw.map((s, i) => {
+        try {
+            return sanitizeMacroStep(s);
+        }
+        catch (e) {
+            throw new Error(`invalid macro step at index ${i}: ${e?.message || String(e)}`);
+        }
+    });
+}
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'embed_link');
+const MACROS_PATH = path.join(CONFIG_DIR, 'macros.json');
+export function getMacrosPath() {
+    return MACROS_PATH;
+}
+async function readJsonOrNull(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        try {
+            return JSON.parse(raw);
+        }
+        catch (e) {
+            throw new Error(`invalid macros store JSON: ${filePath}: ${e?.message || String(e)}`);
+        }
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+}
+async function writeJsonAtomic(filePath, obj) {
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    const base = path.basename(filePath);
+    const nonce = `${Date.now()}.${randomUUID()}`;
+    const tmp = path.join(dir, `${base}.${nonce}.tmp`);
+    const bak = path.join(dir, `${base}.${nonce}.bak`);
+    const content = JSON.stringify(obj, null, 2);
+    await fs.writeFile(tmp, content, 'utf8');
+    // Cross-platform atomic-ish replace:
+    // - POSIX: rename overwrites
+    // - Windows: rename fails if dst exists; use a best-effort backup swap.
+    try {
+        await fs.rename(tmp, filePath);
+        return;
+    }
+    catch (e) {
+        // fall through to backup swap
+        if (e?.code !== 'EEXIST' && e?.code !== 'EPERM' && e?.code !== 'EACCES') {
+            // cleanup tmp best-effort, but don't hide the root error
+            try {
+                await fs.unlink(tmp);
+            }
+            catch { }
+            throw e;
+        }
+    }
+    let hadOld = false;
+    try {
+        await fs.rename(filePath, bak);
+        hadOld = true;
+    }
+    catch (e) {
+        if (e?.code !== 'ENOENT') {
+            try {
+                await fs.unlink(tmp);
+            }
+            catch { }
+            throw e;
+        }
+    }
+    try {
+        await fs.rename(tmp, filePath);
+        if (hadOld) {
+            // best-effort cleanup of backup file
+            try {
+                await fs.unlink(bak);
+            }
+            catch { }
+        }
+    }
+    catch (e) {
+        // restore old if we moved it
+        if (hadOld) {
+            try {
+                await fs.rename(bak, filePath);
+            }
+            catch { }
+        }
+        try {
+            await fs.unlink(tmp);
+        }
+        catch { }
+        throw e;
+    }
+}
+function sanitizeStoredScript(raw) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error('invalid macro script: expected object');
+    }
+    const id = String(raw.id || '').trim();
+    const name = String(raw.name || '').trim();
+    const order = Number(raw.order);
+    const createdAtMs = Number(raw.createdAtMs);
+    const updatedAtMs = Number(raw.updatedAtMs);
+    if (!id)
+        throw new Error('invalid macro script: missing id');
+    if (!name)
+        throw new Error('invalid macro script: missing name');
+    if (!Number.isFinite(order))
+        throw new Error('invalid macro script: order must be a number');
+    if (!Number.isFinite(createdAtMs))
+        throw new Error('invalid macro script: createdAtMs must be a number');
+    if (!Number.isFinite(updatedAtMs))
+        throw new Error('invalid macro script: updatedAtMs must be a number');
+    const steps = sanitizeMacroSteps(raw.steps);
+    return {
+        id,
+        name,
+        order: Math.floor(order),
+        steps,
+        version: 1,
+        createdAtMs: Math.floor(createdAtMs),
+        updatedAtMs: Math.floor(updatedAtMs),
+    };
+}
+function normalizeStoreFile(rec) {
+    if (rec === null) {
+        return { version: 1, scripts: [] };
+    }
+    if (!rec || typeof rec !== 'object') {
+        throw new Error('invalid macros store: expected object');
+    }
+    if (rec.version !== 1) {
+        throw new Error(`unsupported macros store version: ${String(rec.version)}`);
+    }
+    if (!Array.isArray(rec.scripts)) {
+        throw new Error('invalid macros store: scripts must be an array');
+    }
+    const scripts = rec.scripts.map((s, i) => {
+        try {
+            return sanitizeStoredScript(s);
+        }
+        catch (e) {
+            throw new Error(`invalid macro script at index ${i}: ${e?.message || String(e)}`);
+        }
+    });
+    return { version: 1, scripts };
+}
+function sortScripts(scripts) {
+    return [...scripts].sort((a, b) => {
+        const ao = Number.isFinite(a.order) ? a.order : 0;
+        const bo = Number.isFinite(b.order) ? b.order : 0;
+        if (ao !== bo)
+            return ao - bo;
+        return String(a.name || '').localeCompare(String(b.name || ''));
+    });
+}
+export async function listMacroScripts() {
+    const rec = normalizeStoreFile(await readJsonOrNull(MACROS_PATH));
+    return sortScripts(rec.scripts);
+}
+export async function getMacroScript(id) {
+    const scripts = await listMacroScripts();
+    return scripts.find((s) => s.id === id) || null;
+}
+export async function upsertMacroScript(input) {
+    const now = Date.now();
+    const rec = normalizeStoreFile(await readJsonOrNull(MACROS_PATH));
+    const id = (input.id || '').trim() || randomUUID();
+    const idx = rec.scripts.findIndex((s) => s.id === id);
+    const name = String(input.name || '').trim();
+    if (!name)
+        throw new Error('invalid macro script: missing name');
+    const order = Number(input.order);
+    if (!Number.isFinite(order))
+        throw new Error('invalid macro script: order must be a number');
+    const steps = sanitizeMacroSteps(input.steps);
+    const next = {
+        id,
+        name,
+        order: Math.floor(order),
+        steps,
+        version: 1,
+        createdAtMs: idx >= 0 ? rec.scripts[idx].createdAtMs : now,
+        updatedAtMs: now,
+    };
+    if (idx >= 0)
+        rec.scripts[idx] = next;
+    else
+        rec.scripts.push(next);
+    await writeJsonAtomic(MACROS_PATH, { version: 1, scripts: rec.scripts });
+    return next;
+}
+export async function deleteMacroScript(id) {
+    const rec = normalizeStoreFile(await readJsonOrNull(MACROS_PATH));
+    const before = rec.scripts.length;
+    rec.scripts = rec.scripts.filter((s) => s.id !== id);
+    if (rec.scripts.length === before)
+        return false;
+    await writeJsonAtomic(MACROS_PATH, { version: 1, scripts: rec.scripts });
+    return true;
+}

package/dist/macro/runner.js

@@ -0,0 +1,168 @@
+import { Buffer } from 'node:buffer';
+import { getBoardUartResourceManager } from '../board_uart/resource.js';
+import { addSessionConsumer, listBoardUartSessions, removeSessionConsumer } from '../board_uart/sessions.js';
+let current = null;
+export function getCurrentRun() {
+    if (!current)
+        return null;
+    return {
+        runId: current.runId,
+        scriptId: current.script.id,
+        status: current.status,
+        stepIndex: current.stepIndex,
+        stepCount: current.script.steps.length,
+        step: current.script.steps[current.stepIndex],
+    };
+}
+export function stopCurrentRun() {
+    if (!current || current.status !== 'running')
+        return false;
+    current.cancelled = true;
+    return true;
+}
+async function sleep(ms) {
+    const delay = Number.isFinite(ms) && ms > 0 ? ms : 0;
+    if (!delay)
+        return;
+    await new Promise((resolve) => setTimeout(resolve, delay));
+}
+async function resolveSessionId(preferred) {
+    const id = (preferred || '').trim();
+    if (id)
+        return id;
+    const sessions = await listBoardUartSessions();
+    const def = sessions.find((s) => s.isDefault);
+    if (def)
+        return def.id;
+    if (sessions.length > 0)
+        return sessions[0].id;
+    throw new Error('No active board uart session');
+}
+async function waitForOutput(params) {
+    const mgr = getBoardUartResourceManager();
+    // respect BoardUart suspension
+    await mgr.getStatus();
+    const waitFor = String(params.waitFor || '');
+    if (!waitFor)
+        return;
+    const sessionId = params.sessionId;
+    const timeoutMs = params.timeoutMs;
+    const consumerId = `macro-expect-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    let done = false;
+    let output = '';
+    const maxChars = 16384;
+    const cleanup = () => {
+        if (done)
+            return;
+        done = true;
+        try {
+            removeSessionConsumer(sessionId, consumerId);
+        }
+        catch {
+            // ignore
+        }
+    };
+    return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            reject(new Error('expect timeout'));
+        }, timeoutMs);
+        addSessionConsumer({
+            consumerId,
+            sessionId,
+            onData: (chunk) => {
+                if (done)
+                    return;
+                try {
+                    const text = chunk.toString('utf8');
+                    output = (output + text).slice(-maxChars);
+                    if (output.includes(waitFor)) {
+                        clearTimeout(timer);
+                        cleanup();
+                        resolve();
+                    }
+                }
+                catch {
+                    // ignore decode errors
+                }
+            },
+            onError: (e) => {
+                if (done)
+                    return;
+                clearTimeout(timer);
+                cleanup();
+                reject(e);
+            },
+        }).catch((e) => {
+            clearTimeout(timer);
+            cleanup();
+            reject(e);
+        });
+    });
+}
+export async function runMacroScript(params) {
+    if (current && current.status === 'running') {
+        return { status: 'busy', message: 'another macro is running' };
+    }
+    const run = {
+        runId: params.runId,
+        script: params.script,
+        status: 'running',
+        stepIndex: 0,
+        cancelled: false,
+    };
+    current = run;
+    const push = (patch) => {
+        params.onUpdate({
+            runId: run.runId,
+            scriptId: run.script.id,
+            status: run.status,
+            stepIndex: run.stepIndex,
+            stepCount: run.script.steps.length,
+            step: run.script.steps[run.stepIndex],
+            ...patch,
+        });
+    };
+    try {
+        const sessionId = await resolveSessionId(params.sessionId);
+        const mgr = getBoardUartResourceManager();
+        push({ status: 'running', message: 'started' });
+        for (let i = 0; i < run.script.steps.length; i++) {
+            run.stepIndex = i;
+            const step = run.script.steps[i];
+            if (run.cancelled) {
+                run.status = 'stopped';
+                push({ status: 'stopped', message: 'stopped' });
+                return { status: 'stopped' };
+            }
+            push({ status: 'running', stepIndex: i, step });
+            if (step.kind === 'send') {
+                const buf = Buffer.from(String(step.dataBase64 || ''), 'base64');
+                await mgr.write({ sessionId, data: buf });
+            }
+            else if (step.kind === 'delay') {
+                await sleep(step.delayMs);
+            }
+            else if (step.kind === 'expect') {
+                const timeoutMs = typeof step.timeoutMs === 'number' && step.timeoutMs > 0
+                    ? step.timeoutMs
+                    : params.defaultExpectTimeoutMs;
+                await waitForOutput({ sessionId, waitFor: step.waitFor, timeoutMs });
+            }
+            else {
+                throw new Error(`unknown step kind: ${step.kind}`);
+            }
+        }
+        run.status = 'done';
+        push({ status: 'done', message: 'done', stepIndex: run.script.steps.length });
+        return { status: 'done' };
+    }
+    catch (e) {
+        run.status = 'error';
+        push({ status: 'error', message: e?.message || String(e) });
+        return { status: 'error', message: e?.message || String(e) };
+    }
+    finally {
+        current = null;
+    }
+}