claude-cn-flag-check 0.1.0

package/bin/cli.js

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+'use strict';
+
+const { checkLive, getSignalLists, CaptureError } = require('../src/index');
+
+const USAGE = `claude-cn-flag-check — Claude Code 会不会把你的环境标记成「中国用户」?
+
+默认进行【真实检测】:实际运行一次 claude,捕获它真正发出的 system prompt,
+读取其中隐写的地区标记(而非计算预测)。为保真会临时映射 /etc/hosts 把真实
+中转主机名指向本地(需 root,自动备份+还原),并用临时配置隔离,不碰你的真实
+~/.claude,不使用真实凭证(本地拦截)。
+
+用法:
+  claude-cn-flag-check [选项]
+
+选项:
+  --no-capture           不运行 claude,改用从二进制复刻的逻辑做计算预测
+  --base-url <url>       检查一个假设的 ANTHROPIC_BASE_URL(what-if,计算预测)
+  --tz <zone>            检查一个假设的 IANA 时区(what-if,计算预测)
+  --assume-first-party   模拟 _CLAUDE_CODE_ASSUME_FIRST_PARTY_BASE_URL=1
+  --snapshot             使用内置清单快照,跳过从二进制实时提取
+  --binary <path>        指定用于提取清单的 claude 二进制路径
+  --show-list            打印解码出的域名 / AI 实验室关键词清单
+  --json                 机器可读输出(含 observed / capture.mode)
+  --no-anim              关闭扫描动画
+  -h, --help             显示帮助
+  -v, --version          显示版本
+
+退出码:0 = 未标记(安全),1 = 会被识别为中国请求,2 = 真实捕获失败。`;
+
+function parseArgs(argv) {
+  const opts = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case '-h':
+      case '--help':
+        opts.help = true;
+        break;
+      case '-v':
+      case '--version':
+        opts.version = true;
+        break;
+      case '--json':
+        opts.json = true;
+        break;
+      case '--show-list':
+        opts.showList = true;
+        break;
+      case '--snapshot':
+        opts.preferSnapshot = true;
+        break;
+      case '--assume-first-party':
+        opts.assumeFirstParty = true;
+        break;
+      case '--no-anim':
+        opts.noAnim = true;
+        break;
+      case '--no-capture':
+        opts.noCapture = true;
+        break;
+      case '--base-url':
+        opts.baseUrl = argv[++i];
+        break;
+      case '--tz':
+        opts.timezone = argv[++i];
+        break;
+      case '--binary':
+        opts.binaryPath = argv[++i];
+        break;
+      default:
+        process.stderr.write(`未知选项: ${a}\n`);
+        process.exit(2);
+    }
+  }
+  return opts;
+}
+
+const COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
+const c = (code, s) => (COLOR ? `\x1b[${code}m${s}\x1b[0m` : s);
+const red = (s) => c('31', s);
+const green = (s) => c('32', s);
+const yellow = (s) => c('33', s);
+const cyan = (s) => c('36', s);
+const dim = (s) => c('2', s);
+const bold = (s) => c('1', s);
+
+const w = (s) => process.stdout.write(s);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// 分档 → 中文标签 / 颜色
+const LEVEL = {
+  safe: { label: '安全', color: green, bar: green },
+  low: { label: '低', color: green, bar: green },
+  medium: { label: '中', color: yellow, bar: yellow },
+  high: { label: '高', color: red, bar: red },
+};
+
+// 各信号的中文名与修复建议(展示层持有,detect 只给数据)
+const SIGNAL_INFO = {
+  cnTZ: {
+    name: '系统时区',
+    hint: '中国时区,会把日期分隔符 - 改成 /',
+    fix: '用非中国时区启动:TZ=Asia/Tokyo claude(时区挂代理也会泄露,这一招最有效)',
+  },
+  known: {
+    name: '中转域名清单',
+    hint: '中转主机命中内置清单,撇号被改成 U+2019',
+    fix: '换一个不在清单、且非 *.cn 或其子域的中转主机',
+  },
+  labKw: {
+    name: 'AI 实验室关键词',
+    hint: '中转主机含中国 AI 实验室关键词,撇号被改成 U+02BC',
+    fix: '换一个主机名不含 AI 实验室关键词的中转',
+  },
+};
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const pkg = require('../package.json');
+
+  if (opts.help) return w(USAGE + '\n'), 0;
+  if (opts.version) return w(pkg.version + '\n'), 0;
+
+  if (opts.showList) return showList(opts);
+
+  let report;
+  try {
+    report = await checkLive({ ...opts, log: (s) => COLOR && !opts.json && process.stderr.write(dim(`  … ${s}\n`)) });
+  } catch (e) {
+    if (e instanceof CaptureError) {
+      process.stderr.write(red(`\n✗ 真实捕获失败:${e.message}\n`));
+      process.stderr.write(dim(`  (code: ${e.code}) 可加 --no-capture 退回计算预测,或用 root 运行。\n`));
+      return 2;
+    }
+    throw e;
+  }
+
+  if (opts.json) {
+    w(JSON.stringify(report, null, 2) + '\n');
+    return report.marked ? 1 : 0;
+  }
+
+  const animate = COLOR && !opts.noAnim;
+  await printReport(report, animate);
+  return report.marked ? 1 : 0;
+}
+
+function showList(opts) {
+  const lists = getSignalLists(opts);
+  if (opts.json) {
+    w(JSON.stringify(lists, null, 2) + '\n');
+    return 0;
+  }
+  w(`来源: ${lists.source}${lists.version ? ` (v${lists.version})` : ''}  XOR密钥=${lists.xorKey}\n`);
+  w(`\n域名清单(${lists.domains.length} 条):\n`);
+  w('  ' + lists.domains.join('\n  ') + '\n');
+  w(`\nAI 实验室关键词(${lists.labKeywords.length} 条):\n`);
+  w('  ' + lists.labKeywords.join('\n  ') + '\n');
+  return 0;
+}
+
+async function printReport(r, animate) {
+  w(bold('claude-cn-flag-check') + dim('  Claude Code 中国用户标记自查\n'));
+  w(
+    dim(
+      `清单来源: ${r.lists.source}${r.lists.version ? ` v${r.lists.version}` : ''} · ` +
+        `${r.lists.domainCount} 域名 / ${r.lists.keywordCount} 关键词\n\n`,
+    ),
+  );
+
+  w(bold('环境(按真实配置解析,非仅进程环境变量)\n'));
+  const tzMark = r.overrides.timezone ? dim('  [命令行覆盖]') : dim(`  ← ${r.resolution.timezone.source || '未知来源'}`);
+  const buMark = r.overrides.baseUrl
+    ? dim('  [命令行覆盖]')
+    : dim(`  ← ${r.resolution.baseUrl.source || '所有来源均未设置 → 第一方'}`);
+  w(`  系统时区            ${r.input.timezone || dim('(未知)')}${tzMark}\n`);
+  w(`  ANTHROPIC_BASE_URL  ${r.input.baseUrl || dim('(未设置)')}${buMark}\n`);
+  if (r.input.host) w(`  中转主机            ${r.input.host}\n`);
+  w('\n');
+
+  // ——— 判定依据:逐条列出检查过的配置来源 ———
+  renderEvidence(r);
+
+  // ——— 检测项:先全部列出为「待检测」,再逐项刷新结果 ———
+  const items = buildChecks(r);
+  w(bold(`检测项(${items.length} 项区域信号)\n`));
+  await runChecks(items, animate);
+  w('\n');
+
+  // ——— 风险分(count-up 动画) ———
+  await renderScore(r, animate);
+
+  // ——— 隐写载荷 ———
+  const capMode = r.capture && r.capture.mode;
+  const capLabel =
+    capMode === 'observed'
+      ? green('真实捕获 ✓')
+      : capMode === 'first-party'
+        ? green('第一方端点 · 确定安全')
+        : yellow('计算预测');
+  w(bold('实际发出的载体行') + '  ' + capLabel + '\n');
+  if (r.capture && r.capture.reason) w(dim(`  ← ${r.capture.reason}\n`));
+  w(`  ${cyan(JSON.stringify(r.carrier.dateLine))}\n`);
+  w(dim(`  撇号 ${r.carrier.apostropheCodepoint}`));
+  w(dim(r.carrier.separatorSwapped ? ',分隔符 - → /\n' : '\n'));
+  w(dim(`  hex: ${r.carrier.dateLineHex}\n\n`));
+
+  // ——— 判定与修复 ———
+  renderVerdict(r);
+}
+
+// 逐条打印配置解析依据(用户可见「我们凭什么这么判」)
+function renderEvidence(r) {
+  if (r.overrides.baseUrl && r.overrides.timezone) return; // 全手动覆盖,无需依据
+  w(bold('判定依据(检查了这些真实来源)\n'));
+
+  const line = (e) => {
+    const key = e.key ? ` ${e.key}` : '';
+    switch (e.status) {
+      case 'set':
+        return `  ${green('✓')} ${e.source}${key} = ${cyan(maskUrl(e.value))}${e.note ? dim('  · ' + e.note) : ''}`;
+      case 'absent':
+        return `  ${dim('·')} ${e.source}${dim(`${key} 未设置`)}`;
+      case 'missing':
+        return `  ${dim('·')} ${e.source} ${dim('文件不存在')}`;
+      default:
+        return `  ${dim('·')} ${e.source}`;
+    }
+  };
+
+  if (!r.overrides.baseUrl) {
+    w(dim('  ANTHROPIC_BASE_URL:\n'));
+    for (const e of r.resolution.baseUrl.evidence) w(line(e) + '\n');
+  }
+  if (!r.overrides.timezone) {
+    w(dim('  时区(TZ / 系统):\n'));
+    for (const e of r.resolution.timezone.evidence) w(line(e) + '\n');
+  }
+  w('\n');
+}
+
+function maskUrl(v) {
+  return v; // base URL 无敏感信息;token 类不在解析范围内,不会出现在这里
+}
+
+// 构造检测项列表(含前置端点门)
+function buildChecks(r) {
+  const items = [];
+  items.push({
+    name: '端点类型',
+    weight: null,
+    // 命中=第三方(会触发检测)。第一方则整套跳过。
+    status: r.firstParty ? 'safe' : 'gate',
+    detailSafe: '第一方端点(官方 / 未设 base_url / 逃逸开关),整套检测跳过',
+    detailGate: '第三方中转端点,触发地区检测',
+  });
+  for (const id of ['cnTZ', 'known', 'labKw']) {
+    const info = SIGNAL_INFO[id];
+    let status;
+    if (r.firstParty) status = 'skip';
+    else status = r.signals[id] ? 'hit' : 'clear';
+    items.push({ id, name: info.name, weight: r.weights[id], status, hint: info.hint });
+  }
+  return items;
+}
+
+async function runChecks(items, animate) {
+  const pending = (it) =>
+    `  ${dim('◌')} ${it.name}${it.weight != null ? dim(` (权重 ${it.weight})`) : ''} ${dim('…')}`;
+  const resolved = (it) => {
+    const wt = it.weight != null ? dim(` (权重 ${it.weight})`) : '';
+    switch (it.status) {
+      case 'gate':
+        return `  ${yellow('⚑')} ${it.name}${wt}  ${yellow('第三方中转')} ${dim('· ' + it.detailGate)}`;
+      case 'safe':
+        return `  ${green('✓')} ${it.name}${wt}  ${green('第一方端点')} ${dim('· ' + it.detailSafe)}`;
+      case 'skip':
+        return `  ${dim('–')} ${it.name}${wt}  ${dim('跳过')}`;
+      case 'hit':
+        return `  ${red('✗')} ${it.name}${wt}  ${red('命中')} ${dim('· ' + it.hint)}`;
+      case 'clear':
+        return `  ${green('✓')} ${it.name}${wt}  ${green('未命中')}`;
+    }
+  };
+
+  if (!animate) {
+    for (const it of items) w(resolved(it) + '\n');
+    return;
+  }
+  // 先全部打印为待检测
+  for (const it of items) w(pending(it) + '\n');
+  // 光标上移 N 行,逐项清行重写
+  w(`\x1b[${items.length}A`);
+  for (const it of items) {
+    await sleep(240);
+    w('\x1b[2K\r' + resolved(it) + '\n');
+  }
+}
+
+async function renderScore(r, animate) {
+  const lv = LEVEL[r.level];
+  const width = 24;
+  const drawBar = (val) => {
+    const filled = Math.round((val / 100) * width);
+    return lv.bar('█'.repeat(filled)) + dim('░'.repeat(width - filled));
+  };
+  const line = (val) =>
+    `  ${bold('风险分')} ${lv.color(bold(String(val).padStart(3)))}${dim('/100')}  ${drawBar(val)}  ${lv.color('[' + lv.label + ']')}`;
+
+  if (animate && r.score > 0) {
+    const steps = 16;
+    for (let i = 1; i <= steps; i++) {
+      const val = Math.round((r.score * i) / steps);
+      w('\r' + line(val));
+      await sleep(28);
+    }
+    w('\r' + line(r.score) + '\n\n');
+  } else {
+    w(line(r.score) + '\n\n');
+  }
+}
+
+function renderVerdict(r) {
+  if (r.firstParty) {
+    w(green(bold('✓ 安全:第一方端点,无论时区如何都不会被打标记。\n')));
+    return;
+  }
+  if (!r.marked) {
+    w(green(bold('✓ 未标记:走中转,但未命中任何中国信号。\n')));
+    return;
+  }
+
+  const chance = { low: '低', medium: '中', high: '高' }[r.level];
+  w(red(bold('✗ 会被识别为中国大陆请求。\n')));
+  w(`  进入封号风控队列的可能性:${LEVEL[r.level].color(bold(chance))}\n`);
+  const parts = [];
+  if (r.carrier.apostropheCodepoint !== 'U+0027') parts.push(`撇号 ${r.carrier.apostropheCodepoint}`);
+  if (r.carrier.separatorSwapped) parts.push('斜杠日期');
+  w(dim(`  服务器读回:${parts.join(' + ')} → 组成 2–3 bit 中国标记\n\n`));
+
+  w(bold('触发的特征与修复\n'));
+  for (const f of r.features) {
+    const info = SIGNAL_INFO[f.id];
+    w(`  ${yellow('•')} [${info.name} · 权重 ${r.weights[f.id]}] ${info.hint}\n`);
+    w(`    ${dim('修复:')} ${info.fix}\n`);
+  }
+  w('\n');
+  w(
+    dim(
+      '逃逸开关:_CLAUDE_CODE_ASSUME_FIRST_PARTY_BASE_URL=1 可彻底关闭检测\n' +
+        '(告诉客户端把你的 base_url 当作第一方)。依赖前请了解其影响。\n',
+    ),
+  );
+}
+
+main()
+  .then((code) => process.exit(code))
+  .catch((err) => {
+    process.stderr.write(String(err && err.stack ? err.stack : err) + '\n');
+    process.exit(2);
+  });

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "claude-cn-flag-check",
+  "version": "0.1.0",
+  "description": "Check whether Claude Code would covertly flag your environment as a China user (timezone + relay-hostname region marking). Reproduces the client's bundled detection logic for self-audit.",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "privacy",
+    "steganography",
+    "region-detection",
+    "self-check",
+    "cli"
+  ],
+  "homepage": "https://github.com/shellus/claude-cn-flag-check#readme",
+  "bugs": {
+    "url": "https://github.com/shellus/claude-cn-flag-check/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shellus/claude-cn-flag-check.git"
+  },
+  "license": "MIT",
+  "author": "shellus <353358601@qq.com>",
+  "type": "commonjs",
+  "main": "src/index.js",
+  "bin": {
+    "claude-cn-flag-check": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "start": "node bin/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/capture.js

@@ -0,0 +1,204 @@
+'use strict';
+
+/**
+ * REAL capture: run the actual Claude Code binary once against a local endpoint
+ * and read the system prompt it genuinely emits, so the marker is *observed*,
+ * not predicted.
+ *
+ * To keep the marker faithful we must let Claude Code see the real relay
+ * hostname (the apostrophe depends on it) while the request lands on our local
+ * server. We do that by:
+ *   1. writing a throwaway CLAUDE_CONFIG_DIR whose settings.json points
+ *      ANTHROPIC_BASE_URL at http://<realHost>:<port>,
+ *   2. temporarily mapping <realHost> → 127.0.0.1 in /etc/hosts (backed up and
+ *      restored, with signal handlers as a safety net),
+ *   3. capturing the POST /v1/messages body and extracting `Today's date is …`.
+ *
+ * No real credentials are used (we intercept before anything leaves the box)
+ * and nothing in the user's real ~/.claude is touched.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const net = require('net');
+const path = require('path');
+const http = require('http');
+const { spawn } = require('child_process');
+const { resolveBinaryPath } = require('./extract');
+
+const HOSTS_PATH = '/etc/hosts';
+const MARKER = '# claude-cn-flag-check (temporary — auto-removed)';
+
+function getFreePort() {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.listen(0, '127.0.0.1', () => {
+      const p = srv.address().port;
+      srv.close(() => resolve(p));
+    });
+    srv.on('error', reject);
+  });
+}
+
+function parseCarrier(body) {
+  // Match Today<apostrophe>s date is <date>. across the raw JSON body.
+  const m = body.match(/Today(.)s date is (\d{4}[/-]\d{2}[/-]\d{2})/);
+  if (!m) return null;
+  const apostrophe = m[1];
+  const date = m[2];
+  return { apostrophe, date, separatorSwapped: date.includes('/'), dateLine: `Today${apostrophe}s date is ${date}.` };
+}
+
+function readHosts() {
+  try {
+    return fs.readFileSync(HOSTS_PATH, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function needsHostsEntry(host) {
+  if (!host || host === '127.0.0.1' || host === 'localhost') return false;
+  return true;
+}
+
+/**
+ * Run one real capture.
+ *
+ * @param {object} o
+ * @param {string} o.host       real relay hostname to preserve in the marker
+ * @param {string} o.baseUrl    the real ANTHROPIC_BASE_URL (for the model/scheme)
+ * @param {string=} o.model     model to request (from real settings if any)
+ * @param {number=} o.timeoutMs default 30000
+ * @param {(s:string)=>void=} o.log  progress logger
+ * @returns {Promise<{apostrophe,date,separatorSwapped,dateLine,raw,host}>}
+ */
+async function captureReal(o) {
+  const host = o.host;
+  const log = o.log || (() => {});
+  const timeoutMs = o.timeoutMs || 30000;
+
+  const claudeBin = resolveBinaryPath();
+  if (!claudeBin) throw new CaptureError('未找到 claude 二进制(claude 未安装或不在 PATH)', 'no-binary');
+
+  const spoof = needsHostsEntry(host);
+  if (spoof) {
+    const hosts = readHosts();
+    if (hosts == null) throw new CaptureError(`无法读取 ${HOSTS_PATH}`, 'hosts-read');
+    try {
+      fs.accessSync(HOSTS_PATH, fs.constants.W_OK);
+    } catch {
+      throw new CaptureError(`需要写入 ${HOSTS_PATH} 以保真捕获(请用 root 运行,或加 --no-capture 退回计算预测)`, 'hosts-perm');
+    }
+  }
+
+  const port = await getFreePort();
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cnflag-cap-'));
+  const configDir = path.join(tmpDir, '.claude');
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(configDir, 'settings.json'),
+    JSON.stringify({ env: { ANTHROPIC_BASE_URL: `http://${host}:${port}`, ANTHROPIC_AUTH_TOKEN: 'sk-cnflag-local-capture' } }),
+  );
+
+  let hostsBackup = null;
+  let child = null;
+  let server = null;
+  const cleanup = () => {
+    if (hostsBackup != null) {
+      try {
+        fs.writeFileSync(HOSTS_PATH, hostsBackup);
+      } catch {
+        /* best effort */
+      }
+      hostsBackup = null;
+    }
+    if (child) {
+      try {
+        child.kill('SIGKILL');
+      } catch {
+        /* ignore */
+      }
+    }
+    if (server) {
+      try {
+        server.close();
+      } catch {
+        /* ignore */
+      }
+    }
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  };
+  const onSignal = () => {
+    cleanup();
+    process.exit(130);
+  };
+  process.on('SIGINT', onSignal);
+  process.on('SIGTERM', onSignal);
+
+  try {
+    if (spoof) {
+      hostsBackup = readHosts();
+      fs.writeFileSync(HOSTS_PATH, hostsBackup.replace(/\n?$/, '\n') + `127.0.0.1 ${host} ${MARKER}\n`);
+      log(`临时映射 ${host} → 127.0.0.1(/etc/hosts)`);
+    }
+
+    const captured = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new CaptureError('捕获超时(claude 未在时限内发出请求)', 'timeout')), timeoutMs);
+
+      server = http.createServer((req, res) => {
+        let b = '';
+        req.on('data', (c) => (b += c));
+        req.on('end', () => {
+          if (req.method === 'POST' && b.length > 0) {
+            const parsed = parseCarrier(b);
+            if (parsed) {
+              clearTimeout(timer);
+              resolve({ ...parsed, raw: b, host });
+            }
+          }
+          if (req.url && req.url.includes('messages')) {
+            res.writeHead(200, { 'content-type': 'text/event-stream' });
+            res.end(
+              'event: message_start\ndata: {"type":"message_start","message":{"id":"x","type":"message","role":"assistant","model":"x","content":[],"stop_reason":null,"usage":{"input_tokens":1,"output_tokens":1}}}\n\nevent: message_stop\ndata: {"type":"message_stop"}\n\n',
+            );
+          } else {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end('{}');
+          }
+        });
+      });
+      server.on('error', reject);
+      server.listen(port, '127.0.0.1', () => {
+        log('本地捕获端点就绪,启动 claude…');
+        const args = ['-p', 'ping', '--output-format', 'text'];
+        if (o.model) args.push('--model', o.model);
+        child = spawn(claudeBin, args, {
+          env: { ...process.env, CLAUDE_CONFIG_DIR: configDir, ANTHROPIC_BASE_URL: `http://${host}:${port}` },
+          stdio: ['ignore', 'ignore', 'ignore'],
+        });
+        child.on('error', (e) => reject(new CaptureError(`启动 claude 失败: ${e.message}`, 'spawn')));
+      });
+    });
+
+    return captured;
+  } finally {
+    process.removeListener('SIGINT', onSignal);
+    process.removeListener('SIGTERM', onSignal);
+    cleanup();
+  }
+}
+
+class CaptureError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = 'CaptureError';
+    this.code = code;
+  }
+}
+
+module.exports = { captureReal, CaptureError, parseCarrier };