@volcengine/tls-observer-opencode-install 0.0.3

package/dist/index.js

@@ -0,0 +1,744 @@
+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-opencode';
+const PLUGIN_PACKAGE_NAME = '@volcengine/tls-observer-opencode';
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+const DEFAULT_LEGACY_CONFIG_PATH = __rspack_external_node_path_c5b9b54f.join(homedir(), '.config', 'opencode', 'config.json');
+const DEFAULT_PLUGINS_ROOT = __rspack_external_node_path_c5b9b54f.join(homedir(), '.config', 'opencode', 'plugins');
+const DEFAULT_ENV_TARGET = __rspack_external_node_path_c5b9b54f.join(homedir(), '.config', 'opencode', 'tls-observer-opencode.env');
+const DEFAULT_DATA_ROOT = __rspack_external_node_path_c5b9b54f.join(homedir(), '.config', 'opencode', 'plugins', 'data', PLUGIN_NAME);
+const DEFAULT_REGION = 'cn-beijing';
+const DEFAULT_PROJECT_NAME = 'opencode_observability';
+const DEFAULT_APP_NAME_PREFIX = 'opencode-observability';
+const DEFAULT_TLS_ENDPOINT = 'tls-cn-beijing.volces.com';
+const DEFAULT_LOG_APP_TYPE = 'OpenCode';
+const DEFAULT_TEMPLATE_NAME = 'OpenCode';
+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) {
+        if (!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 pluginsRoot = readEnvString('OPENCODE_PLUGINS_ROOT') || readEnvString('OPENCODE_SKILLS_ROOT') || DEFAULT_PLUGINS_ROOT;
+    const options = {
+        help: false,
+        nonInteractive: readEnvBool('OPENCODE_TLS_INSTALL_NON_INTERACTIVE'),
+        force: readEnvBool('OPENCODE_TLS_INSTALL_FORCE'),
+        beta: readEnvBool('OPENCODE_TLS_INSTALL_BETA'),
+        skipTlsConfig: readEnvBool('OPENCODE_TLS_INSTALL_SKIP_TLS_CONFIG'),
+        advancedPaths: readEnvBool('OPENCODE_TLS_INSTALL_ADVANCED_PATHS'),
+        registry: readEnvString('OPENCODE_TLS_NPM_REGISTRY') || readEnvString('npm_config_registry') || readEnvString('NPM_CONFIG_REGISTRY') || DEFAULT_REGISTRY,
+        pluginPackage: readEnvString('OPENCODE_TLS_PLUGIN_PACKAGE') || PLUGIN_PACKAGE_NAME,
+        pluginVersion: readEnvString('OPENCODE_TLS_PLUGIN_VERSION'),
+        legacyConfigPath: readEnvString('OPENCODE_SETTINGS_PATH') || DEFAULT_LEGACY_CONFIG_PATH,
+        pluginsRoot,
+        pluginTarget: readEnvString('OPENCODE_PLUGIN_TARGET') || __rspack_external_node_path_c5b9b54f.join(pluginsRoot, PLUGIN_NAME),
+        pluginEntryTarget: readEnvString('OPENCODE_PLUGIN_ENTRY_TARGET') || __rspack_external_node_path_c5b9b54f.join(pluginsRoot, `${PLUGIN_NAME}.js`),
+        envTarget: readEnvString('OPENCODE_TLS_ENV_TARGET') || DEFAULT_ENV_TARGET,
+        dataRoot: readEnvString('OPENCODE_TLS_DATA_ROOT') || DEFAULT_DATA_ROOT,
+        region: readEnvString('OPENCODE_TLS_REGION') || DEFAULT_REGION,
+        otelEndpoint: readEnvString('OPENCODE_TLS_OTEL_ENDPOINT'),
+        traceTopicId: readEnvString('OPENCODE_TLS_TRACE_TOPIC_ID'),
+        apiKey: readEnvString('OPENCODE_TLS_API_KEY'),
+        ak: readEnvString('OPENCODE_TLS_AK'),
+        sk: readEnvString('OPENCODE_TLS_SK'),
+        authMode: readEnvString('OPENCODE_TLS_AUTH_MODE') || 'header',
+        exportTimeoutMs: readEnvString('OPENCODE_TLS_EXPORT_TIMEOUT_MS') || '20000',
+        exportTimeoutRetries: readEnvString('OPENCODE_TLS_EXPORT_TIMEOUT_RETRIES') || '1',
+        captureContent: readEnvString('OPENCODE_TLS_CAPTURE_CONTENT') || '1',
+        tlsEndpoint: readEnvString('OPENCODE_TLS_ENDPOINT'),
+        projectId: readEnvString('OPENCODE_TLS_PROJECT_ID'),
+        projectName: readEnvString('OPENCODE_TLS_PROJECT_NAME'),
+        logAppId: readEnvString('OPENCODE_TLS_LOG_APP_ID'),
+        logAppName: readEnvString('OPENCODE_TLS_LOG_APP_NAME'),
+        logAppType: readEnvString('OPENCODE_TLS_LOG_APP_TYPE') || DEFAULT_LOG_APP_TYPE,
+        templateName: readEnvString('OPENCODE_TLS_TEMPLATE_NAME') || DEFAULT_TEMPLATE_NAME,
+        templateId: readEnvString('OPENCODE_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 ('--advanced-paths' === current) options.advancedPaths = 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 ('--settings-path' === current) options.legacyConfigPath = takeArg(argv, index++, current);
+        else if ('--plugins-root' === current || '--skills-root' === current) {
+            options.pluginsRoot = takeArg(argv, index++, current);
+            options.pluginTarget = __rspack_external_node_path_c5b9b54f.join(options.pluginsRoot, PLUGIN_NAME);
+            options.pluginEntryTarget = __rspack_external_node_path_c5b9b54f.join(options.pluginsRoot, `${PLUGIN_NAME}.js`);
+        } else if ('--plugin-target' === current) options.pluginTarget = takeArg(argv, index++, current);
+        else if ('--plugin-entry-target' === current) options.pluginEntryTarget = 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 ('--region' === current) options.region = 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 ('--tls-endpoint' === current) options.tlsEndpoint = 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 OpenCode installer
+
+Usage:
+  tls-observer-opencode-install [options]
+  npm exec -y --package=@volcengine/tls-observer-opencode-install -- tls-observer-opencode-install [options]
+
+Options:
+  --non-interactive              Read required inputs from flags/env
+  --force                        Overwrite existing plugin/env files
+  --beta                         Install @volcengine/tls-observer-opencode@beta instead of @latest
+  --skip-tls-config              Install plugin without writing TLS env
+  --advanced-paths               Prompt for OpenCode path overrides
+  --registry <url>               NPM registry for plugin package. Default: https://registry.npmjs.org
+  --plugin-version <version>     Exact plugin version or dist-tag. Overrides --beta
+  --region <region>              TLS region. Default: cn-beijing
+  --tls-endpoint <host>          TLS Producer endpoint. Derived from region by default
+  --otel-endpoint <url>          Deprecated legacy endpoint alias
+  --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
+  --plugins-root <path>          Default: ~/.config/opencode/plugins
+  --plugin-target <path>         Default: ~/.config/opencode/plugins/tls-observer-opencode
+  --plugin-entry-target <path>   Default: ~/.config/opencode/plugins/tls-observer-opencode.js
+  --env-target <path>            Default: ~/.config/opencode/tls-observer-opencode.env
+`);
+}
+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: 已设置，回车保留\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 OPENCODE_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, --region, or legacy --otel-endpoint');
+    if (!options.traceTopicId) missing.push('--trace-topic-id or OPENCODE_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 OpenCode installer');
+        if (options.advancedPaths) {
+            options.pluginsRoot = await promptRequired(rl, 'OpenCode plugins root', options.pluginsRoot);
+            options.pluginTarget = await promptRequired(rl, 'OpenCode plugin target', options.pluginTarget);
+            options.pluginEntryTarget = await promptRequired(rl, 'OpenCode plugin entry file', options.pluginEntryTarget);
+            options.envTarget = await promptRequired(rl, 'TLS env output path', options.envTarget);
+            options.dataRoot = await promptRequired(rl, 'Plugin data root', options.dataRoot);
+        }
+        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('OPENCODE_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: 'OpenCode 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 assertPluginRuntime(pluginSource) {
+    const entry = __rspack_external_node_path_c5b9b54f.join(pluginSource, 'dist', 'index.js');
+    const manifest = __rspack_external_node_path_c5b9b54f.join(pluginSource, 'package.json');
+    if (await pathExists(manifest) && await pathExists(entry)) return;
+    throw new Error(`Plugin package is missing runtime files: ${pluginSource}. Expected dist/index.js and package.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-opencode-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
+    ];
+    try {
+        await execFileAsync(npm, args, {
+            timeout: 120000
+        });
+    } catch (error) {
+        const detail = error && 'object' == typeof error && 'stderr' in error ? String(error.stderr || '') : error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to install plugin package ${packageSpec} from ${options.registry}: ${detail}`);
+    }
+    const source = pluginPackagePath(root, options.pluginPackage);
+    await assertPluginRuntime(source);
+    return {
+        root,
+        source,
+        packageSpec
+    };
+}
+async function findLocalPluginSource() {
+    const explicit = readEnvString('OPENCODE_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(`OPENCODE_PLUGIN_SOURCE does not point to a built runtime package: ${explicit}. Run the plugin build first.`);
+}
+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(__rspack_external_node_path_c5b9b54f.dirname(options.pluginTarget), {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(options.pluginTarget, {
+        recursive: true
+    });
+    const runtimeEntries = [
+        'dist',
+        'README.md',
+        'package.json'
+    ];
+    try {
+        for (const entry of runtimeEntries)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';
+        console.log('插件依赖安装中，请稍后...');
+        try {
+            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);
+            });
+        } catch (error) {
+            const detail = error && 'object' == typeof error && 'stderr' in error ? String(error.stderr || '') : error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to install plugin dependencies at ${options.pluginTarget}: ${detail}`);
+        }
+        return {
+            source,
+            target: options.pluginTarget,
+            packageSpec: tempInstall?.packageSpec,
+            version: await readPluginVersion(source)
+        };
+    } finally{
+        if (tempInstall) await __rspack_external_node_fs_promises_153e37e0.rm(tempInstall.root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+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 writeJsonFile(filePath, value, mode) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+    if (mode) await __rspack_external_node_fs_promises_153e37e0.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, {
+        mode
+    });
+    else await __rspack_external_node_fs_promises_153e37e0.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+async function writePluginEntry(options) {
+    if (await pathExists(options.pluginEntryTarget) && !options.force) throw new Error(`Plugin entry target exists: ${options.pluginEntryTarget}. Re-run with --force.`);
+    const runtimePath = __rspack_external_node_path_c5b9b54f.join(options.pluginTarget, 'dist', 'index.js');
+    const runtimeSpecifier = toRelativeImportSpecifier(__rspack_external_node_path_c5b9b54f.dirname(options.pluginEntryTarget), runtimePath);
+    const contents = [
+        '// Generated by tls-observer-opencode installer.',
+        `import plugin from ${JSON.stringify(runtimeSpecifier)};`,
+        '',
+        'export const TlsObserverOpenCodePlugin = plugin;',
+        'export default plugin;',
+        ''
+    ].join('\n');
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(options.pluginEntryTarget), {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(options.pluginEntryTarget, contents, 'utf8');
+    return options.pluginEntryTarget;
+}
+function toRelativeImportSpecifier(fromDir, targetPath) {
+    const relativePath = __rspack_external_node_path_c5b9b54f.relative(fromDir, targetPath).split(__rspack_external_node_path_c5b9b54f.sep).join('/');
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+async function cleanupLegacyConfig(options) {
+    if (!options.legacyConfigPath || !await pathExists(options.legacyConfigPath)) return;
+    const config = await readJsonFile(options.legacyConfigPath, {});
+    if (!config || 'object' != typeof config || Array.isArray(config)) return;
+    let changed = false;
+    if ('plugins' in config) {
+        delete config.plugins;
+        changed = true;
+    }
+    if ('env' in config) {
+        delete config.env;
+        changed = true;
+    }
+    if (!changed) return;
+    await writeJsonFile(options.legacyConfigPath, config);
+    return options.legacyConfigPath;
+}
+function envLine(key, value) {
+    if (null == value || '' === value) return;
+    return `${key}=${String(value)}`;
+}
+function buildTlsEnv(options) {
+    const lines = [
+        '# Generated by tls-observer-opencode installer.',
+        '# Keep this file local because it can contain credentials.',
+        envLine('OPENCODE_TLS_REGION', options.region),
+        envLine('OPENCODE_TLS_ENDPOINT', options.tlsEndpoint),
+        envLine('OPENCODE_TLS_OTEL_ENDPOINT', options.otelEndpoint),
+        envLine('OPENCODE_TLS_TRACE_TOPIC_ID', options.traceTopicId),
+        envLine('OPENCODE_TLS_API_KEY', options.apiKey),
+        envLine('OPENCODE_TLS_AK', options.ak),
+        envLine('OPENCODE_TLS_SK', options.sk),
+        envLine('OPENCODE_TLS_AUTH_MODE', options.authMode),
+        envLine('OPENCODE_TLS_EXPORT_TIMEOUT_MS', options.exportTimeoutMs),
+        envLine('OPENCODE_TLS_EXPORT_TIMEOUT_RETRIES', options.exportTimeoutRetries),
+        envLine('OPENCODE_TLS_CAPTURE_CONTENT', options.captureContent),
+        envLine('OPENCODE_TLS_DATA_ROOT', options.dataRoot)
+    ].filter(Boolean);
+    return `${lines.join('\n')}\n`;
+}
+async function writeTlsEnv(options) {
+    if (options.skipTlsConfig) return null;
+    const envTargetExists = await pathExists(options.envTarget);
+    if (envTargetExists && !options.force) throw new Error(`TLS env target exists: ${options.envTarget}. Re-run with --force.`);
+    await writeJsonFile(__rspack_external_node_path_c5b9b54f.join(options.dataRoot, 'state', 'install.json'), {
+        installed_at: new Date().toISOString(),
+        plugin_id: PLUGIN_PACKAGE_NAME,
+        plugin_target: options.pluginTarget,
+        plugin_entry_target: options.pluginEntryTarget
+    });
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(options.envTarget), {
+        recursive: true
+    });
+    if (envTargetExists) {
+        await __rspack_external_node_fs_promises_153e37e0.chmod(options.envTarget, 384).catch(()=>void 0);
+        await __rspack_external_node_fs_promises_153e37e0.rm(options.envTarget, {
+            force: true
+        });
+    }
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(options.envTarget, buildTlsEnv(options), {
+        flag: 'wx',
+        mode: 384
+    });
+    await __rspack_external_node_fs_promises_153e37e0.chmod(options.envTarget, 384);
+    return options.envTarget;
+}
+function printCompletion({ plugin, pluginEntryTarget, envTarget, cleanedConfigTarget }) {
+    console.log('');
+    console.log('Install complete');
+    console.log(`  Plugin: ${plugin.target}`);
+    if (plugin.packageSpec) console.log(`  Plugin package: ${plugin.packageSpec}`);
+    if (plugin.version) console.log(`  Plugin version: ${plugin.version}`);
+    console.log(`  Plugin entry: ${pluginEntryTarget}`);
+    console.log(`  TLS env: ${envTarget || 'skipped'}`);
+    if (cleanedConfigTarget) console.log(`  Cleaned legacy config: ${cleanedConfigTarget}`);
+    console.log('');
+    console.log('数据访问说明');
+    console.log('安装后，插件会读取会话文件');
+    console.log('会话文件中的用户请求、模型回复、工具调用记录和 token 用量会整理成诊断数据，上传到你配置的火山引擎 TLS');
+    console.log('如配置 API Key 或 AK/SK，凭据只写入本机 env 文件，用于上传鉴权');
+    console.log('');
+    console.log('Next steps:');
+    console.log('  1. Restart OpenCode environment.');
+    console.log('  2. Run one OpenCode turn.');
+    console.log('  3. Check TLS Trace Topic for agent.turn.');
+}
+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 pluginEntryTarget = await writePluginEntry(options);
+    const envTarget = await writeTlsEnv(options);
+    const cleanedConfigTarget = await cleanupLegacyConfig(options);
+    printCompletion({
+        plugin,
+        pluginEntryTarget,
+        envTarget,
+        cleanedConfigTarget
+    });
+}
+export { run };