sema-core 1.0.11 → 1.0.13

package/dist/manager/TaskManager.js

@@ -0,0 +1,664 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManager = void 0;
+exports.getTaskManager = getTaskManager;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const platform_1 = require("../util/platform");
+const log_1 = require("../util/log");
+const EventSystem_1 = require("../events/EventSystem");
+const process_1 = require("../util/process");
+class TaskManager {
+    constructor() {
+        this.tasks = new Map();
+        this.watchers = new Map();
+        this.notifyCallback = null;
+    }
+    setNotifyCallback(cb) {
+        this.notifyCallback = cb;
+    }
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    getTasks() {
+        return Array.from(this.tasks.values());
+    }
+    getTaskList() {
+        return Array.from(this.tasks.values())
+            .filter(t => !t.foreground)
+            .map(t => ({
+            taskId: t.taskId,
+            pid: t.pid,
+            filepath: t.filepath,
+            status: t.status,
+            type: t.type,
+            command: t.command,
+            agentType: t.agentType,
+            foreground: t.foreground,
+            startTime: t.startTime,
+            endTime: t.endTime,
+        }));
+    }
+    getRunningTasks() {
+        return Array.from(this.tasks.values()).filter(t => t.status === 'running');
+    }
+    /**
+     * 订阅任务的流式输出（UI 打开任务详情面板时调用）
+     * 立即补发已有输出，后续增量实时推送
+     * @returns unwatch 函数，UI 关闭面板时调用
+     */
+    watchTask(taskId, onDelta) {
+        if (!this.watchers.has(taskId)) {
+            this.watchers.set(taskId, new Set());
+        }
+        this.watchers.get(taskId).add(onDelta);
+        // 补发已有输出
+        const record = this.tasks.get(taskId);
+        if (record?.output) {
+            onDelta(record.output);
+        }
+        return () => {
+            this.watchers.get(taskId)?.delete(onDelta);
+        };
+    }
+    /**
+     * 为 run_in_background=true 的命令 spawn 独立进程
+     */
+    spawnBashTask(command, toolUseId, agentContext) {
+        const running = this.getRunningTasks();
+        if (running.length >= TaskManager.MAX_RUNNING_TASKS) {
+            throw new Error(`Maximum number of running background tasks (${TaskManager.MAX_RUNNING_TASKS}) reached. Stop or wait for existing tasks to complete before starting new ones.`);
+        }
+        (0, process_1.ensureTaskDir)();
+        const taskId = crypto.randomBytes(4).toString('hex');
+        const filepath = path.join(process_1.TASK_OUTPUT_DIR, `${taskId}.output`);
+        // 初始化输出文件
+        fs.writeFileSync(filepath, '');
+        const record = {
+            taskId,
+            type: 'Bash',
+            command,
+            toolUseId,
+            filepath,
+            status: 'running',
+            output: '',
+            startTime: Date.now(),
+        };
+        this.tasks.set(taskId, record);
+        const { bin, args } = (0, process_1.getShellForSpawn)();
+        const childProcess = (0, child_process_1.spawn)(bin, [...args, command], {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            ...(platform_1.IS_WIN ? { windowsHide: true } : {}),
+        });
+        record._process = childProcess;
+        record.pid = childProcess.pid;
+        (0, log_1.logInfo)(`[TaskManager] spawnBashTask taskId=${taskId} pid=${childProcess.pid} command=${command}`);
+        // emit task:start
+        (0, EventSystem_1.getEventBus)().emit('task:start', { taskId, pid: childProcess.pid, command, filepath, status: record.status, type: 'Bash' });
+        const appendChunk = (chunk) => {
+            record.output += chunk;
+            // 限制内存上限
+            if (record.output.length > process_1.MAX_OUTPUT_SIZE) {
+                record.output = record.output.slice(-process_1.MAX_OUTPUT_SIZE);
+            }
+            try {
+                fs.appendFileSync(filepath, chunk);
+            }
+            catch (e) {
+                (0, log_1.logWarn)(`[TaskManager] appendFileSync 失败: ${e}`);
+            }
+            this._notifyWatchers(taskId, chunk);
+        };
+        childProcess.stdout?.on('data', (data) => appendChunk(data.toString()));
+        childProcess.stderr?.on('data', (data) => appendChunk(data.toString()));
+        childProcess.on('exit', (code) => {
+            const exitCode = code ?? 1;
+            (0, log_1.logInfo)(`[TaskManager] task ${taskId} exited with code ${exitCode}`);
+            this._finishTask(record, exitCode);
+        });
+        childProcess.on('error', (error) => {
+            (0, log_1.logError)(`[TaskManager] task ${taskId} process error: ${error}`);
+            appendChunk(`\n[Process error: ${error.message}]`);
+            this._finishTask(record, 1);
+        });
+        return { taskId, filepath };
+    }
+    /**
+     * 接管超时的持久 shell 进程
+     */
+    takeoverTask(ctx, command, toolUseId, agentContext) {
+        const running = this.getRunningTasks();
+        if (running.length >= TaskManager.MAX_RUNNING_TASKS) {
+            (0, process_1.killProcess)(ctx.shellProcess);
+            throw new Error(`Maximum number of running background tasks (${TaskManager.MAX_RUNNING_TASKS}) reached. Cannot transfer timed-out command to background.`);
+        }
+        (0, process_1.ensureTaskDir)();
+        const taskId = crypto.randomBytes(4).toString('hex');
+        const filepath = path.join(process_1.TASK_OUTPUT_DIR, `${taskId}.output`);
+        // 将超时前的部分输出写入文件
+        fs.writeFileSync(filepath, ctx.partialOutput);
+        const record = {
+            taskId,
+            type: 'Bash',
+            command,
+            toolUseId,
+            filepath,
+            status: 'running',
+            output: ctx.partialOutput,
+            _shellProcess: ctx.shellProcess,
+            startTime: Date.now(),
+        };
+        this.tasks.set(taskId, record);
+        const takeoverPid = ctx.shellProcess.pid;
+        record.pid = takeoverPid;
+        (0, log_1.logInfo)(`[TaskManager] takeoverTask taskId=${taskId} pid=${takeoverPid} command=${command}`);
+        (0, EventSystem_1.getEventBus)().emit('task:start', { taskId, pid: takeoverPid, command, filepath, status: record.status, type: 'Bash' });
+        // 记录已读取的文件偏移量
+        let stdoutOffset = ctx.partialOutput.length;
+        let stderrOffset = 0;
+        const pollTimer = setInterval(() => {
+            try {
+                // 检查 shell 进程是否已退出（异常退出）
+                const shellExited = ctx.shellProcess.exitCode !== null;
+                // 读取 stdout 增量
+                if (fs.existsSync(ctx.stdoutFile)) {
+                    const content = fs.readFileSync(ctx.stdoutFile).toString('utf8');
+                    if (content.length > stdoutOffset) {
+                        const chunk = content.slice(stdoutOffset);
+                        stdoutOffset = content.length;
+                        record.output += chunk;
+                        if (record.output.length > process_1.MAX_OUTPUT_SIZE) {
+                            record.output = record.output.slice(-process_1.MAX_OUTPUT_SIZE);
+                        }
+                        try {
+                            fs.appendFileSync(filepath, chunk);
+                        }
+                        catch { }
+                        this._notifyWatchers(taskId, chunk);
+                    }
+                }
+                // 读取 stderr 增量
+                if (fs.existsSync(ctx.stderrFile)) {
+                    const content = fs.readFileSync(ctx.stderrFile).toString('utf8');
+                    if (content.length > stderrOffset) {
+                        const chunk = content.slice(stderrOffset);
+                        stderrOffset = content.length;
+                        record.output += chunk;
+                        if (record.output.length > process_1.MAX_OUTPUT_SIZE) {
+                            record.output = record.output.slice(-process_1.MAX_OUTPUT_SIZE);
+                        }
+                        try {
+                            fs.appendFileSync(filepath, chunk);
+                        }
+                        catch { }
+                        this._notifyWatchers(taskId, chunk);
+                    }
+                }
+                // 检查 statusFile：命令正常完成
+                if (fs.existsSync(ctx.statusFile) && fs.statSync(ctx.statusFile).size > 0) {
+                    const exitCodeStr = fs.readFileSync(ctx.statusFile, 'utf8').trim();
+                    const exitCode = Number(exitCodeStr) || 0;
+                    // 先读完最终输出（防止 shell exit handler 删文件后读到空）
+                    if (fs.existsSync(ctx.stdoutFile)) {
+                        const content = fs.readFileSync(ctx.stdoutFile).toString('utf8');
+                        if (content.length > stdoutOffset) {
+                            const chunk = content.slice(stdoutOffset);
+                            record.output += chunk;
+                            try {
+                                fs.appendFileSync(filepath, chunk);
+                            }
+                            catch { }
+                        }
+                    }
+                    if (fs.existsSync(ctx.stderrFile)) {
+                        const content = fs.readFileSync(ctx.stderrFile).toString('utf8');
+                        if (content.length > stderrOffset) {
+                            const chunk = content.slice(stderrOffset);
+                            record.output += chunk;
+                            try {
+                                fs.appendFileSync(filepath, chunk);
+                            }
+                            catch { }
+                        }
+                    }
+                    clearInterval(pollTimer);
+                    record._pollTimer = undefined;
+                    // kill 旧 shell
+                    (0, process_1.killProcess)(ctx.shellProcess);
+                    this._finishTask(record, exitCode);
+                    return;
+                }
+                // shell 异常退出且没有 statusFile → 失败
+                if (shellExited) {
+                    clearInterval(pollTimer);
+                    record._pollTimer = undefined;
+                    this._finishTask(record, ctx.shellProcess.exitCode ?? 1);
+                    return;
+                }
+            }
+            catch (error) {
+                (0, log_1.logWarn)(`[TaskManager] takeoverTask poll error: ${error}`);
+            }
+        }, 200);
+        record._pollTimer = pollTimer;
+        return { taskId, filepath };
+    }
+    /**
+     * 注册前台 Agent 任务（不启动独立执行，仅创建 record 用于转后台）
+     */
+    registerForegroundAgent(taskId, description, toolUseId, abortController, unlinkAbort, agentType) {
+        (0, process_1.ensureTaskDir)();
+        const filepath = path.join(process_1.TASK_OUTPUT_DIR, `${taskId}.output`);
+        fs.writeFileSync(filepath, '');
+        const record = {
+            taskId,
+            type: 'Agent',
+            command: description,
+            toolUseId,
+            filepath,
+            status: 'running',
+            output: '',
+            foreground: true,
+            _abortController: abortController,
+            _unlinkAbort: unlinkAbort,
+            startTime: Date.now(),
+            agentType,
+        };
+        this.tasks.set(taskId, record);
+        (0, log_1.logInfo)(`[TaskManager] registerForegroundAgent taskId=${taskId} description=${description}`);
+    }
+    /**
+     * 设置前台 agent 的转后台 resolve 回调
+     */
+    setTransferResolve(taskId, resolve) {
+        const record = this.tasks.get(taskId);
+        if (record) {
+            record._transferResolve = resolve;
+        }
+    }
+    /**
+     * 将指定前台 agent 转为后台运行
+     * 1. 解除子AC与主AC的联动
+     * 2. resolve transferSignal，让 Agent.ts 的 Promise.race 立刻返回
+     * 3. 标记 foreground=false
+     */
+    transferToBackground(taskId) {
+        const record = this.tasks.get(taskId);
+        if (!record || !record.foreground || record.status !== 'running') {
+            return false;
+        }
+        // 解除与主AC的联动
+        if (record._unlinkAbort) {
+            record._unlinkAbort();
+            record._unlinkAbort = undefined;
+        }
+        // 标记为后台
+        record.foreground = false;
+        // 触发 transferSignal，让 Promise.race 立刻返回
+        if (record._transferResolve) {
+            record._transferResolve();
+            record._transferResolve = undefined;
+        }
+        (0, log_1.logInfo)(`[TaskManager] transferToBackground taskId=${taskId}`);
+        (0, EventSystem_1.getEventBus)().emit('task:transfer', { taskId, from: 'foreground', to: 'background' });
+        return true;
+    }
+    /**
+     * 将所有前台 agent 转为后台
+     * @returns 被转的 taskId 列表
+     */
+    transferAllForeground() {
+        const transferred = [];
+        for (const record of this.tasks.values()) {
+            if (record.foreground && record.status === 'running') {
+                if (this.transferToBackground(record.taskId)) {
+                    transferred.push(record.taskId);
+                }
+            }
+        }
+        return transferred;
+    }
+    /**
+     * 完结 Agent 任务记录（供 Agent.ts 在前台/转后台完成时调用）
+     */
+    finalizeTask(taskId, exitCode, output, usage) {
+        const record = this.tasks.get(taskId);
+        if (!record || record.status !== 'running')
+            return;
+        if (output !== undefined)
+            record.output = output;
+        if (usage)
+            record.usage = usage;
+        this._finishTask(record, exitCode);
+    }
+    /**
+     * 为后台 Agent 创建任务记录并异步执行
+     * @param taskId 复用 Agent.ts 已生成的 taskId
+     * @param description 任务描述（用于通知摘要）
+     * @param toolUseId 触发该任务的 tool_use_id
+     * @param executeFn 实际执行函数，接收独立 AbortController，返回结果文本和可选的 usage 统计
+     */
+    spawnAgentTask(taskId, description, toolUseId, executeFn, agentType) {
+        const running = this.getRunningTasks();
+        if (running.length >= TaskManager.MAX_RUNNING_TASKS) {
+            throw new Error(`Maximum number of running background tasks (${TaskManager.MAX_RUNNING_TASKS}) reached. Stop or wait for existing tasks to complete before starting new ones.`);
+        }
+        (0, process_1.ensureTaskDir)();
+        const filepath = path.join(process_1.TASK_OUTPUT_DIR, `${taskId}.output`);
+        fs.writeFileSync(filepath, '');
+        const abortController = new AbortController();
+        const record = {
+            taskId,
+            type: 'Agent',
+            command: description,
+            toolUseId,
+            filepath,
+            status: 'running',
+            output: '',
+            _abortController: abortController,
+            startTime: Date.now(),
+            agentType,
+        };
+        this.tasks.set(taskId, record);
+        (0, log_1.logInfo)(`[TaskManager] spawnAgentTask taskId=${taskId} description=${description}`);
+        (0, EventSystem_1.getEventBus)().emit('task:start', { taskId, command: description, filepath: '', status: record.status, type: 'Agent', agentType });
+        const promise = executeFn(abortController).then((raw) => {
+            const result = typeof raw === 'string' ? raw : raw.result;
+            const usage = typeof raw === 'string' ? undefined : raw.usage;
+            record.output = result;
+            if (usage)
+                record.usage = usage;
+            try {
+                fs.writeFileSync(filepath, result);
+            }
+            catch (e) {
+                (0, log_1.logWarn)(`[TaskManager] writeFileSync failed for agent task: ${e}`);
+            }
+            this._finishTask(record, 0);
+        }).catch((error) => {
+            const isAborted = abortController.signal.aborted;
+            const msg = isAborted
+                ? '[Agent interrupted]'
+                : `[Agent error: ${error instanceof Error ? error.message : String(error)}]`;
+            if (!record.output)
+                record.output = msg;
+            try {
+                fs.appendFileSync(filepath, msg);
+            }
+            catch { }
+            this._finishTask(record, isAborted ? 0 : 1);
+        });
+        record._promise = promise;
+        return { taskId, filepath };
+    }
+    /**
+     * 停止所有正在运行的任务
+     */
+    stopAllTasks() {
+        const running = this.getRunningTasks();
+        let count = 0;
+        for (const record of running) {
+            if (this.stopTask(record.taskId)) {
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * 停止指定任务
+     */
+    stopTask(taskId) {
+        const record = this.tasks.get(taskId);
+        if (!record)
+            return false;
+        // 清理定时器
+        if (record._pollTimer) {
+            clearInterval(record._pollTimer);
+            record._pollTimer = undefined;
+        }
+        // kill 进程 / abort agent
+        let killed = false;
+        if (record._process) {
+            killed = (0, process_1.killProcess)(record._process);
+        }
+        if (record._shellProcess) {
+            killed = (0, process_1.killProcess)(record._shellProcess) || killed;
+        }
+        if (record._abortController) {
+            record._abortController.abort();
+            killed = true;
+        }
+        if (!killed) {
+            (0, log_1.logWarn)(`[TaskManager] stopTask taskId=${taskId} kill failed`);
+            return false;
+        }
+        record.status = 'killed';
+        record.endTime = Date.now();
+        (0, log_1.logInfo)(`[TaskManager] stopTask taskId=${taskId} pid=${record.pid}`);
+        (0, EventSystem_1.getEventBus)().emit('task:end', {
+            taskId,
+            status: 'killed',
+            summary: this._formatTaskSummary(record, 'killed'),
+        });
+        // Agent 被中止时也发送 task-notification（前台任务除外，其结果由 Agent.ts yield 返回）
+        if (record.type === 'Agent' && !record.foreground) {
+            this._notify(record);
+        }
+        this._pruneFinishedTasks();
+        return true;
+    }
+    /**
+     * 等待任务完成（Promise）
+     * @param onChunk 每次有新增输出时回调，参数为 delta（增量内容）
+     */
+    waitForTask(taskId, timeout = 30000, onChunk, abortSignal) {
+        return new Promise((resolve) => {
+            const record = this.tasks.get(taskId);
+            if (!record) {
+                resolve({ taskId, type: 'Bash', command: '', toolUseId: '', filepath: '', status: 'failed', output: '', startTime: 0 });
+                return;
+            }
+            if (record.status !== 'running') {
+                resolve(record);
+                return;
+            }
+            let unwatch;
+            if (onChunk) {
+                unwatch = this.watchTask(taskId, onChunk);
+            }
+            const cleanup = () => {
+                if (unwatch)
+                    unwatch();
+                clearTimeout(timer);
+                (0, EventSystem_1.getEventBus)().off('task:end', listener);
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve(record);
+            }, timeout);
+            const listener = (data) => {
+                if (data.taskId === taskId) {
+                    cleanup();
+                    resolve(record);
+                }
+            };
+            (0, EventSystem_1.getEventBus)().on('task:end', listener);
+            // 中断支持：停止等待，不影响后台任务本身
+            if (abortSignal) {
+                if (abortSignal.aborted) {
+                    cleanup();
+                    resolve(record);
+                    return;
+                }
+                abortSignal.addEventListener('abort', () => {
+                    cleanup();
+                    resolve(record);
+                }, { once: true });
+            }
+        });
+    }
+    /**
+     * 清理所有资源
+     */
+    dispose() {
+        for (const record of this.tasks.values()) {
+            if (record.status !== 'running')
+                continue;
+            try {
+                if (record._pollTimer) {
+                    clearInterval(record._pollTimer);
+                    record._pollTimer = undefined;
+                }
+                let killed = false;
+                if (record._process) {
+                    killed = (0, process_1.killProcess)(record._process);
+                }
+                if (record._shellProcess) {
+                    killed = (0, process_1.killProcess)(record._shellProcess) || killed;
+                }
+                if (record._abortController) {
+                    record._abortController.abort();
+                    killed = true;
+                }
+                if (!killed) {
+                    (0, log_1.logWarn)(`[TaskManager] dispose: kill failed for taskId=${record.taskId} pid=${record.pid}`);
+                }
+                record.status = 'killed';
+                (0, EventSystem_1.getEventBus)().emit('task:end', {
+                    taskId: record.taskId,
+                    status: 'killed',
+                    summary: this._formatTaskSummary(record, 'killed'),
+                });
+            }
+            catch (error) {
+                (0, log_1.logError)(`[TaskManager] dispose: error cleaning up taskId=${record.taskId}: ${error}`);
+                record.status = 'killed';
+            }
+        }
+        this.tasks.clear();
+        this.watchers.clear();
+    }
+    _notifyWatchers(taskId, delta) {
+        const cbs = this.watchers.get(taskId);
+        if (!cbs?.size)
+            return;
+        cbs.forEach(cb => cb(delta));
+    }
+    _formatTaskSummary(record, status) {
+        const cmd = record.command.length > 50
+            ? record.command.slice(0, 50) + '...'
+            : record.command;
+        return `${record.type} "${cmd}" ${status}`;
+    }
+    _finishTask(record, exitCode) {
+        if (record.status !== 'running')
+            return;
+        record.status = exitCode === 0 ? 'completed' : 'failed';
+        record.exitCode = exitCode;
+        record.endTime = Date.now();
+        // 清理 watchers
+        this.watchers.delete(record.taskId);
+        (0, EventSystem_1.getEventBus)().emit('task:end', {
+            taskId: record.taskId,
+            status: record.status,
+            summary: this._formatTaskSummary(record, record.status),
+        });
+        // 前台任务正常完成，不需要 notify（结果由 Agent.ts yield 返回）
+        // 只有后台任务（包括转后台的）才 notify
+        if (!record.foreground) {
+            this._notify(record);
+        }
+        this._pruneFinishedTasks();
+    }
+    /**
+     * 清理已结束的任务，只保留最新的 MAX_FINISHED_TASKS 个
+     */
+    _pruneFinishedTasks() {
+        const finished = Array.from(this.tasks.values())
+            .filter(t => t.status !== 'running');
+        if (finished.length <= TaskManager.MAX_FINISHED_TASKS)
+            return;
+        const toRemove = finished.slice(0, finished.length - TaskManager.MAX_FINISHED_TASKS);
+        for (const t of toRemove) {
+            this.tasks.delete(t.taskId);
+            this.watchers.delete(t.taskId);
+        }
+    }
+    _notify(record) {
+        if (!this.notifyCallback)
+            return;
+        let msg;
+        if (record.type === 'Agent') {
+            const usageTag = record.usage
+                ? `\n<usage><total_tokens>${record.usage.totalTokens}</total_tokens><tool_uses>${record.usage.toolUses}</tool_uses><duration_ms>${record.usage.durationMs}</duration_ms></usage>`
+                : '';
+            msg = `<task-notification>
+<task-id>${record.taskId}</task-id>
+<tool-use-id>${record.toolUseId}</tool-use-id>
+<status>${record.status}</status>
+<summary>Agent "${record.command}" ${record.status}</summary>
+<result>${record.output}</result>${usageTag}
+</task-notification>`;
+        }
+        else {
+            msg = `<task-notification>
+<task-id>${record.taskId}</task-id>
+<tool-use-id>${record.toolUseId}</tool-use-id>
+<output-file>${record.filepath}</output-file>
+<status>${record.status}</status>
+<summary>Background bash command ${record.status} (exit code ${record.exitCode ?? 'N/A'})</summary>
+</task-notification>
+Read the output file to retrieve the result: ${record.filepath}`;
+        }
+        this.notifyCallback(msg);
+    }
+}
+exports.TaskManager = TaskManager;
+TaskManager.MAX_FINISHED_TASKS = 10;
+TaskManager.MAX_RUNNING_TASKS = 5;
+// 单例
+let instance = null;
+function getTaskManager() {
+    if (!instance) {
+        instance = new TaskManager();
+    }
+    return instance;
+}
+//# sourceMappingURL=TaskManager.js.map