@coze-arch/cli 0.0.1-alpha.dcc485 → 0.0.1-alpha.de4758

package/lib/cli.js

@@ -4,6 +4,9 @@
 var commander = require('commander');
 var path = require('path');
 var fs = require('fs');
+var debug = require('debug');
+var node_http = require('node:http');
+var node_https = require('node:https');
 var node_path = require('node:path');
 var node_fs = require('node:fs');
 var shelljs = require('shelljs');
@@ -129,6 +132,2161 @@ const generateTemplatesHelpText = () => {
   return lines.join('\n');
 };
 
+var DEFAULT_SIZE = 10;
+var DEFAULT_WAIT = 1000;
+var stringifyBatch = function (list) {
+    return JSON.stringify({
+        ev_type: 'batch',
+        list: list,
+    });
+};
+function createBatchSender(config) {
+    var transport = config.transport;
+    var endpoint = config.endpoint, _a = config.size, size = _a === void 0 ? DEFAULT_SIZE : _a, _b = config.wait, wait = _b === void 0 ? DEFAULT_WAIT : _b;
+    var batch = [];
+    var tid = 0;
+    var fail;
+    var success;
+    var sender = {
+        getSize: function () {
+            return size;
+        },
+        getWait: function () {
+            return wait;
+        },
+        setSize: function (v) {
+            size = v;
+        },
+        setWait: function (v) {
+            wait = v;
+        },
+        getEndpoint: function () {
+            return endpoint;
+        },
+        setEndpoint: function (v) {
+            endpoint = v;
+        },
+        send: function (e) {
+            batch.push(e);
+            if (batch.length >= size) {
+                sendBatch.call(this);
+            }
+            clearTimeout(tid);
+            tid = setTimeout(sendBatch.bind(this), wait);
+        },
+        flush: function () {
+            clearTimeout(tid);
+            sendBatch.call(this);
+        },
+        getBatchData: function () {
+            return batch.length ? stringifyBatch(batch) : '';
+        },
+        clear: function () {
+            clearTimeout(tid);
+            batch = [];
+        },
+        fail: function (cb) {
+            fail = cb;
+        },
+        success: function (cb) {
+            success = cb;
+        },
+    };
+    function sendBatch() {
+        if (!batch.length) {
+            return;
+        }
+        var data = this.getBatchData();
+        transport.post({
+            url: endpoint,
+            data: data,
+            fail: function (err) {
+                fail && fail(err, data);
+            },
+            success: function () {
+                success && success(data);
+            },
+        });
+        batch = [];
+    }
+    return sender;
+}
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+var noop$1 = function () { return ({}); };
+function id(v) {
+    return v;
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isObject(o) {
+    return typeof o === 'object' && o !== null;
+}
+var objProto = Object.prototype;
+function isArray(o) {
+    return objProto.toString.call(o) === '[object Array]';
+}
+function isBoolean(o) {
+    return typeof o === 'boolean';
+}
+function isNumber(o) {
+    return typeof o === 'number';
+}
+function isString(o) {
+    return typeof o === 'string';
+}
+
+// 检查数组中是否有元素
+function arrayIncludes(array, value) {
+    if (!isArray(array)) {
+        return false;
+    }
+    if (array.length === 0) {
+        return false;
+    }
+    var k = 0;
+    while (k < array.length) {
+        if (array[k] === value) {
+            return true;
+        }
+        k++;
+    }
+    return false;
+}
+var arrayRemove = function (arr, e) {
+    if (!isArray(arr)) {
+        return arr;
+    }
+    var i = arr.indexOf(e);
+    if (i >= 0) {
+        var arr_ = arr.slice();
+        arr_.splice(i, 1);
+        return arr_;
+    }
+    return arr;
+};
+/**
+ * 按路径访问对象属性
+ * @param target 待访问对象
+ * @param property 访问属性路径
+ * @param { (target: any, property: string): any } visitor 访问器
+ */
+var safeVisit = function (target, path, visitor) {
+    var _a, _b;
+    var paths = path.split('.');
+    var _c = __read(paths), method = _c[0], rest = _c.slice(1);
+    while (target && rest.length > 0) {
+        target = target[method];
+        _a = rest, _b = __read(_a), method = _b[0], rest = _b.slice(1);
+    }
+    if (!target) {
+        return undefined;
+    }
+    return visitor(target, method);
+};
+
+function safeStringify(a) {
+    try {
+        return isString(a) ? a : JSON.stringify(a);
+    }
+    catch (err) {
+        return '[FAILED_TO_STRINGIFY]:' + String(err);
+    }
+}
+
+function createContextAgent() {
+    var context = {};
+    var stringified = {};
+    var contextAgent = {
+        set: function (k, v) {
+            context[k] = v;
+            stringified[k] = safeStringify(v);
+            return contextAgent;
+        },
+        merge: function (ctx) {
+            context = __assign(__assign({}, context), ctx);
+            Object.keys(ctx).forEach(function (key) {
+                stringified[key] = safeStringify(ctx[key]);
+            });
+            return contextAgent;
+        },
+        delete: function (k) {
+            delete context[k];
+            delete stringified[k];
+            return contextAgent;
+        },
+        clear: function () {
+            context = {};
+            stringified = {};
+            return contextAgent;
+        },
+        get: function (k) {
+            return stringified[k];
+        },
+        toString: function () {
+            return __assign({}, stringified);
+        },
+    };
+    return contextAgent;
+}
+
+var getPrintString = function () {
+    // @ts-expect-error
+    if (''.padStart) {
+        return function (str, prefixLength) {
+            if (prefixLength === void 0) { prefixLength = 8; }
+            return str.padStart(prefixLength, ' ');
+        };
+    }
+    return function (str) { return str; };
+};
+var printString = getPrintString();
+var errCount = 0;
+var error = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    // eslint-disable-next-line no-console
+    console.error.apply(console, __spreadArray(['[SDK]', Date.now(), printString("" + errCount++)], __read(args), false));
+};
+var warnCount = 0;
+var warn = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    // eslint-disable-next-line no-console
+    console.warn.apply(console, __spreadArray(['[SDK]', Date.now(), printString("" + warnCount++)], __read(args), false));
+};
+
+var isHitBySampleRate = function (sampleRate) {
+    if (Math.random() < Number(sampleRate)) {
+        return true;
+    }
+    return false;
+};
+var isHitByRandom = function (random, sampleRate) {
+    if (random < Number(sampleRate)) {
+        return true;
+    }
+    return false;
+};
+
+var runProcessors = function (fns) {
+    return function (e) {
+        var r = e;
+        for (var i = 0; i < fns.length; i++) {
+            if (r) {
+                try {
+                    r = fns[i](r);
+                }
+                catch (err) {
+                    error(err);
+                }
+            }
+            else {
+                break;
+            }
+        }
+        return r;
+    };
+};
+
+/**
+ * 生成uuid
+ * stolen from https://github.com/kelektiv/node-uuid#readme uuid/v4
+ *
+ * @returns
+ */
+function mathRNG() {
+    var rnds = new Array(16);
+    var r = 0;
+    for (var i = 0; i < 16; i++) {
+        if ((i & 0x03) === 0) {
+            r = Math.random() * 0x100000000;
+        }
+        rnds[i] = (r >>> ((i & 0x03) << 3)) & 0xff;
+    }
+    return rnds;
+}
+function bytesToUuid(buf) {
+    var byteToHex = [];
+    for (var index = 0; index < 256; ++index) {
+        byteToHex[index] = (index + 0x100).toString(16).substr(1);
+    }
+    var i = 0;
+    var bth = byteToHex;
+    // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
+    return [
+        bth[buf[i++]],
+        bth[buf[i++]],
+        bth[buf[i++]],
+        bth[buf[i++]],
+        '-',
+        bth[buf[i++]],
+        bth[buf[i++]],
+        '-',
+        bth[buf[i++]],
+        bth[buf[i++]],
+        '-',
+        bth[buf[i++]],
+        bth[buf[i++]],
+        '-',
+        bth[buf[i++]],
+        bth[buf[i++]],
+        bth[buf[i++]],
+        bth[buf[i++]],
+        bth[buf[i++]],
+        bth[buf[i++]],
+    ].join('');
+}
+function uuid() {
+    var rnds = mathRNG();
+    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    return bytesToUuid(rnds);
+}
+
+function createDestroyAgent() {
+    var destroyed = false;
+    var data = {};
+    var removeTearDownGroup = function (tearDownGroup) {
+        tearDownGroup.length &&
+            tearDownGroup.forEach(function (v) {
+                try {
+                    v();
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        tearDownGroup.length = 0;
+    };
+    var removeByPluginName = function (pluginName) {
+        data[pluginName] &&
+            data[pluginName].forEach(function (e) {
+                removeTearDownGroup(e[1]);
+            });
+        data[pluginName] = undefined;
+    };
+    var removeByEvType = function (evType) {
+        Object.keys(data).forEach(function (k) {
+            data[k] &&
+                data[k].forEach(function (e) {
+                    if (e[0] === evType) {
+                        removeTearDownGroup(e[1]);
+                    }
+                });
+        });
+    };
+    return {
+        /**
+         * register tearDownGroup for a single plugin.
+         */
+        set: function (pluginName, evType, tearDownGroup) {
+            if (data[pluginName])
+                data[pluginName].push([evType, tearDownGroup]);
+            else
+                data[pluginName] = [[evType, tearDownGroup]];
+            // auto remove tearDownGroup if destroyed
+            destroyed && removeTearDownGroup(tearDownGroup);
+        },
+        has: function (pluginName) {
+            return !!data[pluginName];
+        },
+        /**
+         * remove tearDownGroup for a single plugin.
+         */
+        remove: removeByPluginName,
+        /**
+         * remove tearDownGroup by event type
+         */
+        removeByEvType: removeByEvType,
+        /**
+         * clear all tearDownGroup
+         */
+        clear: function () {
+            destroyed = true;
+            Object.keys(data).forEach(function (k) {
+                removeByPluginName(k);
+            });
+        },
+    };
+}
+
+// max size of preStartQueue
+var PRESTART_QUEUE_MAX_SIZE = 500;
+// slice size to operate preStartQueue
+var PRESTART_QUEUE_OP_SLICE_SIZE = 50;
+function cachePreStartData(client, preStartQueue, processed) {
+    preStartQueue.push(processed);
+    if (preStartQueue.length < PRESTART_QUEUE_MAX_SIZE) {
+        return;
+    }
+    // delete some data to prevent OOM
+    var deleteData = preStartQueue.splice(0, PRESTART_QUEUE_OP_SLICE_SIZE);
+    if (client.savePreStartDataToDb) {
+        void client.savePreStartDataToDb(deleteData);
+    }
+}
+function consumePreStartData(client) {
+    var preStartQueue = client.getPreStartQueue();
+    preStartQueue.forEach(function (e) { return client.build(e); });
+    preStartQueue.length = 0;
+}
+
+var EVENTS = [
+    'init',
+    'start',
+    'config',
+    'beforeDestroy',
+    'provide',
+    'beforeReport',
+    'report',
+    'beforeBuild',
+    'build',
+    'beforeSend',
+    'send',
+    'beforeConfig',
+];
+
+function createClient(creationConfig) {
+    var builder = creationConfig.builder, createSender = creationConfig.createSender, createDefaultConfig = creationConfig.createDefaultConfig, createConfigManager = creationConfig.createConfigManager, userConfigNormalizer = creationConfig.userConfigNormalizer, initConfigNormalizer = creationConfig.initConfigNormalizer, validateInitConfig = creationConfig.validateInitConfig;
+    var sender;
+    var configManager;
+    var handlers = {};
+    EVENTS.forEach(function (e) { return (handlers[e] = []); });
+    var inited = false;
+    var started = false;
+    var destroyed = false;
+    // 缓存 start 之前 build 的事件
+    var preStartQueue = [];
+    // 禁止通过 provide 挂载的字段名
+    var reservedNames = [];
+    var destroyAgent = createDestroyAgent();
+    var client = {
+        getBuilder: function () { return builder; },
+        getSender: function () { return sender; },
+        getPreStartQueue: function () { return preStartQueue; },
+        init: function (c) {
+            if (inited) {
+                warn('already inited');
+                return;
+            }
+            if (c && isObject(c) && validateInitConfig(c)) {
+                var defaultConfig = createDefaultConfig(c);
+                if (!defaultConfig) {
+                    throw new Error('defaultConfig missing');
+                }
+                var initConfig = initConfigNormalizer(c);
+                configManager = createConfigManager(defaultConfig);
+                configManager.setConfig(initConfig);
+                configManager.onChange(function () {
+                    handle('config');
+                });
+                sender = createSender(configManager.getConfig());
+                if (!sender) {
+                    throw new Error('sender missing');
+                }
+                inited = true;
+                handle('init', true);
+            }
+            else {
+                throw new Error('invalid InitConfig, init failed');
+            }
+        },
+        set: function (c) {
+            if (!inited) {
+                return;
+            }
+            if (c && isObject(c)) {
+                handle('beforeConfig', false, c);
+                configManager === null || configManager === void 0 ? void 0 : configManager.setConfig(c);
+            }
+        },
+        config: function (c) {
+            if (!inited) {
+                return;
+            }
+            if (c && isObject(c)) {
+                handle('beforeConfig', false, c);
+                configManager === null || configManager === void 0 ? void 0 : configManager.setConfig(userConfigNormalizer(c));
+            }
+            return configManager === null || configManager === void 0 ? void 0 : configManager.getConfig();
+        },
+        provide: function (name, value) {
+            if (arrayIncludes(reservedNames, name)) {
+                warn("cannot provide " + name + ", reserved");
+                return;
+            }
+            client[name] = value;
+            handle('provide', false, name);
+        },
+        start: function () {
+            if (!inited) {
+                return;
+            }
+            if (started) {
+                return;
+            }
+            configManager === null || configManager === void 0 ? void 0 : configManager.onReady(function () {
+                started = true;
+                handle('start', true);
+                consumePreStartData(client);
+            });
+        },
+        report: function (data) {
+            if (!data) {
+                return;
+            }
+            var preReport = runProcessors(handlers['beforeReport'])(data);
+            if (!preReport) {
+                return;
+            }
+            var processed = runProcessors(handlers['report'])(preReport);
+            if (!processed) {
+                return;
+            }
+            if (started) {
+                this.build(processed);
+            }
+            else {
+                cachePreStartData(client, preStartQueue, processed);
+            }
+        },
+        build: function (data) {
+            if (!started) {
+                return;
+            }
+            var preBuild = runProcessors(handlers['beforeBuild'])(data);
+            if (!preBuild) {
+                return;
+            }
+            var built = builder.build(preBuild);
+            if (!built) {
+                return;
+            }
+            var processed = runProcessors(handlers['build'])(built);
+            if (!processed) {
+                return;
+            }
+            this.send(processed);
+        },
+        send: function (data) {
+            if (!started) {
+                return;
+            }
+            var processed = runProcessors(handlers['beforeSend'])(data);
+            if (processed) {
+                sender.send(processed);
+                handle('send', false, processed);
+            }
+        },
+        destroy: function () {
+            destroyAgent.clear();
+            destroyed = true;
+            preStartQueue.length = 0;
+            handle('beforeDestroy', true);
+        },
+        on: function (ev, handler) {
+            if ((ev === 'init' && inited) || (ev === 'start' && started) || (ev === 'beforeDestroy' && destroyed)) {
+                try {
+                    ;
+                    handler();
+                }
+                catch (_err) {
+                    // ignore
+                }
+            }
+            else if (handlers[ev]) {
+                handlers[ev].push(handler);
+            }
+        },
+        off: function (ev, handler) {
+            if (handlers[ev])
+                handlers[ev] = arrayRemove(handlers[ev], handler);
+        },
+        destroyAgent: destroyAgent,
+    };
+    reservedNames = Object.keys(client);
+    return client;
+    function handle(ev, once) {
+        if (once === void 0) { once = false; }
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        handlers[ev].forEach(function (f) {
+            try {
+                f.apply(void 0, __spreadArray([], __read(args), false));
+            }
+            catch (_err) {
+                // ignore
+            }
+        });
+        if (once) {
+            handlers[ev].length = 0;
+        }
+    }
+}
+
+var ContextPlugin = function (client) {
+    var contextAgent = createContextAgent();
+    client.provide('context', contextAgent);
+    client.on('report', function (ev) {
+        if (!ev.extra) {
+            ev.extra = {};
+        }
+        ev.extra.context = contextAgent.toString();
+        return ev;
+    });
+};
+
+function IntegrationPlugin(client, runAfterSetup) {
+    client.on('init', function () {
+        var nameList = [];
+        var applyIntegrations = function (integrations) {
+            integrations.forEach(function (integration) {
+                var integrationName = integration.name;
+                if (!arrayIncludes(nameList, integrationName)) {
+                    nameList.push(integrationName);
+                    integration.setup(client);
+                    client.destroyAgent.set(integrationName, integrationName, [
+                        function () {
+                            nameList = arrayRemove(nameList, integrationName);
+                            integration.tearDown && integration.tearDown();
+                        },
+                    ]);
+                }
+            });
+        };
+        client.provide('applyIntegrations', applyIntegrations);
+        var config = client.config();
+        if (config && config.integrations) {
+            applyIntegrations(config.integrations);
+        }
+    });
+}
+
+var DevtoolsPlugin = function (client) {
+    try {
+        if (typeof window === 'object' && isObject(window) && window.__SLARDAR_DEVTOOLS_GLOBAL_HOOK__) {
+            window.__SLARDAR_DEVTOOLS_GLOBAL_HOOK__.push(client);
+        }
+    }
+    catch (e) {
+        // ignore
+    }
+};
+
+var now = function () { return Date.now(); };
+
+function getDefaultBrowser() {
+    if (typeof window === 'object' && isObject(window))
+        return window;
+}
+
+// 获取全局注册表
+var getGlobalRegistry = function (global) {
+    if (!global)
+        return;
+    if (!global.__SLARDAR_REGISTRY__) {
+        global.__SLARDAR_REGISTRY__ = {
+            Slardar: {
+                plugins: [],
+                errors: [],
+                subject: {},
+            },
+        };
+    }
+    return global.__SLARDAR_REGISTRY__.Slardar;
+};
+var reportSelfError = function () {
+    var errorInfo = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        errorInfo[_i] = arguments[_i];
+    }
+    var registry = getGlobalRegistry(getDefaultBrowser());
+    if (!registry)
+        return;
+    if (!registry.errors) {
+        registry.errors = [];
+    }
+    registry.errors.push(errorInfo);
+};
+
+/**
+ * Special support in Perfsee for analyzing call stacks of custom events and custom metrics.
+ */
+// eslint-disable-next-line
+var getStacksOnPerfsee = function (constructor) {
+    var _a;
+    // @ts-expect-error
+    if (typeof window !== 'object' || !window.__perfsee__) {
+        return;
+    }
+    var obj = {};
+    (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, obj, constructor);
+    return obj.stack;
+};
+
+var CUSTOM_EV_TYPE = 'custom';
+
+var CUSTOM_EVENT_TYPE = 'event';
+var CUSTOM_LOG_TYPE = 'log';
+var normalizeCustomEventData = function (raw) {
+    if (!raw || !isObject(raw)) {
+        return;
+    }
+    // name is required
+    if (!raw['name'] || !isString(raw['name'])) {
+        return;
+    }
+    var res = {
+        name: raw['name'],
+        type: CUSTOM_EVENT_TYPE,
+    };
+    if ('metrics' in raw && isObject(raw['metrics'])) {
+        var rMetrics = raw['metrics'];
+        var metrics = {};
+        for (var k in rMetrics) {
+            if (isNumber(rMetrics[k])) {
+                metrics[k] = rMetrics[k];
+            }
+        }
+        res.metrics = metrics;
+    }
+    if ('categories' in raw && isObject(raw['categories'])) {
+        var rCategories = raw['categories'];
+        var categories = {};
+        for (var k in rCategories) {
+            categories[k] = safeStringify(rCategories[k]);
+        }
+        res.categories = categories;
+    }
+    if ('attached_log' in raw && isString(raw['attached_log'])) {
+        res.attached_log = raw['attached_log'];
+    }
+    return res;
+};
+var normalizeCustomLogData = function (raw) {
+    if (!raw || !isObject(raw)) {
+        return;
+    }
+    // content is required
+    if (!raw['content'] || !isString(raw['content'])) {
+        return;
+    }
+    var rContent = raw['content'];
+    var res = {
+        content: safeStringify(rContent),
+        type: CUSTOM_LOG_TYPE,
+        level: 'info',
+    };
+    if ('level' in raw) {
+        res.level = raw['level'];
+    }
+    if ('extra' in raw && isObject(raw['extra'])) {
+        var rExtra = raw['extra'];
+        var metrics = {};
+        var categories = {};
+        for (var k in rExtra) {
+            if (isNumber(rExtra[k])) {
+                metrics[k] = rExtra[k];
+            }
+            else {
+                categories[k] = safeStringify(rExtra[k]);
+            }
+        }
+        res.metrics = metrics;
+        res.categories = categories;
+    }
+    if ('attached_log' in raw && isString(raw['attached_log'])) {
+        res.attached_log = raw['attached_log'];
+    }
+    return res;
+};
+var CustomPlugin = function (client) {
+    var sendEvent = function (data) {
+        var normalized = normalizeCustomEventData(data);
+        if (normalized) {
+            var stacks = getStacksOnPerfsee(sendEvent);
+            if (stacks) {
+                // @ts-expect-error
+                normalized.stacks = stacks;
+            }
+            client.report({
+                ev_type: CUSTOM_EV_TYPE,
+                payload: normalized,
+                extra: {
+                    timestamp: now(),
+                },
+            });
+        }
+    };
+    var sendLog = function (data) {
+        var normalized = normalizeCustomLogData(data);
+        if (normalized) {
+            client.report({
+                ev_type: CUSTOM_EV_TYPE,
+                payload: normalized,
+                extra: {
+                    timestamp: now(),
+                },
+            });
+        }
+    };
+    client.provide('sendEvent', sendEvent);
+    client.provide('sendLog', sendLog);
+};
+
+/* eslint-disable @typescript-eslint/prefer-for-of */
+var withSampleRate = function (ev, sampleRate) {
+    var common = ev.common || {};
+    common.sample_rate = sampleRate;
+    ev.common = common;
+    return ev;
+};
+var hitFnWithRandom = function (preCalc, sampleRate, isHitBySampleRate, random, isHitByRandom) {
+    return preCalc
+        ? (function (h) { return function () {
+            return h;
+        }; })(isHitByRandom(random, sampleRate))
+        : function () { return isHitBySampleRate(sampleRate); };
+};
+var parseValues = function (values, type) {
+    return values.map(function (v) {
+        switch (type) {
+            case 'number':
+                return Number(v);
+            case 'boolean':
+                return v === '1';
+            case 'string': // default to string
+            default:
+                return String(v);
+        }
+    });
+};
+var checkVal = function (val, values, op) {
+    switch (op) {
+        case 'eq':
+            return arrayIncludes(values, val);
+        case 'neq':
+            return !arrayIncludes(values, val);
+        case 'gt':
+            return val > values[0];
+        case 'gte':
+            return val >= values[0];
+        case 'lt':
+            return val < values[0];
+        case 'lte':
+            return val <= values[0];
+        case 'regex':
+            return Boolean(val.match(new RegExp(values.join('|'))));
+        case 'not_regex':
+            return !val.match(new RegExp(values.join('|')));
+        default: {
+            // unknown op
+            return false;
+        }
+    }
+};
+var checkFilter = function (ev, field, op, values) {
+    var val = safeVisit(ev, field, function (t, p) {
+        return t[p];
+    });
+    if (val === undefined) {
+        return false;
+    }
+    var field_type = isBoolean(val) ? 'bool' : isNumber(val) ? 'number' : 'string';
+    return checkVal(val, parseValues(values, field_type), op);
+};
+var matchFilter = function (ev, filter) {
+    try {
+        return filter.type === 'rule'
+            ? checkFilter(ev, filter.field, filter.op, filter.values)
+            : filter.type === 'and'
+                ? filter.children.every(function (f) { return matchFilter(ev, f); })
+                : filter.children.some(function (f) { return matchFilter(ev, f); });
+    }
+    catch (e) {
+        reportSelfError(e);
+        return false;
+    }
+};
+var getHitMap = function (rules, preCalcHit, baseRate, isHitBySampleRate, random, isHitByRandom) {
+    var hitMap = {};
+    Object.keys(rules).forEach(function (name) {
+        var _a = rules[name], enable = _a.enable, sample_rate = _a.sample_rate, conditional_sample_rules = _a.conditional_sample_rules;
+        if (enable) {
+            hitMap[name] = {
+                enable: enable,
+                sample_rate: sample_rate,
+                effectiveSampleRate: sample_rate * baseRate,
+                hit: hitFnWithRandom(preCalcHit, sample_rate, isHitBySampleRate, random, isHitByRandom),
+            };
+            if (conditional_sample_rules) {
+                hitMap[name].conditional_hit_rules = conditional_sample_rules.map(function (_a) {
+                    var s = _a.sample_rate, filter = _a.filter;
+                    return ({
+                        sample_rate: s,
+                        hit: hitFnWithRandom(preCalcHit, s, isHitBySampleRate, random, isHitByRandom),
+                        effectiveSampleRate: s * baseRate,
+                        filter: filter,
+                    });
+                });
+            }
+        }
+        else {
+            hitMap[name] = {
+                enable: enable,
+                hit: function () {
+                    /* istanbul ignore next */
+                    return false;
+                },
+                sample_rate: 0,
+                effectiveSampleRate: 0,
+            };
+        }
+    });
+    return hitMap;
+};
+var getSampler = function (userId, config, isHitBySampleRate, isHitByRandom, destroyFns) {
+    if (!config)
+        return id;
+    // r的设计是为了允许外部传入随机数，用于彻底实现按用户采样
+    var baseRate = config.sample_rate, include_users = config.include_users, sample_granularity = config.sample_granularity, rules = config.rules, _a = config.r, random = _a === void 0 ? Math.random() : _a;
+    // 用户名单采样
+    var userHit = arrayIncludes(include_users, userId);
+    if (userHit) {
+        return function (ev) { return withSampleRate(ev, 1); };
+    }
+    // should pre calculate hit
+    var preCalcHit = sample_granularity === 'session';
+    var baseHit = hitFnWithRandom(preCalcHit, baseRate, isHitBySampleRate, random, isHitByRandom);
+    var hitMap = getHitMap(rules, preCalcHit, baseRate, isHitBySampleRate, random, isHitByRandom);
+    return function (ev) {
+        var _a;
+        // 总采样必须命中才有后续
+        if (!baseHit()) {
+            preCalcHit && destroyFns[0]();
+            return false;
+        }
+        // 未配置的事件类型
+        if (!(ev.ev_type in hitMap)) {
+            return withSampleRate(ev, baseRate);
+        }
+        // 忽略未开启的事件类型
+        if (!hitMap[ev.ev_type].enable) {
+            preCalcHit && destroyFns[1](ev.ev_type);
+            return false;
+        }
+        // 跳过采样配置
+        if ((_a = ev.common) === null || _a === void 0 ? void 0 : _a.sample_rate) {
+            return ev;
+        }
+        var hitConfig = hitMap[ev.ev_type];
+        var conditions = hitConfig.conditional_hit_rules;
+        if (conditions) {
+            // 先判断条件采样
+            for (var i = 0; i < conditions.length; i++) {
+                if (matchFilter(ev, conditions[i].filter)) {
+                    if (conditions[i].hit()) {
+                        return withSampleRate(ev, conditions[i].effectiveSampleRate);
+                    }
+                    // 条件匹配后不再搜索
+                    return false;
+                }
+            }
+        }
+        // 事件类型采样
+        if (!hitConfig.hit()) {
+            // not hit ev_type and no condition, destroy side effect
+            !(conditions && conditions.length) && preCalcHit && destroyFns[1](ev.ev_type);
+            return false;
+        }
+        // 事件类型默认采样已经命中
+        return withSampleRate(ev, hitConfig.effectiveSampleRate);
+    };
+};
+var SamplePlugin = function (client) {
+    client.on('start', function () {
+        var _a = client.config(), userId = _a.userId, sample = _a.sample;
+        var destroyFns = [
+            function () {
+                client.destroy();
+            },
+            function (ev_type) {
+                client.destroyAgent.removeByEvType(ev_type);
+            },
+        ];
+        var sampler = getSampler(userId, sample, isHitBySampleRate, isHitByRandom, destroyFns);
+        client.on('build', sampler);
+    });
+};
+
+var builder = {
+    build: function (e) {
+        return {
+            ev_type: e.ev_type,
+            payload: e.payload,
+            common: __assign(__assign({}, (e.extra || {})), (e.overrides || {})),
+        };
+    },
+};
+
+var REPORT_DOMAIN = "mon.zijieapi.com";
+var SDK_VERSION = "2.1.8" ;
+var SDK_NAME = 'SDK_BASE';
+var SETTINGS_PATH = '/monitor_web/settings/browser-settings';
+var BATCH_REPORT_PATH = "/monitor_browser/collect/batch/";
+var DEFAULT_SAMPLE_CONFIG = {
+    sample_rate: 1,
+    include_users: [],
+    sample_granularity: 'session',
+    rules: {},
+};
+var DEFAULT_SENDER_SIZE = 20;
+var DEFAULT_SAMPLE_GRANULARITY = 'session';
+
+function normalizeStrictFields(config) {
+    var e_1, _a;
+    var strictFields = ['userId', 'deviceId', 'sessionId', 'env'];
+    try {
+        for (var strictFields_1 = __values(strictFields), strictFields_1_1 = strictFields_1.next(); !strictFields_1_1.done; strictFields_1_1 = strictFields_1.next()) {
+            var k = strictFields_1_1.value;
+            if (!config[k]) {
+                delete config[k];
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (strictFields_1_1 && !strictFields_1_1.done && (_a = strictFields_1.return)) _a.call(strictFields_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return config;
+}
+function normalizeInitConfig(config) {
+    return normalizeStrictFields(__assign({}, config));
+}
+function validateInitConfig(config) {
+    return isObject(config) && 'bid' in config && 'transport' in config;
+}
+function normalizeUserConfig(config) {
+    return normalizeStrictFields(__assign({}, config));
+}
+function parseServerConfig(serverConfig) {
+    if (!serverConfig) {
+        return {};
+    }
+    var sample = serverConfig.sample, timestamp = serverConfig.timestamp, _a = serverConfig.quota_rate, quota_rate = _a === void 0 ? 1 : _a;
+    if (!sample) {
+        return {};
+    }
+    var sample_rate = sample.sample_rate, _b = sample.sample_granularity, sample_granularity = _b === void 0 ? DEFAULT_SAMPLE_GRANULARITY : _b, include_users = sample.include_users, _c = sample.rules, rules = _c === void 0 ? [] : _c;
+    return {
+        sample: {
+            include_users: include_users,
+            sample_rate: sample_rate * quota_rate,
+            sample_granularity: sample_granularity,
+            rules: rules.reduce(function (prev, cur) {
+                var name = cur.name, enable = cur.enable, sample_rate = cur.sample_rate, conditional_sample_rules = cur.conditional_sample_rules;
+                prev[name] = {
+                    enable: enable,
+                    sample_rate: sample_rate,
+                    conditional_sample_rules: conditional_sample_rules,
+                };
+                return prev;
+            }, {}),
+        },
+        serverTimestamp: timestamp,
+    };
+}
+
+/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
+var getReportUrl = function (domain, path) {
+    if (path === void 0) { path = BATCH_REPORT_PATH; }
+    return "" + (domain && domain.indexOf('//') >= 0 ? '' : 'https://') + domain + path;
+};
+var getSettingsUrl = function (domain, path) {
+    if (path === void 0) { path = SETTINGS_PATH; }
+    return "" + (domain && domain.indexOf('//') >= 0 ? '' : 'https://') + domain + path;
+};
+var getDefaultUserId = function () {
+    return uuid();
+};
+var getDefaultDeviceId = function () {
+    return uuid();
+};
+var getViewId = function (pid) { return pid + "_" + Date.now(); };
+var getDefaultSessionId = function () {
+    return uuid();
+};
+
+var createConfigManager = function (defaultConfig) {
+    // the merged config
+    var config = defaultConfig;
+    // save it so we know when initConfig is set
+    var initConfig;
+    // save UserConfig so we can merge with priority
+    var userConfig = {};
+    // save the original server config, from get_setting response
+    var serverConfig;
+    // cache the parsed ServerConfig, used in merge
+    var parsedServerConfig;
+    var onReady = noop$1;
+    // call when config changed
+    var onChange = noop$1;
+    return {
+        getConfig: function () {
+            return config;
+        },
+        setConfig: function (c) {
+            userConfig = __assign(__assign({}, userConfig), (c || {}));
+            updateConfig();
+            if (!initConfig) {
+                // handle init
+                initConfig = c;
+                if (config.useLocalConfig || !config.bid) {
+                    parsedServerConfig = {};
+                    onReady();
+                }
+                else {
+                    getServerConfig(config.transport, config.domain, config.bid, function (res) {
+                        serverConfig = res;
+                        handleServerConfig();
+                    });
+                }
+            }
+            return config;
+        },
+        onChange: function (fn) {
+            onChange = fn;
+        },
+        onReady: function (fn) {
+            onReady = fn;
+            if (parsedServerConfig) {
+                onReady();
+            }
+        },
+    };
+    function updateConfig() {
+        var newConfig = __assign(__assign(__assign({}, defaultConfig), (parsedServerConfig || {})), userConfig);
+        newConfig.sample = mergeSampleConfig(mergeSampleConfig(defaultConfig.sample, parsedServerConfig === null || parsedServerConfig === void 0 ? void 0 : parsedServerConfig.sample), userConfig.sample);
+        config = newConfig;
+        onChange();
+    }
+    function handleServerConfig() {
+        parsedServerConfig = parseServerConfig(serverConfig);
+        updateConfig();
+        onReady();
+    }
+};
+function getServerConfig(transport, domain, bid, cb) {
+    if (!transport.get) {
+        return cb({});
+    }
+    transport.get({
+        withCredentials: true,
+        url: getSettingsUrl(domain) + "?bid=" + bid + "&store=1",
+        success: function (res) {
+            cb(res.data || {});
+        },
+        fail: function () {
+            cb({ sample: { sample_rate: 0.001 } });
+        },
+    });
+}
+function mergeSampleConfig(a, b) {
+    if (!a || !b)
+        return a || b;
+    var res = __assign(__assign({}, a), b);
+    res.include_users = __spreadArray(__spreadArray([], __read((a.include_users || [])), false), __read((b.include_users || [])), false);
+    res.rules = __spreadArray(__spreadArray([], __read(Object.keys(a.rules || {})), false), __read(Object.keys(b.rules || {})), false).reduce(function (obj, key) {
+        var _a, _b;
+        if (!(key in obj)) {
+            if (key in (a.rules || {}) && key in (b.rules || {})) {
+                obj[key] = __assign(__assign({}, a.rules[key]), b.rules[key]);
+                obj[key].conditional_sample_rules = __spreadArray(__spreadArray([], __read((a.rules[key].conditional_sample_rules || [])), false), __read((b.rules[key].conditional_sample_rules || [])), false);
+            }
+            else {
+                obj[key] = ((_a = a.rules) === null || _a === void 0 ? void 0 : _a[key]) || ((_b = b.rules) === null || _b === void 0 ? void 0 : _b[key]);
+            }
+        }
+        return obj;
+    }, {});
+    return res;
+}
+
+var addEnvToSendEvent = function (ev, config) {
+    var _a = config || {}, version = _a.version, name = _a.name;
+    var extra = {
+        url: '',
+        protocol: '',
+        domain: '',
+        path: '',
+        query: '',
+        timestamp: Date.now(),
+        sdk_version: version || SDK_VERSION,
+        sdk_name: name || SDK_NAME,
+    };
+    return __assign(__assign({}, ev), { extra: __assign(__assign({}, extra), (ev.extra || {})) });
+};
+var InjectEnvPlugin = function (client) {
+    client.on('report', function (ev) {
+        return addEnvToSendEvent(ev, client.config());
+    });
+};
+
+var addConfigToReportEvent = function (ev, config) {
+    var extra = {};
+    extra.bid = config.bid;
+    extra.pid = config.pid;
+    extra.view_id = config.viewId;
+    extra.user_id = config.userId;
+    extra.device_id = config.deviceId;
+    extra.session_id = config.sessionId;
+    extra.release = config.release;
+    extra.env = config.env;
+    return __assign(__assign({}, ev), { extra: __assign(__assign({}, extra), (ev.extra || {})) });
+};
+var InjectConfigPlugin = function (client) {
+    client.on('beforeBuild', function (ev) {
+        return addConfigToReportEvent(ev, client.config());
+    });
+};
+
+// createSender has side effects(register onClose behaviour)
+// so it must be create lazily
+function createSender(config) {
+    return createBatchSender(config);
+}
+
+/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
+var getDefaultConfig = function (_c) { return ({
+    bid: '',
+    pid: '',
+    viewId: getViewId('_'),
+    userId: getDefaultUserId(),
+    deviceId: getDefaultDeviceId(),
+    sessionId: getDefaultSessionId(),
+    domain: REPORT_DOMAIN,
+    release: '',
+    env: 'production',
+    sample: DEFAULT_SAMPLE_CONFIG,
+    plugins: {},
+    transport: {
+        get: noop$1,
+        post: noop$1,
+    },
+    useLocalConfig: false,
+}); };
+var createMinimalClient = function (_a) {
+    var _b = _a === void 0 ? {} : _a, _d = _b.createSender, createSender$1 = _d === void 0 ? function (config) {
+        return createSender({
+            size: DEFAULT_SENDER_SIZE,
+            endpoint: getReportUrl(config.domain),
+            transport: config.transport,
+        });
+    } : _d, _e = _b.builder, builder$1 = _e === void 0 ? builder : _e, _f = _b.createDefaultConfig, createDefaultConfig = _f === void 0 ? getDefaultConfig : _f;
+    var client = createClient({
+        validateInitConfig: validateInitConfig,
+        initConfigNormalizer: normalizeInitConfig,
+        userConfigNormalizer: normalizeUserConfig,
+        createSender: createSender$1,
+        builder: builder$1,
+        createDefaultConfig: createDefaultConfig,
+        createConfigManager: createConfigManager,
+    });
+    ContextPlugin(client);
+    InjectConfigPlugin(client);
+    InjectEnvPlugin(client);
+    IntegrationPlugin(client);
+    DevtoolsPlugin(client);
+    return client;
+};
+var createBaseClient = function (config) {
+    if (config === void 0) { config = {}; }
+    var client = createMinimalClient(config);
+    SamplePlugin(client);
+    CustomPlugin(client);
+    return client;
+};
+
+var browserClient = createBaseClient();
+
+/**
+ * Node.js 环境的 HTTP Transport 实现
+ * 使用原生 http/https 模块实现网络请求
+ */
+
+
+
+const log$2 = debug('slardar:transport');
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const noop = () => {};
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * 执行 HTTP/HTTPS 请求
+ */
+function makeRequest(options) {
+  const { url, method, data, success = noop, fail = noop, getResponseText = noop } = options;
+
+  log$2('Making %s request to %s', method, url);
+  if (data) {
+    log$2('Request data: %s', data.slice(0, 200));
+  }
+
+  // 检查 URL 是否有效
+  if (!url || typeof url !== 'string') {
+    const error = new Error(`Invalid URL: ${url}`);
+    log$2('Invalid URL provided: %o', url);
+    fail(error);
+    return;
+  }
+
+  try {
+    const urlObj = new URL(url);
+    log$2('Parsed URL - protocol: %s, hostname: %s, port: %s, path: %s',
+      urlObj.protocol, urlObj.hostname, urlObj.port, urlObj.pathname);
+
+    const isHttps = urlObj.protocol === 'https:';
+    const request = isHttps ? node_https.request : node_http.request;
+
+    const req = request(
+      {
+        hostname: urlObj.hostname,
+        port: urlObj.port,
+        path: urlObj.pathname + urlObj.search,
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          ...(data && { 'Content-Length': Buffer.byteLength(data) }),
+        },
+      },
+      res => {
+        log$2('Response callback triggered: status=%s', res.statusCode);
+        let responseText = '';
+
+        res.on('data', chunk => {
+          log$2('Response data chunk received: %s bytes', chunk.length);
+          responseText += chunk.toString();
+        });
+
+        res.on('end', () => {
+          log$2('Response end event fired');
+          log$2('Response received: status=%s, body=%s', res.statusCode, responseText.slice(0, 200));
+          getResponseText(responseText);
+
+          try {
+            if (res.statusCode && res.statusCode >= 400) {
+              log$2('Request failed with status %s: %s', res.statusCode, responseText);
+              fail(new Error(responseText || res.statusMessage || 'Request failed'));
+            } else if (responseText) {
+              // eslint-disable-next-line no-restricted-syntax -- Parsing trusted Slardar API responses
+              const result = JSON.parse(responseText);
+              log$2('Request succeeded');
+              success(result);
+            } else {
+              log$2('Request succeeded with empty response');
+              success({});
+            }
+          } catch (e) {
+            log$2('Failed to parse response: %s', (e ).message);
+            fail(e );
+          }
+        });
+      },
+    );
+
+    req.on('error', err => {
+      log$2('Request error: %s', err.message);
+      fail(err);
+    });
+
+    req.on('timeout', () => {
+      log$2('Request timeout');
+      req.destroy();
+      fail(new Error('Request timeout'));
+    });
+
+    if (data) {
+      req.write(data);
+    }
+
+    req.end();
+  } catch (e) {
+    log$2('Exception during request: %s', (e ).message);
+    fail(e );
+  }
+}
+
+/**
+ * 创建 Node.js 环境的 Transport
+ */
+function createNodeTransport() {
+  return {
+    get(options) {
+      log$2('Transport GET called: %s', options.url);
+      makeRequest({
+        method: 'GET',
+        ...options,
+      });
+    },
+    post({ url, data }) {
+      log$2('Transport POST called: %s', url);
+      makeRequest({
+        method: 'POST',
+        url,
+        data: typeof data === 'string' ? data : JSON.stringify(data),
+      });
+    },
+  };
+}
+
+function _nullishCoalesce$3(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain$6(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/**
+ * Slardar CLI Reporter 主类
+ * 封装 @slardar/base 的初始化和上报逻辑
+ */
+
+
+
+
+
+
+// 创建 debug 实例
+// 使用方式: DEBUG=slardar:* your-cli-command
+const log$1 = debug('slardar:reporter');
+
+/**
+ * Slardar CLI Reporter
+ * 提供简洁的 API 用于 CLI 工具的监控数据上报
+ */
+class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.call(this);SlardarCLIReporter.prototype.__init2.call(this); }
+   __init() {this.initialized = false;}
+    __init2() {this.client = browserClient;}
+
+  /**
+   * 初始化 Slardar Reporter
+   * @param config 初始化配置
+   *
+   * @example
+   * ```typescript
+   * reporter.setup({
+   *   bid: 'my_cli_app',
+   *   release: '1.0.0',
+   *   env: 'production',
+   * });
+   * ```
+   */
+  setup(config) {
+    if (this.initialized) {
+      log$1('Already initialized, skipping setup');
+      return;
+    }
+
+    try {
+      log$1('Initializing Slardar with config:', {
+        bid: config.bid,
+        release: config.release,
+        env: config.env,
+        userId: config.userId,
+      });
+
+      const transport = createNodeTransport();
+
+      this.client.init({
+        bid: config.bid,
+        transport,
+        userId: config.userId,
+        deviceId: config.deviceId,
+        sessionId: config.sessionId,
+        release: config.release,
+        env: config.env,
+        name: config.name,
+        useLocalConfig: _nullishCoalesce$3(config.useLocalConfig, () => ( false)), // 默认使用服务端配置
+        domain: config.domain,
+        // 设置本地采样率，确保事件不被过滤
+        sample: {
+          event: 1, // 100% 采样自定义事件
+        },
+      });
+
+      // 添加 beforeSend 钩子来追踪事件是否被过滤
+      this.client.on('beforeSend', (ev) => {
+        log$1('beforeSend hook called for event: %s', (_optionalChain$6([ev, 'optionalAccess', _ => _.ev_type]) ) || 'unknown');
+        return ev; // 必须返回 ev 才能继续上报
+      });
+
+      this.client.start();
+      this.initialized = true;
+      log$1('Slardar initialized successfully');
+    } catch (error) {
+      log$1('Failed to initialize:', error);
+    }
+  }
+
+  /**
+   * 检查是否已初始化
+   */
+   ensureInitialized() {
+    if (!this.initialized) {
+      log$1('Not initialized, call setup() first');
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * 上报自定义事件
+   * @param name 事件名称
+   * @param metrics 指标数据（数值类型）
+   * @param categories 分类维度（字符串类型）
+   */
+  sendEvent(
+    name,
+    metrics,
+    categories,
+  ) {
+    if (!this.ensureInitialized()) {
+      return;
+    }
+
+    try {
+      log$1('Sending event:', { name, metrics, categories });
+      this.client.sendEvent({
+        name,
+        metrics,
+        categories,
+      });
+    } catch (error) {
+      log$1('Failed to send event:', error);
+    }
+  }
+
+  /**
+   * 上报 JS 错误（会显示在 Slardar JS 错误总览页面）
+   * @param error Error 对象
+   * @param extra 额外的上下文信息
+   * @param source 错误来源信息
+   */
+  reportError(
+    error,
+    extra,
+    source,
+  ) {
+    if (!this.ensureInitialized()) {
+      return;
+    }
+
+    try {
+      const errorEvent = {
+        ev_type: 'js_error' ,
+        payload: {
+          error: {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+          },
+          breadcrumbs: [], // CLI 环境暂不收集面包屑
+          extra,
+          source: source || { type: 'manual' }, // 默认为手动捕获
+        },
+      };
+
+      log$1('Reporting JS error:', {
+        name: error.name,
+        message: error.message.slice(0, 100),
+        stack: _optionalChain$6([error, 'access', _2 => _2.stack, 'optionalAccess', _3 => _3.slice, 'call', _4 => _4(0, 200)]),
+        extra,
+        source,
+      });
+
+      // 使用 Slardar 的 js_error 事件类型，这样会显示在 JS 错误总览页面
+      this.client.report(errorEvent);
+      log$1('JS error reported successfully');
+    } catch (err) {
+      log$1('Failed to report error:', err);
+    }
+  }
+
+
+  /**
+   * 设置全局上下文
+   */
+  setContext(key, value) {
+    if (!this.ensureInitialized()) {
+      return;
+    }
+    this.client.context.set(key, value);
+  }
+
+  /**
+   * 批量设置全局上下文
+   */
+  mergeContext(context) {
+    if (!this.ensureInitialized()) {
+      return;
+    }
+    log$1('Merging context:', context);
+    this.client.context.merge(context);
+  }
+
+  /**
+   * 删除全局上下文
+   */
+  deleteContext(key) {
+    if (!this.ensureInitialized()) {
+      return;
+    }
+    this.client.context.delete(key);
+  }
+
+  /**
+   * 清空全局上下文
+   */
+  clearContext() {
+    if (!this.ensureInitialized()) {
+      return;
+    }
+    this.client.context.clear();
+  }
+
+  /**
+   * 更新用户配置
+   */
+  updateConfig(
+    config
+
+,
+  ) {
+    if (!this.ensureInitialized()) {
+      return;
+    }
+
+    try {
+      log$1('Updating config:', config);
+      this.client.config({
+        userId: config.userId,
+        release: config.release,
+        sessionId: config.sessionId,
+        env: config.env,
+      });
+    } catch (error) {
+      log$1('Failed to update config:', error);
+    }
+  }
+
+  /**
+   * 立即上报（不等待队列）
+   * @param waitMs 等待时间（毫秒），默认 1500ms，用于确保设置请求完成和事件发送
+   */
+  async flush(waitMs = 1500) {
+    if (!this.ensureInitialized()) {
+      return;
+    }
+    log$1('Flushing Slardar data...');
+    this.client.getSender().flush();
+    log$1('Waiting %dms for events to be sent...', waitMs);
+    await new Promise(resolve => setTimeout(resolve, waitMs));
+    log$1('Slardar data flushed');
+  }
+
+  /**
+   * 获取原始 Slardar client（用于高级用法）
+   */
+  getRawClient() {
+    return this.client;
+  }
+}
+
+/**
+ * 默认导出的单例实例
+ */
+const reporter = new SlardarCLIReporter();
+
+function _optionalChain$5(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+/**
+ * CLI 通用事件类型常量
+ * 仅包含通用的 CLI 工具事件，不包含具体业务逻辑
+ */
+const CLI_EVENTS = {
+  /** CLI 启动 */
+  CLI_START: 'cli_start',
+  /** CLI 命令执行 */
+  CLI_COMMAND: 'cli_command',
+  /** CLI 命令完成 */
+  CLI_COMMAND_COMPLETE: 'cli_command_complete',
+  /** CLI 错误 */
+  CLI_ERROR: 'cli_error',
+  /** 网络请求 */
+  NETWORK_REQUEST: 'network_request',
+  /** 文件操作 */
+  FILE_OPERATION: 'file_operation',
+} ;
+
+ 
+
+/**
+ * 事件构建器 - 提供更友好的事件创建接口
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const EventBuilder = {
+  /**
+   * 构建 CLI 启动事件
+   */
+  cliStart(metrics) {
+    return {
+      name: CLI_EVENTS.CLI_START,
+      metrics: {
+        duration: 0,
+        ...metrics,
+      },
+    };
+  },
+
+  /**
+   * 构建 CLI 命令执行事件
+   */
+  cliCommand(
+    command,
+    options
+
+
+
+,
+  ) {
+    return {
+      name: CLI_EVENTS.CLI_COMMAND,
+      categories: {
+        command,
+        args: _optionalChain$5([options, 'optionalAccess', _ => _.args]),
+        status: 'running' ,
+        ..._optionalChain$5([options, 'optionalAccess', _2 => _2.categories]),
+      },
+      metrics: _optionalChain$5([options, 'optionalAccess', _3 => _3.metrics]),
+    };
+  },
+
+  /**
+   * 构建 CLI 命令完成事件
+   */
+  cliCommandComplete(
+    command,
+    success,
+    duration,
+    options
+
+
+
+,
+  ) {
+    return {
+      name: CLI_EVENTS.CLI_COMMAND_COMPLETE,
+      categories: {
+        command,
+        args: _optionalChain$5([options, 'optionalAccess', _4 => _4.args]),
+        status: success ? ('success' ) : ('fail' ),
+        ..._optionalChain$5([options, 'optionalAccess', _5 => _5.categories]),
+      },
+      metrics: {
+        duration,
+        ...(_optionalChain$5([options, 'optionalAccess', _6 => _6.errorCode]) && { errorCode: options.errorCode }),
+      },
+    };
+  },
+
+  /**
+   * 构建网络请求事件
+   */
+  networkRequest(
+    url,
+    options
+
+
+
+
+,
+  ) {
+    return {
+      name: CLI_EVENTS.NETWORK_REQUEST,
+      categories: {
+        url,
+        method: _optionalChain$5([options, 'optionalAccess', _7 => _7.method]) || 'GET',
+        statusCode: _optionalChain$5([options, 'optionalAccess', _8 => _8.statusCode, 'optionalAccess', _9 => _9.toString, 'call', _10 => _10()]),
+        status: _optionalChain$5([options, 'optionalAccess', _11 => _11.success]) ? ('success' ) : ('fail' ),
+      },
+      metrics: {
+        duration: _optionalChain$5([options, 'optionalAccess', _12 => _12.duration]),
+      },
+    };
+  },
+
+  /**
+   * 构建文件操作事件
+   */
+  fileOperation(
+    operation,
+    filePath,
+    options
+
+
+
+,
+  ) {
+    return {
+      name: CLI_EVENTS.FILE_OPERATION,
+      categories: {
+        operation,
+        filePath,
+        status: _optionalChain$5([options, 'optionalAccess', _13 => _13.success]) ? ('success' ) : ('fail' ),
+      },
+      metrics: {
+        duration: _optionalChain$5([options, 'optionalAccess', _14 => _14.duration]),
+        fileSize: _optionalChain$5([options, 'optionalAccess', _15 => _15.fileSize]),
+      },
+    };
+  },
+
+  /**
+   * 构建错误事件
+   */
+  cliError(
+    error,
+    context,
+  ) {
+    return {
+      name: CLI_EVENTS.CLI_ERROR,
+      categories: {
+        errorName: error.name,
+        errorMessage: error.message,
+        stack: error.stack || '',
+        ...context,
+      },
+      metrics: {
+        errorCode: 1,
+      },
+    };
+  },
+};
+
+var name = "@coze-arch/cli";
+var version = "0.0.1-alpha.de4758";
+var description = "coze coding devtools cli";
+var license = "MIT";
+var author = "fanwenjie.fe@bytedance.com";
+var maintainers = [
+];
+var bin = {
+	coze: "bin/main"
+};
+var files = [
+	"lib",
+	"bin",
+	"lib/**/.npmrc",
+	"!**/*.tsbuildinfo",
+	"!**/*.map"
+];
+var scripts = {
+	prebuild: "tsx scripts/prebuild.ts",
+	build: "tsx scripts/build.ts",
+	create: "tsx scripts/create-template.ts",
+	lint: "eslint ./ --cache",
+	postpublish: "bash scripts/sync-npmmirror.sh",
+	test: "vitest --run --passWithNoTests",
+	"test:all": "bash scripts/test-coverage.sh",
+	"test:cov": "vitest --run --passWithNoTests --coverage",
+	"test:e2e": "NODE_ENV=test bash scripts/e2e.sh",
+	"test:perf": "vitest bench --run --config vitest.perf.config.ts",
+	"test:perf:compare": "bash scripts/compare-perf.sh",
+	"test:perf:save": "bash scripts/run-perf-with-output.sh"
+};
+var dependencies = {
+	"@iarna/toml": "^2.2.5",
+	ajv: "^8.17.1",
+	"ajv-formats": "^3.0.1",
+	"change-case": "^5.4.4",
+	commander: "~12.1.0",
+	debug: "^4.3.7",
+	ejs: "^3.1.10",
+	"js-yaml": "^4.1.0",
+	minimist: "^1.2.5",
+	shelljs: "^0.10.0"
+};
+var devDependencies = {
+	"@coze-arch/cli-logger": "workspace:*",
+	"@coze-arch/cli-slardar": "workspace:*",
+	"@coze-arch/eslint-config": "workspace:*",
+	"@coze-arch/monorepo-kits": "workspace:*",
+	"@coze-arch/rollup-config": "workspace:*",
+	"@coze-arch/ts-config": "workspace:*",
+	"@coze-arch/vitest-config": "workspace:*",
+	"@coze-coding/lambda": "workspace:*",
+	"@inquirer/prompts": "^3.2.0",
+	"@playwright/test": "~1.55.0",
+	"@types/debug": "^4.1.12",
+	"@types/ejs": "^3.1.5",
+	"@types/iarna__toml": "^2.0.5",
+	"@types/js-yaml": "^4.0.9",
+	"@types/minimatch": "^5.1.2",
+	"@types/minimist": "^1.2.5",
+	"@types/node": "^24",
+	"@types/shelljs": "^0.10.0",
+	"@vitest/coverage-v8": "~4.0.18",
+	"json-schema-to-typescript": "^15.0.3",
+	minimatch: "^10.0.1",
+	playwright: "~1.55.0",
+	rollup: "^4.41.1",
+	sucrase: "^3.35.0",
+	"tree-kill": "^1.2.2",
+	tsx: "^4.20.6",
+	"vite-tsconfig-paths": "^4.2.1",
+	vitest: "~4.0.18"
+};
+var publishConfig = {
+	access: "public",
+	registry: "https://registry.npmjs.org"
+};
+var cozePublishConfig = {
+	bin: {
+		coze: "bin/main"
+	}
+};
+var packageJson = {
+	name: name,
+	version: version,
+	"private": false,
+	description: description,
+	license: license,
+	author: author,
+	maintainers: maintainers,
+	bin: bin,
+	files: files,
+	scripts: scripts,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	publishConfig: publishConfig,
+	cozePublishConfig: cozePublishConfig
+};
+
+function _optionalChain$4(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/**
+ * Slardar 监控初始化和上报
+ */
+
+const log = debug('slardar:cli');
+
+/**
+ * 安全执行函数包装器
+ * 捕获并静默处理所有错误，确保 Slardar 上报失败不影响 CLI 正常运行
+ * 支持同步和异步函数
+ */
+function safeRun(
+  name,
+  fn,
+) {
+  return ((...args) => {
+    try {
+      log('Calling Slardar function: %s', name);
+      const result = fn(...args);
+
+      // 如果是 Promise，处理异步错误
+      if (result instanceof Promise) {
+        return result
+          .then(res => {
+            log('Slardar function %s completed', name);
+            return res;
+          })
+          .catch(error => {
+            log(
+              'Slardar function %s failed: %s',
+              name,
+              (error ).message,
+            );
+            void error;
+          });
+      }
+
+      log('Slardar function %s completed', name);
+      return result;
+    } catch (error) {
+      // Slardar 上报失败不应影响 CLI 正常运行，但要记录错误
+      log('Slardar function %s failed: %s', name, (error ).message);
+    }
+  }) ;
+}
+
+/**
+ * 初始化 Slardar Reporter
+ */
+const initSlardar = safeRun('initSlardar', () => {
+  reporter.setup({
+    bid: 'coze_codign_cli',
+    release: packageJson.version,
+    env: process.env.NODE_ENV || 'production',
+    userId: process.env.USER,
+    projectId: process.env.COZE_PROJECT_ID || '',
+    useLocalConfig: false, // 启用服务端采样率配置
+    domain: 'mon.zijieapi.com', // Node.js 环境上报域名
+  });
+
+  // 设置全局上下文
+  reporter.mergeContext({
+    platform: process.platform,
+    nodeVersion: process.version,
+    cliVersion: packageJson.version,
+  });
+});
+
+/**
+ * 上报命令执行
+ */
+const reportCommandStart = safeRun(
+  'reportCommandStart',
+  (
+    command,
+    args,
+    extraCategories,
+  ) => {
+    const event = EventBuilder.cliCommand(command, {
+      args,
+      categories: extraCategories,
+    });
+    reporter.sendEvent(event.name, event.metrics, event.categories);
+  },
+);
+
+/**
+ * 上报命令完成
+ */
+const reportCommandComplete = safeRun(
+  'reportCommandComplete',
+  (
+    command,
+    success,
+    duration,
+    options
+
+
+
+
+,
+  ) => {
+    const event = EventBuilder.cliCommandComplete(command, success, duration, {
+      args: _optionalChain$4([options, 'optionalAccess', _ => _.args]),
+      errorCode: _optionalChain$4([options, 'optionalAccess', _2 => _2.errorCode]),
+      categories: {
+        ...(_optionalChain$4([options, 'optionalAccess', _3 => _3.errorMessage]) && { errorMessage: options.errorMessage }),
+        ..._optionalChain$4([options, 'optionalAccess', _4 => _4.categories]),
+      },
+    });
+    reporter.sendEvent(event.name, event.metrics, event.categories);
+  },
+);
+
+/**
+ * 上报错误（使用 JS 错误上报，会显示在 Slardar JS 错误总览页面）
+ */
+const reportError = safeRun(
+  'reportError',
+  (error, context) => {
+    reporter.reportError(error, context, {
+      type: 'cli',
+      data: context,
+    });
+  },
+);
+
+/**
+ * 立即上报（在 CLI 退出前调用）
+ * 等待 500ms 确保设置请求完成和事件发送
+ */
+const flushSlardar = safeRun('flushSlardar', async () => {
+  await reporter.flush();
+});
+
 function _nullishCoalesce$2(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain$3(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var LogLevel; (function (LogLevel) {
   const ERROR = 0; LogLevel[LogLevel["ERROR"] = ERROR] = "ERROR";
   const WARN = 1; LogLevel[LogLevel["WARN"] = WARN] = "WARN";
@@ -143,459 +2301,804 @@ function _nullishCoalesce$2(lhs, rhsFn) { if (lhs != null) { return lhs; } else
 
 
 
-const LOG_LEVEL_MAP = {
-  error: LogLevel.ERROR,
-  warn: LogLevel.WARN,
-  success: LogLevel.SUCCESS,
-  info: LogLevel.INFO,
-  verbose: LogLevel.VERBOSE,
+const LOG_LEVEL_MAP = {
+  error: LogLevel.ERROR,
+  warn: LogLevel.WARN,
+  success: LogLevel.SUCCESS,
+  info: LogLevel.INFO,
+  verbose: LogLevel.VERBOSE,
+};
+
+const COLOR_CODES = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+};
+
+class Logger {
+  
+  
+  
+
+  constructor(options = {}) {
+    this.level = this.parseLogLevel(options.level);
+    this.useColor = _nullishCoalesce$2(options.useColor, () => ( this.isColorSupported()));
+    this.prefix = options.prefix;
+  }
+
+   parseLogLevel(level) {
+    if (level !== undefined) {
+      return level;
+    }
+
+    const envLevel = _optionalChain$3([process, 'access', _ => _.env, 'access', _2 => _2.LOG_LEVEL, 'optionalAccess', _3 => _3.toLowerCase, 'call', _4 => _4()]);
+    if (envLevel && envLevel in LOG_LEVEL_MAP) {
+      return LOG_LEVEL_MAP[envLevel];
+    }
+
+    return LogLevel.INFO;
+  }
+
+   isColorSupported() {
+    // 简单检测：Node.js 环境且支持 TTY
+    return (
+      typeof process !== 'undefined' &&
+      _optionalChain$3([process, 'access', _5 => _5.stdout, 'optionalAccess', _6 => _6.isTTY]) === true &&
+      process.env.NO_COLOR === undefined
+    );
+  }
+
+   colorize(text, color) {
+    if (!this.useColor) {
+      return text;
+    }
+    return `${COLOR_CODES[color]}${text}${COLOR_CODES.reset}`;
+  }
+
+   log(options
+
+
+
+
+
+) {
+    if (options.level > this.level) {
+      return;
+    }
+
+    const icon = this.colorize(options.icon, options.color);
+    const prefix = this.prefix ? `${icon} ${this.prefix}` : icon;
+    console.log(prefix, options.message, ...(_nullishCoalesce$2(options.args, () => ( []))));
+  }
+
+  error(message, ...args) {
+    this.log({
+      level: LogLevel.ERROR,
+      icon: '✖',
+      color: 'red',
+      message,
+      args,
+    });
+  }
+
+  warn(message, ...args) {
+    this.log({
+      level: LogLevel.WARN,
+      icon: '⚠',
+      color: 'yellow',
+      message,
+      args,
+    });
+  }
+
+  success(message, ...args) {
+    this.log({
+      level: LogLevel.SUCCESS,
+      icon: '✓',
+      color: 'green',
+      message,
+      args,
+    });
+  }
+
+  info(message, ...args) {
+    this.log({
+      level: LogLevel.INFO,
+      icon: 'ℹ',
+      color: 'cyan',
+      message,
+      args,
+    });
+  }
+
+  verbose(message, ...args) {
+    this.log({
+      level: LogLevel.VERBOSE,
+      icon: '→',
+      color: 'gray',
+      message,
+      args,
+    });
+  }
+}
+
+// 创建 logger 实例的工厂函数
+const createLogger = (options = {}) =>
+  new Logger(options);
+
+// 导出默认实例
+const logger = createLogger();
+
+/**
+ * 时间统计工具
+ */
+class TimeTracker {
+  
+  
+
+  constructor() {
+    this.startTime = perf_hooks.performance.now();
+    this.lastTime = this.startTime;
+  }
+
+  /**
+   * 记录阶段耗时
+   * @param phaseName 阶段名称
+   */
+  logPhase(phaseName) {
+    const now = perf_hooks.performance.now();
+    const phaseTime = now - this.lastTime;
+    this.lastTime = now;
+
+    logger.verbose(`⏱ ${phaseName}: ${phaseTime.toFixed(2)}ms`);
+  }
+
+  /**
+   * 记录总耗时
+   */
+  logTotal() {
+    const totalTime = perf_hooks.performance.now() - this.startTime;
+    logger.verbose(`⏱ Total time: ${totalTime.toFixed(2)}ms`);
+  }
+
+  /**
+   * 获取当前耗时（不输出日志）
+   * @returns 从开始到现在的总耗时（毫秒）
+   */
+  getElapsedTime() {
+    return perf_hooks.performance.now() - this.startTime;
+  }
+}
+
+/**
+ * 获取模板配置文件路径
+ * @returns templates.json 的绝对路径
+ */
+const getTemplatesConfigPath = () => {
+  const configPath = path.resolve(getTemplatesDir(), 'templates.json');
+  logger.verbose(`Templates config path: ${configPath}`);
+  logger.verbose(`Config file exists: ${fs.existsSync(configPath)}`);
+  return configPath;
 };
 
-const COLOR_CODES = {
-  reset: '\x1b[0m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  green: '\x1b[32m',
-  cyan: '\x1b[36m',
-  gray: '\x1b[90m',
+/**
+ * 获取模板目录路径
+ * @returns __templates__ 目录的绝对路径
+ */
+const getTemplatesDir = () => {
+  const templatesDir = path.resolve(__dirname, './__templates__');
+  logger.verbose(`Templates directory: ${templatesDir}`);
+  logger.verbose(`Templates directory exists: ${fs.existsSync(templatesDir)}`);
+  return templatesDir;
 };
 
-class Logger {
-  
-  
-  
+/**
+ * 加载模板配置文件
+ * 支持 .ts 和 .js 文件（通过 sucrase 注册）
+ *
+ * @param templatePath - 模板目录路径
+ * @returns 模板配置对象
+ */
 
-  constructor(options = {}) {
-    this.level = this.parseLogLevel(options.level);
-    this.useColor = _nullishCoalesce$2(options.useColor, () => ( this.isColorSupported()));
-    this.prefix = options.prefix;
+const loadTemplateConfig = async ( 
+  templatePath,
+) => {
+  logger.verbose(`Loading template config from: ${templatePath}`);
+
+  const tsConfigPath = path.join(templatePath, 'template.config.ts');
+  const jsConfigPath = path.join(templatePath, 'template.config.js');
+
+  logger.verbose('Checking for config files:');
+  logger.verbose(`  - TypeScript: ${tsConfigPath}`);
+  logger.verbose(`  - JavaScript: ${jsConfigPath}`);
+
+  let configPath;
+
+  const [tsExists, jsExists] = await Promise.all([
+    fs$1.access(tsConfigPath).then(
+      () => true,
+      () => false,
+    ),
+    fs$1.access(jsConfigPath).then(
+      () => true,
+      () => false,
+    ),
+  ]);
+
+  logger.verbose('Config file existence check:');
+  logger.verbose(`  - template.config.ts: ${tsExists}`);
+  logger.verbose(`  - template.config.js: ${jsExists}`);
+
+  if (tsExists) {
+    configPath = tsConfigPath;
+  } else if (jsExists) {
+    configPath = jsConfigPath;
+  } else {
+    throw new Error(
+      `Template config not found in ${templatePath}.\n` +
+        'Expected: template.config.ts or template.config.js',
+    );
   }
 
-   parseLogLevel(level) {
-    if (level !== undefined) {
-      return level;
-    }
+  logger.verbose(`Using config file: ${configPath}`);
 
-    const envLevel = _optionalChain$3([process, 'access', _ => _.env, 'access', _2 => _2.LOG_LEVEL, 'optionalAccess', _3 => _3.toLowerCase, 'call', _4 => _4()]);
-    if (envLevel && envLevel in LOG_LEVEL_MAP) {
-      return LOG_LEVEL_MAP[envLevel];
-    }
+  // eslint-disable-next-line @typescript-eslint/no-require-imports, security/detect-non-literal-require -- Sucrase handles .ts files at runtime, path is validated above
+  const config = require(configPath);
 
-    return LogLevel.INFO;
+  logger.verbose('Template config loaded successfully');
+
+  return config.default || config;
+};
+
+/**
+ * 加载模板列表配置
+ *
+ * @param configPath - templates.json 配置文件路径
+ * @returns 模板列表配置
+ */
+const loadTemplatesConfig = async (
+  configPath,
+) => {
+  logger.verbose(`Loading templates config from: ${configPath}`);
+
+  const content = await fs$1.readFile(configPath, 'utf-8');
+  // eslint-disable-next-line no-restricted-syntax -- Static config file loaded at build time, safeJsonParse not needed
+  const config = JSON.parse(content) ;
+
+  logger.verbose(
+    `Found ${config.templates.length} templates: ${config.templates.map(t => t.name).join(', ')}`,
+  );
+
+  return config;
+};
+
+/**
+ * 根据模板名称查找模板元信息
+ *
+ * @param templatesConfig - 模板列表配置
+ * @param templateName - 模板名称
+ * @returns 模板元信息
+ */
+const findTemplate = (
+  templatesConfig,
+  templateName,
+) => {
+  const template = templatesConfig.templates.find(t => t.name === templateName);
+
+  if (!template) {
+    const availableTemplates = templatesConfig.templates
+      .map(t => t.name)
+      .join(', ');
+    throw new Error(
+      `Template "${templateName}" not found.\n` +
+        `Available templates: ${availableTemplates}\n` +
+        'Use --template <name> to specify a template.',
+    );
+  }
+
+  return template;
+};
+
+/**
+ * 获取模板的完整路径
+ *
+ * @param basePath - 模板目录（templates.json 所在目录）
+ * @param templateMetadata - 模板元信息
+ * @returns 模板完整路径
+ */
+const getTemplatePath = async (
+  basePath,
+  templateMetadata,
+) => {
+  logger.verbose('Resolving template path:');
+  logger.verbose(`  - Base path: ${basePath}`);
+  logger.verbose(`  - Template location: ${templateMetadata.location}`);
+
+  // location 是相对于 templates.json 文件的路径
+  const templatePath = path.join(basePath, templateMetadata.location);
+
+  logger.verbose(`  - Resolved path: ${templatePath}`);
+
+  try {
+    await fs$1.access(templatePath);
+    logger.verbose('  - Template directory exists: ✓');
+    // eslint-disable-next-line @coze-arch/use-error-in-catch -- Error handling done in throw statement
+  } catch (e) {
+    logger.error('  - Template directory does not exist: ✗');
+    throw new Error(`Template directory not found: ${templatePath}`);
+  }
+
+  return templatePath;
+};
+
+/**
+ * 对单个模板执行 pnpm install
+ */
+const warmupTemplate = (templatePath, templateName) => {
+  logger.info(`\nWarming up template: ${templateName}`);
+  logger.info(`  Path: ${templatePath}`);
+
+  // 检查是否存在 package.json
+  const packageJsonPath = node_path.join(templatePath, 'package.json');
+  // eslint-disable-next-line security/detect-non-literal-fs-filename
+  if (!node_fs.existsSync(packageJsonPath)) {
+    logger.info(`  ⊘ Skipping ${templateName} (no package.json found)`);
+    return;
+  }
+
+  const result = shelljs.exec('pnpm install', {
+    cwd: templatePath,
+    silent: true,
+  });
+
+  // 输出 stdout
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
   }
 
-   isColorSupported() {
-    // 简单检测：Node.js 环境且支持 TTY
-    return (
-      typeof process !== 'undefined' &&
-      _optionalChain$3([process, 'access', _5 => _5.stdout, 'optionalAccess', _6 => _6.isTTY]) === true &&
-      process.env.NO_COLOR === undefined
-    );
+  // 输出 stderr
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+
+  if (result.code === 0) {
+    logger.success(`  ✓ ${templateName} warmed up successfully`);
+  } else {
+    const errorMessage = [
+      `pnpm install failed for ${templateName} with exit code ${result.code}`,
+      result.stderr ? `\nStderr:\n${result.stderr}` : '',
+      result.stdout ? `\nStdout:\n${result.stdout}` : '',
+    ]
+      .filter(Boolean)
+      .join('');
+
+    throw new Error(errorMessage);
   }
+};
 
-   colorize(text, color) {
-    if (!this.useColor) {
-      return text;
-    }
-    return `${COLOR_CODES[color]}${text}${COLOR_CODES.reset}`;
-  }
+/**
+ * 执行 warmup 命令的内部实现
+ */
+const executeWarmup = async (options) => {
+  const timer = new TimeTracker();
 
-   log(options
+  try {
+    const { template: templateFilter } = options;
 
+    logger.info('Starting template warmup...');
+    timer.logPhase('Initialization');
 
+    // 加载模板配置
+    const configPath = getTemplatesConfigPath();
+    const templatesConfig = await loadTemplatesConfig(configPath);
 
+    logger.verbose(
+      `Found ${templatesConfig.templates.length} templates in config`,
+    );
 
+    // 过滤模板
+    const templatesToWarmup = templateFilter
+      ? templatesConfig.templates.filter(t => t.name === templateFilter)
+      : templatesConfig.templates;
 
-) {
-    if (options.level > this.level) {
+    if (templatesToWarmup.length === 0) {
+      if (templateFilter) {
+        logger.warn(`Template "${templateFilter}" not found`);
+        logger.info(
+          `Available templates: ${templatesConfig.templates.map(t => t.name).join(', ')}`,
+        );
+      } else {
+        logger.warn('No templates found');
+      }
       return;
     }
 
-    const icon = this.colorize(options.icon, options.color);
-    const prefix = this.prefix ? `${icon} ${this.prefix}` : icon;
-    console.log(prefix, options.message, ...(_nullishCoalesce$2(options.args, () => ( []))));
-  }
+    logger.info(
+      `\nWill warm up ${templatesToWarmup.length} template(s): ${templatesToWarmup.map(t => t.name).join(', ')}`,
+    );
 
-  error(message, ...args) {
-    this.log({
-      level: LogLevel.ERROR,
-      icon: '✖',
-      color: 'red',
-      message,
-      args,
-    });
-  }
+    // 获取模板基础路径
+    const basePath = configPath.replace(/\/templates\.json$/, '');
 
-  warn(message, ...args) {
-    this.log({
-      level: LogLevel.WARN,
-      icon: '⚠',
-      color: 'yellow',
-      message,
-      args,
-    });
-  }
+    // 对每个模板执行 pnpm install
+    for (const templateMetadata of templatesToWarmup) {
+      const templatePath = await getTemplatePath(basePath, templateMetadata);
+      warmupTemplate(templatePath, templateMetadata.name);
+      timer.logPhase(`Warmup ${templateMetadata.name}`);
+    }
 
-  success(message, ...args) {
-    this.log({
-      level: LogLevel.SUCCESS,
-      icon: '✓',
-      color: 'green',
-      message,
-      args,
-    });
-  }
+    logger.success('\n✅ All templates warmed up successfully!');
+    logger.info(
+      '\nNext time you run `coze init`, it will be much faster as node_modules are pre-installed.',
+    );
 
-  info(message, ...args) {
-    this.log({
-      level: LogLevel.INFO,
-      icon: 'ℹ',
-      color: 'cyan',
-      message,
-      args,
-    });
+    timer.logTotal();
+  } catch (error) {
+    timer.logTotal();
+    logger.error('Failed to warmup templates:');
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
   }
+};
 
-  verbose(message, ...args) {
-    this.log({
-      level: LogLevel.VERBOSE,
-      icon: '→',
-      color: 'gray',
-      message,
-      args,
+/**
+ * 注册 warmup 命令到 program
+ */
+const registerCommand$4 = program => {
+  program
+    .command('warmup')
+    .description('Pre-install dependencies for templates to speed up init')
+    .option('-t, --template <name>', 'Warmup a specific template only')
+    .action(async options => {
+      await executeWarmup(options);
     });
-  }
-}
+};
+
+// ABOUTME: This file implements the update command for coze CLI
+// ABOUTME: It wraps pnpm update/install to update package dependencies with logging support
 
-// 创建 logger 实例的工厂函数
-const createLogger = (options = {}) =>
-  new Logger(options);
 
-// 导出默认实例
-const logger = createLogger();
 
 /**
- * 时间统计工具
+ * 日志文件名常量
  */
-class TimeTracker {
-  
-  
-
-  constructor() {
-    this.startTime = perf_hooks.performance.now();
-    this.lastTime = this.startTime;
-  }
+const LOG_FILE_NAME$1 = 'update.log';
 
-  /**
-   * 记录阶段耗时
-   * @param phaseName 阶段名称
-   */
-  logPhase(phaseName) {
-    const now = perf_hooks.performance.now();
-    const phaseTime = now - this.lastTime;
-    this.lastTime = now;
+/**
+ * 获取日志目录
+ * 优先使用环境变量 COZE_LOG_DIR，否则使用 ~/.coze-logs
+ */
+const getLogDir$1 = () =>
+  process.env.COZE_LOG_DIR || path.join(os.homedir(), '.coze-logs');
 
-    logger.verbose(`⏱ ${phaseName}: ${phaseTime.toFixed(2)}ms`);
+/**
+ * 解析日志文件路径
+ * - 如果是绝对路径，直接使用
+ * - 如果是相对路径，基于 getLogDir() + 相对路径
+ * - 如果为空，使用 getLogDir() + LOG_FILE_NAME
+ */
+const resolveLogFilePath$1 = (logFile) => {
+  if (!logFile) {
+    return path.join(getLogDir$1(), LOG_FILE_NAME$1);
   }
 
-  /**
-   * 记录总耗时
-   */
-  logTotal() {
-    const totalTime = perf_hooks.performance.now() - this.startTime;
-    logger.verbose(`⏱ Total time: ${totalTime.toFixed(2)}ms`);
+  if (path.isAbsolute(logFile)) {
+    return logFile;
   }
 
-  /**
-   * 获取当前耗时（不输出日志）
-   * @returns 从开始到现在的总耗时（毫秒）
-   */
-  getElapsedTime() {
-    return perf_hooks.performance.now() - this.startTime;
+  return path.join(getLogDir$1(), logFile);
+};
+
+/**
+ * 创建日志写入流
+ */
+const createLogStream$1 = (logFilePath) => {
+  const logDir = path.dirname(logFilePath);
+
+  // 确保日志目录存在
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
   }
-}
+
+  // 使用 'w' 标志覆盖之前的日志
+  return fs.createWriteStream(logFilePath, { flags: 'w' });
+};
 
 /**
- * 获取模板配置文件路径
- * @returns templates.json 的绝对路径
+ * 格式化时间戳
  */
-const getTemplatesConfigPath = () => {
-  const configPath = path.resolve(getTemplatesDir(), 'templates.json');
-  logger.verbose(`Templates config path: ${configPath}`);
-  logger.verbose(`Config file exists: ${fs.existsSync(configPath)}`);
-  return configPath;
+const formatTimestamp = () => {
+  const now = new Date();
+  return now.toISOString();
 };
 
 /**
- * 获取模板目录路径
- * @returns __templates__ 目录的绝对路径
+ * 写入带时间戳的日志
  */
-const getTemplatesDir = () => {
-  const templatesDir = path.resolve(__dirname, './__templates__');
-  logger.verbose(`Templates directory: ${templatesDir}`);
-  logger.verbose(`Templates directory exists: ${fs.existsSync(templatesDir)}`);
-  return templatesDir;
+const writeLogWithTimestamp = (stream, message) => {
+  const timestamp = formatTimestamp();
+  const lines = message.split('\n');
+  lines.forEach(line => {
+    if (line) {
+      stream.write(`[${timestamp}] ${line}\n`);
+    } else {
+      stream.write('\n');
+    }
+  });
+  // 确保数据写入磁盘
+  stream.uncork();
+};
+
+/**
+ * 同时输出到控制台和日志文件
+ */
+const logWithFile = (
+  stream,
+  level,
+  message,
+) => {
+  // 输出到控制台
+  switch (level) {
+    case 'info':
+      logger.info(message);
+      break;
+    case 'success':
+      logger.success(message);
+      break;
+    case 'error':
+      logger.error(message);
+      break;
+    default:
+      logger.info(message);
+      break;
+  }
+
+  // 写入日志文件（带时间戳）
+  writeLogWithTimestamp(stream, `[${level.toUpperCase()}] ${message}`);
 };
 
+// start_aigc
 /**
- * 加载模板配置文件
- * 支持 .ts 和 .js 文件（通过 sucrase 注册）
- *
- * @param templatePath - 模板目录路径
- * @returns 模板配置对象
+ * 构建 pnpm add 命令
  */
+const buildPnpmCommand = (
+  packageName,
+  options
 
-const loadTemplateConfig = async ( 
-  templatePath,
-) => {
-  logger.verbose(`Loading template config from: ${templatePath}`);
 
-  const tsConfigPath = path.join(templatePath, 'template.config.ts');
-  const jsConfigPath = path.join(templatePath, 'template.config.js');
 
-  logger.verbose('Checking for config files:');
-  logger.verbose(`  - TypeScript: ${tsConfigPath}`);
-  logger.verbose(`  - JavaScript: ${jsConfigPath}`);
 
-  let configPath;
+,
+) => {
+  const { global, version, registry, extraArgs } = options;
 
-  const [tsExists, jsExists] = await Promise.all([
-    fs$1.access(tsConfigPath).then(
-      () => true,
-      () => false,
-    ),
-    fs$1.access(jsConfigPath).then(
-      () => true,
-      () => false,
-    ),
-  ]);
+  const parts = ['pnpm', 'add'];
 
-  logger.verbose('Config file existence check:');
-  logger.verbose(`  - template.config.ts: ${tsExists}`);
-  logger.verbose(`  - template.config.js: ${jsExists}`);
+  // 添加全局标记
+  if (global) {
+    parts.push('-g');
+  }
 
-  if (tsExists) {
-    configPath = tsConfigPath;
-  } else if (jsExists) {
-    configPath = jsConfigPath;
+  // 添加包名和版本
+  if (version && version !== 'latest') {
+    parts.push(`${packageName}@${version}`);
   } else {
-    throw new Error(
-      `Template config not found in ${templatePath}.\n` +
-        'Expected: template.config.ts or template.config.js',
-    );
+    parts.push(`${packageName}@latest`);
   }
 
-  logger.verbose(`Using config file: ${configPath}`);
-
-  // eslint-disable-next-line @typescript-eslint/no-require-imports, security/detect-non-literal-require -- Sucrase handles .ts files at runtime, path is validated above
-  const config = require(configPath);
-
-  logger.verbose('Template config loaded successfully');
-
-  return config.default || config;
-};
-
-/**
- * 加载模板列表配置
- *
- * @param configPath - templates.json 配置文件路径
- * @returns 模板列表配置
- */
-const loadTemplatesConfig = async (
-  configPath,
-) => {
-  logger.verbose(`Loading templates config from: ${configPath}`);
-
-  const content = await fs$1.readFile(configPath, 'utf-8');
-  // eslint-disable-next-line no-restricted-syntax -- Static config file loaded at build time, safeJsonParse not needed
-  const config = JSON.parse(content) ;
+  // 添加 registry
+  if (registry) {
+    parts.push(`--registry=${registry}`);
+  }
 
-  logger.verbose(
-    `Found ${config.templates.length} templates: ${config.templates.map(t => t.name).join(', ')}`,
-  );
+  // 添加额外参数
+  if (extraArgs.length > 0) {
+    parts.push(...extraArgs);
+  }
 
-  return config;
+  return parts.join(' ');
 };
+// end_aigc
 
 /**
- * 根据模板名称查找模板元信息
- *
- * @param templatesConfig - 模板列表配置
- * @param templateName - 模板名称
- * @returns 模板元信息
+ * 处理更新失败的错误
  */
-const findTemplate = (
-  templatesConfig,
-  templateName,
+const handleUpdateError = (
+  error,
+  packageName,
+  options,
+  cmdStartTime,
+  logStream,
 ) => {
-  const template = templatesConfig.templates.find(t => t.name === templateName);
+  const err = error instanceof Error ? error : new Error(String(error));
+  logger.error('Failed to update package:');
+  logger.error(err.message);
+
+  // 上报错误
+  reportError(err, {
+    command: 'update',
+    packageName,
+    type: 'execution_error',
+  });
+  reportCommandComplete('update', false, Date.now() - cmdStartTime, {
+    args: JSON.stringify({ packageName, ...options }),
+    errorCode: 1,
+    errorMessage: err.message,
+  });
 
-  if (!template) {
-    const availableTemplates = templatesConfig.templates
-      .map(t => t.name)
-      .join(', ');
-    throw new Error(
-      `Template "${templateName}" not found.\n` +
-        `Available templates: ${availableTemplates}\n` +
-        'Use --template <name> to specify a template.',
-    );
+  // 写入错误到日志文件
+  if (logStream) {
+    writeLogWithTimestamp(logStream, `[ERROR] ${err.message}`);
+    // 等待流关闭后再退出
+    logStream.end(() => {
+      flushSlardar().then(() => {
+        process.exit(1);
+      });
+    });
+  } else {
+    flushSlardar().then(() => {
+      process.exit(1);
+    });
   }
-
-  return template;
 };
 
+// start_aigc
 /**
- * 获取模板的完整路径
- *
- * @param basePath - 模板目录（templates.json 所在目录）
- * @param templateMetadata - 模板元信息
- * @returns 模板完整路径
+ * 执行 update 命令的内部实现
  */
-const getTemplatePath = async (
-  basePath,
-  templateMetadata,
-) => {
-  logger.verbose('Resolving template path:');
-  logger.verbose(`  - Base path: ${basePath}`);
-  logger.verbose(`  - Template location: ${templateMetadata.location}`);
+const executeUpdate = (
+  packageName,
+  options
 
-  // location 是相对于 templates.json 文件的路径
-  const templatePath = path.join(basePath, templateMetadata.location);
 
-  logger.verbose(`  - Resolved path: ${templatePath}`);
 
-  try {
-    await fs$1.access(templatePath);
-    logger.verbose('  - Template directory exists: ✓');
-    // eslint-disable-next-line @coze-arch/use-error-in-catch -- Error handling done in throw statement
-  } catch (e) {
-    logger.error('  - Template directory does not exist: ✗');
-    throw new Error(`Template directory not found: ${templatePath}`);
-  }
 
-  return templatePath;
-};
 
-/**
- * 对单个模板执行 pnpm install
- */
-const warmupTemplate = (templatePath, templateName) => {
-  logger.info(`\nWarming up template: ${templateName}`);
-  logger.info(`  Path: ${templatePath}`);
 
-  // 检查是否存在 package.json
-  const packageJsonPath = node_path.join(templatePath, 'package.json');
-  // eslint-disable-next-line security/detect-non-literal-fs-filename
-  if (!node_fs.existsSync(packageJsonPath)) {
-    logger.info(`  ⊘ Skipping ${templateName} (no package.json found)`);
-    return;
-  }
+,
+) => {
+  const cmdStartTime = Date.now();
+  let logStream = null;
 
-  const result = shelljs.exec('pnpm install', {
-    cwd: templatePath,
-    silent: true,
-  });
+  try {
+    const { global, cwd, version, registry, logFile, extraArgs } = options;
 
-  // 输出 stdout
-  if (result.stdout) {
-    process.stdout.write(result.stdout);
-  }
+    // 上报命令开始
+    reportCommandStart('update', JSON.stringify({ packageName, ...options }));
 
-  // 输出 stderr
-  if (result.stderr) {
-    process.stderr.write(result.stderr);
-  }
+    // 准备日志
+    const logFilePath = resolveLogFilePath$1(logFile);
 
-  if (result.code === 0) {
-    logger.success(`  ✓ ${templateName} warmed up successfully`);
-  } else {
-    const errorMessage = [
-      `pnpm install failed for ${templateName} with exit code ${result.code}`,
-      result.stderr ? `\nStderr:\n${result.stderr}` : '',
-      result.stdout ? `\nStdout:\n${result.stdout}` : '',
-    ]
-      .filter(Boolean)
-      .join('');
+    // 调试：确认日志路径
+    logger.info(`Log file path resolved to: ${logFilePath}`);
 
-    throw new Error(errorMessage);
-  }
-};
+    logStream = createLogStream$1(logFilePath);
 
-/**
- * 执行 warmup 命令的内部实现
- */
-const executeWarmup = async (options) => {
-  const timer = new TimeTracker();
+    // 调试：确认流已创建
+    logger.info('Log stream created successfully');
 
-  try {
-    const { template: templateFilter } = options;
+    logWithFile(logStream, 'info', `Updating package: ${packageName}`);
 
-    logger.info('Starting template warmup...');
-    timer.logPhase('Initialization');
+    // 构建命令
+    const command = buildPnpmCommand(packageName, {
+      global,
+      version,
+      registry,
+      extraArgs,
+    });
 
-    // 加载模板配置
-    const configPath = getTemplatesConfigPath();
-    const templatesConfig = await loadTemplatesConfig(configPath);
+    // 确定工作目录
+    const workingDir = cwd
+      ? path.isAbsolute(cwd)
+        ? cwd
+        : path.join(process.cwd(), cwd)
+      : process.cwd();
 
-    logger.verbose(
-      `Found ${templatesConfig.templates.length} templates in config`,
-    );
+    logWithFile(logStream, 'info', `Executing: ${command}`);
+    logWithFile(logStream, 'info', `Working directory: ${workingDir}`);
+    logWithFile(logStream, 'info', `Log file: ${logFilePath}`);
 
-    // 过滤模板
-    const templatesToWarmup = templateFilter
-      ? templatesConfig.templates.filter(t => t.name === templateFilter)
-      : templatesConfig.templates;
+    // 记录命令开始时间
+    writeLogWithTimestamp(logStream, '--- Command execution started ---');
 
-    if (templatesToWarmup.length === 0) {
-      if (templateFilter) {
-        logger.warn(`Template "${templateFilter}" not found`);
-        logger.info(
-          `Available templates: ${templatesConfig.templates.map(t => t.name).join(', ')}`,
-        );
-      } else {
-        logger.warn('No templates found');
-      }
-      return;
+    // 同步执行命令
+    const result = shelljs.exec(command, {
+      cwd: workingDir,
+      silent: true, // 使用 silent 来捕获输出
+    });
+
+    // 将输出写入控制台和日志文件（带时间戳）
+    if (result.stdout) {
+      process.stdout.write(result.stdout);
+      writeLogWithTimestamp(logStream, result.stdout.trim());
     }
 
-    logger.info(
-      `\nWill warm up ${templatesToWarmup.length} template(s): ${templatesToWarmup.map(t => t.name).join(', ')}`,
-    );
+    if (result.stderr) {
+      process.stderr.write(result.stderr);
+      writeLogWithTimestamp(logStream, result.stderr.trim());
+    }
 
-    // 获取模板基础路径
-    const basePath = configPath.replace(/\/templates\.json$/, '');
+    // 记录命令结束时间
+    writeLogWithTimestamp(logStream, '--- Command execution ended ---');
 
-    // 对每个模板执行 pnpm install
-    for (const templateMetadata of templatesToWarmup) {
-      const templatePath = await getTemplatePath(basePath, templateMetadata);
-      warmupTemplate(templatePath, templateMetadata.name);
-      timer.logPhase(`Warmup ${templateMetadata.name}`);
-    }
+    // 检查执行结果并记录到日志
+    if (result.code === 0) {
+      logWithFile(logStream, 'success', 'Package updated successfully');
+      logWithFile(logStream, 'info', `Log file: ${logFilePath}`);
 
-    logger.success('\n✅ All templates warmed up successfully!');
-    logger.info(
-      '\nNext time you run `coze init`, it will be much faster as node_modules are pre-installed.',
-    );
+      // 上报命令成功
+      reportCommandComplete('update', true, Date.now() - cmdStartTime, {
+        args: JSON.stringify({ packageName, ...options }),
+      });
+      // flush 由 main 函数统一处理
+    } else {
+      const errorMessage = `Command exited with code ${result.code}`;
+      logWithFile(logStream, 'error', errorMessage);
+      logWithFile(
+        logStream,
+        'error',
+        `Check log file for details: ${logFilePath}`,
+      );
 
-    timer.logTotal();
+      // 上报命令失败
+      reportError(new Error(errorMessage), {
+        command: 'update',
+        packageName,
+        exitCode: String(result.code),
+      });
+      reportCommandComplete('update', false, Date.now() - cmdStartTime, {
+        args: JSON.stringify({ packageName, ...options }),
+        errorCode: result.code || 1,
+        errorMessage,
+      });
+    }
+
+    // 关闭日志流并等待写入完成
+    logStream.end(() => {
+      // 流关闭后再退出进程
+      if (result.code !== 0) {
+        // flush 后再退出
+        flushSlardar().then(() => {
+          process.exit(result.code || 1);
+        });
+      }
+      // 成功时 flush 由 main 函数统一处理
+    });
   } catch (error) {
-    timer.logTotal();
-    logger.error('Failed to warmup templates:');
-    logger.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
+    handleUpdateError(error, packageName, options, cmdStartTime, logStream);
   }
 };
+// end_aigc
 
 /**
- * 注册 warmup 命令到 program
+ * 注册 update 命令到 program
  */
-const registerCommand$4 = program => {
+const registerCommand$3 = program => {
   program
-    .command('warmup')
-    .description('Pre-install dependencies for templates to speed up init')
-    .option('-t, --template <name>', 'Warmup a specific template only')
-    .action(async options => {
-      await executeWarmup(options);
+    .command('update <package>')
+    .description('Update a package dependency')
+    .option('-g, --global', 'Update package globally', false)
+    .option('-c, --cwd <path>', 'Working directory for the update')
+    .option(
+      '--to <version>',
+      'Version to update to (default: latest)',
+      'latest',
+    )
+    .option('--registry <url>', 'Registry URL to use for the update')
+    .option('--log-file <path>', 'Log file path')
+    .allowUnknownOption() // 允许透传参数给 pnpm
+    .action((packageName, options, command) => {
+      // 收集所有未知选项作为额外参数
+      const extraArgs = command.args.slice(1);
+
+      executeUpdate(packageName, {
+        ...options,
+        version: options.to, // 将 --to 映射到 version
+        extraArgs,
+      });
     });
 };
 
@@ -979,7 +3482,9 @@ const rules = [
 /**
  * 执行 fix 命令的内部实现
  */
-const executeFix = async (options = {}) => {
+const executeFix = async (
+  options = {},
+) => {
   try {
     const cwd = process.cwd();
     const projectFolder = options.directory
@@ -1037,7 +3542,7 @@ const executeFix = async (options = {}) => {
 /**
  * 注册 fix 命令到 program
  */
-const registerCommand$3 = program => {
+const registerCommand$2 = program => {
   program
     .command('fix')
     .description(
@@ -1056,13 +3561,13 @@ function _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else
 /**
  * 日志文件名常量
  */
-const LOG_FILE_NAME$1 = 'dev.log';
+const LOG_FILE_NAME = 'dev.log';
 
 /**
  * 获取日志目录
  * 优先使用环境变量 COZE_LOG_DIR，否则使用 ~/.coze-logs
  */
-const getLogDir$1 = () =>
+const getLogDir = () =>
   process.env.COZE_LOG_DIR || path.join(os.homedir(), '.coze-logs');
 
 /**
@@ -1071,22 +3576,22 @@ const getLogDir$1 = () =>
  * - 如果是相对路径，基于 getLogDir() + 相对路径
  * - 如果为空，使用 getLogDir() + LOG_FILE_NAME
  */
-const resolveLogFilePath$1 = (logFile) => {
+const resolveLogFilePath = (logFile) => {
   if (!logFile) {
-    return path.join(getLogDir$1(), LOG_FILE_NAME$1);
+    return path.join(getLogDir(), LOG_FILE_NAME);
   }
 
   if (path.isAbsolute(logFile)) {
     return logFile;
   }
 
-  return path.join(getLogDir$1(), logFile);
+  return path.join(getLogDir(), logFile);
 };
 
 /**
  * 创建日志写入流
  */
-const createLogStream$1 = (logFilePath) => {
+const createLogStream = (logFilePath) => {
   const logDir = path.dirname(logFilePath);
 
   // 确保日志目录存在
@@ -1105,9 +3610,14 @@ const executeRun = async (
   commandName,
   options = {},
 ) => {
+  const cmdStartTime = Date.now();
+
   try {
     logger.info(`Running ${commandName} command...`);
 
+    // 上报命令开始
+    reportCommandStart(commandName, JSON.stringify(options));
+
     // 1. 对于 build 命令，先执行 fix 以确保项目配置正确
     if (['dev', 'build'].includes(commandName)) {
       logger.info('\n🔧 Running fix command before build...\n');
@@ -1125,8 +3635,8 @@ const executeRun = async (
     const commandArgs = getCommandConfig(config, commandName);
 
     // 3. 准备日志
-    const logFilePath = resolveLogFilePath$1(options.logFile);
-    const logStream = createLogStream$1(logFilePath);
+    const logFilePath = resolveLogFilePath(options.logFile);
+    const logStream = createLogStream(logFilePath);
 
     // 4. 执行命令
     const commandString = commandArgs.join(' ');
@@ -1159,14 +3669,34 @@ const executeRun = async (
       logStream.end();
 
       if (code !== 0) {
-        logger.error(
-          `Command exited with code ${_nullishCoalesce$1(code, () => ( 'unknown'))}${signal ? ` and signal ${signal}` : ''}`,
-        );
+        const errorMessage = `Command exited with code ${_nullishCoalesce$1(code, () => ( 'unknown'))}${signal ? ` and signal ${signal}` : ''}`;
+        logger.error(errorMessage);
         logger.error(`Check log file for details: ${logFilePath}`);
-        process.exit(code || 1);
+
+        // 上报命令失败
+        reportError(new Error(errorMessage), {
+          command: commandName,
+          exitCode: String(_nullishCoalesce$1(code, () => ( 'unknown'))),
+          signal: _nullishCoalesce$1(signal, () => ( 'none')),
+          logFile: logFilePath,
+        });
+        reportCommandComplete(commandName, false, Date.now() - cmdStartTime, {
+          args: JSON.stringify(options),
+          errorCode: _nullishCoalesce$1(code, () => ( 1)),
+          errorMessage,
+        });
+        flushSlardar().then(() => {
+          process.exit(code || 1);
+        });
       } else {
         logger.success('Command completed successfully');
         logger.info(`Log file: ${logFilePath}`);
+
+        // 上报命令成功
+        reportCommandComplete(commandName, true, Date.now() - cmdStartTime, {
+          args: JSON.stringify(options),
+        });
+        // flush 由 main 函数统一处理
       }
     });
 
@@ -1177,19 +3707,46 @@ const executeRun = async (
         logger.error(`Stack trace:\n${error.stack}`);
       }
       logStream.end();
-      process.exit(1);
+
+      // 上报错误
+      reportError(error, {
+        command: commandName,
+        type: 'child_process_error',
+      });
+      reportCommandComplete(commandName, false, Date.now() - cmdStartTime, {
+        args: JSON.stringify(options),
+        errorCode: 1,
+        errorMessage: error.message,
+      });
+      flushSlardar().then(() => {
+        process.exit(1);
+      });
     });
   } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
     logger.error(`Failed to run ${commandName} command:`);
-    logger.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
+    logger.error(err.message);
+
+    // 上报错误
+    reportError(err, {
+      command: commandName,
+      type: 'execution_error',
+    });
+    reportCommandComplete(commandName, false, Date.now() - cmdStartTime, {
+      args: JSON.stringify(options),
+      errorCode: 1,
+      errorMessage: err.message,
+    });
+    flushSlardar().then(() => {
+      process.exit(1);
+    });
   }
 };
 
 /**
  * 注册 dev/build/start 命令到 program
  */
-const registerCommand$2 = program => {
+const registerCommand$1 = program => {
   // dev 命令
   program
     .command('dev')
@@ -1521,12 +4078,6 @@ const convertDotfileName = (filePath) => {
 // ABOUTME: Handles file content rendering, hook execution, and file writing
 
 
-
-
-
-
-
-
 // start_aigc
 /**
  * 执行文件渲染钩子
@@ -1677,11 +4228,6 @@ const writeRenderedFile = async (options
 // ABOUTME: Provides dry-run file collection and conflict checking
 
 
-
-
-
-
-
 // start_aigc
 /**
  * 收集所有将要写入的文件路径（dry-run 阶段）
@@ -1722,13 +4268,44 @@ const collectFilesToRender = async (options
 
   return filesToWrite;
 };
+
+/**
+ * 检测文件冲突
+ *
+ * @param outputPath - 输出目录路径
+ * @param filesToWrite - 将要写入的文件路径列表
+ * @returns 冲突的文件路径列表
+ */
+const detectFileConflicts = (
+  outputPath,
+  filesToWrite,
+) => {
+  logger.verbose('\nChecking for file conflicts...');
+
+  const conflicts = [];
+
+  for (const file of filesToWrite) {
+    const fullPath = path.join(outputPath, file);
+    if (fs.existsSync(fullPath)) {
+      conflicts.push(file);
+      logger.verbose(`  ⚠ Conflict detected: ${file}`);
+    }
+  }
+
+  if (conflicts.length === 0) {
+    logger.verbose('  ✓ No conflicts detected');
+  } else {
+    logger.verbose(`  ⚠ ${conflicts.length} conflicts detected`);
+  }
+
+  return conflicts;
+};
 // end_aigc
 
 // ABOUTME: Main file processing orchestration for template rendering
 // ABOUTME: Coordinates file system, rendering, and conflict detection layers
 
 
-
 // start_aigc
 /**
  * 处理单个文件（准备 + 写入）
@@ -1790,7 +4367,7 @@ const processTemplateFiles = async (options
 
 
 ) => {
-  const { templatePath, outputPath, context, templateConfig} = options;
+  const { templatePath, outputPath, context, templateConfig, force } = options;
   logger.verbose('Processing template files:');
   logger.verbose(`  - Template path: ${templatePath}`);
   logger.verbose(`  - Output path: ${outputPath}`);
@@ -1822,7 +4399,7 @@ const processTemplateFiles = async (options
   }
 
   // 阶段 2: Dry-run - 收集所有将要写入的文件
-  await collectFilesToRender({
+  const filesToWrite = await collectFilesToRender({
     files,
     templatePath,
     context,
@@ -1830,7 +4407,20 @@ const processTemplateFiles = async (options
   });
 
   // 阶段 3: 冲突检测（force 为 true 时跳过）
-  {
+  if (!force) {
+    const conflicts = detectFileConflicts(outputPath, filesToWrite);
+
+    if (conflicts.length > 0) {
+      // 有冲突，抛出详细的错误信息
+      const conflictList = conflicts.map(f => `  - ${f}`).join('\n');
+      throw new Error(
+        `File conflicts detected in output directory: ${outputPath}\n\n` +
+          `The following files already exist and would be overwritten:\n${conflictList}\n\n` +
+          'Please remove these files or use a different output directory.\n' +
+          'Or use --force to overwrite existing files.',
+      );
+    }
+  } else {
     logger.verbose(
       '  - Force mode enabled, skipping conflict detection. Existing files will be overwritten.',
     );
@@ -1975,7 +4565,7 @@ const prepareOutputDirectory = (outputPath) => {
 const execute = async (
   options,
 ) => {
-  const { templateName, outputPath, command} = options;
+  const { templateName, outputPath, command, force } = options;
 
   // 1. 加载模板
   const { templatePath } = await loadTemplateMetadata(templateName);
@@ -1999,7 +4589,9 @@ const execute = async (
     templatePath,
     outputPath: absoluteOutputPath,
     context,
-    templateConfig});
+    templateConfig,
+    force,
+  });
 
   // 7. 执行 onAfterRender 钩子
   await executeAfterRenderHook(templateConfig, context, absoluteOutputPath);
@@ -2089,6 +4681,7 @@ const runGitCommand = (command, projectPath) => {
 const runGitInit = (projectPath) => {
   // 检查是否已存在 .git 目录
   const gitDir = path.join(projectPath, '.git');
+
   if (fs.existsSync(gitDir)) {
     logger.info(
       '\n💡 Git repository already exists, skipping git initialization',
@@ -2102,9 +4695,8 @@ const runGitInit = (projectPath) => {
     logger.success('Git repository initialized successfully!');
   } catch (error) {
     // Git 初始化失败不应该导致整个流程失败
-    logger.warn(
-      `Git initialization failed: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.warn(`Git initialization failed: ${errorMessage}`);
     logger.info('You can manually initialize git later with: git init');
   }
 };
@@ -2129,9 +4721,8 @@ const commitChanges = (projectPath) => {
     logger.success('Changes committed successfully!');
   } catch (error) {
     // Commit 失败不应该导致整个流程失败
-    logger.warn(
-      `Git commit failed: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.warn(`Git commit failed: ${errorMessage}`);
     logger.info(
       'You can manually commit later with: git add --all && git commit -m "chore: init env"',
     );
@@ -2152,28 +4743,33 @@ const runDev = (projectPath) => {
 
   logger.info(`Executing: ${cliPath} dev in ${projectPath}`);
 
-  // 使用通用的后台执行函数启动开发服务器
-  // 调用 CLI 自己的 dev 命令
-  const pid = spawnDetached(process.argv[0], [cliPath, 'dev'], {
-    cwd: projectPath,
-    verbose: false, // 不输出额外的进程信息，由 logger 统一处理
-  });
+  try {
+    // 使用通用的后台执行函数启动开发服务器
+    // 调用 CLI 自己的 dev 命令
+    const pid = spawnDetached(process.argv[0], [cliPath, 'dev'], {
+      cwd: projectPath,
+      verbose: false, // 不输出额外的进程信息，由 logger 统一处理
+    });
 
-  logger.success('Development server started in background!');
-  if (pid) {
-    logger.info(`Process ID: ${pid}`);
-    logger.info(
-      '\nThe dev server is running independently. You can close this terminal.',
-    );
-    logger.info(`To stop the server later, use: kill ${pid}`);
+    if (pid) {
+      logger.success('Development server started in background!');
+      logger.info(`Process ID: ${pid}`);
+      logger.info(
+        '\nThe dev server is running independently. You can close this terminal.',
+      );
+      logger.info(`To stop the server later, use: kill ${pid}`);
+    } else {
+      logger.warn('Failed to get process ID for dev server');
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to start dev server: ${errorMessage}`);
   }
 };
 
 /**
- * 执行 init 命令的内部实现
+ * Init 命令执行上下文
  */
-const executeInit = async (
-  options
 
 
 
@@ -2181,280 +4777,183 @@ const executeInit = async (
 
 
 
-,
-  command,
-) => {
-  const timer = new TimeTracker();
 
-  try {
-    const {
-      template: templateName,
-      output: outputPath,
-      skipInstall,
-      skipGit,
-      skipCommit,
-      skipDev,
-      force,
-    } = options;
-
-    logger.info(`Initializing project with template: ${templateName}`);
-    timer.logPhase('Initialization');
 
-    // 执行模板引擎，返回结果对象
-    const result = await execute({
-      templateName,
-      outputPath,
-      command,
-      force,
-    });
-    const { outputPath: absoluteOutputPath, templateConfig, context } = result;
 
-    timer.logPhase('Template engine execution');
-    logger.success('Project created successfully!');
 
-    // 检查是否存在 package.json
-    const packageJsonPath = path.join(absoluteOutputPath, 'package.json');
-    const hasPackageJson = fs.existsSync(packageJsonPath);
 
-    // 安装依赖（始终使用 pnpm install，利用缓存机制）
-    if (!skipInstall) {
-      if (hasPackageJson) {
-        runPnpmInstall(absoluteOutputPath);
-        timer.logPhase('Dependencies installation');
-      } else {
-        logger.info(
-          '\n💡 No package.json found, skipping dependency installation',
-        );
-      }
-    }
 
-    // 执行 onComplete 钩子（在 pnpm install 之后）
-    await executeCompleteHook(templateConfig, context, absoluteOutputPath);
-    timer.logPhase('Complete hook execution');
 
-    // 如果没有跳过 git，则初始化 git 仓库
-    if (!skipGit) {
-      runGitInit(absoluteOutputPath);
-      timer.logPhase('Git initialization');
-    }
 
-    // 如果没有跳过 commit，则提交初始化生成的文件
-    if (!skipCommit) {
-      commitChanges(absoluteOutputPath);
-      timer.logPhase('Git commit');
-    }
 
-    // 如果没有跳过 dev，则启动开发服务器
-    if (!skipDev) {
-      runDev(absoluteOutputPath);
-      timer.logPhase('Dev server startup');
-    } else {
-      // 只有跳过 dev 时才显示 Next steps
-      logger.info('\nNext steps:');
-      logger.info(`  cd ${outputPath}`);
-      if (skipInstall && hasPackageJson) {
-        logger.info('  pnpm install');
-      }
-      if (skipGit) {
-        logger.info('  git init');
-      }
-      if (skipCommit) {
-        logger.info('  git add --all && git commit -m "chore: init env"');
-      }
-      logger.info('  coze dev');
-    }
 
-    // 输出总耗时
-    timer.logTotal();
-  } catch (error) {
-    timer.logTotal();
-    logger.error('Failed to initialize project:');
-    logger.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  }
-};
 
-/**
- * 注册 init 命令到 program
- */
-const registerCommand$1 = program => {
-  program
-    .command('init')
-    .description('Initialize a new project from a template')
-    .argument('[directory]', 'Output directory for the project')
-    .requiredOption('-t, --template <name>', 'Template name')
-    .option('-o, --output <path>', 'Output directory', process.cwd())
-    .option('--skip-install', 'Skip automatic pnpm install', false)
-    .option('--skip-git', 'Skip automatic git initialization', false)
-    .option(
-      '--skip-commit',
-      'Skip automatic git commit after initialization',
-      false,
-    )
-    .option('--skip-dev', 'Skip automatic dev server start', false)
-    .allowUnknownOption() // 允许透传参数
-    .action(async (directory, options, command) => {
-      // 位置参数优先级高于 --output 选项
-      const outputPath = _nullishCoalesce(directory, () => ( options.output));
-      // Always use force mode - overwrite existing files without conflict check
-      const force = true;
-      await executeInit({ ...options, output: outputPath, force }, command);
-    });
-};
 
-// ABOUTME: This file implements the update command for coze CLI
-// ABOUTME: It wraps pnpm update/install to update package dependencies with logging support
 
 
 
 
-/**
- * 日志文件名常量
- */
-const LOG_FILE_NAME = 'update.log';
 
-/**
- * 获取日志目录
- * 优先使用环境变量 COZE_LOG_DIR，否则使用 ~/.coze-logs
- */
-const getLogDir = () =>
-  process.env.COZE_LOG_DIR || path.join(os.homedir(), '.coze-logs');
 
-/**
- * 解析日志文件路径
- * - 如果是绝对路径，直接使用
- * - 如果是相对路径，基于 getLogDir() + 相对路径
- * - 如果为空，使用 getLogDir() + LOG_FILE_NAME
- */
-const resolveLogFilePath = (logFile) => {
-  if (!logFile) {
-    return path.join(getLogDir(), LOG_FILE_NAME);
-  }
 
-  if (path.isAbsolute(logFile)) {
-    return logFile;
-  }
 
-  return path.join(getLogDir(), logFile);
-};
+
+
+
 
 /**
- * 创建日志写入流
+ * 步骤1: 执行模板引擎
  */
-const createLogStream = (logFilePath) => {
-  const logDir = path.dirname(logFilePath);
+const executeTemplateEngineStep = async ctx => {
+  logger.info(`Initializing project with template: ${ctx.templateName}`);
+  ctx.timer.logPhase('Initialization');
+
+  const result = await execute({
+    templateName: ctx.templateName,
+    outputPath: ctx.outputPath,
+    command: ctx.command,
+    force: _nullishCoalesce(ctx.options.force, () => ( false)),
+  });
 
-  // 确保日志目录存在
-  if (!fs.existsSync(logDir)) {
-    fs.mkdirSync(logDir, { recursive: true });
-  }
+  // 保存结果到上下文
+  ctx.absoluteOutputPath = result.outputPath;
+  ctx.templateConfig = result.templateConfig;
+  ctx.context = result.context;
 
-  // 使用 'w' 标志覆盖之前的日志
-  return fs.createWriteStream(logFilePath, { flags: 'w' });
+  ctx.timer.logPhase('Template engine execution');
+  logger.success('Project created successfully!');
 };
 
 /**
- * 格式化时间戳
+ * 步骤2: 检查 package.json 是否存在
  */
-const formatTimestamp = () => {
-  const now = new Date();
-  return now.toISOString();
+const checkPackageJsonStep = ctx => {
+  if (!ctx.absoluteOutputPath) {
+    return;
+  }
+
+  const packageJsonPath = path.join(ctx.absoluteOutputPath, 'package.json');
+  ctx.hasPackageJson = fs.existsSync(packageJsonPath);
 };
 
 /**
- * 写入带时间戳的日志
+ * 步骤3: 安装依赖
  */
-const writeLogWithTimestamp = (stream, message) => {
-  const timestamp = formatTimestamp();
-  const lines = message.split('\n');
-  lines.forEach(line => {
-    if (line) {
-      stream.write(`[${timestamp}] ${line}\n`);
+const installDependenciesStep = ctx => {
+  if (!ctx.absoluteOutputPath) {
+    return;
+  }
+
+  const { skipInstall } = ctx.options;
+
+  if (!skipInstall) {
+    if (ctx.hasPackageJson) {
+      runPnpmInstall(ctx.absoluteOutputPath);
+      ctx.timer.logPhase('Dependencies installation');
     } else {
-      stream.write('\n');
+      logger.info(
+        '\n💡 No package.json found, skipping dependency installation',
+      );
     }
-  });
-  // 确保数据写入磁盘
-  stream.uncork();
+  }
 };
 
 /**
- * 同时输出到控制台和日志文件
+ * 步骤4: 执行完成钩子
  */
-const logWithFile = (
-  stream,
-  level,
-  message,
-) => {
-  // 输出到控制台
-  switch (level) {
-    case 'info':
-      logger.info(message);
-      break;
-    case 'success':
-      logger.success(message);
-      break;
-    case 'error':
-      logger.error(message);
-      break;
-    default:
-      logger.info(message);
-      break;
+const executeCompleteHookStep = async ctx => {
+  if (!ctx.absoluteOutputPath || !ctx.templateConfig || !ctx.context) {
+    return;
   }
 
-  // 写入日志文件（带时间戳）
-  writeLogWithTimestamp(stream, `[${level.toUpperCase()}] ${message}`);
+  await executeCompleteHook(
+    ctx.templateConfig,
+    ctx.context,
+    ctx.absoluteOutputPath,
+  );
+
+  ctx.timer.logPhase('Complete hook execution');
 };
 
-// start_aigc
 /**
- * 构建 pnpm add 命令
+ * 步骤5: 初始化 Git 仓库
  */
-const buildPnpmCommand = (
-  packageName,
-  options
-
+const gitInitStep = ctx => {
+  if (!ctx.absoluteOutputPath) {
+    return;
+  }
 
+  const { skipGit } = ctx.options;
 
+  if (!skipGit) {
+    runGitInit(ctx.absoluteOutputPath);
+    ctx.timer.logPhase('Git initialization');
+  }
+};
 
-,
-) => {
-  const { global, version, registry, extraArgs } = options;
+/**
+ * 步骤6: 提交 Git 变更
+ */
+const gitCommitStep = ctx => {
+  if (!ctx.absoluteOutputPath) {
+    return;
+  }
 
-  const parts = ['pnpm', 'add'];
+  const { skipCommit } = ctx.options;
 
-  // 添加全局标记
-  if (global) {
-    parts.push('-g');
+  if (!skipCommit) {
+    commitChanges(ctx.absoluteOutputPath);
+    ctx.timer.logPhase('Git commit');
   }
+};
 
-  // 添加包名和版本
-  if (version && version !== 'latest') {
-    parts.push(`${packageName}@${version}`);
-  } else {
-    parts.push(`${packageName}@latest`);
+/**
+ * 步骤7: 启动开发服务器
+ */
+const startDevServerStep = ctx => {
+  if (!ctx.absoluteOutputPath) {
+    return;
   }
 
-  // 添加 registry
-  if (registry) {
-    parts.push(`--registry=${registry}`);
-  }
+  const { skipDev, skipInstall, skipGit, skipCommit } = ctx.options;
 
-  // 添加额外参数
-  if (extraArgs.length > 0) {
-    parts.push(...extraArgs);
+  if (!skipDev) {
+    runDev(ctx.absoluteOutputPath);
+    ctx.timer.logPhase('Dev server startup');
+  } else {
+    // 只有跳过 dev 时才显示 Next steps
+    logger.info('\nNext steps:');
+    logger.info(`  cd ${ctx.outputPath}`);
+    if (skipInstall && ctx.hasPackageJson) {
+      logger.info('  pnpm install');
+    }
+    if (skipGit) {
+      logger.info('  git init');
+    }
+    if (skipCommit) {
+      logger.info('  git add --all && git commit -m "chore: init env"');
+    }
+    logger.info('  coze dev');
   }
-
-  return parts.join(' ');
 };
-// end_aigc
 
-// start_aigc
 /**
- * 执行 update 命令的内部实现
+ * Init 命令的所有执行步骤
  */
-const executeUpdate = (
-  packageName,
+const initSteps = [
+  executeTemplateEngineStep,
+  checkPackageJsonStep,
+  installDependenciesStep,
+  executeCompleteHookStep,
+  gitInitStep,
+  gitCommitStep,
+  startDevServerStep,
+];
+
+/**
+ * 执行 init 命令的内部实现
+ */
+const executeInit = async (
   options
 
 
@@ -2462,155 +4961,132 @@ const executeUpdate = (
 
 
 
+
 ,
+  command,
 ) => {
-  let logStream = null;
+  const timer = new TimeTracker();
+  const cmdStartTime = Date.now();
+
+  // 初始化执行上下文
+  const ctx = {
+    options,
+    command,
+    timer,
+    cmdStartTime,
+    templateName: options.template,
+    outputPath: options.output,
+  };
 
   try {
-    const { global, cwd, version, registry, logFile, extraArgs } = options;
-
-    // 准备日志
-    const logFilePath = resolveLogFilePath(logFile);
-
-    // 调试：确认日志路径
-    logger.info(`Log file path resolved to: ${logFilePath}`);
-
-    logStream = createLogStream(logFilePath);
+    // 上报命令开始
+    reportCommandStart(
+      'init',
+      JSON.stringify({ template: ctx.templateName, output: ctx.outputPath }),
+      { template: ctx.templateName },
+    );
 
-    // 调试：确认流已创建
-    logger.info('Log stream created successfully');
+    // 逐个执行步骤
+    for (const step of initSteps) {
+      await step(ctx);
+    }
 
-    logWithFile(logStream, 'info', `Updating package: ${packageName}`);
+    // 输出总耗时
+    timer.logTotal();
 
-    // 构建命令
-    const command = buildPnpmCommand(packageName, {
-      global,
-      version,
-      registry,
-      extraArgs,
+    // 上报命令成功
+    reportCommandComplete('init', true, Date.now() - cmdStartTime, {
+      args: JSON.stringify(options),
+      categories: { template: ctx.templateName },
     });
+    // flush 由 main 函数统一处理
+  } catch (error) {
+    timer.logTotal();
 
-    // 确定工作目录
-    const workingDir = cwd
-      ? path.isAbsolute(cwd)
-        ? cwd
-        : path.join(process.cwd(), cwd)
-      : process.cwd();
-
-    logWithFile(logStream, 'info', `Executing: ${command}`);
-    logWithFile(logStream, 'info', `Working directory: ${workingDir}`);
-    logWithFile(logStream, 'info', `Log file: ${logFilePath}`);
-
-    // 记录命令开始时间
-    writeLogWithTimestamp(logStream, '--- Command execution started ---');
-
-    // 同步执行命令
-    const result = shelljs.exec(command, {
-      cwd: workingDir,
-      silent: true, // 使用 silent 来捕获输出
+    // 上报错误
+    const err = error instanceof Error ? error : new Error(String(error));
+    reportError(err, {
+      command: 'init',
+      template: options.template,
+      output: options.output,
     });
 
-    // 将输出写入控制台和日志文件（带时间戳）
-    if (result.stdout) {
-      process.stdout.write(result.stdout);
-      writeLogWithTimestamp(logStream, result.stdout.trim());
-    }
-
-    if (result.stderr) {
-      process.stderr.write(result.stderr);
-      writeLogWithTimestamp(logStream, result.stderr.trim());
-    }
-
-    // 记录命令结束时间
-    writeLogWithTimestamp(logStream, '--- Command execution ended ---');
-
-    // 检查执行结果并记录到日志
-    if (result.code === 0) {
-      logWithFile(logStream, 'success', 'Package updated successfully');
-      logWithFile(logStream, 'info', `Log file: ${logFilePath}`);
-    } else {
-      logWithFile(
-        logStream,
-        'error',
-        `Command exited with code ${result.code}`,
-      );
-      logWithFile(
-        logStream,
-        'error',
-        `Check log file for details: ${logFilePath}`,
-      );
-    }
-
-    // 关闭日志流并等待写入完成
-    logStream.end(() => {
-      // 流关闭后再退出进程
-      if (result.code !== 0) {
-        process.exit(result.code || 1);
-      }
+    // 上报命令失败
+    reportCommandComplete('init', false, Date.now() - cmdStartTime, {
+      args: JSON.stringify(options),
+      errorCode: 1,
+      errorMessage: err.message,
+      categories: { template: options.template },
     });
-  } catch (error) {
-    logger.error('Failed to update package:');
-    logger.error(error instanceof Error ? error.message : String(error));
+    await flushSlardar();
 
-    // 写入错误到日志文件
-    if (logStream) {
-      writeLogWithTimestamp(
-        logStream,
-        `[ERROR] ${error instanceof Error ? error.message : String(error)}`,
-      );
-      // 等待流关闭后再退出
-      logStream.end(() => {
-        process.exit(1);
-      });
-    } else {
-      process.exit(1);
-    }
+    logger.error('Failed to initialize project:');
+    logger.error(err.message);
+    process.exit(1);
   }
 };
-// end_aigc
 
 /**
- * 注册 update 命令到 program
+ * 注册 init 命令到 program
  */
 const registerCommand = program => {
   program
-    .command('update <package>')
-    .description('Update a package dependency')
-    .option('-g, --global', 'Update package globally', false)
-    .option('-c, --cwd <path>', 'Working directory for the update')
+    .command('init')
+    .description('Initialize a new project from a template')
+    .argument('[directory]', 'Output directory for the project')
+    .requiredOption('-t, --template <name>', 'Template name')
+    .option('-o, --output <path>', 'Output directory', process.cwd())
+    .option('--skip-install', 'Skip automatic pnpm install', false)
+    .option('--skip-git', 'Skip automatic git initialization', false)
     .option(
-      '--to <version>',
-      'Version to update to (default: latest)',
-      'latest',
+      '--skip-commit',
+      'Skip automatic git commit after initialization',
+      false,
     )
-    .option('--registry <url>', 'Registry URL to use for the update')
-    .option('--log-file <path>', 'Log file path')
-    .allowUnknownOption() // 允许透传参数给 pnpm
-    .action((packageName, options, command) => {
-      // 收集所有未知选项作为额外参数
-      const extraArgs = command.args.slice(1);
-
-      executeUpdate(packageName, {
-        ...options,
-        version: options.to, // 将 --to 映射到 version
-        extraArgs,
-      });
+    .option('--skip-dev', 'Skip automatic dev server start', false)
+    .allowUnknownOption() // 允许透传参数
+    .action(async (directory, options, command) => {
+      // 位置参数优先级高于 --output 选项
+      const outputPath = _nullishCoalesce(directory, () => ( options.output));
+      // Always use force mode - overwrite existing files without conflict check
+      const force = true;
+      await executeInit({ ...options, output: outputPath, force }, command);
     });
 };
 
-var version = "0.0.1-alpha.dcc485";
-var packageJson = {
-	version: version};
-
 const commands = [
+  registerCommand,
   registerCommand$1,
-  registerCommand$2,
   registerCommand$4,
+  registerCommand$2,
   registerCommand$3,
-  registerCommand,
 ];
 
-const main = () => {
+const main = async () => {
+  // 初始化 Slardar 监控
+  initSlardar();
+
+  // 监听未捕获的异常
+  process.on('uncaughtException', async (error) => {
+    reportError(error, {
+      type: 'uncaughtException',
+      context: 'global',
+    });
+    await flushSlardar();
+    process.exit(1);
+  });
+
+  // 监听未处理的 Promise rejection
+  process.on('unhandledRejection', async (reason) => {
+    const error = reason instanceof Error ? reason : new Error(String(reason));
+    reportError(error, {
+      type: 'unhandledRejection',
+      context: 'global',
+    });
+    await flushSlardar();
+    process.exit(1);
+  });
+
   const program = new commander.Command();
 
   program
@@ -2625,7 +5101,12 @@ const main = () => {
   // 在 help 输出中添加模板信息
   program.addHelpText('after', generateTemplatesHelpText());
 
-  program.parse(process.argv);
+  // 使用 parseAsync 等待命令执行完成
+  await program.parseAsync(process.argv);
+
+  // 统一在命令执行完成后 flush
+  // 注意：如果命令中调用了 process.exit()，不会执行到这里
+  await flushSlardar();
 };
 
 main();