@alipay/alipay-aipay 1.2.2 → 1.4.9

package/skill/references/normal/scripts/telemetry.mjs

@@ -0,0 +1,1278 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import https from 'node:https';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { execFileSync, spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const internalPrefix = 'ALIPAY_AIPAY_INTERNAL:';
+const disableValues = new Set(['0', 'false', 'off', 'no']);
+const canonicalProductTypes = new Set(['AIPAY', 'WEBPAY', 'APPPAY', 'UNKNOWN']);
+const allowedRootIntents = new Set(['integration_only', 'onboarding_only', 'full_process']);
+const syncLogBizType = 'yuyanmonitorl';
+const syncLogServerURL = 'https://collect.alipay.com/yuyan/';
+const syncLogMonitorVersion = 'alipay-aipay-skill:sync-log';
+const syncLogCode = '1005';
+const syncLogMsg = 'alipay_aipay_skill_event';
+const syncLogYuyanID = '180020010001290755';
+const uploadTimeoutMs = 2500;
+const outboxFlushLimit = 50;
+const outboxClaimTtlMs = 5 * 60 * 1000;
+const outboxMaxRecords = 1000;
+const outboxMaxAgeMs = 7 * 24 * 60 * 60 * 1000;
+const permissionedFlushTtlMs = 12 * 60 * 60 * 1000;
+const platformProjectIdEnvKeys = Object.freeze(['COZE_PROJECT_ID', 'MEOO_PROJECT_ID']);
+const permissionedFlushNetworkErrors = new Set([
+  'ENOTFOUND',
+  'EAI_AGAIN',
+  'ECONNREFUSED',
+  'ECONNRESET',
+  'ETIMEDOUT',
+  'EHOSTUNREACH',
+  'ENETUNREACH',
+  'NETWORK_UNREACHABLE'
+]);
+const productByVariant = { AIPAY: 'AIPAY', WEBPAY: 'WEBPAY', APPPAY: 'APPPAY' };
+const productByName = { '按量付费': 'AIPAY', '网站支付': 'WEBPAY', 'APP 支付': 'APPPAY' };
+const productAliases = {
+  aipay: 'AIPAY',
+  webpay: 'WEBPAY',
+  apppay: 'APPPAY',
+  unknown: 'UNKNOWN',
+  AIPAY: 'AIPAY',
+  WEBPAY: 'WEBPAY',
+  APPPAY: 'APPPAY',
+  UNKNOWN: 'UNKNOWN'
+};
+
+export const approvedStages = Object.freeze([
+  'run.intent_detected',
+  'run.product_clarify.start',
+  'integration.context_prepare.start',
+  'integration.env_prepare.start',
+  'integration.start_confirm.start',
+  'integration.user_confirmed',
+  'integration.pre_dev_reading.start',
+  'integration.code_dev.start',
+  'integration.local_verify.start',
+  'integration.sandbox_acceptance.start',
+  'integration.checklist.start',
+  'integration.closeout.start',
+  'onboarding.mcc_prepare.start',
+  'onboarding.plan_confirm.start',
+  'onboarding.user_confirmed',
+  'onboarding.auth.start',
+  'onboarding.discovery.start',
+  'onboarding.branch_summary.start',
+  'onboarding.material_collect.start',
+  'onboarding.signing.start',
+  'onboarding.service.start',
+  'onboarding.application.start',
+  'onboarding.closeout.start',
+  'run.terminal'
+]);
+
+const stageRules = new Map(approvedStages.map((stage) => [stage, {
+  stage,
+  flow: stage.startsWith('integration.')
+    ? 'integration'
+    : stage.startsWith('onboarding.')
+      ? 'onboarding'
+      : 'common'
+}]));
+
+const messageStageRules = {
+  'product.unsupported': 'run.terminal',
+  'product.clarify': 'run.product_clarify.start',
+
+  'integration.project_path.required': 'integration.context_prepare.start',
+  'integration.context.required': 'integration.context_prepare.start',
+  'integration.project_candidates.select': 'integration.context_prepare.start',
+  'integration.start.confirm': 'integration.start_confirm.start',
+  'integration.checklist.result': 'integration.closeout.start',
+
+  'onboarding.enterprise.unsupported': 'run.terminal',
+  'onboarding.plan.confirm': 'onboarding.plan_confirm.start',
+  'onboarding.discovery.summary': 'onboarding.branch_summary.start',
+  'materials.category.collect': 'onboarding.material_collect.start',
+  'process.partial_result': 'onboarding.closeout.start'
+};
+
+function safeText(value) {
+  return typeof value === 'string' && /^[A-Za-z0-9_.:-]+$/.test(value) ? value : '';
+}
+
+function safeDimension(value, fallback = 'unknown', maxLength = 80) {
+  if (typeof value !== 'string') return fallback;
+  const trimmed = value.trim().replace(/[,\^=\r\n]/g, '_');
+  if (!trimmed) return fallback;
+  return trimmed.slice(0, maxLength);
+}
+
+function normalizeSwitch(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+export function telemetryEnabled(env = process.env) {
+  return !disableValues.has(normalizeSwitch(env.ALIPAY_AIPAY_TELEMETRY));
+}
+
+export function telemetryUploadEnabled(env = process.env) {
+  return telemetryEnabled(env)
+    && !disableValues.has(normalizeSwitch(env.ALIPAY_AIPAY_TELEMETRY_UPLOAD))
+    && !isMaintenanceProcess(env);
+}
+
+function scriptPath() {
+  return fileURLToPath(import.meta.url);
+}
+
+function scriptDir() {
+  return path.dirname(scriptPath());
+}
+
+function skillRoot() {
+  return path.resolve(scriptDir(), '../../..');
+}
+
+function telemetryRoot() {
+  return path.join(os.tmpdir(), 'alipay-aipay-telemetry');
+}
+
+function isMaintenanceProcess(env = process.env, argv = process.argv) {
+  if (normalizeSwitch(env.ALIPAY_AIPAY_TELEMETRY_ALLOW_MAINTENANCE) === '1') return false;
+  if (env.NODE_TEST_CONTEXT) return true;
+  if (env.npm_lifecycle_event === 'test') return true;
+  return argv.some((arg) => /(^|[/\\])test[/\\].+\.test\.mjs$/u.test(String(arg || '')));
+}
+
+function stableStateKey(env = process.env) {
+  const source =
+    env.ALIPAY_AIPAY_SESSION_ID ||
+    platformProjectRunId(env) ||
+    env.CODEX_THREAD_ID ||
+    env.CODEX_SESSION_ID ||
+    env.CLAUDE_CODE_SESSION_ID ||
+    env.OPENCLAW_SESSION_ID ||
+    env.CURSOR_SESSION_ID ||
+    env.CURSOR_TRACE_ID ||
+    env.COZE_SESSION_ID ||
+    env.COZE_CONVERSATION_ID ||
+    env.HERMES_SESSION_ID ||
+    env.OPENAI_CONVERSATION_ID ||
+    env.SESSION_ID ||
+    env.CI_JOB_ID ||
+    '';
+  if (!source) return 'default';
+  if (safeText(source) && source.length <= 128) return source;
+  return `key-${crypto.createHash('sha256').update(source).digest('hex')}`;
+}
+
+function stateDir(env = process.env) {
+  if (env.ALIPAY_AIPAY_TELEMETRY_DIR) return env.ALIPAY_AIPAY_TELEMETRY_DIR;
+  return telemetryRoot();
+}
+
+function runStatePath(env = process.env) {
+  if (env.ALIPAY_AIPAY_RUN_STATE_FILE) return env.ALIPAY_AIPAY_RUN_STATE_FILE;
+  return path.join(stateDir(env), `${stableStateKey(env)}.json`);
+}
+
+function outboxDir(env = process.env) {
+  if (env.ALIPAY_AIPAY_TELEMETRY_OUTBOX_DIR) return env.ALIPAY_AIPAY_TELEMETRY_OUTBOX_DIR;
+  return path.join(stateDir(env), 'outbox');
+}
+
+function uploadStatusPath(env = process.env) {
+  if (env.ALIPAY_AIPAY_TELEMETRY_UPLOAD_STATUS_FILE) return env.ALIPAY_AIPAY_TELEMETRY_UPLOAD_STATUS_FILE;
+  return path.join(stateDir(env), 'upload-status.json');
+}
+
+function permissionedFlushStatePath(env = process.env) {
+  if (env.ALIPAY_AIPAY_TELEMETRY_PERMISSIONED_FLUSH_STATE_FILE) {
+    return env.ALIPAY_AIPAY_TELEMETRY_PERMISSIONED_FLUSH_STATE_FILE;
+  }
+  return path.join(stateDir(env), `${stableStateKey(env)}.permissioned-flush.json`);
+}
+
+export function telemetryStoragePaths(env = process.env) {
+  return {
+    state_dir: stateDir(env),
+    run_state_file: runStatePath(env),
+    outbox_dir: outboxDir(env),
+    upload_status_file: uploadStatusPath(env),
+    permissioned_flush_state_file: permissionedFlushStatePath(env)
+  };
+}
+
+function ensurePrivateDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try {
+    fs.chmodSync(dir, 0o700);
+  } catch {
+    // chmod is best-effort on Windows.
+  }
+}
+
+function readRunState(env = process.env) {
+  try {
+    const statePath = runStatePath(env);
+    const parsed = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    if (!parsed || typeof parsed !== 'object') return null;
+    if (parsed.schema_ver !== 1) return null;
+    if (!safeRunId(parsed.run_id)) return null;
+    const createdAt = Number(parsed.created_at);
+    const updatedAt = Number(parsed.updated_at);
+    if (!Number.isFinite(createdAt) || createdAt <= 0) return null;
+    if (!Number.isFinite(updatedAt) || updatedAt <= 0) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function canReadImplicitRunState(env = process.env) {
+  return !isMaintenanceProcess(env);
+}
+
+function recordLocalTelemetryFailure(errorCode, message, env = process.env) {
+  const safeCode = safeDimension(errorCode, 'LOCAL_TELEMETRY_FAILED', 80);
+  const safeMessage = safeDimension(message || safeCode, safeCode, 240);
+  writeUploadStatus({
+    status: 'local_failed',
+    error_code: safeCode,
+    error_message: safeMessage
+  }, env);
+  emitTelemetryError(new Error(safeCode));
+}
+
+function writeRunState(state, env = process.env) {
+  try {
+    const statePath = runStatePath(env);
+    ensurePrivateDir(path.dirname(statePath));
+    const tempPath = path.join(path.dirname(statePath), `.${path.basename(statePath)}.${process.pid}.tmp`);
+    fs.writeFileSync(tempPath, `${JSON.stringify(state)}\n`, { mode: 0o600 });
+    try {
+      fs.chmodSync(tempPath, 0o600);
+    } catch {
+      // chmod is best-effort on Windows.
+    }
+    fs.renameSync(tempPath, statePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function outboxFilename(event) {
+  const timestamp = Number.isFinite(Number(event?.timestamp)) ? String(Number(event.timestamp)) : String(Date.now());
+  const eventID = safeText(event?.event_id) || crypto.randomUUID();
+  return `${timestamp}-${eventID}.json`;
+}
+
+export function enqueueMetricEvent(event, env = process.env) {
+  try {
+    if (!event) return false;
+    const dir = outboxDir(env);
+    ensurePrivateDir(dir);
+    const filename = outboxFilename(event);
+    const finalPath = path.join(dir, filename);
+    const tempPath = path.join(dir, `.${filename}.${process.pid}.tmp`);
+    const record = {
+      schema_ver: 1,
+      created_at: Date.now(),
+      event
+    };
+    fs.writeFileSync(tempPath, `${JSON.stringify(record)}\n`, { mode: 0o600 });
+    try {
+      fs.chmodSync(tempPath, 0o600);
+    } catch {
+      // chmod is best-effort on Windows.
+    }
+    fs.renameSync(tempPath, finalPath);
+    pruneOutbox(env);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function safeRunId(value) {
+  if (typeof value !== 'string' || !value.trim()) return '';
+  // Sync-log uses comma-separated columns and ^/= delimiters without value escaping.
+  return /[\u0000-\u001f\u007f,^=]/u.test(value) ? '' : value;
+}
+
+function platformProjectRunId(env = process.env) {
+  for (const key of platformProjectIdEnvKeys) {
+    const value = safeRunId(env[key]);
+    if (value) return value;
+  }
+  if (env.MIAODA) {
+    return safeRunId(env.VITE_APP_ID) || safeRunId(env.PLATFORM_ID) || '';
+  }
+  return '';
+}
+
+function explicitRunIdFrom(context, env) {
+  return safeRunId(context.runId || context.run_id || env.ALIPAY_AIPAY_RUN_ID || env.ALIPAY_AIPAY_FLOW_RUN_ID);
+}
+
+function runIdFrom(context, env) {
+  const state = canReadImplicitRunState(env) ? readRunState(env) : null;
+  return safeRunId(platformProjectRunId(env) || explicitRunIdFrom(context, env) || state?.run_id);
+}
+
+function rootIntentFrom(context, env) {
+  const state = canReadImplicitRunState(env) ? readRunState(env) : null;
+  const value = context.rootIntent || context.root_intent || env.ALIPAY_AIPAY_ROOT_INTENT || state?.root_intent;
+  return allowedRootIntents.has(value) ? value : '';
+}
+
+function canonicalProductType(value) {
+  return typeof value === 'string' && productAliases[value] ? productAliases[value] : '';
+}
+
+function productTypeFrom({ ruleProductType, variantName, variables = {}, context = {}, env = process.env }) {
+  const explicit = context.productType || context.product_type || ruleProductType;
+  const explicitCanonical = canonicalProductType(explicit);
+  if (explicitCanonical) return explicitCanonical;
+  const variableCanonical = canonicalProductType(variables.productType);
+  if (variableCanonical) return variableCanonical;
+  if (productByVariant[variantName]) return productByVariant[variantName];
+  if (productByName[variables.productName]) return productByName[variables.productName];
+  if (productByName[context.productName]) return productByName[context.productName];
+  const stateCanonical = canReadImplicitRunState(env) ? canonicalProductType(readRunState(env)?.product_type) : '';
+  if (stateCanonical) return stateCanonical;
+  const envCanonical = canonicalProductType(env.ALIPAY_AIPAY_PRODUCT_TYPE);
+  if (envCanonical) return envCanonical;
+  return 'UNKNOWN';
+}
+
+export function stageMetricEvent(stage, context = {}, nowMs = Date.now(), env = process.env) {
+  const rule = stageRules.get(stage);
+  if (!rule) return null;
+  const state = canReadImplicitRunState(env) ? readRunState(env) : null;
+  const explicitRunId = platformProjectRunId(env) || explicitRunIdFrom(context, env);
+  if (state && (!explicitRunId || explicitRunId === state.run_id) && !runStateCompatibleWithEventContext(state, context)) {
+    return null;
+  }
+  const runId = runIdFrom(context, env);
+  if (!runId) return null;
+  const event = {
+    schema_ver: 2,
+    event_id: crypto.randomUUID(),
+    skill: 'alipay-aipay',
+    run_id: runId,
+    stage: rule.stage,
+    timestamp: nowMs,
+    flow: rule.flow,
+    product_type: productTypeFrom({ ruleProductType: context.productType || context.product_type, context, env })
+  };
+  if (!canonicalProductTypes.has(event.product_type)) event.product_type = 'UNKNOWN';
+  const rootIntent = rootIntentFrom(context, env);
+  if (rootIntent) event.root_intent = rootIntent;
+  return event;
+}
+
+export function messageMetricEvent(messageId, variantName, variables = {}, context = {}, nowMs = Date.now(), env = process.env) {
+  const stage = messageStageRules[messageId];
+  if (!stage) return null;
+  const stageEvent = stageMetricEvent(stage, {
+    ...context,
+    productType: productTypeFrom({ variantName, variables, context, env })
+  }, nowMs, env);
+  return stageEvent;
+}
+
+export function emitMetricEvent(event, { env = process.env, stream = process.stderr, upload = true } = {}) {
+  if (!telemetryEnabled(env) || !event) return false;
+  stream.write(`${internalPrefix}METRIC_EVENT=${JSON.stringify(event)}\n`);
+  if (upload) scheduleSyncLogUpload(event, env);
+  return true;
+}
+
+export function emitStageMetric(stage, context = {}) {
+  try {
+    return emitMetricEvent(stageMetricEvent(stage, context));
+  } catch {
+    return false;
+  }
+}
+
+export function emitMessageMetric(messageId, variantName, variables = {}, context = {}) {
+  try {
+    const event = messageMetricEvent(messageId, variantName, variables, context);
+    if (event?.stage === 'run.terminal' && telemetryEnabled()) updateExistingRunStateFromEvent(event);
+    return emitMetricEvent(event);
+  } catch {
+    return false;
+  }
+}
+
+export function emitTerminalMetric(context = {}) {
+  try {
+    if (!telemetryEnabled()) return false;
+    const event = stageMetricEvent('run.terminal', context);
+    if (!event) return false;
+    updateExistingRunStateFromEvent(event);
+    return emitMetricEvent(event);
+  } catch {
+    return false;
+  }
+}
+
+function parseCliArgs(argv) {
+  const command = argv[2];
+  const args = { _: [] };
+  for (let index = 3; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) {
+      args._.push(token);
+      continue;
+    }
+    const name = token.slice(2);
+    const value = argv[index + 1];
+    if (value === undefined || value.startsWith('--')) throw new Error(`参数 --${name} 缺少取值`);
+    args[name] = value;
+    index += 1;
+  }
+  return { command, args };
+}
+
+function contextFromCliArgs(args) {
+  return {
+    runId: args['run-id'],
+    rootIntent: args['root-intent'],
+    productType: args['product-type'],
+    productName: args['product-name']
+  };
+}
+
+function assertCliArgs(args, allowedOptions, positionalCount) {
+  for (const name of Object.keys(args)) {
+    if (name !== '_' && !allowedOptions.has(name)) throw new Error(`不支持参数 --${name}`);
+  }
+  if (args._.length !== positionalCount) throw new Error('invalid telemetry arguments');
+}
+
+function createRunState(args, env = process.env, nowMs = Date.now()) {
+  const runId = platformProjectRunId(env) || safeRunId(args['run-id']) || crypto.randomUUID();
+  const rootIntent = args['root-intent'];
+  if (!allowedRootIntents.has(rootIntent)) throw new Error('--root-intent 仅支持 integration_only、onboarding_only、full_process');
+  const productType = canonicalProductType(args['product-type']) || 'UNKNOWN';
+  return {
+    schema_ver: 1,
+    run_id: runId,
+    root_intent: rootIntent,
+    product_type: productType,
+    created_at: nowMs,
+    updated_at: nowMs
+  };
+}
+
+function compatibleProductType(existingProductType, requestedProductType) {
+  const existing = canonicalProductType(existingProductType) || 'UNKNOWN';
+  const requested = canonicalProductType(requestedProductType) || 'UNKNOWN';
+  return existing === requested || existing === 'UNKNOWN' || requested === 'UNKNOWN';
+}
+
+function runStateCompatibleWithEventContext(state, context = {}) {
+  if (!state) return true;
+  const requestedRootIntent = context.rootIntent || context.root_intent;
+  if (requestedRootIntent && state.root_intent && state.root_intent !== requestedRootIntent) return false;
+  const requestedProductType = canonicalProductType(context.productType || context.product_type);
+  if (requestedProductType && !compatibleProductType(state.product_type, requestedProductType)) return false;
+  return true;
+}
+
+function mergeProductType(existingProductType, requestedProductType) {
+  const existing = canonicalProductType(existingProductType) || 'UNKNOWN';
+  const requested = canonicalProductType(requestedProductType) || 'UNKNOWN';
+  if (existing === 'UNKNOWN' && requested !== 'UNKNOWN') return requested;
+  if (requested === 'UNKNOWN' && existing !== 'UNKNOWN') return existing;
+  return requested;
+}
+
+function reusableRunState(existing, requestedRootIntent, requestedProductType) {
+  if (!existing || existing.terminal) return false;
+  if (existing.root_intent !== requestedRootIntent) return false;
+  return compatibleProductType(existing.product_type, requestedProductType);
+}
+
+function createOrReuseRunState(args, env = process.env, nowMs = Date.now()) {
+  const rootIntent = args['root-intent'];
+  if (!allowedRootIntents.has(rootIntent)) throw new Error('--root-intent 仅支持 integration_only、onboarding_only、full_process');
+  const requestedProductType = canonicalProductType(args['product-type']) || 'UNKNOWN';
+  const requestedRunId = platformProjectRunId(env) || safeRunId(args['run-id']);
+  const existing = readRunState(env);
+  if (reusableRunState(existing, rootIntent, requestedProductType) && (!requestedRunId || existing.run_id === requestedRunId)) {
+    return {
+      ...existing,
+      root_intent: rootIntent,
+      product_type: mergeProductType(existing.product_type, requestedProductType),
+      updated_at: nowMs
+    };
+  }
+  return createRunState(args, env, nowMs);
+}
+
+function updateRunStateFromEvent(event, env = process.env) {
+  const existing = readRunState(env) || {};
+  const next = {
+    ...existing,
+    schema_ver: 1,
+    run_id: event.run_id,
+    root_intent: event.root_intent || existing.root_intent || '',
+    product_type: event.product_type && event.product_type !== 'UNKNOWN' ? event.product_type : existing.product_type || 'UNKNOWN',
+    created_at: existing.created_at || Date.now(),
+    updated_at: Date.now()
+  };
+  if (event.stage === 'run.terminal') {
+    next.terminal = true;
+    next.terminal_at = Number.isFinite(Number(event.timestamp)) ? Number(event.timestamp) : Date.now();
+  } else if (existing.terminal && existing.run_id === event.run_id) {
+    next.terminal = existing.terminal;
+    next.terminal_at = existing.terminal_at;
+  }
+  writeRunState(next, env);
+}
+
+function updateExistingRunStateFromEvent(event, env = process.env) {
+  const existing = readRunState(env);
+  if (!existing) return false;
+  if (existing.run_id !== event.run_id) return false;
+  if (!runStateCompatibleWithEventContext(existing, {
+    rootIntent: event.root_intent,
+    productType: event.product_type
+  })) return false;
+  updateRunStateFromEvent(event, env);
+  return true;
+}
+
+function normalizeOS(platform = process.platform) {
+  switch (platform) {
+    case 'darwin':
+      return 'macOS';
+    case 'linux':
+      return 'Linux';
+    case 'win32':
+      return 'Windows';
+    default:
+      return 'Other';
+  }
+}
+
+function normalizePlatform(value) {
+  const normalized = String(value || '').trim().toLowerCase().replace(/[_\s-]/g, '');
+  if (normalized === 'codex') return 'codex';
+  if (normalized === 'claudecode' || normalized === 'claude') return 'claudecode';
+  if (normalized === 'cursor') return 'cursor';
+  if (normalized === 'coze') return 'coze';
+  if (normalized === 'meoo') return 'meoo';
+  if (normalized === 'miaoda') return 'miaoda';
+  if (normalized === 'openclaw') return 'openclaw';
+  if (normalized === 'traesolo') return 'traesolo';
+  if (normalized === 'qoder') return 'qoder';
+  if (/^[a-z0-9.]{1,40}$/.test(normalized) && normalized !== 'unknown') return normalized;
+  return 'unknown';
+}
+
+function platformFromEnv(env = process.env) {
+  if (env.ALIPAY_AIPAY_PLATFORM) return normalizePlatform(env.ALIPAY_AIPAY_PLATFORM);
+  if (env.AIPAY_AGENT_TYPE) return normalizePlatform(env.AIPAY_AGENT_TYPE);
+  if (env.DEV_TOOL_NAME) return normalizePlatform(env.DEV_TOOL_NAME);
+  if (env.PLATFORM) return normalizePlatform(env.PLATFORM);
+  if (env.CLAUDE_CODE_SESSION_ID || env.CLAUDE_SESSION_ID || env.CLAUDECODE || env.CLAUDE_CODE_ENTRYPOINT) return 'claudecode';
+  if (env.OPENCLAW_SESSION_ID || env.OPENCLAW_AGENT_ID) return 'openclaw';
+  if (env.CURSOR_TRACE_ID || env.CURSOR_SESSION_ID || env.CURSOR_AGENT || env.CURSOR_LAYOUT) return 'cursor';
+  if (env.COZE_PROJECT_ID || env.COZE_SESSION_ID || env.COZE_CONVERSATION_ID) return 'coze';
+  if (env.MEOO_PROJECT_ID) return 'meoo';
+  if (env.MIAODA) return 'miaoda';
+  if (env.CODEX_CI || env.CODEX_THREAD_ID || env.CODEX_SESSION_ID || env.CODEX_SANDBOX_NETWORK_DISABLED !== undefined) return 'codex';
+  if (env.TRAE_BRAND_NAME) return 'traesolo';
+  if (env.QODER_CLI) return 'qoder';
+  return 'unknown';
+}
+
+function modelFromEnv(env = process.env) {
+  return safeDimension(env.AIPAY_MODEL || 'unknown');
+}
+
+function skillVersionFromDisk() {
+  try {
+    const raw = fs.readFileSync(path.join(skillRoot(), 'VERSION'), 'utf8').trim();
+    const match = raw.match(/^v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)$/);
+    if (match) return `v${match[1]}`;
+  } catch {
+    // fall through
+  }
+  return 'unknown';
+}
+
+function isLocalSkillCheckout() {
+  try {
+    return fs.existsSync(path.join(skillRoot(), '../.git'));
+  } catch {
+    return false;
+  }
+}
+
+function machineCodeRaw(env = process.env) {
+  const explicit = env.ALIPAY_AIPAY_MACHINE_CODE || env.AIPAY_MACHINE_CODE;
+  if (explicit) return explicit;
+  try {
+    if (process.platform === 'linux') {
+      for (const file of ['/etc/machine-id', '/var/lib/dbus/machine-id']) {
+        if (fs.existsSync(file)) {
+          const value = fs.readFileSync(file, 'utf8').trim();
+          if (value) return value;
+        }
+      }
+    }
+    if (process.platform === 'darwin') {
+      const output = execFileSync('ioreg', ['-rd1', '-c', 'IOPlatformExpertDevice'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 1000
+      });
+      const match = output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (match?.[1]) return match[1];
+    }
+    if (process.platform === 'win32') {
+      const output = execFileSync('REG', ['QUERY', 'HKLM\\SOFTWARE\\Microsoft\\Cryptography', '/v', 'MachineGuid'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 1000
+      });
+      const match = output.match(/MachineGuid\s+REG_SZ\s+([^\s\r\n]+)/);
+      if (match?.[1]) return match[1];
+    }
+  } catch {
+    // fall through
+  }
+  try {
+    const hostname = os.hostname();
+    if (hostname) return `hostname:${hostname}`;
+  } catch {
+    // fall through
+  }
+  return '';
+}
+
+function machineUserID(env = process.env) {
+  const raw = machineCodeRaw(env);
+  if (!raw) return 'anonymous_uid';
+  const hash = crypto.createHash('sha256').update(String(raw)).digest('hex').slice(0, 32);
+  return `machine_${hash}`;
+}
+
+function monitorEnv(env = process.env) {
+  switch (normalizeSwitch(env.AIPAY_BUILD_ENV)) {
+    case 'dev':
+      return 'DEV';
+    case 'pre':
+      return 'PRE';
+    case 'prod':
+      return 'PROD';
+    default:
+      break;
+  }
+  const skillVersion = skillVersionFromDisk();
+  if (/^v?\d+\.\d+\.\d+-/.test(skillVersion)) return 'PRE';
+  if (skillVersion !== 'unknown' && !isLocalSkillCheckout()) return 'PROD';
+  return 'DEV';
+}
+
+export function buildSyncLogReport(event, env = process.env) {
+  if (!event) return null;
+  const skillVersion = skillVersionFromDisk();
+  return {
+    item: {
+      code: syncLogCode,
+      msg: syncLogMsg,
+      d1: normalizeOS(),
+      d2: platformFromEnv(env),
+      d3: modelFromEnv(env),
+      d4: skillVersion,
+      d5: event.product_type || 'UNKNOWN',
+      c1: event.run_id,
+      c2: event.stage,
+      c3: event.timestamp
+    },
+    options: {
+      Env: monitorEnv(env),
+      SprintID: skillVersion,
+      UserID: machineUserID(env),
+      YuyanID: syncLogYuyanID
+    }
+  };
+}
+
+function serializeSyncLogParam4(param4) {
+  return Object.keys(param4)
+    .filter((key) => param4[key] !== undefined && param4[key] !== null)
+    .sort()
+    .map((key) => `${key}=${param4[key]}`)
+    .join('^');
+}
+
+export function buildSyncLogLine(userID, param4, date = new Date()) {
+  const pad = (value, length = 2) => String(value).padStart(length, '0');
+  const clientLogTime = [
+    `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`,
+    `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}:${date.getMilliseconds()}`
+  ].join(' ');
+
+  return [
+    'D-AE',
+    clientLogTime,
+    '',
+    '',
+    '2',
+    '',
+    '',
+    userID || 'anonymous_uid',
+    '1000',
+    '102023',
+    'H5behavior',
+    '2',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    'zh-cn',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    serializeSyncLogParam4(param4)
+  ].join(',');
+}
+
+function buildParam4(item, options) {
+  const param4 = { ...item };
+  if (options.SprintID) param4.bm_sid = options.SprintID;
+  if (options.Env && !param4.env) param4.env = options.Env;
+  if (options.YuyanID) param4.yuyan_id = options.YuyanID;
+  param4.monitor_ver = syncLogMonitorVersion;
+  return param4;
+}
+
+export function syncLogRequestBody(report, nowMs = Date.now()) {
+  const param4 = buildParam4(report.item, report.options);
+  return `data=${encodeURIComponent(buildSyncLogLine(report.options.UserID || 'anonymous_uid', param4))}&time=${nowMs}`;
+}
+
+export function isSuccessfulHttpStatus(statusCode) {
+  const code = Number(statusCode || 0);
+  return code >= 200 && code < 300;
+}
+
+export function sendSyncLogReportDetailed(report, { timeoutMs = uploadTimeoutMs } = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    try {
+      if (!report?.item || !report?.options) {
+        finish({ ok: false, error_code: 'INVALID_REPORT', error_message: 'invalid report' });
+        return;
+      }
+      const body = syncLogRequestBody(report);
+      const req = https.request(`${syncLogServerURL}?biztype=${syncLogBizType}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+          'Content-Length': Buffer.byteLength(body)
+        },
+        timeout: timeoutMs
+      }, (resp) => {
+        resp.resume();
+        resp.on('end', () => {
+          const statusCode = Number(resp.statusCode || 0);
+          const ok = isSuccessfulHttpStatus(statusCode);
+          finish({
+            ok,
+            status_code: statusCode || undefined,
+            error_code: ok ? undefined : statusCode > 0 ? `HTTP_${statusCode}` : 'NO_HTTP_STATUS',
+            error_message: ok ? undefined : statusCode > 0
+              ? `sync log endpoint returned ${statusCode}`
+              : 'sync log endpoint returned no HTTP status'
+          });
+        });
+      });
+      req.on('timeout', () => {
+        finish({ ok: false, error_code: 'ETIMEDOUT', error_message: 'request timeout' });
+        req.destroy();
+      });
+      req.on('error', (error) => finish({
+        ok: false,
+        error_code: safeDimension(error?.code || error?.name || 'REQUEST_ERROR', 'REQUEST_ERROR', 80),
+        error_message: safeDimension(error?.message || 'request error', 'request error', 240)
+      }));
+      req.end(body);
+    } catch (error) {
+      finish({
+        ok: false,
+        error_code: safeDimension(error?.code || error?.name || 'REQUEST_ERROR', 'REQUEST_ERROR', 80),
+        error_message: safeDimension(error?.message || 'request error', 'request error', 240)
+      });
+    }
+  });
+}
+
+export async function sendSyncLogReport(report, { timeoutMs = uploadTimeoutMs } = {}) {
+  const result = await sendSyncLogReportDetailed(report, { timeoutMs });
+  return result.ok;
+}
+
+function outboxFiles(env = process.env) {
+  try {
+    const dir = outboxDir(env);
+    recoverStaleOutboxClaims(env);
+    pruneOutbox(env);
+    return outboxRecordEntries(dir)
+      .sort((left, right) => left.name.localeCompare(right.name))
+      .map((entry) => entry.file);
+  } catch {
+    return [];
+  }
+}
+
+function outboxRecordEntries(dir) {
+  return fs.readdirSync(dir)
+    .filter((name) => name.endsWith('.json') && !name.startsWith('.'))
+    .map((name) => {
+      const file = path.join(dir, name);
+      let mtimeMs = 0;
+      try {
+        mtimeMs = fs.statSync(file).mtimeMs;
+      } catch {
+        // The file may have been claimed or removed concurrently.
+      }
+      return { file, name, mtimeMs };
+    })
+    .filter((entry) => entry.mtimeMs > 0);
+}
+
+function pruneOutbox(env = process.env, nowMs = Date.now()) {
+  try {
+    const dir = outboxDir(env);
+    let entries = outboxRecordEntries(dir);
+    for (const entry of entries) {
+      if (nowMs - entry.mtimeMs <= outboxMaxAgeMs) continue;
+      try {
+        fs.unlinkSync(entry.file);
+      } catch {
+        // A concurrent flush may have claimed it first.
+      }
+    }
+    entries = outboxRecordEntries(dir);
+    const overflow = entries.length - outboxMaxRecords;
+    if (overflow <= 0) return;
+    entries
+      .sort((left, right) => left.mtimeMs - right.mtimeMs || left.name.localeCompare(right.name))
+      .slice(0, overflow)
+      .forEach((entry) => {
+        try {
+          fs.unlinkSync(entry.file);
+        } catch {
+          // Best-effort local retention cap.
+        }
+      });
+  } catch {
+    // Pruning is best-effort and must not affect the customer flow.
+  }
+}
+
+function recoverStaleOutboxClaims(env = process.env, nowMs = Date.now()) {
+  try {
+    const dir = outboxDir(env);
+    for (const name of fs.readdirSync(dir)) {
+      if (!name.includes('.json.sending.')) continue;
+      const claimedPath = path.join(dir, name);
+      const stat = fs.statSync(claimedPath);
+      if (nowMs - stat.mtimeMs < outboxClaimTtlMs) continue;
+      const originalName = name.replace(/\.sending\.[^.]+$/, '');
+      const originalPath = path.join(dir, originalName);
+      try {
+        if (fs.existsSync(originalPath)) fs.unlinkSync(claimedPath);
+        else fs.renameSync(claimedPath, originalPath);
+      } catch {
+        // Leave the claim for a later recovery attempt.
+      }
+    }
+  } catch {
+    // Recovery is best-effort.
+  }
+}
+
+function claimOutboxFile(file) {
+  const claimedPath = `${file}.sending.${process.pid}`;
+  try {
+    fs.renameSync(file, claimedPath);
+    return claimedPath;
+  } catch {
+    return '';
+  }
+}
+
+function releaseOutboxClaim(claimedPath) {
+  const originalPath = claimedPath.replace(/\.sending\.[^.]+$/, '');
+  try {
+    if (fs.existsSync(originalPath)) fs.unlinkSync(claimedPath);
+    else fs.renameSync(claimedPath, originalPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readOutboxRecord(file) {
+  try {
+    const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!record || record.schema_ver !== 1) return null;
+    if (record.report?.item && record.report?.options) return record;
+    if (record.event?.run_id && record.event?.stage && Number.isFinite(Number(record.event?.timestamp))) return record;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function writeUploadStatus(status, env = process.env) {
+  try {
+    const statusPath = uploadStatusPath(env);
+    ensurePrivateDir(path.dirname(statusPath));
+    const next = {
+      schema_ver: 1,
+      updated_at: Date.now(),
+      ...status
+    };
+    const tempPath = path.join(path.dirname(statusPath), `.${path.basename(statusPath)}.${process.pid}.tmp`);
+    fs.writeFileSync(tempPath, `${JSON.stringify(next)}\n`, { mode: 0o600 });
+    try {
+      fs.chmodSync(tempPath, 0o600);
+    } catch {
+      // chmod is best-effort on Windows.
+    }
+    fs.renameSync(tempPath, statusPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readUploadStatus(env = process.env) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(uploadStatusPath(env), 'utf8'));
+    if (!parsed || parsed.schema_ver !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function readPermissionedFlushState(env = process.env, nowMs = Date.now()) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(permissionedFlushStatePath(env), 'utf8'));
+    if (!parsed || parsed.schema_ver !== 1) return null;
+    const requestedAt = Number(parsed.requested_at || 0);
+    if (!Number.isFinite(requestedAt) || nowMs - requestedAt > permissionedFlushTtlMs) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function writePermissionedFlushState(state, env = process.env) {
+  try {
+    const statePath = permissionedFlushStatePath(env);
+    ensurePrivateDir(path.dirname(statePath));
+    const tempPath = path.join(path.dirname(statePath), `.${path.basename(statePath)}.${process.pid}.tmp`);
+    fs.writeFileSync(tempPath, `${JSON.stringify({ schema_ver: 1, ...state })}\n`, { mode: 0o600 });
+    try {
+      fs.chmodSync(tempPath, 0o600);
+    } catch {
+      // chmod is best-effort on Windows.
+    }
+    fs.renameSync(tempPath, statePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function networkUploadFailure(status) {
+  const errorCode = safeDimension(status?.error_code || '', '', 80).toUpperCase();
+  if (permissionedFlushNetworkErrors.has(errorCode)) return errorCode;
+  const message = String(status?.error_message || '').toUpperCase();
+  for (const code of permissionedFlushNetworkErrors) {
+    if (message.includes(code)) return code;
+  }
+  if (message.includes('GETADDRINFO') || message.includes('COULD_NOT_RESOLVE') || message.includes('COULD NOT RESOLVE')) {
+    return 'ENOTFOUND';
+  }
+  return '';
+}
+
+export function permissionedFlushDecision(env = process.env, nowMs = Date.now(), { markRequested = false } = {}) {
+  const outboxCount = outboxFiles(env).length;
+  const status = readUploadStatus(env);
+  const errorCode = networkUploadFailure(status);
+  const existing = readPermissionedFlushState(env, nowMs);
+  const alreadyRequested = Boolean(existing);
+  const result = {
+    needed: false,
+    outbox_count: outboxCount,
+    already_requested: alreadyRequested,
+    error_code: errorCode || safeDimension(status?.error_code || '', '', 80),
+    status: safeDimension(status?.status || 'unknown', 'unknown', 80)
+  };
+  if (!telemetryUploadEnabled(env) || outboxCount <= 0 || !errorCode) {
+    return result;
+  }
+  if (alreadyRequested) {
+    return {
+      ...result,
+      requested_at: existing.requested_at
+    };
+  }
+  result.needed = true;
+  if (markRequested) {
+    writePermissionedFlushState({
+      requested_at: nowMs,
+      error_code: errorCode,
+      outbox_count: outboxCount
+    }, env);
+    result.requested_at = nowMs;
+  }
+  return result;
+}
+
+export async function flushOutbox(env = process.env, {
+  limit = outboxFlushLimit,
+  timeoutMs = uploadTimeoutMs,
+  sender = sendSyncLogReportDetailed
+} = {}) {
+  const result = { attempted: 0, sent: 0, retained: 0, invalid: 0 };
+  if (!telemetryUploadEnabled(env)) return result;
+  const files = outboxFiles(env).slice(0, Math.max(0, limit));
+  for (const file of files) {
+    const claimedFile = claimOutboxFile(file);
+    if (!claimedFile) continue;
+    const record = readOutboxRecord(claimedFile);
+    if (!record) {
+      result.invalid += 1;
+      try {
+        fs.unlinkSync(claimedFile);
+      } catch {
+        // best-effort cleanup.
+      }
+      continue;
+    }
+    const report = record.report?.item && record.report?.options ? record.report : buildSyncLogReport(record.event, env);
+    if (!report) {
+      result.invalid += 1;
+      try {
+        fs.unlinkSync(claimedFile);
+      } catch {
+        // best-effort cleanup.
+      }
+      continue;
+    }
+    result.attempted += 1;
+    let sendResult = { ok: false, error_code: 'SENDER_FAILED', error_message: 'sender failed' };
+    try {
+      const rawSendResult = await sender(report, { timeoutMs });
+      sendResult = typeof rawSendResult === 'boolean' ? { ok: rawSendResult } : rawSendResult;
+    } catch (error) {
+      sendResult = {
+        ok: false,
+        error_code: safeDimension(error?.code || error?.name || 'SENDER_THROW', 'SENDER_THROW', 80),
+        error_message: safeDimension(error?.message || 'sender threw', 'sender threw', 240)
+      };
+    }
+    if (sendResult?.ok) {
+      result.sent += 1;
+      try {
+        fs.unlinkSync(claimedFile);
+      } catch {
+        // If delete fails, keep the record for a later retry.
+        result.retained += 1;
+        releaseOutboxClaim(claimedFile);
+      }
+      continue;
+    }
+    writeUploadStatus({
+      status: 'failed',
+      attempted: result.attempted,
+      sent: result.sent,
+      retained: files.length - result.attempted + 1,
+      status_code: sendResult?.status_code,
+      error_code: sendResult?.error_code || 'UPLOAD_FAILED',
+      error_message: sendResult?.error_message || 'upload failed'
+    }, env);
+    releaseOutboxClaim(claimedFile);
+    result.retained += files.length - result.attempted + 1;
+    break;
+  }
+  if (result.sent > 0 && result.retained === 0) {
+    writeUploadStatus({
+      status: 'success',
+      attempted: result.attempted,
+      sent: result.sent,
+      retained: 0
+    }, env);
+  }
+  return result;
+}
+
+function spawnOutboxFlush(env = process.env) {
+  if (!telemetryUploadEnabled(env)) return false;
+  try {
+    const child = spawn(process.execPath, [scriptPath(), 'flush-outbox-worker'], {
+      detached: true,
+      stdio: 'ignore',
+      env: {
+        ...env,
+        ALIPAY_AIPAY_TELEMETRY_UPLOAD_TIMEOUT_MS: env.ALIPAY_AIPAY_TELEMETRY_UPLOAD_TIMEOUT_MS || String(uploadTimeoutMs)
+      }
+    });
+    child.on('error', (error) => {
+      writeUploadStatus({
+        status: 'spawn_failed',
+        error_code: safeDimension(error?.code || error?.name || 'UPLOAD_SPAWN_FAILED', 'UPLOAD_SPAWN_FAILED', 80),
+        error_message: safeDimension(error?.message || 'failed to start background telemetry uploader', 'failed to start background telemetry uploader', 240)
+      }, env);
+    });
+    child.unref();
+    return true;
+  } catch {
+    writeUploadStatus({
+      status: 'spawn_failed',
+      error_code: 'UPLOAD_SPAWN_FAILED',
+      error_message: 'failed to start background telemetry uploader'
+    }, env);
+    return false;
+  }
+}
+
+function scheduleSyncLogUpload(event, env = process.env) {
+  if (!telemetryUploadEnabled(env)) return false;
+  if (!enqueueMetricEvent(event, env)) {
+    recordLocalTelemetryFailure('LOCAL_OUTBOX_WRITE_FAILED', 'failed to write local telemetry outbox', env);
+    return false;
+  }
+  return spawnOutboxFlush(env);
+}
+
+function emitTelemetryError(error) {
+  try {
+    const message = safeDimension(error instanceof Error ? error.message : String(error), 'unknown', 240);
+    process.stderr.write(`${internalPrefix}TELEMETRY_ERROR=${message}\n`);
+  } catch {
+    // Telemetry must stay nonblocking.
+  }
+}
+
+export async function runTelemetryCli(argv = process.argv) {
+  try {
+    const { command, args } = parseCliArgs(argv);
+    if (command === 'upload-status' && args._.length === 0) {
+      assertCliArgs(args, new Set(), 0);
+      const status = readUploadStatus(process.env) || { schema_ver: 1, status: 'unknown' };
+      process.stderr.write(`${internalPrefix}TELEMETRY_UPLOAD_STATUS=${JSON.stringify(status)}\n`);
+      return 0;
+    }
+    if (command === 'permissioned-flush-needed' && args._.length === 0) {
+      assertCliArgs(args, new Set(), 0);
+      const decision = permissionedFlushDecision(process.env, Date.now(), { markRequested: true });
+      process.stderr.write(`${internalPrefix}PERMISSIONED_FLUSH_DECISION=${JSON.stringify(decision)}\n`);
+      if (decision.needed) {
+        process.stderr.write(`${internalPrefix}PERMISSIONED_FLUSH_NEEDED=true\n`);
+      }
+      return 0;
+    }
+    if (command === 'flush-outbox') {
+      assertCliArgs(args, new Set(), 0);
+      if (!telemetryEnabled(process.env)) return 0;
+      spawnOutboxFlush(process.env);
+      return 0;
+    }
+    if (command === 'flush-outbox-worker') {
+      assertCliArgs(args, new Set(), 0);
+      if (!telemetryEnabled(process.env)) return 0;
+      const timeout = Number(process.env.ALIPAY_AIPAY_TELEMETRY_UPLOAD_TIMEOUT_MS || uploadTimeoutMs);
+      await flushOutbox(process.env, { timeoutMs: Number.isFinite(timeout) ? timeout : uploadTimeoutMs });
+      return 0;
+    }
+    if (!telemetryEnabled(process.env)) return 0;
+    if (command === 'start-run') {
+      assertCliArgs(args, new Set(['root-intent', 'product-type', 'run-id']), 0);
+      const state = createOrReuseRunState(args);
+      if (!writeRunState(state)) {
+        recordLocalTelemetryFailure('LOCAL_RUN_STATE_WRITE_FAILED', 'failed to write local telemetry run state');
+      }
+      const event = stageMetricEvent('run.intent_detected', {
+        runId: state.run_id,
+        rootIntent: state.root_intent,
+        productType: state.product_type
+      });
+      emitMetricEvent(event);
+      return 0;
+    }
+    if (command === 'current-run-id') {
+      assertCliArgs(args, new Set(), 0);
+      const state = canReadImplicitRunState(process.env) ? readRunState(process.env) : null;
+      if (state?.run_id) {
+        process.stderr.write(`${internalPrefix}RUN_ID=${state.run_id}\n`);
+      } else {
+        process.stderr.write(`${internalPrefix}RUN_ID_MISSING=true\n`);
+      }
+      return 0;
+    }
+    if (command !== 'stage' || args._.length !== 1) {
+      emitTelemetryError(new Error('invalid telemetry arguments'));
+      return 0;
+    }
+    assertCliArgs(args, new Set(['run-id', 'root-intent', 'product-type', 'product-name']), 1);
+    const event = stageMetricEvent(args._[0], contextFromCliArgs(args));
+    if (event) updateExistingRunStateFromEvent(event);
+    emitMetricEvent(event);
+    return 0;
+  } catch (error) {
+    emitTelemetryError(error);
+    return 0;
+  }
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  runTelemetryCli(process.argv).then((code) => {
+    process.exitCode = code;
+  }, (error) => {
+    emitTelemetryError(error);
+    process.exitCode = 0;
+  });
+}