@volcengine/tls-observer-trae-install 0.0.2

package/dist/index.js

@@ -0,0 +1,749 @@
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { homedir, tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+import promises from "node:readline/promises";
+import { randomInt } from "node:crypto";
+import * as __rspack_external_node_fs_promises_153e37e0 from "node:fs/promises";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+const execFileAsync = promisify(execFile);
+const PLUGIN_NAME = 'tls-observer-trae';
+const PLUGIN_PACKAGE_NAME = '@volcengine/tls-observer-trae';
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+const DEFAULT_TRAE_ROOT = __rspack_external_node_path_c5b9b54f.join(homedir(), '.trae-cn');
+const DEFAULT_PLUGIN_TARGET = __rspack_external_node_path_c5b9b54f.join(DEFAULT_TRAE_ROOT, 'plugins', PLUGIN_NAME);
+const DEFAULT_ENV_TARGET = __rspack_external_node_path_c5b9b54f.join(DEFAULT_TRAE_ROOT, 'tls-observer-trae.env');
+const DEFAULT_DATA_ROOT = __rspack_external_node_path_c5b9b54f.join(DEFAULT_TRAE_ROOT, 'plugins', 'data', PLUGIN_NAME);
+const DEFAULT_HOOK_CONFIG_TARGET = __rspack_external_node_path_c5b9b54f.join(DEFAULT_TRAE_ROOT, 'hooks.json');
+const DEFAULT_REGION = 'cn-beijing';
+const DEFAULT_TLS_ENDPOINT = 'tls-cn-beijing.volces.com';
+const DEFAULT_PROJECT_NAME = 'trae_observability';
+const DEFAULT_APP_NAME_PREFIX = 'trae-observability';
+const DEFAULT_LOG_APP_TYPE = 'Trae';
+const DEFAULT_TEMPLATE_NAME = 'Trae';
+function readEnvString(key) {
+    const value = process.env[key];
+    return 'string' == typeof value && value.trim() ? value.trim() : void 0;
+}
+function readEnvBool(key) {
+    const value = readEnvString(key);
+    return value ? /^(1|true|yes|y|on)$/i.test(value) : false;
+}
+function takeArg(argv, index, flag) {
+    const value = argv[index + 1];
+    if ('string' != typeof value || value.startsWith('--')) throw new Error(`${flag} requires a value`);
+    return value;
+}
+function defaultTlsEndpointForRegion(region) {
+    return region ? `tls-${region}.volces.com` : DEFAULT_TLS_ENDPOINT;
+}
+function randomSuffix() {
+    const alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
+    let value = '';
+    for(let index = 0; index < 8; index += 1)value += alphabet[randomInt(alphabet.length)];
+    return value;
+}
+function defaultAppName() {
+    return `${DEFAULT_APP_NAME_PREFIX}_${randomSuffix()}`;
+}
+function applyDerivedDefaults(options) {
+    if (options.region && !options.tlsEndpoint && !options.otelEndpoint) options.tlsEndpoint = defaultTlsEndpointForRegion(options.region);
+    if (!options.projectName && !options.projectId) options.projectName = DEFAULT_PROJECT_NAME;
+    if (!options.logAppName) options.logAppName = defaultAppName();
+}
+function parseCliOptions(argv = process.argv.slice(2)) {
+    const options = {
+        help: false,
+        nonInteractive: readEnvBool('TRAE_TLS_INSTALL_NON_INTERACTIVE'),
+        force: readEnvBool('TRAE_TLS_INSTALL_FORCE'),
+        beta: readEnvBool('TRAE_TLS_INSTALL_BETA'),
+        skipTlsConfig: readEnvBool('TRAE_TLS_INSTALL_SKIP_TLS_CONFIG'),
+        healthCheck: readEnvBool('TRAE_TLS_INSTALL_HEALTH_CHECK'),
+        registry: readEnvString('TRAE_TLS_NPM_REGISTRY') || readEnvString('npm_config_registry') || readEnvString('NPM_CONFIG_REGISTRY') || DEFAULT_REGISTRY,
+        pluginPackage: readEnvString('TRAE_TLS_PLUGIN_PACKAGE') || PLUGIN_PACKAGE_NAME,
+        pluginVersion: readEnvString('TRAE_TLS_PLUGIN_VERSION'),
+        pluginTarget: readEnvString('TRAE_PLUGIN_TARGET') || DEFAULT_PLUGIN_TARGET,
+        envTarget: readEnvString('TRAE_TLS_ENV_TARGET') || DEFAULT_ENV_TARGET,
+        dataRoot: readEnvString('TRAE_TLS_DATA_ROOT') || DEFAULT_DATA_ROOT,
+        hookConfigTarget: readEnvString('TRAE_HOOK_CONFIG_TARGET') || DEFAULT_HOOK_CONFIG_TARGET,
+        region: readEnvString('TRAE_TLS_REGION') || DEFAULT_REGION,
+        tlsEndpoint: readEnvString('TRAE_TLS_ENDPOINT'),
+        otelEndpoint: readEnvString('TRAE_TLS_OTEL_ENDPOINT'),
+        traceTopicId: readEnvString('TRAE_TLS_TRACE_TOPIC_ID'),
+        apiKey: readEnvString('TRAE_TLS_API_KEY'),
+        ak: readEnvString('TRAE_TLS_AK'),
+        sk: readEnvString('TRAE_TLS_SK'),
+        authMode: readEnvString('TRAE_TLS_AUTH_MODE') || 'header',
+        exportTimeoutMs: readEnvString('TRAE_TLS_EXPORT_TIMEOUT_MS') || '20000',
+        exportTimeoutRetries: readEnvString('TRAE_TLS_EXPORT_TIMEOUT_RETRIES') || '1',
+        captureContent: readEnvString('TRAE_TLS_CAPTURE_CONTENT') || '1',
+        projectId: readEnvString('TRAE_TLS_PROJECT_ID'),
+        projectName: readEnvString('TRAE_TLS_PROJECT_NAME'),
+        logAppId: readEnvString('TRAE_TLS_LOG_APP_ID'),
+        logAppName: readEnvString('TRAE_TLS_LOG_APP_NAME'),
+        logAppType: readEnvString('TRAE_TLS_LOG_APP_TYPE') || DEFAULT_LOG_APP_TYPE,
+        templateName: readEnvString('TRAE_TLS_TEMPLATE_NAME') || DEFAULT_TEMPLATE_NAME,
+        templateId: readEnvString('TRAE_TLS_TEMPLATE_ID')
+    };
+    for(let index = 0; index < argv.length; index += 1){
+        const current = argv[index];
+        if ('--help' === current || '-h' === current) options.help = true;
+        else if ('--non-interactive' === current) options.nonInteractive = true;
+        else if ('--force' === current) options.force = true;
+        else if ('--beta' === current) options.beta = true;
+        else if ('--skip-tls-config' === current) options.skipTlsConfig = true;
+        else if ('--health-check' === current) options.healthCheck = true;
+        else if ('--registry' === current) options.registry = takeArg(argv, index++, current);
+        else if ('--plugin-package' === current) options.pluginPackage = takeArg(argv, index++, current);
+        else if ('--plugin-version' === current) options.pluginVersion = takeArg(argv, index++, current);
+        else if ('--plugin-target' === current) options.pluginTarget = takeArg(argv, index++, current);
+        else if ('--env-target' === current) options.envTarget = takeArg(argv, index++, current);
+        else if ('--data-root' === current) options.dataRoot = takeArg(argv, index++, current);
+        else if ('--hook-config-target' === current) options.hookConfigTarget = takeArg(argv, index++, current);
+        else if ('--region' === current) options.region = takeArg(argv, index++, current);
+        else if ('--tls-endpoint' === current) options.tlsEndpoint = takeArg(argv, index++, current);
+        else if ('--otel-endpoint' === current) options.otelEndpoint = takeArg(argv, index++, current);
+        else if ('--trace-topic-id' === current) options.traceTopicId = takeArg(argv, index++, current);
+        else if ('--api-key' === current) options.apiKey = takeArg(argv, index++, current);
+        else if ('--ak' === current) options.ak = takeArg(argv, index++, current);
+        else if ('--sk' === current) options.sk = takeArg(argv, index++, current);
+        else if ('--auth-mode' === current) options.authMode = takeArg(argv, index++, current);
+        else if ('--export-timeout-ms' === current) options.exportTimeoutMs = takeArg(argv, index++, current);
+        else if ('--export-timeout-retries' === current) options.exportTimeoutRetries = takeArg(argv, index++, current);
+        else if ('--capture-content' === current) options.captureContent = takeArg(argv, index++, current);
+        else if ('--project-id' === current) options.projectId = takeArg(argv, index++, current);
+        else if ('--project-name' === current) options.projectName = takeArg(argv, index++, current);
+        else if ('--app-name' === current || '--log-app-name' === current) options.logAppName = takeArg(argv, index++, current);
+        else if ('--log-app-id' === current) options.logAppId = takeArg(argv, index++, current);
+        else if ('--log-app-type' === current) options.logAppType = takeArg(argv, index++, current);
+        else if ('--template-name' === current) options.templateName = takeArg(argv, index++, current);
+        else if ('--template-id' === current) options.templateId = takeArg(argv, index++, current);
+        else throw new Error(`Unknown option: ${current}`);
+    }
+    return options;
+}
+function printHelp() {
+    console.log(`TLS Observer Trae installer
+
+Usage:
+  tls-observer-trae-install [options]
+  npm exec -y --package=@volcengine/tls-observer-trae-install -- tls-observer-trae-install [options]
+
+Options:
+  --non-interactive              Read required inputs from flags/env
+  --force                        Overwrite existing runtime/env files
+  --beta                         Install @volcengine/tls-observer-trae@beta instead of @latest
+  --skip-tls-config              Install runtime without writing TLS env
+  --health-check                 Check ctx-cli/CFS environment after install
+  --registry <url>               NPM registry. Default: https://registry.npmjs.org
+  --plugin-version <version>     Exact runtime version or dist-tag. Overrides --beta
+  --plugin-target <path>         Default: ~/.trae-cn/plugins/tls-observer-trae
+  --env-target <path>            Default: ~/.trae-cn/tls-observer-trae.env
+  --data-root <path>             Default: ~/.trae-cn/plugins/data/tls-observer-trae
+  --hook-config-target <path>    Default: ~/.trae-cn/hooks.json
+  --region <region>              TLS region. Default: cn-beijing
+  --tls-endpoint <host>          TLS Producer endpoint. Derived from region by default
+  --trace-topic-id <id>          TLS trace topic ID
+  --api-key <value>              TLS API Key
+  --ak <value>                   TLS Access Key
+  --sk <value>                   TLS Secret Key
+  --project-name <name>          TLS Project name for AK/SK auto creation
+  --app-name <name>              TLS LogApp name for AK/SK auto creation
+  --capture-content <0|1>        Default: 1
+`);
+}
+function createReadline() {
+    return promises.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false
+    });
+}
+async function promptText(rl, message, defaultValue = '') {
+    const suffix = defaultValue ? `\n    default: ${defaultValue}\n> ` : '\n> ';
+    const answer = await rl.question(`${message}${suffix}`);
+    return answer.trim() || defaultValue;
+}
+async function promptRequired(rl, message, defaultValue = '') {
+    while(true){
+        const value = await promptText(rl, message, defaultValue);
+        if (value.trim()) return value.trim();
+        console.log('This value is required.');
+    }
+}
+function setTerminalEcho(enabled) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+    try {
+        execFileSync('stty', [
+            enabled ? 'echo' : '-echo'
+        ], {
+            stdio: [
+                'inherit',
+                'ignore',
+                'ignore'
+            ]
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function promptSecret(rl, message, defaultValue = '') {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) return promptRequired(rl, message, defaultValue);
+    rl.pause();
+    return new Promise((resolve, reject)=>{
+        const input = process.stdin;
+        let value = '';
+        let finished = false;
+        const previousRawMode = input.isRaw;
+        let echoDisabled = false;
+        const suffix = defaultValue ? '\n    default: already set, press enter to keep\n> ' : '\n> ';
+        function cleanup() {
+            input.off('data', onData);
+            input.setRawMode(Boolean(previousRawMode));
+            if (echoDisabled) setTerminalEcho(true);
+            input.pause();
+            rl.resume();
+        }
+        function finish() {
+            if (finished) return;
+            finished = true;
+            cleanup();
+            process.stdout.write('\n');
+            const resolvedValue = value.trim() || defaultValue;
+            if (resolvedValue) resolve(resolvedValue);
+            else {
+                console.log('This value is required.');
+                resolve(promptSecret(rl, message, defaultValue));
+            }
+        }
+        function onData(buffer) {
+            for (const char of buffer.toString('utf8')){
+                if (finished) return;
+                if ('\u0003' === char) {
+                    finished = true;
+                    cleanup();
+                    reject(new Error('Interrupted'));
+                    return;
+                }
+                if ('\r' === char || '\n' === char) return void finish();
+                if ('\u007f' === char || '\b' === char) {
+                    if (value.length > 0) {
+                        value = [
+                            ...value
+                        ].slice(0, -1).join('');
+                        process.stdout.write('\b \b');
+                    }
+                    continue;
+                }
+                value += char;
+                process.stdout.write('*');
+            }
+        }
+        input.resume();
+        input.setRawMode(true);
+        input.on('data', onData);
+        echoDisabled = setTerminalEcho(false);
+        process.stdout.write(`${message}${suffix}`);
+    });
+}
+function detectAuthType(options) {
+    if (options.apiKey) return 'apiKey';
+    if (options.ak || options.sk) return 'aksk';
+}
+function validateBaseTlsConfig(options) {
+    const missing = [];
+    if (!options.region) missing.push('--region or TRAE_TLS_REGION');
+    const authType = detectAuthType(options);
+    if (!authType) missing.push('--api-key or --ak/--sk');
+    if ('apiKey' === authType && (options.ak || options.sk)) throw new Error('API Key and AK/SK cannot be used together');
+    if ('aksk' === authType && (!options.ak || !options.sk)) missing.push('--ak and --sk');
+    if (missing.length > 0) throw new Error(`Missing required TLS config: ${missing.join(', ')}`);
+}
+function validateTlsConfig(options) {
+    validateBaseTlsConfig(options);
+    const missing = [];
+    if (!options.tlsEndpoint && !options.otelEndpoint) missing.push('--tls-endpoint or --region');
+    if (!options.traceTopicId) missing.push('--trace-topic-id or TRAE_TLS_TRACE_TOPIC_ID');
+    if (missing.length > 0) throw new Error(`Missing required TLS config: ${missing.join(', ')}`);
+}
+async function collectInteractiveOptions(options) {
+    if (options.nonInteractive) {
+        if (!options.skipTlsConfig) {
+            applyDerivedDefaults(options);
+            validateBaseTlsConfig(options);
+        }
+        return options;
+    }
+    const rl = createReadline();
+    try {
+        console.log('TLS Observer Trae installer');
+        options.force = true;
+        if (!options.skipTlsConfig) {
+            options.region = await promptRequired(rl, 'TLS region', options.region || DEFAULT_REGION);
+            applyDerivedDefaults(options);
+            const authType = await promptRequired(rl, 'Auth type, apiKey or aksk', detectAuthType(options) || 'apiKey');
+            if ('apiKey' === authType) {
+                options.traceTopicId = await promptRequired(rl, 'Trace topic ID', options.traceTopicId || '');
+                options.apiKey = await promptSecret(rl, 'TLS API Key', options.apiKey || '');
+                options.ak = void 0;
+                options.sk = void 0;
+            } else if ('aksk' === authType) {
+                options.projectName = await promptRequired(rl, 'TLS Project name', options.projectName || DEFAULT_PROJECT_NAME);
+                options.logAppName = await promptRequired(rl, 'TLS LogApp name', options.logAppName || defaultAppName());
+                options.ak = await promptSecret(rl, 'TLS AK', options.ak || '');
+                options.sk = await promptSecret(rl, 'TLS SK', options.sk || '');
+                options.apiKey = void 0;
+            } else throw new Error('Auth type must be apiKey or aksk');
+        }
+        return options;
+    } finally{
+        rl.close();
+    }
+}
+function moduleSpecifier(specifier) {
+    if (specifier.startsWith('.') || specifier.startsWith('/') || /^[A-Za-z]:[\\/]/.test(specifier)) return pathToFileURL(__rspack_external_node_path_c5b9b54f.resolve(specifier)).href;
+    return specifier;
+}
+async function loadOpenapiModule() {
+    return import(moduleSpecifier(readEnvString('TRAE_TLS_OPENAPI_MODULE') || '@volcengine/openapi'));
+}
+function createTlsService(options, openapiModule) {
+    if (!openapiModule?.tlsOpenapi?.TlsService) throw new Error('@volcengine/openapi must export tlsOpenapi.TlsService');
+    const isAkSk = !options.apiKey;
+    const tlsService = new openapiModule.tlsOpenapi.TlsService({
+        host: options.tlsEndpoint || defaultTlsEndpointForRegion(options.region),
+        region: options.region,
+        accessKeyId: isAkSk ? options.ak : 'anonymous',
+        secretKey: isAkSk ? options.sk : 'anonymous',
+        protocol: 'https:',
+        version: '0.3.0'
+    });
+    const axiosConfig = options.apiKey ? {
+        proxy: false,
+        headers: {
+            'x-tls-anonymous-identity': options.apiKey
+        }
+    } : {
+        proxy: false
+    };
+    return {
+        isAkSk,
+        DescribeProjects: (payload)=>tlsService.DescribeProjects(payload, axiosConfig),
+        CreateProject: (payload)=>tlsService.CreateProject(payload, axiosConfig),
+        DescribeApps: (payload)=>tlsService.createAPI('DescribeApps', {
+                method: 'GET'
+            })(payload, axiosConfig),
+        CreateApp: (payload)=>tlsService.createAPI('CreateApp', {
+                method: 'POST'
+            })(payload, axiosConfig),
+        DescribeLogApps: (payload)=>tlsService.createAPI('DescribeLogApps', {
+                method: 'GET'
+            })(payload, axiosConfig),
+        DescribeTemplates: (payload)=>tlsService.createAPI('DescribeTemplates', {
+                method: 'GET'
+            })(payload, axiosConfig)
+    };
+}
+async function ensureTemplateId(tlsService, options) {
+    if (options.templateId) return options.templateId;
+    const response = await tlsService.DescribeTemplates({
+        TemplateName: options.templateName,
+        PageNumber: 1,
+        PageSize: 20
+    });
+    const template = response.Templates?.find((item)=>item.TemplateName === options.templateName);
+    const templateId = String(template?.TemplateId || '').trim();
+    if (!templateId) throw new Error(`DescribeTemplates did not return TemplateId for ${options.templateName}. Pass --template-id or --trace-topic-id.`);
+    return templateId;
+}
+async function ensureProjectId(tlsService, options) {
+    if (options.projectId) return options.projectId;
+    const response = await tlsService.DescribeProjects({
+        ProjectName: options.projectName,
+        PageSize: 100,
+        PageNumber: 1
+    });
+    const project = response.Projects?.find((item)=>item.ProjectName === options.projectName);
+    const existingProjectId = String(project?.ProjectId || '').trim();
+    if (existingProjectId) return existingProjectId;
+    const created = await tlsService.CreateProject({
+        ProjectName: options.projectName,
+        Description: 'Trae observability',
+        Region: options.region
+    });
+    const projectId = String(created.ProjectId || '').trim();
+    if (!projectId) throw new Error('CreateProject succeeded but did not return ProjectId');
+    return projectId;
+}
+async function ensureLogApp(tlsService, options, projectId) {
+    if (options.logAppId) return options.logAppId;
+    const appResponse = await tlsService.DescribeApps({
+        AppName: options.logAppName,
+        AppType: 'LogApp'
+    });
+    const total = appResponse.total ?? appResponse.Total ?? 0;
+    if (total > 0) {
+        const app = appResponse.apps?.[0] || appResponse.Apps?.[0];
+        const logAppId = String(app?.Resources?.[0]?.Id || app?.Sources?.[0]?.Id || '').trim();
+        if (logAppId) return logAppId;
+    }
+    const templateId = await ensureTemplateId(tlsService, options);
+    const created = await tlsService.CreateApp({
+        AppName: options.logAppName,
+        AppType: 'LogApp',
+        LogAppReq: {
+            LogAppName: options.logAppName,
+            LogAppType: options.logAppType,
+            ProjectId: projectId
+        },
+        TemplateId: templateId
+    });
+    const logAppId = String(created.Sources?.[0]?.Id || '').trim();
+    if (!logAppId) throw new Error('CreateApp succeeded but did not return Sources[0].Id');
+    return logAppId;
+}
+function topicMapFromLogApps(response) {
+    const topics = response?.LogApps?.[0]?.RelatedResourceList || [];
+    const topicMap = {};
+    for (const topic of topics){
+        const resourceName = String(topic?.ResourceName || '');
+        const topicName = resourceName.split('_').filter(Boolean).at(-1);
+        const resourceId = String(topic?.ResourceID || '').trim();
+        if (topicName && resourceId) topicMap[topicName] = resourceId;
+    }
+    return topicMap;
+}
+async function ensureTlsResources(options) {
+    applyDerivedDefaults(options);
+    if (options.skipTlsConfig || options.apiKey || options.traceTopicId || !options.ak || !options.sk) return {
+        created: false
+    };
+    const openapiModule = await loadOpenapiModule();
+    const tlsService = createTlsService(options, openapiModule);
+    const projectId = await ensureProjectId(tlsService, options);
+    const logAppId = await ensureLogApp(tlsService, options, projectId);
+    options.logAppId = logAppId;
+    const logApps = await tlsService.DescribeLogApps({
+        PageNumber: 1,
+        PageSize: 20,
+        LogAppId: logAppId,
+        LogAppType: options.logAppType
+    });
+    const topics = topicMapFromLogApps(logApps);
+    if (!options.traceTopicId) options.traceTopicId = topics.trace;
+    return {
+        created: true,
+        logAppId,
+        traceTopicId: options.traceTopicId
+    };
+}
+async function pathExists(filePath) {
+    try {
+        await __rspack_external_node_fs_promises_153e37e0.stat(filePath);
+        return true;
+    } catch (error) {
+        if ('ENOENT' === error.code) return false;
+        throw error;
+    }
+}
+async function readJsonFile(filePath, fallback) {
+    try {
+        return JSON.parse(await __rspack_external_node_fs_promises_153e37e0.readFile(filePath, 'utf8'));
+    } catch (error) {
+        if ('ENOENT' === error.code) return fallback;
+        throw error;
+    }
+}
+async function assertPluginRuntime(pluginSource) {
+    const entry = __rspack_external_node_path_c5b9b54f.join(pluginSource, 'dist', 'index.js');
+    const hooks = __rspack_external_node_path_c5b9b54f.join(pluginSource, 'hooks', 'hooks.json');
+    if (await pathExists(entry) && await pathExists(hooks)) return;
+    throw new Error(`Runtime package is missing files: ${pluginSource}. Expected dist/index.js and hooks/hooks.json.`);
+}
+function pluginPackagePath(tempRoot, packageName) {
+    return __rspack_external_node_path_c5b9b54f.join(tempRoot, 'node_modules', ...packageName.split('/'));
+}
+function pluginPackageSpec(options) {
+    const version = options.pluginVersion || (options.beta ? 'beta' : 'latest');
+    return `${options.pluginPackage}@${version}`;
+}
+async function installPluginPackageToTemp(options) {
+    const root = await __rspack_external_node_fs_promises_153e37e0.mkdtemp(__rspack_external_node_path_c5b9b54f.join(tmpdir(), 'tls-observer-trae-plugin-'));
+    const packageSpec = pluginPackageSpec(options);
+    const npm = 'win32' === process.platform ? 'npm.cmd' : 'npm';
+    const args = [
+        'install',
+        '--prefix',
+        root,
+        "--ignore-scripts",
+        '--no-audit',
+        '--no-fund',
+        '--omit=dev',
+        '--registry',
+        options.registry,
+        packageSpec
+    ];
+    await execFileAsync(npm, args, {
+        timeout: 120000
+    });
+    const source = pluginPackagePath(root, options.pluginPackage);
+    await assertPluginRuntime(source);
+    return {
+        root,
+        source,
+        packageSpec
+    };
+}
+async function findLocalPluginSource() {
+    const explicit = readEnvString('TRAE_TLS_PLUGIN_SOURCE');
+    if (!explicit) return;
+    const manifest = await readJsonFile(__rspack_external_node_path_c5b9b54f.join(explicit, 'package.json'), {});
+    const publishDirectory = manifest.publishConfig?.directory;
+    const candidates = publishDirectory ? [
+        __rspack_external_node_path_c5b9b54f.join(explicit, publishDirectory)
+    ] : [
+        explicit
+    ];
+    for (const candidate of candidates)try {
+        await assertPluginRuntime(candidate);
+        return candidate;
+    } catch  {}
+    throw new Error(`TRAE_TLS_PLUGIN_SOURCE does not point to a built runtime package: ${explicit}.`);
+}
+async function readPluginVersion(pluginSource) {
+    const manifest = await readJsonFile(__rspack_external_node_path_c5b9b54f.join(pluginSource, 'package.json'), {});
+    return manifest.version;
+}
+async function installPlugin(options) {
+    if (await pathExists(options.pluginTarget) && !options.force) throw new Error(`Plugin target exists: ${options.pluginTarget}. Re-run with --force.`);
+    const localSource = await findLocalPluginSource();
+    const tempInstall = localSource ? void 0 : await installPluginPackageToTemp(options);
+    const source = localSource || tempInstall.source;
+    await __rspack_external_node_fs_promises_153e37e0.rm(options.pluginTarget, {
+        recursive: true,
+        force: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(options.pluginTarget, {
+        recursive: true
+    });
+    for (const entry of [
+        'dist',
+        'hooks',
+        'README.md',
+        'package.json'
+    ])await __rspack_external_node_fs_promises_153e37e0.cp(__rspack_external_node_path_c5b9b54f.join(source, entry), __rspack_external_node_path_c5b9b54f.join(options.pluginTarget, entry), {
+        recursive: true
+    });
+    const npm = 'win32' === process.platform ? 'npm.cmd' : 'npm';
+    await new Promise((resolve, reject)=>{
+        const child = spawn(npm, [
+            'install',
+            '--omit=dev',
+            "--ignore-scripts",
+            '--no-audit',
+            '--no-fund'
+        ], {
+            cwd: options.pluginTarget,
+            stdio: 'inherit'
+        });
+        const timer = setTimeout(()=>{
+            child.kill();
+            reject(new Error('npm install timed out after 120s'));
+        }, 120000);
+        child.on('exit', (code)=>{
+            clearTimeout(timer);
+            if (0 === code) resolve();
+            else reject(new Error(`npm install exited with code ${code}`));
+        });
+        child.on('error', reject);
+    });
+    if (tempInstall) await __rspack_external_node_fs_promises_153e37e0.rm(tempInstall.root, {
+        recursive: true,
+        force: true
+    });
+    return {
+        source,
+        target: options.pluginTarget,
+        packageSpec: tempInstall?.packageSpec,
+        version: await readPluginVersion(source)
+    };
+}
+function envLine(key, value) {
+    if (null == value || '' === value) return;
+    return `${key}=${String(value)}`;
+}
+function buildTlsEnv(options) {
+    const lines = [
+        '# Generated by tls-observer-trae installer.',
+        '# Keep this file local because it can contain credentials.',
+        envLine('TRAE_TLS_REGION', options.region),
+        envLine('TRAE_TLS_ENDPOINT', options.tlsEndpoint),
+        envLine('TRAE_TLS_OTEL_ENDPOINT', options.otelEndpoint),
+        envLine('TRAE_TLS_TRACE_TOPIC_ID', options.traceTopicId),
+        envLine('TRAE_TLS_API_KEY', options.apiKey),
+        envLine('TRAE_TLS_AK', options.ak),
+        envLine('TRAE_TLS_SK', options.sk),
+        envLine('TRAE_TLS_AUTH_MODE', options.authMode),
+        envLine('TRAE_TLS_EXPORT_TIMEOUT_MS', options.exportTimeoutMs),
+        envLine('TRAE_TLS_EXPORT_TIMEOUT_RETRIES', options.exportTimeoutRetries),
+        envLine('TRAE_TLS_CAPTURE_CONTENT', options.captureContent),
+        envLine('TRAE_TLS_DATA_ROOT', options.dataRoot)
+    ].filter(Boolean);
+    return `${lines.join('\n')}\n`;
+}
+async function writeTlsEnv(options) {
+    if (options.skipTlsConfig) return null;
+    if (await pathExists(options.envTarget) && !options.force) throw new Error(`TLS env target exists: ${options.envTarget}. Re-run with --force.`);
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(options.envTarget), {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(options.envTarget, buildTlsEnv(options), {
+        mode: 384
+    });
+    return options.envTarget;
+}
+async function writeHookReferenceConfig(options) {
+    const shellQuote = (value)=>`'${value.replace(/'/g, "'\\''")}'`;
+    const command = `TRAE_TLS_ENV_FILE=${shellQuote(options.envTarget)} node ${shellQuote(__rspack_external_node_path_c5b9b54f.join(options.pluginTarget, 'dist', 'index.js'))}`;
+    const config = {
+        version: 1,
+        hooks: {
+            UserPromptSubmit: [
+                {
+                    hooks: [
+                        {
+                            type: 'command',
+                            command,
+                            timeout: 30
+                        }
+                    ]
+                }
+            ],
+            PreToolUse: [
+                {
+                    hooks: [
+                        {
+                            type: 'command',
+                            command,
+                            timeout: 30
+                        }
+                    ]
+                }
+            ],
+            PostToolUse: [
+                {
+                    hooks: [
+                        {
+                            type: 'command',
+                            command,
+                            timeout: 30
+                        }
+                    ]
+                }
+            ],
+            Stop: [
+                {
+                    hooks: [
+                        {
+                            type: 'command',
+                            command,
+                            timeout: 30
+                        }
+                    ]
+                }
+            ]
+        }
+    };
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(options.hookConfigTarget), {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(options.hookConfigTarget, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    return options.hookConfigTarget;
+}
+async function writeInstallState(options, plugin) {
+    const target = __rspack_external_node_path_c5b9b54f.join(options.dataRoot, 'state', 'install.json');
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(target), {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(target, `${JSON.stringify({
+        installed_at: new Date().toISOString(),
+        plugin_name: PLUGIN_NAME,
+        plugin_target: plugin.target,
+        env_target: options.envTarget,
+        hook_config_target: options.hookConfigTarget
+    }, null, 2)}\n`, 'utf8');
+}
+async function runHealthCheck(options) {
+    const missingCfsEnv = [
+        'CFS_TOKEN',
+        'CFS_IPC_NAME'
+    ].filter((key)=>!process.env[key]?.trim());
+    const result = {
+        ctx_cli_on_path: false,
+        contextfs_ready: 0 === missingCfsEnv.length,
+        contextfs_missing_env: missingCfsEnv,
+        cfs_token_present: Boolean(process.env.CFS_TOKEN),
+        cfs_ipc_name_present: Boolean(process.env.CFS_IPC_NAME),
+        cfs_transport: process.env.CFS_TRANSPORT || 'ipc'
+    };
+    try {
+        await execFileAsync('ctx-cli', [
+            '--help'
+        ], {
+            timeout: 5000,
+            env: {
+                ...process.env,
+                CFS_TRANSPORT: process.env.CFS_TRANSPORT || 'ipc'
+            }
+        });
+        result.ctx_cli_on_path = true;
+    } catch (error) {
+        result.ctx_cli_error = error instanceof Error ? error.message : String(error);
+    }
+    if (!result.contextfs_ready) result.note = 'ctx-cli can only read context:// resources inside Trae hook/toolhost environment with CFS_TOKEN and CFS_IPC_NAME.';
+    const target = __rspack_external_node_path_c5b9b54f.join(options.dataRoot, 'state', 'health-check.json');
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(target), {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(target, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+    return result;
+}
+function printCompletion({ plugin, envTarget, hookConfigTarget, health }) {
+    console.log('');
+    console.log('Install complete');
+    console.log(`  Runtime: ${plugin.target}`);
+    if (plugin.packageSpec) console.log(`  Runtime package: ${plugin.packageSpec}`);
+    if (plugin.version) console.log(`  Runtime version: ${plugin.version}`);
+    console.log(`  TLS env: ${envTarget || 'skipped'}`);
+    console.log(`  Hook reference: ${hookConfigTarget}`);
+    if (health) console.log(`  Health check: ${JSON.stringify(health)}`);
+    console.log('');
+    console.log('Next steps:');
+    console.log('  1. Confirm Trae hook/plugin config path for your Trae build.');
+    console.log('  2. Wire the command from the hook reference file.');
+    console.log('  3. Run one Trae turn and check logs/send/latest.send-log.json under the data root.');
+}
+async function run(argv = process.argv.slice(2)) {
+    const parsed = parseCliOptions(argv);
+    if (parsed.help) return void printHelp();
+    const options = await collectInteractiveOptions(parsed);
+    if (!options.skipTlsConfig) {
+        const resourceResult = await ensureTlsResources(options);
+        if (resourceResult.created && !options.traceTopicId) throw new Error('TLS LogApp was created but trace topic discovery failed. Pass --trace-topic-id.');
+        applyDerivedDefaults(options);
+        validateTlsConfig(options);
+    }
+    const plugin = await installPlugin(options);
+    const envTarget = await writeTlsEnv(options);
+    const hookConfigTarget = await writeHookReferenceConfig(options);
+    await writeInstallState(options, plugin);
+    const health = options.healthCheck ? await runHealthCheck(options) : void 0;
+    printCompletion({
+        plugin,
+        envTarget,
+        hookConfigTarget,
+        health
+    });
+}
+export { run };