ClaudeCode下载代理(Worker)

1. Claude Code 是什么？#

简单来讲，Claude Code 就是一款 AI 智能编程工具，具有强大的 Vibe Coding 能力，详细介绍请看 Claude Code 使用笔记。

2. 入门安装#

由于不可抗因素，Claude 的母公司 Anthropic 对中国大陆拒绝提供 AI 服务，禁止使用 Claude 系列模型。但我们仅仅只是想使用 Claude Code 这个工具（Claude Code ≠ AI 模型），所以不要再发出类似于”Cursor 不如 Claude”这种驴唇不对马嘴的言论了。

官方的 NPM 安装方式已处于废弃状态，更推荐使用原生安装。

但正如前文所说，如果直接使用官方命令（国内正常网络环境下）：

1
irm https://claude.ai/install.ps1 | iex

大概率会得到以下报错：下载出错页面图片因此，我们提供了基于 Cloudflare Worker 的加速下载方案。

3. Worker 配置#

3.1 核心 Worker 代码#

请将 SELF_BASE 修改为你要使用的加速域名：

1
const CLAUDE = "https://claude.ai";
2
const SELF_BASE = "https://你的加速域名";
3
const ALLOWED_INSTALL = new Set(["/install.ps1", "/install.sh", "/install.cmd"]);
4
// 安装脚本体积上限 1MB（正常脚本 <50KB，此值仅防异常/被劫持场景）
5
const MAX_INSTALL_SCRIPT_SIZE = 1 * 1024 * 1024;
6

7
function isAllowedGcsPath(p) {
8
  // 只允许 claude-code-dist-* bucket 下的路径
9
  const pathOnly = p.split('?')[0];
10
  return /^claude-code-dist-[0-9a-f\-]+\//.test(pathOnly);
11
}
12

13
function withTimeout(ms) {
14
  const controller = new AbortController();
15
  const id = setTimeout(
16
    () => controller.abort(new Error("Upstream fetch timeout")),
17
    ms
18
  );
19
  return { controller, cancel: () => clearTimeout(id) };
20
}
21

22
/** 安全文本响应头 */
23
function secHeaders(extra = {}) {
24
  return {
25
    "Content-Type": "text/plain; charset=utf-8",
26
    "Cache-Control": "no-store",
27
    "X-Content-Type-Options": "nosniff",
28
    "X-Frame-Options": "DENY",
29
    ...extra,
30
  };
31
}
32

33
async function buildUpstreamErrorResponse({
34
  title,
35
  upstreamResp,
36
  extraHeaders = {},
37
}) {
38
  // 消费 body 防止连接泄漏
39
  try { await upstreamResp.text(); } catch {}
40

41
  const body = [
42
    title,
43
    `Time: ${new Date().toISOString()}`,
44
    `Upstream status: ${upstreamResp.status}`,
45
  ].join("\n");
46

47
  return new Response(body, {
48
    status: 502,
49
    headers: secHeaders({
50
      "X-Proxy-Error": "upstream_non_ok",
51
      ...extraHeaders,
52
    }),
53
  });
54
}
55

56
export default {
57
  async fetch(request) {
58
    const url = new URL(request.url);
59
    let path = url.pathname;
60

61
    // ===== 处理 OPTIONS 预检请求 =====
62
    if (request.method === "OPTIONS") {
63
      return new Response(null, {
64
        status: 204,
65
        headers: {
66
          "Access-Control-Allow-Origin": "*",
67
          "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS",
68
          "Access-Control-Allow-Headers": "Content-Type, User-Agent, Accept, Accept-Encoding",
69
          "Access-Control-Max-Age": "86400",
70
        },
71
      });
72
    }
73

74
    // ===== 只允许 GET / HEAD =====
75
    if (!["GET", "HEAD"].includes(request.method)) {
76
      return new Response("Method Not Allowed", {
77
        status: 405,
78
        headers: secHeaders(),
79
      });
80
    }
81

82
    if (path === "/favicon.ico") {
83
      return new Response(null, { status: 204 });
84
    }
85

86
    // 健康检查页面
87
    if (path === "/") {
88
      const clientIp = request.headers.get("CF-Connecting-IP") || "unknown";
89
      const clientCountry = request.headers.get("CF-IPCountry") || "unknown";
90

91
      const checks = await Promise.allSettled([
92
        (async () => {
93
          const { controller, cancel } = withTimeout(15000);
94
          try {
95
            const resp = await fetch(CLAUDE + "/install.ps1", {
96
              signal: controller.signal,
97
              headers: { "User-Agent": "Mozilla/5.0" },
98
            });
99
            cancel();
100
            if (!resp.ok) return { ok: false, msg: `HTTP ${resp.status}` };
101
            const text = await resp.text();
102
            const hasGcs = text.includes("storage.googleapis.com/");
103
            const rewritten = text.replace(
104
              /\$GCS_BUCKET = "https:\/\/storage\.googleapis\.com\/([^"]+)"/g,
105
              `$GCS_BUCKET = "${SELF_BASE}/gcs/$1"`
106
            );
107
            const ok = rewritten.includes(SELF_BASE + "/gcs/");
108
            return { ok, msg: ok ? "拉取成功，改写正常" : (hasGcs ? "正则未匹配" : "源脚本无 GCS 链接") };
109
          } catch (e) {
110
            cancel();
111
            return { ok: false, msg: String(e) };
112
          }
113
        })(),
114
        (async () => {
115
          const { controller, cancel } = withTimeout(20000);
116
          try {
117
            const resp = await fetch(
118
              `https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/latest`,
119
              { signal: controller.signal, headers: { "User-Agent": "CloudflareWorker/1.0" } }
120
            );
121
            cancel();
122
            if (!resp.ok) return { ok: false, msg: `HTTP ${resp.status}` };
123
            const version = (await resp.text()).trim();
124
            return { ok: true, msg: `版本: ${version}` };
125
          } catch (e) {
126
            cancel();
127
            return { ok: false, msg: String(e) };
128
          }
129
        })(),
130
      ]);
131

132
      const ps1Status = checks[0].status === "fulfilled" ? checks[0].value : { ok: false, msg: "检查失败" };
133
      const gcsStatus = checks[1].status === "fulfilled" ? checks[1].value : { ok: false, msg: "检查失败" };
134

135
      const html = `<!DOCTYPE html>
136
<html>
137
<head>
138
  <meta charset="utf-8">
139
  <meta name="viewport" content="width=device-width, initial-scale=1">
140
  <title>Claude Code Proxy - 健康检查</title>
141
  <style>
142
    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; margin: 40px; background: #f5f5f5; }
143
    .container { max-width: 600px; margin: 0 auto; background: white; padding: 30px; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
144
    h1 { color: #333; margin-bottom: 30px; }
145
    .check { margin: 20px 0; padding: 15px; border-left: 4px solid #ddd; background: #fafafa; }
146
    .check.ok { border-left-color: #22c55e; background: #f0fdf4; }
147
    .check.fail { border-left-color: #ef4444; background: #fef2f2; }
148
    .status { font-weight: bold; margin-bottom: 5px; }
149
    .status.ok { color: #22c55e; }
150
    .status.fail { color: #ef4444; }
151
    .msg { color: #666; font-size: 14px; }
152
    .info { margin-top: 30px; padding: 15px; background: #f0f9ff; border-left: 4px solid #3b82f6; }
153
    .info-title { font-weight: bold; color: #1e40af; margin-bottom: 8px; }
154
    .info-item { color: #666; font-size: 14px; margin: 5px 0; }
155
  </style>
156
</head>
157
<body>
158
  <div class="container">
159
    <h1>✓ Claude Code Proxy 运行正常</h1>
160

161
    <div class="check ${ps1Status.ok ? "ok" : "fail"}">
162
      <div class="status ${ps1Status.ok ? "ok" : "fail"}">
163
        ${ps1Status.ok ? "✓" : "✗"} install.ps1 改写
164
      </div>
165
      <div class="msg">${ps1Status.msg}</div>
166
    </div>
167

168
    <div class="check ${gcsStatus.ok ? "ok" : "fail"}">
169
      <div class="status ${gcsStatus.ok ? "ok" : "fail"}">
170
        ${gcsStatus.ok ? "✓" : "✗"} GCS 代理
171
      </div>
172
      <div class="msg">${gcsStatus.msg}</div>
173
    </div>
174

175
    <div class="info">
176
      <div class="info-title">访问者信息</div>
177
      <div class="info-item">IP: ${clientIp}</div>
178
      <div class="info-item">地区: ${clientCountry}</div>
179
      <div class="info-item">时间: ${new Date().toISOString()}</div>
180
    </div>
181

182
    <div style="margin-top:20px;padding:15px;background:#fff3cd;border:1px solid #ffc107;border-radius:4px;">
183
      <strong>声明</strong>
184
      <p style="margin:8px 0;font-size:14px;color:#333;">本站为非官方代理，仅用于中国大陆加速 Claude Code 安装。</p>
185
      <p style="margin:8px 0;font-size:14px;">官方网站：<a href="https://claude.ai" target="_blank" rel="noopener" style="color:#0066cc;">https://claude.ai</a></p>
186
    </div>
187
  </div>
188
</body>
189
</html>`;
190

191
      return new Response(html, {
192
        status: 200,
193
        headers: { "Content-Type": "text/html; charset=utf-8" },
194
      });
195
    }
196

197
    // 安装脚本：从 claude.ai 拉取，改写 GCS 链接指向自身
198
    if (ALLOWED_INSTALL.has(path)) {
199
      const upstreamUrl = CLAUDE + path;
200
      const { controller, cancel } = withTimeout(15000);
201

202
      let upstream;
203
      try {
204
        const fetchOpts = {
205
          method: request.method,
206
          headers: {
207
            "User-Agent": request.headers.get("User-Agent") || "Mozilla/5.0",
208
            Accept: "*/*",
209
          },
210
          redirect: "follow",
211
          signal: controller.signal,
212
        };
213
        upstream = await fetch(upstreamUrl, fetchOpts);
214
      } catch (e) {
215
        cancel();
216
        return new Response(
217
          `Upstream fetch failed (install script)\nTime: ${new Date().toISOString()}\nError: ${String(e)}\n`,
218
          {
219
            status: 504,
220
            headers: secHeaders({ "X-Proxy-Error": "install_fetch_failed" }),
221
          }
222
        );
223
      } finally {
224
        cancel();
225
      }
226

227
      // HEAD 直接透传状态 + 头（不读 body）
228
      if (request.method === "HEAD") {
229
        const h = new Headers(upstream.headers);
230
        h.set("Cache-Control", "no-store, max-age=0, must-revalidate");
231
        h.set("Pragma", "no-cache");
232
        h.set("Expires", "0");
233
        h.set("X-Content-Type-Options", "nosniff");
234
        h.set("X-Proxy-Source", `rewrite:${path}`);
235
        return new Response(null, { status: upstream.status, headers: h });
236
      }
237

238
      if (!upstream.ok) {
239
        return buildUpstreamErrorResponse({
240
          title: "Failed to fetch install script from claude.ai",
241
          upstreamResp: upstream,
242
          extraHeaders: { "X-Proxy-Source": `rewrite:${path}` },
243
        });
244
      }
245

246
      // ---- 大小保护：先查 Content-Length 头 ----
247
      const cl = Number(upstream.headers.get("content-length") || "0");
248
      if (cl > MAX_INSTALL_SCRIPT_SIZE) {
249
        await upstream.body?.cancel();
250
        return new Response(
251
          `Install script too large (content-length: ${cl})\n`,
252
          {
253
            status: 502,
254
            headers: secHeaders({ "X-Proxy-Source": `rewrite:${path}` }),
255
          }
256
        );
257
      }
258

259
      const text = await upstream.text();
260

261
      // ---- 大小保护：再查实际 body 长度（Content-Length 可能缺失或不准） ----
262
      if (text.length > MAX_INSTALL_SCRIPT_SIZE) {
263
        return new Response("Install script body too large\n", {
264
          status: 502,
265
          headers: secHeaders({ "X-Proxy-Source": `rewrite:${path}` }),
266
        });
267
      }
268

269
      // 改写 GCS 链接 → 走自身代理
270
      // PowerShell: $GCS_BUCKET = "https://storage.googleapis.com/..."
271
      let rewritten = text.replace(
272
        /\$GCS_BUCKET = "https:\/\/storage\.googleapis\.com\/([^"]+)"/g,
273
        `$GCS_BUCKET = "${SELF_BASE}/gcs/$1"`
274
      );
275
      // Shell: GCS_BUCKET="https://storage.googleapis.com/..."
276
      rewritten = rewritten.replace(
277
        /GCS_BUCKET="https:\/\/storage\.googleapis\.com\/([^"]+)"/g,
278
        `GCS_BUCKET="${SELF_BASE}/gcs/$1"`
279
      );
280
      // CMD: set "GCS_BUCKET=https://storage.googleapis.com/..."
281
      rewritten = rewritten.replace(
282
        /set "GCS_BUCKET=https:\/\/storage\.googleapis\.com\/([^"]+)"/g,
283
        `set "GCS_BUCKET=${SELF_BASE}/gcs/$1"`
284
      );
285

286
      return new Response(rewritten, {
287
        status: 200,
288
        headers: {
289
          "Content-Type": "text/plain; charset=utf-8",
290
          "Cache-Control": "no-store, max-age=0, must-revalidate",
291
          Pragma: "no-cache",
292
          Expires: "0",
293
          "X-Content-Type-Options": "nosniff",
294
          "X-Proxy-Source": `rewrite:${path}`,
295
        },
296
      });
297
    }
298

299
    //  /gcs/*：代理到 storage.googleapis.com（白名单路径）
300
    if (path.startsWith("/gcs/")) {
301
      const gcsPath = path.slice("/gcs/".length);
302

303
      if (!isAllowedGcsPath(gcsPath)) {
304
        return new Response("Forbidden", { status: 403, headers: secHeaders() });
305
      }
306

307
      // 转发查询字符串
308
      const target = `https://storage.googleapis.com/${gcsPath}${url.search}`;
309

310
      // 白名单转发请求头，不泄漏 Cookie / Authorization / 用户 IP 等
311
      const fwdHeaders = new Headers();
312
      const FORWARD = [
313
        "Range",
314
        "Accept",
315
        "Accept-Encoding",
316
        "If-None-Match",
317
        "If-Modified-Since",
318
      ];
319
      for (const h of FORWARD) {
320
        const v = request.headers.get(h);
321
        if (v) fwdHeaders.set(h, v);
322
      }
323
      fwdHeaders.set("User-Agent", "CloudflareWorker/1.0");
324

325
      // exe/二进制文件按版本路径缓存，latest 和 manifest 不缓存
326
      const isCacheable = !gcsPath.endsWith("/latest") && !gcsPath.endsWith("/manifest.json");
327
      const isExe = gcsPath.endsWith("/claude.exe");
328
      const timeoutMs = isExe ? 600000 : 20000;
329
      const { controller, cancel } = withTimeout(timeoutMs);
330

331
      let upstream;
332
      try {
333
        const fetchOpts = {
334
          method: request.method,
335
          headers: fwdHeaders,
336
          redirect: "follow",
337
          signal: controller.signal,
338
          cf: isCacheable
339
            ? { cacheEverything: true, cacheTtl: 86400 }
340
            : { cacheEverything: false, cacheTtl: 0 },
341
        };
342
        upstream = await fetch(target, fetchOpts);
343
      } catch (e) {
344
        cancel();
345
        return new Response(
346
          `Upstream fetch failed (gcs proxy)\nTime: ${new Date().toISOString()}\nError: ${String(e)}\n`,
347
          {
348
            status: 504,
349
            headers: secHeaders({
350
              "X-Proxy-Error": "gcs_fetch_failed",
351
              "X-Proxy-Source": `gcs:${gcsPath}`,
352
            }),
353
          }
354
        );
355
      } finally {
356
        cancel();
357
      }
358

359
      // 304 Not Modified：透传（CF 缓存层内部条件请求可能产生）
360
      if (upstream.status === 304) {
361
        const respHeaders = new Headers(upstream.headers);
362
        respHeaders.set("X-Proxy-Source", `gcs:${gcsPath}`);
363
        respHeaders.set("X-Content-Type-Options", "nosniff");
364
        return new Response(null, { status: 304, headers: respHeaders });
365
      }
366

367
      // 非 2xx：返回友好错误，状态 502（避免客户端工具误当正常内容）
368
      if (!(upstream.status >= 200 && upstream.status < 300)) {
369
        return buildUpstreamErrorResponse({
370
          title: "GCS upstream returned non-2xx",
371
          upstreamResp: upstream,
372
          extraHeaders: { "X-Proxy-Source": `gcs:${gcsPath}` },
373
        });
374
      }
375

376
      // 成功：流式透传 body
377
      const respHeaders = new Headers(upstream.headers);
378
      respHeaders.set("Cache-Control", isCacheable ? "public, max-age=86400" : "no-store, max-age=0");
379
      respHeaders.set("X-Proxy-Source", `gcs:${gcsPath}`);
380
      respHeaders.set("X-Content-Type-Options", "nosniff");
381
      // 确保保留 Content-Length 和 Content-Type
382
      if (!respHeaders.has("Content-Type")) {
383
        respHeaders.set("Content-Type", "application/octet-stream");
384
      }
385

386
      return new Response(upstream.body, {
387
        status: upstream.status,
388
        headers: respHeaders,
389
      });
390
    }
391

392
    return new Response("Not Found", { status: 404, headers: secHeaders() });
393
  },
394
};

3.2 Worker 路由#

我们利用 Worker 的路由来进行转发（workers.dev 域名在大陆无法正常访问），请务必填写为 你的加速域名/*：

Worker路由图片

然后记录下你的 Worker 分配的子域名，例如 abc.abc.workers.dev：

Worker子域图片

4. 加速域名配置#

来到你托管在 Cloudflare 的域名下，选择 DNS — 记录，将你预定的加速域名 CNAME 指向你的 Worker 分配的子域名，如图所示（记得开启小黄云）：

DNS域名图片

5. 使用#

部署完成后，访问你的加速域名：

能否成功下载也取决于你的网络能否正常连接到 Cloudflare，请耐心等待，Worker 速度可能不太稳定。

加速域名图片

然后选择适合你终端的下载方式（以 PowerShell 为例）：

1
irm https://c.ai0728.com.cn/install.ps1 | iex

成功效果：

成功代理图片