windows-exe-decompiler-mcp-server 0.1.0

package/dist/job-queue.js

@@ -0,0 +1,407 @@
+/**
+ * Job Queue - In-memory task queue with priority support
+ *
+ * Implements requirements 21.1 and 21.2:
+ * - Task enqueueing with unique job_id
+ * - Priority-based task ordering
+ * - Job status tracking and cancellation
+ */
+import { randomUUID } from 'crypto';
+import { EventEmitter } from 'events';
+// Re-export types for convenience
+export { JobPriority } from './types.js';
+/**
+ * In-memory job queue with priority support
+ *
+ * Features:
+ * - Priority-based ordering
+ * - Job status tracking
+ * - Cancellation support
+ * - Event-based completion notifications
+ */
+export class JobQueue extends EventEmitter {
+    jobs = new Map();
+    queue = [];
+    defaultRetryPolicy = {
+        maxRetries: 3,
+        backoffMs: 1000,
+        retryableErrors: ['E_TIMEOUT', 'E_RESOURCE_EXHAUSTED', 'E_WORKER_UNAVAILABLE']
+    };
+    /**
+     * Enqueue a new job
+     *
+     * @param job - Job configuration (id will be generated if not provided)
+     * @returns Job ID
+     */
+    enqueue(job) {
+        const jobId = randomUUID();
+        const fullJob = {
+            ...job,
+            id: jobId,
+            createdAt: new Date().toISOString(),
+            attempts: 0,
+            retryPolicy: job.retryPolicy || this.defaultRetryPolicy
+        };
+        const entry = {
+            job: fullJob,
+            status: 'queued'
+        };
+        this.jobs.set(jobId, entry);
+        this.queue.push(fullJob);
+        // Sort queue by priority (descending)
+        this.sortQueue();
+        this.emit('job:enqueued', jobId);
+        return jobId;
+    }
+    /**
+     * Get job status
+     *
+     * @param jobId - Job identifier
+     * @returns Job status or undefined if not found
+     */
+    getStatus(jobId) {
+        const entry = this.jobs.get(jobId);
+        if (!entry) {
+            return undefined;
+        }
+        return {
+            id: jobId,
+            status: entry.status,
+            progress: entry.progress,
+            startedAt: entry.startedAt,
+            finishedAt: entry.finishedAt,
+            error: entry.error
+        };
+    }
+    /**
+     * Cancel a job
+     *
+     * @param jobId - Job identifier
+     * @returns True if job was cancelled, false if not found or already completed
+     */
+    cancel(jobId, reason) {
+        const entry = this.jobs.get(jobId);
+        if (!entry) {
+            return false;
+        }
+        // Can only cancel queued or running jobs
+        if (entry.status !== 'queued' && entry.status !== 'running') {
+            return false;
+        }
+        // Remove from queue if still queued
+        if (entry.status === 'queued') {
+            this.queue = this.queue.filter(j => j.id !== jobId);
+        }
+        // Update status
+        entry.status = 'cancelled';
+        entry.finishedAt = new Date().toISOString();
+        entry.cancelReason = reason;
+        entry.error = reason ? `Cancelled: ${reason}` : 'Cancelled by user';
+        this.emit('job:cancelled', jobId, reason);
+        return true;
+    }
+    /**
+     * Register a completion callback for a job
+     *
+     * @param jobId - Job identifier
+     * @param callback - Callback function to invoke when job completes
+     */
+    onComplete(jobId, callback) {
+        const handler = (completedJobId, result) => {
+            if (completedJobId === jobId) {
+                callback(result);
+                this.removeListener('job:completed', handler);
+                this.removeListener('job:failed', handler);
+            }
+        };
+        this.on('job:completed', handler);
+        this.on('job:failed', handler);
+    }
+    /**
+     * Get the next job from the queue (highest priority)
+     *
+     * @returns Next job or undefined if queue is empty
+     */
+    dequeue() {
+        const job = this.queue.shift();
+        if (job) {
+            const entry = this.jobs.get(job.id);
+            if (entry) {
+                entry.status = 'running';
+                entry.startedAt = new Date().toISOString();
+                this.emit('job:started', job.id);
+            }
+        }
+        return job;
+    }
+    /**
+     * Mark a job as completed
+     *
+     * Requirements: 21.4, 21.5, 28.2 - Job completion with retry logic
+     *
+     * @param jobId - Job identifier
+     * @param result - Job execution result
+     */
+    complete(jobId, result) {
+        const entry = this.jobs.get(jobId);
+        if (!entry) {
+            return;
+        }
+        // Check if job should be retried on failure
+        if (!result.ok && this.shouldRetry(entry.job, result)) {
+            this.retryJob(entry.job);
+            return;
+        }
+        // Mark as completed or failed (no more retries)
+        entry.status = result.ok ? 'completed' : 'failed';
+        entry.finishedAt = new Date().toISOString();
+        entry.result = result;
+        if (!result.ok) {
+            entry.error = result.errors.join('; ');
+        }
+        const eventName = result.ok ? 'job:completed' : 'job:failed';
+        this.emit(eventName, jobId, result);
+    }
+    /**
+     * Check if a failed job should be retried
+     *
+     * Requirements: 21.5, 28.2 - Retry policy evaluation
+     *
+     * @param job - Job that failed
+     * @param result - Job execution result
+     * @returns True if job should be retried
+     */
+    shouldRetry(job, result) {
+        // Check if we've exceeded max retries
+        if (job.attempts >= job.retryPolicy.maxRetries) {
+            return false;
+        }
+        // Check if any error is retryable
+        const hasRetryableError = result.errors.some(error => job.retryPolicy.retryableErrors.some(retryableError => error.includes(retryableError)));
+        return hasRetryableError;
+    }
+    /**
+     * Retry a failed job with exponential backoff
+     *
+     * Requirements: 21.5, 28.2 - Exponential backoff retry
+     *
+     * @param job - Job to retry
+     */
+    retryJob(job) {
+        // Increment attempts counter
+        job.attempts += 1;
+        // Calculate exponential backoff delay
+        const backoffMs = this.calculateBackoff(job);
+        // Schedule retry after backoff delay
+        setTimeout(() => {
+            this.requeue(job);
+            this.emit('job:retry', job.id, job.attempts, backoffMs);
+        }, backoffMs);
+        // Emit retry scheduled event
+        this.emit('job:retry-scheduled', job.id, job.attempts, backoffMs);
+    }
+    /**
+     * Calculate exponential backoff delay
+     *
+     * Requirements: 21.5, 28.2 - Exponential backoff calculation
+     *
+     * Formula: baseBackoff * (2 ^ (attempts - 1))
+     *
+     * @param job - Job to calculate backoff for
+     * @returns Backoff delay in milliseconds
+     */
+    calculateBackoff(job) {
+        const baseBackoff = job.retryPolicy.backoffMs;
+        const exponentialFactor = Math.pow(2, job.attempts - 1);
+        return baseBackoff * exponentialFactor;
+    }
+    /**
+     * Update job progress
+     *
+     * @param jobId - Job identifier
+     * @param progress - Progress percentage (0-100)
+     */
+    updateProgress(jobId, progress) {
+        const entry = this.jobs.get(jobId);
+        if (entry && entry.status === 'running') {
+            entry.progress = Math.max(0, Math.min(100, progress));
+            this.emit('job:progress', jobId, entry.progress);
+        }
+    }
+    /**
+     * Get queue length
+     *
+     * @returns Number of jobs in queue (not including running jobs)
+     */
+    getQueueLength() {
+        return this.queue.length;
+    }
+    /**
+     * Get all jobs with a specific status
+     *
+     * @param status - Job status to filter by
+     * @returns Array of job statuses
+     */
+    getJobsByStatus(status) {
+        const results = [];
+        for (const [jobId, entry] of this.jobs.entries()) {
+            if (entry.status === status) {
+                results.push({
+                    id: jobId,
+                    status: entry.status,
+                    progress: entry.progress,
+                    startedAt: entry.startedAt,
+                    finishedAt: entry.finishedAt,
+                    error: entry.error
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Get full job status list with lightweight execution context.
+     */
+    listStatuses(status) {
+        const rows = [];
+        for (const [jobId, entry] of this.jobs.entries()) {
+            if (status && entry.status !== status) {
+                continue;
+            }
+            rows.push({
+                id: jobId,
+                status: entry.status,
+                progress: entry.progress,
+                startedAt: entry.startedAt,
+                finishedAt: entry.finishedAt,
+                error: entry.error,
+                tool: entry.job.tool,
+                sampleId: entry.job.sampleId,
+                attempts: entry.job.attempts,
+                timeout: entry.job.timeout,
+                createdAt: entry.job.createdAt,
+                cancelReason: entry.cancelReason,
+            });
+        }
+        rows.sort((a, b) => new Date(b.createdAt).getTime() -
+            new Date(a.createdAt).getTime());
+        return rows;
+    }
+    /**
+     * Get job result
+     *
+     * @param jobId - Job identifier
+     * @returns Job result or undefined if not found or not completed
+     */
+    getResult(jobId) {
+        const entry = this.jobs.get(jobId);
+        return entry?.result;
+    }
+    /**
+     * Clear completed jobs older than specified age
+     *
+     * @param maxAgeMs - Maximum age in milliseconds
+     * @returns Number of jobs cleared
+     */
+    clearOldJobs(maxAgeMs) {
+        const now = Date.now();
+        let cleared = 0;
+        for (const [jobId, entry] of this.jobs.entries()) {
+            if (entry.status === 'completed' || entry.status === 'failed' || entry.status === 'cancelled') {
+                if (entry.finishedAt) {
+                    const finishedTime = new Date(entry.finishedAt).getTime();
+                    if (now - finishedTime > maxAgeMs) {
+                        this.jobs.delete(jobId);
+                        cleared++;
+                    }
+                }
+            }
+        }
+        return cleared;
+    }
+    /**
+     * Mark stale running jobs as failed.
+     * Emits `job:reaped` with affected job ids for observability.
+     */
+    reapStaleRunningJobs(maxRuntimeMs, nowMs = Date.now()) {
+        const reaped = [];
+        for (const [jobId, entry] of this.jobs.entries()) {
+            if (entry.status !== 'running' || !entry.startedAt) {
+                continue;
+            }
+            const startedAtMs = new Date(entry.startedAt).getTime();
+            if (!Number.isFinite(startedAtMs)) {
+                continue;
+            }
+            const elapsed = nowMs - startedAtMs;
+            if (elapsed <= maxRuntimeMs) {
+                continue;
+            }
+            entry.status = 'failed';
+            entry.finishedAt = new Date(nowMs).toISOString();
+            entry.error = `E_TIMEOUT: stale running job reaped after ${elapsed}ms`;
+            if (!entry.result) {
+                entry.result = {
+                    jobId,
+                    ok: false,
+                    data: undefined,
+                    errors: [entry.error],
+                    warnings: [],
+                    artifacts: [],
+                    metrics: {
+                        elapsedMs: elapsed,
+                        peakRssMb: 0,
+                    },
+                };
+            }
+            reaped.push(jobId);
+        }
+        if (reaped.length > 0) {
+            this.emit('job:reaped', reaped, maxRuntimeMs);
+        }
+        return reaped;
+    }
+    /**
+     * Get total number of jobs tracked
+     *
+     * @returns Total job count
+     */
+    getTotalJobs() {
+        return this.jobs.size;
+    }
+    /**
+     * Re-enqueue a job for retry (used by retry mechanism)
+     *
+     * Requirements: 21.5, 28.2 - Failure retry mechanism
+     *
+     * @param job - Job to re-enqueue (with updated attempts count)
+     */
+    requeue(job) {
+        // Update the job entry
+        const entry = this.jobs.get(job.id);
+        if (entry) {
+            entry.job = job;
+            entry.status = 'queued';
+            entry.error = undefined;
+            entry.startedAt = undefined;
+            entry.finishedAt = undefined;
+        }
+        // Add back to queue
+        this.queue.push(job);
+        this.sortQueue();
+        this.emit('job:requeued', job.id, job.attempts);
+    }
+    /**
+     * Sort queue by priority (descending)
+     */
+    sortQueue() {
+        this.queue.sort((a, b) => {
+            // Higher priority first
+            if (a.priority !== b.priority) {
+                return b.priority - a.priority;
+            }
+            // If same priority, FIFO (earlier created first)
+            return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+        });
+    }
+}
+//# sourceMappingURL=job-queue.js.map

package/dist/logger.d.ts

@@ -0,0 +1,106 @@
+/**
+ * 结构化日志模块
+ *
+ * 使用 pino 库实现结构化日志记录，支持：
+ * - 操作日志
+ * - 错误日志（包含完整堆栈）
+ * - 性能指标日志
+ * - 审计日志
+ *
+ * 验收标准：
+ * - 需求 30.4: 使用 pino 库记录结构化日志
+ * - 需求 30.5: 记录完整的错误堆栈和上下文信息
+ */
+import pino from 'pino';
+/**
+ * 日志级别
+ */
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+/**
+ * 性能指标
+ */
+export interface PerformanceMetrics {
+    elapsedMs: number;
+    peakRssMb?: number;
+    cpuPercent?: number;
+}
+/**
+ * 操作上下文
+ */
+export interface OperationContext {
+    operation: string;
+    sampleId?: string;
+    toolName?: string;
+    userId?: string;
+    [key: string]: unknown;
+}
+/**
+ * 审计事件
+ */
+export interface AuditEvent {
+    operation: string;
+    user?: string;
+    sampleId?: string;
+    decision: 'allow' | 'deny' | 'partial';
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * 全局 logger 实例
+ */
+export declare const logger: pino.Logger<never, boolean>;
+/**
+ * 创建子 logger（带上下文）
+ */
+export declare function createChildLogger(context: Record<string, unknown>): pino.Logger<never, boolean>;
+/**
+ * 记录操作开始
+ */
+export declare function logOperationStart(context: OperationContext): void;
+/**
+ * 记录操作完成
+ */
+export declare function logOperationComplete(context: OperationContext, metrics: PerformanceMetrics): void;
+/**
+ * 记录操作失败
+ */
+export declare function logOperationError(context: OperationContext, error: Error, metrics?: Partial<PerformanceMetrics>): void;
+/**
+ * 记录审计事件
+ */
+export declare function logAudit(event: AuditEvent): void;
+/**
+ * 记录性能指标
+ */
+export declare function logMetrics(operation: string, metrics: PerformanceMetrics, context?: Record<string, unknown>): void;
+/**
+ * 记录警告
+ */
+export declare function logWarning(message: string, context?: Record<string, unknown>): void;
+/**
+ * 记录调试信息
+ */
+export declare function logDebug(message: string, context?: Record<string, unknown>): void;
+/**
+ * 记录错误（通用）
+ */
+export declare function logError(error: Error, context?: Record<string, unknown>): void;
+/**
+ * 创建性能计时器
+ */
+export declare function createTimer(): {
+    /**
+     * 结束计时并返回性能指标
+     */
+    end(): PerformanceMetrics;
+};
+/**
+ * 包装异步操作，自动记录日志和性能指标
+ */
+export declare function withLogging<T>(context: OperationContext, fn: () => Promise<T>): Promise<T>;
+/**
+ * 包装同步操作，自动记录日志和性能指标
+ */
+export declare function withLoggingSync<T>(context: OperationContext, fn: () => T): T;
+export default logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.js

@@ -0,0 +1,176 @@
+/**
+ * 结构化日志模块
+ *
+ * 使用 pino 库实现结构化日志记录，支持：
+ * - 操作日志
+ * - 错误日志（包含完整堆栈）
+ * - 性能指标日志
+ * - 审计日志
+ *
+ * 验收标准：
+ * - 需求 30.4: 使用 pino 库记录结构化日志
+ * - 需求 30.5: 记录完整的错误堆栈和上下文信息
+ */
+import pino from 'pino';
+import { config } from './config.js';
+/**
+ * 创建 pino logger 实例
+ *
+ * CRITICAL: All logs must go to stderr to avoid interfering with MCP protocol on stdout
+ */
+function createLogger() {
+    // Create destination that writes to stderr (fd 2)
+    const destination = pino.destination({ dest: 2, sync: false });
+    return pino({
+        level: config.logging.level || 'info',
+        // 基础字段
+        base: {
+            pid: process.pid,
+            hostname: undefined, // 不记录 hostname 以减少日志大小
+        },
+        // 时间戳格式
+        timestamp: pino.stdTimeFunctions.isoTime,
+        // 序列化错误对象
+        serializers: {
+            err: pino.stdSerializers.err,
+            error: pino.stdSerializers.err,
+        },
+    }, destination);
+}
+/**
+ * 全局 logger 实例
+ */
+export const logger = createLogger();
+/**
+ * 创建子 logger（带上下文）
+ */
+export function createChildLogger(context) {
+    return logger.child(context);
+}
+/**
+ * 记录操作开始
+ */
+export function logOperationStart(context) {
+    logger.info(context, `Operation started: ${context.operation}`);
+}
+/**
+ * 记录操作完成
+ */
+export function logOperationComplete(context, metrics) {
+    logger.info({ ...context, metrics }, `Operation completed: ${context.operation} (${metrics.elapsedMs}ms)`);
+}
+/**
+ * 记录操作失败
+ */
+export function logOperationError(context, error, metrics) {
+    logger.error({
+        ...context,
+        err: error,
+        metrics,
+        // 确保记录完整的错误堆栈
+        stack: error.stack,
+        errorName: error.name,
+        errorMessage: error.message,
+    }, `Operation failed: ${context.operation} - ${error.message}`);
+}
+/**
+ * 记录审计事件
+ */
+export function logAudit(event) {
+    logger.info({
+        audit: true,
+        ...event,
+    }, `Audit: ${event.operation} - ${event.decision}`);
+}
+/**
+ * 记录性能指标
+ */
+export function logMetrics(operation, metrics, context) {
+    logger.info({
+        metrics: true,
+        operation,
+        ...metrics,
+        ...context,
+    }, `Metrics: ${operation} - ${metrics.elapsedMs}ms`);
+}
+/**
+ * 记录警告
+ */
+export function logWarning(message, context) {
+    logger.warn(context, message);
+}
+/**
+ * 记录调试信息
+ */
+export function logDebug(message, context) {
+    logger.debug(context, message);
+}
+/**
+ * 记录错误（通用）
+ */
+export function logError(error, context) {
+    logger.error({
+        ...context,
+        err: error,
+        stack: error.stack,
+        errorName: error.name,
+        errorMessage: error.message,
+    }, error.message);
+}
+/**
+ * 创建性能计时器
+ */
+export function createTimer() {
+    const startTime = Date.now();
+    return {
+        /**
+         * 结束计时并返回性能指标
+         */
+        end() {
+            const endTime = Date.now();
+            const endMemory = process.memoryUsage();
+            return {
+                elapsedMs: endTime - startTime,
+                peakRssMb: Math.round(endMemory.rss / 1024 / 1024),
+            };
+        },
+    };
+}
+/**
+ * 包装异步操作，自动记录日志和性能指标
+ */
+export async function withLogging(context, fn) {
+    const timer = createTimer();
+    logOperationStart(context);
+    try {
+        const result = await fn();
+        const metrics = timer.end();
+        logOperationComplete(context, metrics);
+        return result;
+    }
+    catch (error) {
+        const metrics = timer.end();
+        logOperationError(context, error, metrics);
+        throw error;
+    }
+}
+/**
+ * 包装同步操作，自动记录日志和性能指标
+ */
+export function withLoggingSync(context, fn) {
+    const timer = createTimer();
+    logOperationStart(context);
+    try {
+        const result = fn();
+        const metrics = timer.end();
+        logOperationComplete(context, metrics);
+        return result;
+    }
+    catch (error) {
+        const metrics = timer.end();
+        logOperationError(context, error, metrics);
+        throw error;
+    }
+}
+export default logger;
+//# sourceMappingURL=logger.js.map