@volcengine/tls-observer-claude-code-install 0.0.1

package/dist/index.js

@@ -0,0 +1,627 @@
+import { execFile, 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-claude-code';
+const PLUGIN_PACKAGE_NAME = '@volcengine/tls-observer-claude-code';
+const PLUGIN_ID = `${PLUGIN_NAME}@skills-dir`;
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+const DEFAULT_SETTINGS_PATH = __rspack_external_node_path_c5b9b54f.join(homedir(), '.claude', 'settings.json');
+const DEFAULT_SKILLS_ROOT = __rspack_external_node_path_c5b9b54f.join(homedir(), '.claude', 'skills');
+const DEFAULT_ENV_TARGET = __rspack_external_node_path_c5b9b54f.join(homedir(), '.claude', 'tls-observer-claude-code.env');
+const DEFAULT_DATA_ROOT = __rspack_external_node_path_c5b9b54f.join(homedir(), '.claude', 'plugins', 'data', PLUGIN_NAME);
+const DEFAULT_REGION = 'cn-guilin-boe';
+const DEFAULT_PROJECT_NAME = 'claude_code_observability';
+const DEFAULT_APP_NAME_PREFIX = 'claude-code-observability';
+const DEFAULT_TLS_ENDPOINT = 'tls-cn-guilin-boe.volces.com';
+const DEFAULT_LOG_APP_TYPE = 'Claude';
+const DEFAULT_TEMPLATE_NAME = 'Claude';
+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 normalizeEndpointHost(endpoint) {
+    return String(endpoint || '').trim().replace(/^https?:\/\//i, '').replace(/\/.*$/, '').replace(/:\d+$/, '');
+}
+function defaultOtelEndpointForRegion(region, tlsEndpoint) {
+    return `https://${normalizeEndpointHost(tlsEndpoint) || defaultTlsEndpointForRegion(region)}:4318/v1/traces`;
+}
+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.tlsEndpoint = defaultTlsEndpointForRegion(options.region);
+        if (!options.otelEndpoint) options.otelEndpoint = defaultOtelEndpointForRegion(options.region, options.tlsEndpoint);
+    }
+    if (!options.projectName && !options.projectId) options.projectName = DEFAULT_PROJECT_NAME;
+    if (!options.logAppName) options.logAppName = defaultAppName();
+}
+function parseCliOptions(argv = process.argv.slice(2)) {
+    const skillsRoot = readEnvString('CLAUDE_CODE_SKILLS_ROOT') || DEFAULT_SKILLS_ROOT;
+    const options = {
+        help: false,
+        nonInteractive: readEnvBool('CLAUDE_CODE_TLS_INSTALL_NON_INTERACTIVE'),
+        force: readEnvBool('CLAUDE_CODE_TLS_INSTALL_FORCE'),
+        beta: readEnvBool('CLAUDE_CODE_TLS_INSTALL_BETA'),
+        skipTlsConfig: readEnvBool('CLAUDE_CODE_TLS_INSTALL_SKIP_TLS_CONFIG'),
+        advancedPaths: readEnvBool('CLAUDE_CODE_TLS_INSTALL_ADVANCED_PATHS'),
+        registry: readEnvString('CLAUDE_CODE_TLS_NPM_REGISTRY') || readEnvString('npm_config_registry') || readEnvString('NPM_CONFIG_REGISTRY') || DEFAULT_REGISTRY,
+        pluginPackage: readEnvString('CLAUDE_CODE_TLS_PLUGIN_PACKAGE') || PLUGIN_PACKAGE_NAME,
+        pluginVersion: readEnvString('CLAUDE_CODE_TLS_PLUGIN_VERSION'),
+        settingsPath: readEnvString('CLAUDE_CODE_SETTINGS_PATH') || DEFAULT_SETTINGS_PATH,
+        skillsRoot,
+        pluginTarget: readEnvString('CLAUDE_CODE_PLUGIN_TARGET') || __rspack_external_node_path_c5b9b54f.join(skillsRoot, PLUGIN_NAME),
+        envTarget: readEnvString('CLAUDE_CODE_TLS_ENV_TARGET') || DEFAULT_ENV_TARGET,
+        dataRoot: readEnvString('CLAUDE_CODE_TLS_DATA_ROOT') || DEFAULT_DATA_ROOT,
+        region: readEnvString('CLAUDE_CODE_TLS_REGION'),
+        otelEndpoint: readEnvString('CLAUDE_CODE_TLS_OTEL_ENDPOINT'),
+        traceTopicId: readEnvString('CLAUDE_CODE_TLS_TRACE_TOPIC_ID'),
+        apiKey: readEnvString('CLAUDE_CODE_TLS_API_KEY'),
+        ak: readEnvString('CLAUDE_CODE_TLS_AK'),
+        sk: readEnvString('CLAUDE_CODE_TLS_SK'),
+        authMode: readEnvString('CLAUDE_CODE_TLS_AUTH_MODE') || 'header',
+        exportTimeoutMs: readEnvString('CLAUDE_CODE_TLS_EXPORT_TIMEOUT_MS') || '20000',
+        exportTimeoutRetries: readEnvString('CLAUDE_CODE_TLS_EXPORT_TIMEOUT_RETRIES') || '1',
+        captureContent: readEnvString('CLAUDE_CODE_TLS_CAPTURE_CONTENT') || '1',
+        tlsEndpoint: readEnvString('CLAUDE_CODE_TLS_ENDPOINT'),
+        projectId: readEnvString('CLAUDE_CODE_TLS_PROJECT_ID'),
+        projectName: readEnvString('CLAUDE_CODE_TLS_PROJECT_NAME'),
+        logAppId: readEnvString('CLAUDE_CODE_TLS_LOG_APP_ID'),
+        logAppName: readEnvString('CLAUDE_CODE_TLS_LOG_APP_NAME'),
+        logAppType: readEnvString('CLAUDE_CODE_TLS_LOG_APP_TYPE') || DEFAULT_LOG_APP_TYPE,
+        templateName: readEnvString('CLAUDE_CODE_TLS_TEMPLATE_NAME') || DEFAULT_TEMPLATE_NAME,
+        templateId: readEnvString('CLAUDE_CODE_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.settingsPath = takeArg(argv, index++, current);
+        else if ('--skills-root' === current) {
+            options.skillsRoot = takeArg(argv, index++, current);
+            options.pluginTarget = __rspack_external_node_path_c5b9b54f.join(options.skillsRoot, PLUGIN_NAME);
+        } 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 ('--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 Claude Code installer
+
+Usage:
+  tls-observer-claude-code-install [options]
+  npm exec -y --package=@volcengine/tls-observer-claude-code-install -- tls-observer-claude-code-install [options]
+
+Options:
+  --non-interactive              Read required inputs from flags/env
+  --force                        Overwrite existing plugin/env files
+  --beta                         Install @volcengine/tls-observer-claude-code@beta instead of @latest
+  --skip-tls-config              Install plugin without writing TLS env
+  --advanced-paths               Prompt for Claude 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
+  --otel-endpoint <url>          OTLP traces endpoint
+  --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
+  --settings-path <path>         Default: ~/.claude/settings.json
+  --plugin-target <path>         Default: ~/.claude/skills/tls-observer-claude-code
+  --env-target <path>            Default: ~/.claude/tls-observer-claude-code.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.');
+    }
+}
+async function promptSecret(rl, message, defaultValue = '') {
+    return promptRequired(rl, message, defaultValue);
+}
+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 CLAUDE_CODE_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.otelEndpoint) missing.push('--otel-endpoint or CLAUDE_CODE_TLS_OTEL_ENDPOINT');
+    if (!options.traceTopicId) missing.push('--trace-topic-id or CLAUDE_CODE_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 Claude Code installer');
+        if (options.advancedPaths) {
+            options.settingsPath = await promptRequired(rl, 'Claude settings path', options.settingsPath);
+            options.pluginTarget = await promptRequired(rl, 'Claude plugin target', options.pluginTarget);
+            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.otelEndpoint = await promptRequired(rl, 'OTLP trace endpoint', options.otelEndpoint);
+                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('CLAUDE_CODE_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: 'Claude Code 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 manifest = __rspack_external_node_path_c5b9b54f.join(pluginSource, '.claude-plugin', 'plugin.json');
+    const hooks = __rspack_external_node_path_c5b9b54f.join(pluginSource, 'hooks', 'hooks.json');
+    const entry = __rspack_external_node_path_c5b9b54f.join(pluginSource, 'dist', 'index.js');
+    if (await pathExists(manifest) && await pathExists(hooks) && await pathExists(entry)) return;
+    throw new Error(`Plugin package is missing runtime files: ${pluginSource}. Expected dist/index.js, hooks/hooks.json, and .claude-plugin/plugin.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-claude-code-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('CLAUDE_CODE_PLUGIN_SOURCE');
+    if (!explicit) return;
+    const candidates = [
+        explicit
+    ].filter((candidate)=>Boolean(candidate));
+    for (const candidate of candidates)try {
+        await assertPluginRuntime(candidate);
+        return candidate;
+    } catch  {}
+    throw new Error(`CLAUDE_CODE_PLUGIN_SOURCE does not point to a built plugin: ${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(__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',
+        'hooks',
+        '.claude-plugin',
+        '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',
+                    '--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 writeSettings(options) {
+    const settings = await readJsonFile(options.settingsPath, {});
+    if (!settings.enabledPlugins || 'object' != typeof settings.enabledPlugins || Array.isArray(settings.enabledPlugins)) settings.enabledPlugins = {};
+    if (!settings.env || 'object' != typeof settings.env || Array.isArray(settings.env)) settings.env = {};
+    settings.enabledPlugins[PLUGIN_ID] = true;
+    settings.env.CLAUDE_CODE_TLS_ENV_FILE = options.envTarget;
+    await writeJsonFile(options.settingsPath, settings);
+}
+function envLine(key, value) {
+    if (null == value || '' === value) return;
+    return `${key}=${String(value)}`;
+}
+function buildTlsEnv(options) {
+    const lines = [
+        '# Generated by tls-observer-claude-code installer.',
+        '# Keep this file local because it can contain credentials.',
+        envLine('CLAUDE_CODE_TLS_REGION', options.region),
+        envLine('CLAUDE_CODE_TLS_OTEL_ENDPOINT', options.otelEndpoint),
+        envLine('CLAUDE_CODE_TLS_TRACE_TOPIC_ID', options.traceTopicId),
+        envLine('CLAUDE_CODE_TLS_API_KEY', options.apiKey),
+        envLine('CLAUDE_CODE_TLS_AK', options.ak),
+        envLine('CLAUDE_CODE_TLS_SK', options.sk),
+        envLine('CLAUDE_CODE_TLS_AUTH_MODE', options.authMode),
+        envLine('CLAUDE_CODE_TLS_EXPORT_TIMEOUT_MS', options.exportTimeoutMs),
+        envLine('CLAUDE_CODE_TLS_EXPORT_TIMEOUT_RETRIES', options.exportTimeoutRetries),
+        envLine('CLAUDE_CODE_TLS_CAPTURE_CONTENT', options.captureContent),
+        envLine('CLAUDE_CODE_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 writeJsonFile(__rspack_external_node_path_c5b9b54f.join(options.dataRoot, 'state', 'install.json'), {
+        installed_at: new Date().toISOString(),
+        plugin_id: PLUGIN_ID,
+        plugin_target: options.pluginTarget
+    });
+    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;
+}
+function printCompletion({ plugin, settingsPath, envTarget }) {
+    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(`  Settings: ${settingsPath}`);
+    console.log(`  TLS env: ${envTarget || 'skipped'}`);
+    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 Claude Code or run /reload-plugins.');
+    console.log('  2. Run one Claude Code 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);
+    await writeSettings(options);
+    const envTarget = await writeTlsEnv(options);
+    printCompletion({
+        plugin,
+        settingsPath: options.settingsPath,
+        envTarget
+    });
+}
+export { run };

package/dist/installer/installer-runner.d.ts

@@ -0,0 +1,2 @@
+declare function run(argv?: string[]): Promise<void>;
+export { run };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@volcengine/tls-observer-claude-code-install",
+  "version": "0.0.1",
+  "description": "One-step installer for the TLS Observer Claude Code plugin.",
+  "type": "module",
+  "bin": {
+    "tls-observer-claude-code-install": "bin/tls-observer-claude-code-install.mjs"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "src",
+    "scripts",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "rslib build",
+    "check": "tsc --noEmit",
+    "format": "prettier --write \"bin/**/*.mjs\" \"scripts/**/*.mjs\" \"src/**/*.ts\" \"*.json\"",
+    "format:check": "prettier --check \"bin/**/*.mjs\" \"scripts/**/*.mjs\" \"src/**/*.ts\" \"*.json\"",
+    "sync-plugin": "node scripts/sync-plugin.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@volcengine/openapi": "^1.36.1"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.21.5",
+    "@types/node": "^24.10.9",
+    "prettier": "^3.4.2",
+    "typescript": "^6.0.3"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}