@geek-fun/serverlessinsight 0.4.0 → 0.5.0

package/dist/src/common/lockManager.js

@@ -0,0 +1,212 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readLockFileForCommand = exports.withLock = exports.forceUnlock = exports.formatLockInfo = exports.generateLockId = exports.getLockPath = exports.LockError = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_child_process_1 = require("node:child_process");
+const constants_1 = require("./constants");
+const lang_1 = require("../lang");
+class LockError extends Error {
+    constructor(message, lockInfo) {
+        super(message);
+        this.lockInfo = lockInfo;
+        this.name = 'LockError';
+    }
+}
+exports.LockError = LockError;
+const getLockPath = (statePath) => {
+    return `${statePath}${constants_1.LOCK_FILE_SUFFIX}`;
+};
+exports.getLockPath = getLockPath;
+const generateLockId = () => {
+    return node_crypto_1.default.randomBytes(16).toString('hex');
+};
+exports.generateLockId = generateLockId;
+const getUserEmail = () => {
+    // Try to get git user email first
+    try {
+        const email = (0, node_child_process_1.execSync)('git config user.email', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim();
+        if (email)
+            return email;
+    }
+    catch {
+        // Ignore errors
+    }
+    // Fallback to username@hostname
+    const username = node_os_1.default.userInfo().username || 'unknown';
+    const hostname = node_os_1.default.hostname() || 'unknown';
+    return `${username}@${hostname}`;
+};
+const createLockMetadata = (statePath, operation) => {
+    return {
+        id: (0, exports.generateLockId)(),
+        user: getUserEmail(),
+        processId: process.pid,
+        hostname: node_os_1.default.hostname(),
+        operation,
+        acquiredAt: new Date().toISOString(),
+        path: statePath,
+    };
+};
+const readLockFile = (lockPath) => {
+    try {
+        if (node_fs_1.default.existsSync(lockPath)) {
+            const content = node_fs_1.default.readFileSync(lockPath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // If we can't read the lock file, treat it as if it doesn't exist
+    }
+    return null;
+};
+const writeLockFile = (lockPath, metadata) => {
+    const lockDir = node_path_1.default.dirname(lockPath);
+    if (!node_fs_1.default.existsSync(lockDir)) {
+        node_fs_1.default.mkdirSync(lockDir, { recursive: true });
+    }
+    node_fs_1.default.writeFileSync(lockPath, JSON.stringify(metadata, null, 2), 'utf-8');
+};
+const removeLockFile = (lockPath) => {
+    if (node_fs_1.default.existsSync(lockPath)) {
+        node_fs_1.default.unlinkSync(lockPath);
+    }
+};
+const isLockStale = (lock) => {
+    const acquiredAt = new Date(lock.acquiredAt).getTime();
+    const now = Date.now();
+    return now - acquiredAt > constants_1.STALE_LOCK_THRESHOLD;
+};
+const getTimeAgo = (acquiredAt) => {
+    const now = new Date();
+    const minutesAgo = Math.floor((now.getTime() - acquiredAt.getTime()) / 60000);
+    if (minutesAgo < 1) {
+        return lang_1.lang.__('LOCK_TIME_AGO_LESS_THAN_MINUTE');
+    }
+    else if (minutesAgo === 1) {
+        return lang_1.lang.__('LOCK_TIME_AGO_ONE_MINUTE');
+    }
+    else if (minutesAgo < 60) {
+        return lang_1.lang.__('LOCK_TIME_AGO_MINUTES', { minutes: String(minutesAgo) });
+    }
+    else {
+        const hoursAgo = Math.floor(minutesAgo / 60);
+        if (hoursAgo === 1) {
+            return lang_1.lang.__('LOCK_TIME_AGO_ONE_HOUR');
+        }
+        else {
+            return lang_1.lang.__('LOCK_TIME_AGO_HOURS', { hours: String(hoursAgo) });
+        }
+    }
+};
+const formatLockInfo = (lock) => {
+    const acquiredAt = new Date(lock.acquiredAt);
+    const timeAgo = getTimeAgo(acquiredAt);
+    return `
+${lang_1.lang.__('LOCK_INFO_HEADER')}
+${lang_1.lang.__('LOCK_INFO_ID', { id: lock.id })}
+${lang_1.lang.__('LOCK_INFO_HELD_BY', { user: lock.user })}
+${lang_1.lang.__('LOCK_INFO_PROCESS', { operation: lock.operation, processId: String(lock.processId) })}
+${lang_1.lang.__('LOCK_INFO_HOST', { hostname: lock.hostname })}
+${lang_1.lang.__('LOCK_INFO_ACQUIRED', { acquiredAt: acquiredAt.toISOString(), timeAgo })}
+${lang_1.lang.__('LOCK_INFO_OPERATION', { operation: lock.operation })}
+`;
+};
+exports.formatLockInfo = formatLockInfo;
+const sleep = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+const acquireLockInternal = async (statePath, operation, options = {}) => {
+    const timeout = options.timeout ?? constants_1.DEFAULT_LOCK_TIMEOUT;
+    const retryDelay = options.retryDelay ?? constants_1.DEFAULT_LOCK_RETRY_DELAY;
+    const maxRetries = options.maxRetries ?? Math.ceil(timeout / retryDelay);
+    const lockPath = (0, exports.getLockPath)(statePath);
+    const metadata = createLockMetadata(statePath, operation);
+    const startTime = Date.now();
+    let attempt = 0;
+    while (attempt <= maxRetries) {
+        // Check if lock file exists
+        const existingLock = readLockFile(lockPath);
+        if (!existingLock) {
+            // No lock exists, try to acquire
+            try {
+                writeLockFile(lockPath, metadata);
+                // Verify we got the lock by reading it back
+                const verifyLock = readLockFile(lockPath);
+                if (verifyLock && verifyLock.id === metadata.id) {
+                    return metadata;
+                }
+            }
+            catch {
+                // Failed to write lock, will retry
+            }
+        }
+        else {
+            // Lock exists, check if it's stale
+            if (isLockStale(existingLock)) {
+                // Lock is stale, but we don't auto-remove it
+                // User must use force-unlock
+                throw new LockError(`State is currently locked (stale lock detected).\n${(0, exports.formatLockInfo)(existingLock)}\nThis lock appears to be stale. If you are certain no other operation is running, use:\n  si force-unlock ${existingLock.id}`, existingLock);
+            }
+            // Check if timeout exceeded
+            if (Date.now() - startTime >= timeout) {
+                throw new LockError(`Failed to acquire lock after ${timeout / 1000} seconds.\n${(0, exports.formatLockInfo)(existingLock)}\nIf you are certain no other operation is running, use:\n  si force-unlock ${existingLock.id}`, existingLock);
+            }
+        }
+        // Wait before retrying with exponential backoff
+        const delay = Math.min(retryDelay * Math.pow(2, attempt), 30000); // Cap at 30 seconds
+        await sleep(delay);
+        attempt++;
+    }
+    // This shouldn't be reached, but just in case
+    const existingLock = readLockFile(lockPath);
+    throw new LockError(`Failed to acquire lock.\n${existingLock ? (0, exports.formatLockInfo)(existingLock) : ''}\nIf you are certain no other operation is running, use:\n  si force-unlock ${existingLock?.id || 'unknown'}`, existingLock || undefined);
+};
+const releaseLockInternal = (statePath, lockId) => {
+    const lockPath = (0, exports.getLockPath)(statePath);
+    const existingLock = readLockFile(lockPath);
+    // Only release if the lock ID matches
+    if (existingLock && existingLock.id === lockId) {
+        removeLockFile(lockPath);
+    }
+};
+const forceUnlock = (statePath, lockId) => {
+    const lockPath = (0, exports.getLockPath)(statePath);
+    const existingLock = readLockFile(lockPath);
+    if (!existingLock) {
+        return false; // No lock to remove
+    }
+    if (existingLock.id !== lockId) {
+        throw new Error(`Lock ID mismatch. Current lock ID is ${existingLock.id}, but you provided ${lockId}`);
+    }
+    removeLockFile(lockPath);
+    return true;
+};
+exports.forceUnlock = forceUnlock;
+const withLock = async (statePath, operation, fn, options) => {
+    let lock = null;
+    try {
+        lock = await acquireLockInternal(statePath, operation, options);
+        return await fn();
+    }
+    finally {
+        if (lock) {
+            releaseLockInternal(statePath, lock.id);
+        }
+    }
+};
+exports.withLock = withLock;
+// Export only for forceUnlock command which needs to read lock info
+const readLockFileForCommand = (statePath) => {
+    const lockPath = (0, exports.getLockPath)(statePath);
+    return readLockFile(lockPath);
+};
+exports.readLockFileForCommand = readLockFileForCommand;

package/dist/src/common/logger.js

@@ -5,11 +5,94 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 const pino_1 = __importDefault(require("pino"));
-const logger = (0, pino_1.default)({
+const pino_pretty_1 = __importDefault(require("pino-pretty"));
+const child_process_1 = require("child_process");
+const iconv_lite_1 = __importDefault(require("iconv-lite"));
+const stream_1 = require("stream");
+const CODE_PAGE_TO_ENCODING = {
+    932: 'shift_jis', // Japanese
+    936: 'gbk', // Simplified Chinese
+    949: 'euc-kr', // Korean
+    950: 'big5', // Traditional Chinese
+    1250: 'windows-1250', // Central European
+    1251: 'windows-1251', // Cyrillic
+    1252: 'windows-1252', // Latin I
+    1253: 'windows-1253', // Greek
+    1254: 'windows-1254', // Turkish
+    1255: 'windows-1255', // Hebrew
+    1256: 'windows-1256', // Arabic
+    1257: 'windows-1257', // Baltic
+    1258: 'windows-1258', // Vietnamese
+    65001: 'utf8', // UTF-8
+    1200: 'utf16le', // UTF-16 LE
+    1201: 'utf16be', // UTF-16 BE
+    20127: 'ascii', // ASCII
+    28591: 'iso-8859-1', // Latin-1
+};
+const getSystemEncoding = () => {
+    if (process.platform === 'win32') {
+        try {
+            const codePageOutput = (0, child_process_1.execSync)('chcp', {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).toString();
+            const codePageMatch = codePageOutput.match(/(\d+)\s*$/m);
+            if (codePageMatch) {
+                const codePage = parseInt(codePageMatch[1], 10);
+                return CODE_PAGE_TO_ENCODING[codePage] || 'utf8';
+            }
+        }
+        catch {
+            // fallback to environment variable detection
+        }
+    }
+    const langEnv = (process.env.LANG ||
+        process.env.LC_ALL ||
+        process.env.LC_CTYPE ||
+        '').toLowerCase();
+    if (['utf8', 'utf-8'].find((lang) => langEnv.includes(lang))) {
+        return 'utf8';
+    }
+    if (['gbk', 'gb2312'].find((lang) => langEnv.includes(lang))) {
+        return 'gbk';
+    }
+    if (['shift_jis', 'sjis'].find((lang) => langEnv.includes(lang))) {
+        return 'shift_jis';
+    }
+    if (langEnv.includes('big5')) {
+        return 'big5';
+    }
+    return 'utf8';
+};
+class EncodingTransformStream extends stream_1.Writable {
+    constructor(encoding) {
+        super();
+        this.encoding = encoding;
+        this.formatLog = pino_pretty_1.default.prettyFactory({
+            colorize: true,
+            translateTime: 'HH:MM:ss',
+            ignore: 'pid,hostname',
+            messageFormat: '{msg}',
+        });
+    }
+    _write(chunk, encoding, callback) {
+        try {
+            const stringChunk = typeof chunk === 'string' ? chunk : chunk.toString();
+            const formattedChunk = this.formatLog(stringChunk);
+            if (this.encoding !== 'utf8' && iconv_lite_1.default.encodingExists(this.encoding)) {
+                process.stdout.write(iconv_lite_1.default.toEncoding(formattedChunk, 'utf8'));
+            }
+            else {
+                process.stdout.write(formattedChunk);
+            }
+            callback();
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+}
+exports.logger = (0, pino_1.default)({
     name: 'ServerlessInsight',
     level: ['ServerlessInsight', '*'].includes(process.env.DEBUG || '') ? 'debug' : 'info',
-    transport: {
-        target: 'pino-pretty',
-    },
-});
-exports.logger = logger;
+}, new EncodingTransformStream(getSystemEncoding()));

package/dist/src/common/providerEnum.js

@@ -5,7 +5,6 @@ var ProviderEnum;
 (function (ProviderEnum) {
     ProviderEnum["HUAWEI"] = "huawei";
     ProviderEnum["ALIYUN"] = "aliyun";
-    // TENCENT = 'TENCENT',
-    // AWS = 'AZURE',
-    // AZURE = 'AZURE',
+    ProviderEnum["TENCENT"] = "tencent";
+    ProviderEnum["AWS"] = "aws";
 })(ProviderEnum || (exports.ProviderEnum = ProviderEnum = {}));

package/dist/src/common/runtimeMapper.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSupportedRuntimes = exports.isRuntimeSupported = exports.mapRuntime = exports.StandardRuntime = void 0;
+const providerEnum_1 = require("./providerEnum");
+var StandardRuntime;
+(function (StandardRuntime) {
+    StandardRuntime["NODEJS24"] = "nodejs24";
+    StandardRuntime["NODEJS22"] = "nodejs22";
+    StandardRuntime["NODEJS20"] = "nodejs20";
+    StandardRuntime["NODEJS18"] = "nodejs18";
+    StandardRuntime["NODEJS16"] = "nodejs16";
+    StandardRuntime["NODEJS14"] = "nodejs14";
+    StandardRuntime["NODEJS12"] = "nodejs12";
+    StandardRuntime["NODEJS10"] = "nodejs10";
+    StandardRuntime["PYTHON3_14"] = "python3.14";
+    StandardRuntime["PYTHON3_13"] = "python3.13";
+    StandardRuntime["PYTHON3_12"] = "python3.12";
+    StandardRuntime["PYTHON3_11"] = "python3.11";
+    StandardRuntime["PYTHON3_10"] = "python3.10";
+    StandardRuntime["PYTHON3_9"] = "python3.9";
+    StandardRuntime["PYTHON3_7"] = "python3.7";
+    StandardRuntime["PYTHON3_6"] = "python3.6";
+    StandardRuntime["JAVA25"] = "java25";
+    StandardRuntime["JAVA21"] = "java21";
+    StandardRuntime["JAVA17"] = "java17";
+    StandardRuntime["JAVA11"] = "java11";
+    StandardRuntime["JAVA8"] = "java8";
+    StandardRuntime["PHP8_0"] = "php8.0";
+    StandardRuntime["PHP7_4"] = "php7.4";
+    StandardRuntime["PHP7_2"] = "php7.2";
+    StandardRuntime["PHP5_6"] = "php5.6";
+    StandardRuntime["GO1"] = "go1";
+    StandardRuntime["DOTNET_CORE3_1"] = "dotnet_core3.1";
+})(StandardRuntime || (exports.StandardRuntime = StandardRuntime = {}));
+const runtimeMappings = {
+    [StandardRuntime.NODEJS24]: {
+        [providerEnum_1.ProviderEnum.AWS]: 'nodejs24.x',
+    },
+    [StandardRuntime.NODEJS22]: {
+        [providerEnum_1.ProviderEnum.AWS]: 'nodejs22.x',
+    },
+    [StandardRuntime.NODEJS20]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'nodejs20',
+        [providerEnum_1.ProviderEnum.AWS]: 'nodejs20.x',
+    },
+    [StandardRuntime.NODEJS18]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'nodejs18',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Nodejs18.15',
+    },
+    [StandardRuntime.NODEJS16]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'nodejs16',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Nodejs16.13',
+    },
+    [StandardRuntime.NODEJS14]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'nodejs14',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Nodejs14.18',
+    },
+    [StandardRuntime.NODEJS12]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'nodejs12',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Nodejs12.16',
+    },
+    [StandardRuntime.NODEJS10]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'nodejs10',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Nodejs10.15',
+    },
+    [StandardRuntime.PYTHON3_14]: {
+        [providerEnum_1.ProviderEnum.AWS]: 'python3.14',
+    },
+    [StandardRuntime.PYTHON3_13]: {
+        [providerEnum_1.ProviderEnum.AWS]: 'python3.13',
+    },
+    [StandardRuntime.PYTHON3_12]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'python3.12',
+        [providerEnum_1.ProviderEnum.AWS]: 'python3.12',
+    },
+    [StandardRuntime.PYTHON3_11]: {
+        [providerEnum_1.ProviderEnum.AWS]: 'python3.11',
+    },
+    [StandardRuntime.PYTHON3_10]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'python3.10',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Python3.10',
+        [providerEnum_1.ProviderEnum.AWS]: 'python3.10',
+    },
+    [StandardRuntime.PYTHON3_9]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'python3.9',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Python3.9',
+    },
+    [StandardRuntime.PYTHON3_7]: {
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Python3.7',
+    },
+    [StandardRuntime.PYTHON3_6]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'python3.6',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Python3.6',
+    },
+    [StandardRuntime.JAVA25]: {
+        [providerEnum_1.ProviderEnum.AWS]: 'java25',
+    },
+    [StandardRuntime.JAVA21]: {
+        [providerEnum_1.ProviderEnum.AWS]: 'java21',
+    },
+    [StandardRuntime.JAVA17]: {
+        [providerEnum_1.ProviderEnum.AWS]: 'java17',
+    },
+    [StandardRuntime.JAVA11]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'java11',
+        [providerEnum_1.ProviderEnum.AWS]: 'java11',
+    },
+    [StandardRuntime.JAVA8]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'java8',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Java8',
+        [providerEnum_1.ProviderEnum.AWS]: 'java8.al2',
+    },
+    [StandardRuntime.PHP8_0]: {
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Php8.0',
+    },
+    [StandardRuntime.PHP7_4]: {
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Php7.4',
+    },
+    [StandardRuntime.PHP7_2]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'php7.2',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Php7.2',
+    },
+    [StandardRuntime.PHP5_6]: {
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Php5.6',
+    },
+    [StandardRuntime.GO1]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: 'go 1.x',
+        [providerEnum_1.ProviderEnum.TENCENT]: 'Go1',
+    },
+    [StandardRuntime.DOTNET_CORE3_1]: {
+        [providerEnum_1.ProviderEnum.ALIYUN]: '.NET Core 3.1',
+    },
+};
+const mapRuntime = (standardRuntime, provider) => {
+    const mapping = runtimeMappings[standardRuntime];
+    if (!mapping) {
+        throw new Error(`Unsupported standard runtime: ${standardRuntime}`);
+    }
+    const providerRuntime = mapping[provider];
+    if (!providerRuntime) {
+        throw new Error(`Runtime ${standardRuntime} is not supported for provider ${provider}. ` +
+            `Supported providers for this runtime: ${Object.keys(mapping).join(', ')}`);
+    }
+    return providerRuntime;
+};
+exports.mapRuntime = mapRuntime;
+const isRuntimeSupported = (standardRuntime, provider) => {
+    const mapping = runtimeMappings[standardRuntime];
+    return !!mapping && !!mapping[provider];
+};
+exports.isRuntimeSupported = isRuntimeSupported;
+const getSupportedRuntimes = (provider) => {
+    if (!provider) {
+        return Object.values(StandardRuntime);
+    }
+    return Object.entries(runtimeMappings)
+        .filter(([, mapping]) => !!mapping[provider])
+        .map(([runtime]) => runtime);
+};
+exports.getSupportedRuntimes = getSupportedRuntimes;

package/dist/src/common/scfClient.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTdsqlcClient = exports.createTencentCloudClient = void 0;
+const tencentcloud = __importStar(require("tencentcloud-sdk-nodejs-scf"));
+const cynosdb = __importStar(require("tencentcloud-sdk-nodejs-cynosdb"));
+const cos_nodejs_sdk_v5_1 = __importDefault(require("cos-nodejs-sdk-v5"));
+const ScfClient = tencentcloud.scf.v20180416.Client;
+const CynosdbClient = cynosdb.cynosdb.v20190107.Client;
+const createTencentCloudClient = (context) => {
+    const scfClientConfig = {
+        credential: {
+            secretId: context.accessKeyId,
+            secretKey: context.accessKeySecret,
+        },
+        region: context.region,
+        profile: {
+            httpProfile: {
+                endpoint: 'scf.tencentcloudapi.com',
+            },
+        },
+    };
+    const scfClient = new ScfClient(scfClientConfig);
+    const cosClient = new cos_nodejs_sdk_v5_1.default({
+        SecretId: context.accessKeyId,
+        SecretKey: context.accessKeySecret,
+    });
+    return {
+        scf: scfClient,
+        cos: cosClient,
+    };
+};
+exports.createTencentCloudClient = createTencentCloudClient;
+const createTdsqlcClient = (context) => {
+    const clientConfig = {
+        credential: {
+            secretId: context.accessKeyId,
+            secretKey: context.accessKeySecret,
+        },
+        region: context.region,
+        profile: {
+            httpProfile: {
+                endpoint: 'cynosdb.tencentcloudapi.com',
+            },
+        },
+    };
+    return new CynosdbClient(clientConfig);
+};
+exports.createTdsqlcClient = createTdsqlcClient;

package/dist/src/common/stateManager.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRoleArnFromState = exports.getAllResources = exports.removeResource = exports.setResource = exports.getResource = exports.saveStateWithLock = exports.saveState = exports.loadState = exports.ensureStateDir = exports.getStatePath = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const types_1 = require("../types");
+const lockManager_1 = require("./lockManager");
+const STATE_DIR = '.serverlessinsight';
+const STATE_FILE = 'state.json';
+const getStatePath = (baseDir = process.cwd()) => {
+    return node_path_1.default.join(baseDir, STATE_DIR, STATE_FILE);
+};
+exports.getStatePath = getStatePath;
+const ensureStateDir = (baseDir = process.cwd()) => {
+    const stateDir = node_path_1.default.join(baseDir, STATE_DIR);
+    if (!node_fs_1.default.existsSync(stateDir)) {
+        node_fs_1.default.mkdirSync(stateDir, { recursive: true });
+    }
+};
+exports.ensureStateDir = ensureStateDir;
+/**
+ * Load state file.
+ */
+const loadState = (provider, baseDir = process.cwd()) => {
+    const statePath = (0, exports.getStatePath)(baseDir);
+    try {
+        if (node_fs_1.default.existsSync(statePath)) {
+            const content = node_fs_1.default.readFileSync(statePath, 'utf-8');
+            const state = JSON.parse(content);
+            return state;
+        }
+        // If file doesn't exist or is invalid, return empty state
+    }
+    catch {
+        // Ignore error
+    }
+    return { version: types_1.CURRENT_STATE_VERSION, provider, resources: {} };
+};
+exports.loadState = loadState;
+const saveState = (state, baseDir = process.cwd()) => {
+    (0, exports.ensureStateDir)(baseDir);
+    const statePath = (0, exports.getStatePath)(baseDir);
+    // Ensure we always save with current version
+    const stateToSave = {
+        ...state,
+        version: types_1.CURRENT_STATE_VERSION,
+    };
+    node_fs_1.default.writeFileSync(statePath, JSON.stringify(stateToSave, null, 2), 'utf-8');
+};
+exports.saveState = saveState;
+/**
+ * Save state with automatic locking.
+ * This should be used by high-level operations like deploy/destroy.
+ */
+const saveStateWithLock = async (state, operation, baseDir = process.cwd(), options) => {
+    const statePath = (0, exports.getStatePath)(baseDir);
+    await (0, lockManager_1.withLock)(statePath, operation, async () => {
+        (0, exports.saveState)(state, baseDir);
+    }, options);
+};
+exports.saveStateWithLock = saveStateWithLock;
+const getResource = (state, resourceId) => {
+    return state.resources[resourceId];
+};
+exports.getResource = getResource;
+const setResource = (state, resourceId, resourceState) => {
+    return {
+        ...state,
+        resources: {
+            ...state.resources,
+            [resourceId]: resourceState,
+        },
+    };
+};
+exports.setResource = setResource;
+const removeResource = (state, resourceId) => {
+    const { [resourceId]: _, ...remainingResources } = state.resources;
+    return {
+        ...state,
+        resources: remainingResources,
+    };
+};
+exports.removeResource = removeResource;
+const getAllResources = (state) => {
+    return state.resources;
+};
+exports.getAllResources = getAllResources;
+/**
+ * Extract role ARN from function state for event resources.
+ * Looks through all function resources to find a RAM role instance and returns its ARN.
+ */
+const getRoleArnFromState = (state) => {
+    const allResources = (0, exports.getAllResources)(state);
+    for (const [logicalId, resourceState] of Object.entries(allResources)) {
+        if (logicalId.startsWith('functions.')) {
+            const ramRoleInstance = resourceState.instances?.find((i) => i.type === 'ALIYUN_RAM_ROLE');
+            if (ramRoleInstance?.arn) {
+                return ramRoleInstance.arn;
+            }
+        }
+    }
+    return undefined;
+};
+exports.getRoleArnFromState = getRoleArnFromState;