codora-anthropic-auth 0.0.1

package/README.md

@@ -0,0 +1,56 @@
+# codora-anthropic-auth
+
+Anthropic (Claude) authentication plugin for Codora.
+
+## Installation
+
+```bash
+npm install codora-anthropic-auth
+```
+
+## Usage
+
+```javascript
+import { AnthropicAuthPlugin } from 'codora-anthropic-auth';
+
+// 在 Codora 中注册插件
+const plugin = await AnthropicAuthPlugin({ client: codoraClient });
+```
+
+## Authentication Methods
+
+This plugin provides three authentication methods:
+
+1. **Claude Pro/Max** - OAuth login for Claude Pro/Max subscribers
+2. **Create an API Key** - OAuth login that creates an API key automatically
+3. **Manually enter API Key** - Direct API key input
+
+## How It Works
+
+### OAuth Flow (Claude Pro/Max)
+
+1. User initiates login
+2. Plugin generates PKCE challenge
+3. User is redirected to `claude.ai/oauth/authorize`
+4. User authorizes and receives a code
+5. Plugin exchanges code for access/refresh tokens
+6. Tokens are stored and used for API requests
+
+### API Key Flow
+
+1. User enters API key manually
+2. Key is stored and used for API requests
+
+## Plugin Interface
+
+```typescript
+interface AuthHook {
+  provider: "anthropic"
+  loader: (getAuth, provider) => Promise<{ apiKey, fetch }>
+  methods: AuthMethod[]
+}
+```
+
+## License
+
+MIT

package/index.mjs

@@ -0,0 +1,346 @@
+import { generatePKCE } from "@openauthjs/openauth/pkce";
+
+const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+
+/**
+ * @param {"max" | "console"} mode
+ */
+async function authorize(mode) {
+  const pkce = await generatePKCE();
+
+  const baseUrl = mode === "console"
+    ? "https://console.anthropic.com/oauth/authorize"
+    : "https://claude.ai/oauth/authorize";
+
+  const url = new URL(baseUrl);
+  url.searchParams.set("code", "true");
+  url.searchParams.set("client_id", CLIENT_ID);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("redirect_uri", "https://console.anthropic.com/oauth/code/callback");
+  url.searchParams.set("scope", "org:create_api_key user:profile user:inference");
+  url.searchParams.set("code_challenge", pkce.challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("state", pkce.verifier);
+
+  return {
+    url: url.toString(),
+    verifier: pkce.verifier,
+  };
+}
+
+/**
+ * @param {string} code
+ * @param {string} verifier
+ */
+async function exchange(code, verifier) {
+  const splits = code.split("#");
+  const result = await fetch("https://console.anthropic.com/v1/oauth/token", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      code: splits[0],
+      state: splits[1],
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      redirect_uri: "https://console.anthropic.com/oauth/code/callback",
+      code_verifier: verifier,
+    }),
+  });
+  if (!result.ok)
+    return {
+      type: "failed",
+    };
+  const json = await result.json();
+  return {
+    type: "success",
+    refresh: json.refresh_token,
+    access: json.access_token,
+    expires: Date.now() + json.expires_in * 1000,
+  };
+}
+
+/**
+ * Anthropic Auth Plugin for Codora
+ * @param {Object} input - Plugin input from Codora
+ * @param {Object} input.client - Codora client instance
+ */
+export async function AnthropicAuthPlugin({ client }) {
+  return {
+    auth: {
+      provider: "anthropic",
+
+      /**
+       * Loader - 当用户已认证时调用，用于配置 provider
+       */
+      async loader(getAuth, provider) {
+        const auth = await getAuth();
+        if (auth.type === "oauth") {
+          // Claude Pro/Max 用户 - 费用为 0
+          for (const model of Object.values(provider.models)) {
+            model.cost = {
+              input: 0,
+              output: 0,
+              cache: { read: 0, write: 0 },
+            };
+          }
+
+          return {
+            apiKey: "",
+            /**
+             * 自定义 fetch - 处理 OAuth token 刷新和请求修改
+             */
+            async fetch(input, init) {
+              const auth = await getAuth();
+              if (auth.type !== "oauth") return fetch(input, init);
+
+              // Token 过期，刷新
+              if (!auth.access || auth.expires < Date.now()) {
+                const response = await fetch(
+                  "https://console.anthropic.com/v1/oauth/token",
+                  {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                      grant_type: "refresh_token",
+                      refresh_token: auth.refresh,
+                      client_id: CLIENT_ID,
+                    }),
+                  },
+                );
+                if (!response.ok) {
+                  throw new Error(`Token refresh failed: ${response.status}`);
+                }
+                const json = await response.json();
+                await client.auth.set({
+                  path: { id: "anthropic" },
+                  body: {
+                    type: "oauth",
+                    refresh: json.refresh_token,
+                    access: json.access_token,
+                    expires: Date.now() + json.expires_in * 1000,
+                  },
+                });
+                auth.access = json.access_token;
+              }
+
+              // 构建请求头
+              const requestHeaders = new Headers();
+              if (input instanceof Request) {
+                input.headers.forEach((value, key) => {
+                  requestHeaders.set(key, value);
+                });
+              }
+              if (init?.headers) {
+                if (init.headers instanceof Headers) {
+                  init.headers.forEach((value, key) => {
+                    requestHeaders.set(key, value);
+                  });
+                } else if (Array.isArray(init.headers)) {
+                  for (const [key, value] of init.headers) {
+                    if (typeof value !== "undefined") {
+                      requestHeaders.set(key, String(value));
+                    }
+                  }
+                } else {
+                  for (const [key, value] of Object.entries(init.headers)) {
+                    if (typeof value !== "undefined") {
+                      requestHeaders.set(key, String(value));
+                    }
+                  }
+                }
+              }
+
+              // 设置 OAuth 相关头
+              const incomingBeta = requestHeaders.get("anthropic-beta") || "";
+              const incomingBetasList = incomingBeta
+                .split(",")
+                .map((b) => b.trim())
+                .filter(Boolean);
+
+              const mergedBetas = [
+                "oauth-2025-04-20",
+                "interleaved-thinking-2025-05-14",
+                ...incomingBetasList.filter(b => !b.startsWith("oauth-") && !b.startsWith("interleaved-thinking-")),
+              ].join(",");
+
+              requestHeaders.set("authorization", `Bearer ${auth.access}`);
+              requestHeaders.set("anthropic-beta", mergedBetas);
+              requestHeaders.set("user-agent", "claude-cli/2.1.2 (external, cli)");
+              requestHeaders.delete("x-api-key");
+
+              // 处理请求体 - 添加工具前缀
+              const TOOL_PREFIX = "mcp_";
+              let body = init?.body;
+              if (body && typeof body === "string") {
+                try {
+                  const parsed = JSON.parse(body);
+
+                  // 系统提示词处理
+                  if (parsed.system && Array.isArray(parsed.system)) {
+                    parsed.system = parsed.system.map(item => {
+                      if (item.type === 'text' && item.text) {
+                        return {
+                          ...item,
+                          text: item.text
+                            .replace(/Codora/g, 'Claude Code')
+                            .replace(/codora/gi, 'Claude')
+                        };
+                      }
+                      return item;
+                    });
+                  }
+
+                  // 工具定义添加前缀
+                  if (parsed.tools && Array.isArray(parsed.tools)) {
+                    parsed.tools = parsed.tools.map((tool) => ({
+                      ...tool,
+                      name: tool.name ? `${TOOL_PREFIX}${tool.name}` : tool.name,
+                    }));
+                  }
+
+                  // 消息中的 tool_use 添加前缀
+                  if (parsed.messages && Array.isArray(parsed.messages)) {
+                    parsed.messages = parsed.messages.map((msg) => {
+                      if (msg.content && Array.isArray(msg.content)) {
+                        msg.content = msg.content.map((block) => {
+                          if (block.type === "tool_use" && block.name) {
+                            return { ...block, name: `${TOOL_PREFIX}${block.name}` };
+                          }
+                          return block;
+                        });
+                      }
+                      return msg;
+                    });
+                  }
+                  body = JSON.stringify(parsed);
+                } catch (e) {
+                  // ignore parse errors
+                }
+              }
+
+              // 处理 URL
+              let requestInput = input;
+              let requestUrl = null;
+              try {
+                if (typeof input === "string" || input instanceof URL) {
+                  requestUrl = new URL(input.toString());
+                } else if (input instanceof Request) {
+                  requestUrl = new URL(input.url);
+                }
+              } catch {
+                requestUrl = null;
+              }
+
+              if (
+                requestUrl &&
+                requestUrl.pathname === "/v1/messages" &&
+                !requestUrl.searchParams.has("beta")
+              ) {
+                requestUrl.searchParams.set("beta", "true");
+                requestInput =
+                  input instanceof Request
+                    ? new Request(requestUrl.toString(), input)
+                    : requestUrl;
+              }
+
+              const response = await fetch(requestInput, {
+                ...init,
+                body,
+                headers: requestHeaders,
+              });
+
+              // 转换响应流 - 移除工具前缀
+              if (response.body) {
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                const encoder = new TextEncoder();
+
+                const stream = new ReadableStream({
+                  async pull(controller) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                      controller.close();
+                      return;
+                    }
+                    let text = decoder.decode(value, { stream: true });
+                    text = text.replace(/"name"\s*:\s*"mcp_([^"]+)"/g, '"name": "$1"');
+                    controller.enqueue(encoder.encode(text));
+                  },
+                });
+
+                return new Response(stream, {
+                  status: response.status,
+                  statusText: response.statusText,
+                  headers: response.headers,
+                });
+              }
+
+              return response;
+            },
+          };
+        }
+
+        return {};
+      },
+
+      /**
+       * 认证方法列表 - UI 中显示的选项
+       */
+      methods: [
+        {
+          label: "Claude Pro/Max",
+          type: "oauth",
+          authorize: async () => {
+            const { url, verifier } = await authorize("max");
+            return {
+              url: url,
+              instructions: "Paste the authorization code here: ",
+              method: "code",
+              callback: async (code) => {
+                const credentials = await exchange(code, verifier);
+                return credentials;
+              },
+            };
+          },
+        },
+        {
+          label: "Create an API Key",
+          type: "oauth",
+          authorize: async () => {
+            const { url, verifier } = await authorize("console");
+            return {
+              url: url,
+              instructions: "Paste the authorization code here: ",
+              method: "code",
+              callback: async (code) => {
+                const credentials = await exchange(code, verifier);
+                if (credentials.type === "failed") return credentials;
+                const result = await fetch(
+                  `https://api.anthropic.com/api/oauth/claude_cli/create_api_key`,
+                  {
+                    method: "POST",
+                    headers: {
+                      "Content-Type": "application/json",
+                      authorization: `Bearer ${credentials.access}`,
+                    },
+                  },
+                ).then((r) => r.json());
+                return { type: "success", key: result.raw_key };
+              },
+            };
+          },
+        },
+        {
+          provider: "anthropic",
+          label: "Manually enter API Key",
+          type: "api",
+        },
+      ],
+    },
+  };
+}
+
+// 默认导出
+export default AnthropicAuthPlugin;

package/oauth-url.txt

@@ -0,0 +1 @@
+https://claude.ai/oauth/authorize?code=true&client_id=9d1c250a-e61b-44d9-88ed-5944d1962f5e&response_type=code&redirect_uri=https%3A%2F%2Fconsole.anthropic.com%2Foauth%2Fcode%2Fcallback&scope=org%3Acreate_api_key+user%3Aprofile+user%3Ainference&code_challenge=rOluxCwFXn3G1Cu8x5sdNaf2--B5Psh5vE4VATtoIBg&code_challenge_method=S256&state=pmUohgr1gN_oJIs0K3nC1tT4ps8XECWadAHOMFBuG1sF_hsOx4imIOjUmXh-ElwpgCeH26AW3hnG_cyiK0R3cg

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "codora-anthropic-auth",
+  "version": "0.0.1",
+  "description": "Anthropic authentication plugin for Codora",
+  "main": "./index.mjs",
+  "type": "module",
+  "keywords": [
+    "codora",
+    "anthropic",
+    "claude",
+    "auth",
+    "plugin"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@openauthjs/openauth": "^0.4.3"
+  }
+}

package/test-oauth.mjs

@@ -0,0 +1,87 @@
+import { AnthropicAuthPlugin } from "./index.mjs";
+import * as readline from "readline";
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function question(prompt) {
+  return new Promise((resolve) => rl.question(prompt, resolve));
+}
+
+// 模拟存储
+const authStore = {};
+
+const mockClient = {
+  auth: {
+    async set({ path, body }) {
+      authStore[path.id] = body;
+      console.log("\n✓ 认证信息已保存");
+    },
+  },
+};
+
+async function testOAuth() {
+  console.log("=== Codora Anthropic Auth - OAuth 测试 ===\n");
+
+  const plugin = await AnthropicAuthPlugin({ client: mockClient });
+
+  console.log("选择认证方式:");
+  console.log("  1. Claude Pro/Max (OAuth)");
+  console.log("  2. Create an API Key (OAuth)");
+  console.log("  3. Manually enter API Key");
+
+  const choice = await question("\n请选择 (1-3): ");
+
+  const methodIndex = parseInt(choice) - 1;
+  const method = plugin.auth.methods[methodIndex];
+
+  if (!method) {
+    console.log("无效选择");
+    rl.close();
+    return;
+  }
+
+  if (method.type === "api") {
+    const apiKey = await question("请输入 API Key: ");
+    authStore["anthropic"] = { type: "api", key: apiKey };
+    console.log("\n✓ API Key 已保存");
+    console.log("存储内容:", authStore);
+    rl.close();
+    return;
+  }
+
+  // OAuth 流程
+  console.log("\n正在生成授权 URL...");
+  const authResult = await method.authorize();
+
+  console.log("\n请在浏览器中打开以下 URL:");
+  console.log("\n" + authResult.url + "\n");
+
+  console.log("完成授权后，将页面显示的授权码粘贴到下方");
+  const code = await question("\n授权码: ");
+
+  console.log("\n正在交换 Token...");
+  const result = await authResult.callback(code.trim());
+
+  if (result.type === "success") {
+    console.log("\n✓ 认证成功!");
+    if (result.key) {
+      console.log("API Key:", result.key.substring(0, 20) + "...");
+    } else {
+      console.log("Access Token:", result.access?.substring(0, 20) + "...");
+      console.log("Refresh Token:", result.refresh?.substring(0, 20) + "...");
+      console.log("过期时间:", new Date(result.expires).toLocaleString());
+    }
+  } else {
+    console.log("\n✗ 认证失败");
+  }
+
+  rl.close();
+}
+
+testOAuth().catch((e) => {
+  console.error("错误:", e.message);
+  rl.close();
+});

package/test.mjs

@@ -0,0 +1,51 @@
+import { AnthropicAuthPlugin } from "./index.mjs";
+
+// 模拟 Codora client
+const mockClient = {
+  auth: {
+    async set({ path, body }) {
+      console.log("保存认证信息:", { provider: path.id, ...body });
+    },
+  },
+};
+
+async function test() {
+  console.log("=== 测试 Codora Anthropic Auth 插件 ===\n");
+
+  // 1. 加载插件
+  const plugin = await AnthropicAuthPlugin({ client: mockClient });
+  console.log("✓ 插件加载成功\n");
+
+  // 2. 检查认证方法
+  console.log("认证方法列表:");
+  plugin.auth.methods.forEach((method, i) => {
+    console.log(`  ${i + 1}. ${method.label} (${method.type})`);
+  });
+  console.log("");
+
+  // 3. 测试 OAuth 授权 URL 生成
+  console.log("测试 OAuth 流程 (Claude Pro/Max):");
+  const oauthMethod = plugin.auth.methods[0];
+  const authResult = await oauthMethod.authorize();
+
+  console.log("  授权 URL:", authResult.url.substring(0, 80) + "...");
+  console.log("  方法:", authResult.method);
+  console.log("  提示:", authResult.instructions);
+  console.log("");
+
+  // 4. 测试 API Key 方式
+  console.log("测试 API Key 流程:");
+  const apiMethod = plugin.auth.methods[2];
+  console.log("  类型:", apiMethod.type);
+  console.log("  标签:", apiMethod.label);
+  console.log("");
+
+  console.log("=== 测试完成 ===");
+  console.log("\n要完成完整的 OAuth 测试:");
+  console.log("1. 在浏览器打开上面的授权 URL");
+  console.log("2. 登录并授权");
+  console.log("3. 复制授权码");
+  console.log("4. 调用 authResult.callback(code) 完成认证");
+}
+
+test().catch(console.error);