Upload 25 files

Dockerfile

@@ -0,0 +1,28 @@
+FROM linweiyuan/chatgpt-proxy-server-warp
+
+ENV SUDO_USER_NAME dvc890
+ENV MIRROR_URL 'https://mirrors.bfsu.edu.cn/archlinux/$repo/os/$arch'
+
+WORKDIR /app
+
+RUN pacman -Sy --needed --noconfirm go
+ENV PATH="/usr/local/go/bin:${PATH}"
+
+COPY . .
+RUN go build -ldflags="-w -s" -o go-chatgpt-api main.go
+
+COPY --from=builder /app/go-chatgpt-api .
+RUN apk add --no-cache tzdata
+ENV TZ=Asia/Shanghai
+EXPOSE 8080
+EXPOSE 9515
+EXPOSE 40000
+EXPOSE 65535
+
+ENV CHATGPT_PROXY_SERVER=http://localhost:9515
+ENV GO_CHATGPT_API_PROXY=socks5://0.0.0.0:65535
+ENV LOG_LEVEL=OFF
+
+RUN mkdir -p /var/lib/cloudflare-warp
+
+CMD ["bash", "-c", "/bin/bash /run.sh & sleep 3 && exec /app/go-chatgpt-api"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 linweiyuan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,448 @@
 ---
 title: Go Chatgpt Api
-emoji: ⚡
-colorFrom: yellow
-colorTo: gray
+emoji: 💩
+colorFrom: green
+colorTo: indigo
 sdk: docker
 pinned: false
+app_port: 8080
+
+# go-chatgpt-api
+
+### [English Doc](README_en.md)
+
+## 一个尝试绕过 `Cloudflare 403` 和 `Access denied` 的正向代理程序
+
+### 实验性质项目，不保证稳定性和向后兼容，使用风险自负
+
+---
+
+### 使用的过程中遇到问题应该如何解决
+
+汇总贴：https://github.com/linweiyuan/go-chatgpt-api/issues/74
+
+---
+
+### 支持的 API（URL 和参数基本保持着和官网一致，部分接口有些许改动）
+
+---
+
+### ChatGPT APIs
+
+---
+
+- `ChatGPT` 登录（返回 `accessToken`）（目前仅支持 `ChatGPT` 账号，谷歌或微软账号没有测试）
+
+`POST /chatgpt/login`
+
+<details>
+
+```json
+{
+  "username": "email",
+  "password": "password"
+}
+```
+
+</details>
+
+---
+
+- 获取对话列表（历史记录）
+
+`GET /chatgpt/conversations?offset=0&limit=20`
+
+`offset` 不传默认为 0, `limit` 不传默认为 20 (最大为 100)
+
+---
+
+- 获取对话内容
+
+`GET /chatgpt/conversation/{conversationID}`
+
+---
+
+- 新建对话
+
+`POST /chatgpt/conversation`
+
+<details>
+
+```json
+{
+  "action": "next",
+  "messages": [
+    {
+      "id": "message id",
+      "author": {
+        "role": "user"
+      },
+      "content": {
+        "content_type": "text",
+        "parts": [
+          "Hello World"
+        ]
+      }
+    }
+  ],
+  "parent_message_id": "parent message id",
+  "conversation_id": "conversation id",
+  "model": "text-davinci-002-render-sha",
+  "timezone_offset_min": -480,
+  "history_and_training_disabled": false
+}
+```
+
+</details>
+
+---
+
+- 生成对话标题
+
+`POST /chatgpt/conversation/gen_title/{conversationID}`
+
+<details>
+
+```json
+{
+  "message_id": "role assistant response message id"
+}
+```
+
+</details>
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+- 重命名对话标题
+
+`PATCH /chatgpt/conversation/{conversationID}`
+
+<details>
+
+```json
+{
+  "title": "new title"
+}
+```
+
+</details>
+
+---
+
+- 删除单个对话
+
+`PATCH /chatgpt/conversation/{conversationID}`
+
+<details>
+
+```json
+{
+  "is_visible": false
+}
+```
+
+</details>
+
+---
+
+- 删除所有对话
+
+`PATCH /chatgpt/conversations`
+
+<details>
+
+```json
+{
+  "is_visible": false
+}
+```
+
+</details>
+
+---
+
+- 消息反馈
+
+`POST /chatgpt/conversation/message_feedback`
+
+<details>
+
+```json
+{
+  "message_id": "message id",
+  "conversation_id": "conversation id",
+  "rating": "thumbsUp/thumbsDown"
+}
+```
+
+</details>
+
+---
+
+### Platform APIs
+
+---
+
+- `platform` 登录（返回 `sessionKey`）
+
+`POST /platform/login`
+
+<details>
+
+```json
+{
+  "username": "email",
+  "password": "password"
+}
+```
+
+</details>
+
+---
+
+- [List models](https://platform.openai.com/docs/api-reference/models/list)
+
+`GET /platform/v1/models`
+
+---
+
+- [Retrieve model](https://platform.openai.com/docs/api-reference/models/retrieve)
+
+`GET /platform/v1/models/{model}`
+
+---
+
+- [Create completion](https://platform.openai.com/docs/api-reference/completions/create)
+
+`POST /platform/v1/completions`
+
+<details>
+
+```json
+{
+  "model": "text-davinci-003",
+  "prompt": "Say this is a test",
+  "max_tokens": 7,
+  "temperature": 0,
+  "stream": true
+}
+```
+
+</details>
+
+---
+
+- [Create chat completion](https://platform.openai.com/docs/api-reference/chat/create)
+
+`POST /platform/v1/chat/completions`
+
+<details>
+
+```json
+{
+  "messages": [
+    {
+      "role": "user",
+      "content": "Hello World"
+    }
+  ],
+  "model": "gpt-3.5-turbo",
+  "stream": true
+}
+```
+
+</details>
+
+---
+
+- [Create edit](https://platform.openai.com/docs/api-reference/edits/create)
+
+`POST /platform/v1/edits`
+
+<details>
+
+```json
+{
+  "model": "text-davinci-edit-001",
+  "input": "What day of the wek is it?",
+  "instruction": "Fix the spelling mistakes"
+}
+```
+
+</details>
+
+---
+
+- [Create image](https://platform.openai.com/docs/api-reference/images/create)
+
+`POST /platform/v1/images/generations`
+
+<details>
+
+```json
+{
+  "prompt": "A cute dog",
+  "n": 2,
+  "size": "1024x1024"
+}
+```
+
+</details>
+
+---
+
+- [Create embeddings](https://platform.openai.com/docs/api-reference/embeddings/create)
+
+`POST /platform/v1/embeddings`
+
+<details>
+
+```json
+{
+  "model": "text-embedding-ada-002",
+  "input": "The food was delicious and the waiter..."
+}
+```
+
+</details>
+
+---
+
+- [Create moderations](https://platform.openai.com/docs/api-reference/moderations/create)
+
+`POST /platform/v1/moderations`
+
+<details>
+
+```json
+{
+  "model": "text-moderation-stable",
+  "input": "I want to kill them."
+}
+```
+
+</details>
+
+---
+
+- [List files](https://platform.openai.com/docs/api-reference/files/list)
+
+`GET /platform/v1/files`
+
+---
+
+- 获取 `credit grants` （只能传 `sessionKey`）
+
+`GET /platform/dashboard/billing/credit_grants`
+
+---
+
+- 获取 `subscription` （只能传 `sessionKey`）
+
+`GET /platform/dashboard/billing/subscription`
+
+---
+
+- 获取 `api keys` （只能传 `sessionKey`）
+
+`GET /platform/dashboard/user/api_keys`
+
+---
+
+如需设置代理，可以设置环境变量 `GO_CHATGPT_API_PROXY`，比如 `GO_CHATGPT_API_PROXY=http://127.0.0.1:20171`
+或者 `GO_CHATGPT_API_PROXY=socks5://127.0.0.1:20170`，注释掉或者留空则不启用
+
+如需配合 `warp` 使用：`GO_CHATGPT_API_PROXY=socks5://chatgpt-proxy-server-warp:65535`，因为需要设置 `warp`
+的场景已经默认可以直接访问 `ChatGPT` 官网，因此共用一个变量不冲突
+
+---
+
+`docker-compose` 配置文件：
+
+```yaml
+services:
+  go-chatgpt-api:
+    container_name: go-chatgpt-api
+    image: linweiyuan/go-chatgpt-api
+    ports:
+      - 8080:8080
+    environment:
+      - GO_CHATGPT_API_PROXY=
+    restart: unless-stopped
+```
+
+我仅仅在 `Arch Linux` 上进行开发和测试，这是一个滚动更新的版本，意味着系统上所有东西都是最新的，如果你在使用的过程中 `yaml`
+报错了，则可以加上 `version: '3'` 在 `services:` 前面
+
+如果遇到 `Access denied`，但是你的服务器确实在[被支持的国家或地区](https://platform.openai.com/docs/supported-countries)
+，尝试一下这个配置（不保证能解决问题，比如你的服务器在 A 地区，但 A 地不在支持列表内，即使用上了 `warp` 后是 `Cloudflare IP`
+，结果也会是 `403`）：
+
+```yaml
+services:
+  go-chatgpt-api:
+    container_name: go-chatgpt-api
+    image: linweiyuan/go-chatgpt-api
+    ports:
+      - 8080:8080
+    environment:
+      - GO_CHATGPT_API_PROXY=socks5://chatgpt-proxy-server-warp:65535
+    depends_on:
+      - chatgpt-proxy-server-warp
+    restart: unless-stopped
+
+  chatgpt-proxy-server-warp:
+    container_name: chatgpt-proxy-server-warp
+    image: linweiyuan/chatgpt-proxy-server-warp
+    environment:
+      - LOG_LEVEL=OFF
+    restart: unless-stopped
+```
+
+如果你知道什么是 `teams-enroll-token`，可以通过环境变量 `TEAMS_ENROLL_TOKEN` 设置它的值
+
+然后利用这条命令来检查是否生效:
+
+`docker-compose exec chatgpt-proxy-server-warp warp-cli --accept-tos account | awk 'NR==1'`
+
+```
+Account type: Free （没有生效）
+
+Account type: Team （设置正常）
+```
+
+---
+
+如果要让运行的镜像总是保持最新，可以配合这个一起使用：
+
+```yaml
+services:
+  watchtower:
+    container_name: watchtower
+    image: containrrr/watchtower
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    command: --interval 3600
+    restart: unless-stopped
+```
+
+<details>
+
+<summary>广告位</summary>
+
+`Vultr` 推荐链接：https://www.vultr.com/?ref=7372562
+
+---
+
+个人微信（没有验证，谁都能加，添加即通过，不用打招呼，直接把问题发出来，日常和私人问题不聊，不进群；可以解答程序使用问题，但最好自己要有一定的基础；可以远程调试，仅限 `SSH`
+或`ToDesk`，但不保证能解决）：
+
+![](https://linweiyuan.github.io/about/mmqrcode.png)
+
+---
+
+微信赞赏码（经济条件允许的可以考虑支持下）：
+
+![](https://linweiyuan.github.io/about/mm_reward_qrcode.png)
+
+</details>

README_en.md

@@ -0,0 +1,436 @@
+# go-chatgpt-api
+
+### [中文文档](README.md)
+
+## A forward proxy program attempting to bypass `Cloudflare 403` and `Access Denied`.
+
+### Experimental project, with no guarantee of stability and backward compatibility, use at your own risk.
+
+---
+
+### Troubleshooting
+
+English countries does not have the "Great Firewall", so many issues are gone.
+
+More details: https://github.com/linweiyuan/go-chatgpt-api/issues/74
+
+---
+
+### Supported APIs (URL and parameters are mostly consistent with the official website, with slight modifications to some interfaces).
+
+---
+
+## ChatGPT APIs
+
+---
+
+- `ChatGPT` user login (`accessToken` will be returned) (currently `Google` or `Microsoft` accounts are not supported).
+
+`POST /chatgpt/login`
+
+<details>
+
+```json
+{
+  "username": "email",
+  "password": "password"
+}
+```
+
+</details>
+
+---
+
+- get conversation list
+
+`GET /chatgpt/conversations?offset=0&limit=20`
+
+`offset` defaults to 0, `limit` defaults to 20 (max 100).
+
+---
+
+- get conversation content
+
+`GET /chatgpt/conversation/{conversationID}`
+
+---
+
+- create conversation
+
+`POST /chatgpt/conversation`
+
+<details>
+
+```json
+{
+  "action": "next",
+  "messages": [
+    {
+      "id": "message id",
+      "author": {
+        "role": "user"
+      },
+      "content": {
+        "content_type": "text",
+        "parts": [
+          "Hello World"
+        ]
+      }
+    }
+  ],
+  "parent_message_id": "parent message id",
+  "conversation_id": "conversation id",
+  "model": "text-davinci-002-render-sha",
+  "timezone_offset_min": -480,
+  "history_and_training_disabled": false
+}
+```
+
+</details>
+
+---
+
+- generate conversation title
+
+`POST /chatgpt/conversation/gen_title/{conversationID}`
+
+<details>
+
+```json
+{
+  "message_id": "role assistant response message id"
+}
+```
+
+</details>
+
+---
+
+- rename conversation
+
+`PATCH /chatgpt/conversation/{conversationID}`
+
+<details>
+
+```json
+{
+  "title": "new title"
+}
+```
+
+</details>
+
+---
+
+- delete conversation
+
+`PATCH /chatgpt/conversation/{conversationID}`
+
+<details>
+
+```json
+{
+  "is_visible": false
+}
+```
+
+</details>
+
+---
+
+- delete all conversations
+
+`PATCH /chatgpt/conversations`
+
+<details>
+
+```json
+{
+  "is_visible": false
+}
+```
+
+</details>
+
+---
+
+- feedback message
+
+`POST /chatgpt/conversation/message_feedback`
+
+<details>
+
+```json
+{
+  "message_id": "message id",
+  "conversation_id": "conversation id",
+  "rating": "thumbsUp/thumbsDown"
+}
+```
+
+</details>
+
+---
+
+## Platform APIs
+
+---
+
+- `platform` user login (`sessionKey` will be returned)
+
+`POST /platform/login`
+
+<details>
+
+```json
+{
+  "username": "email",
+  "password": "password"
+}
+```
+
+</details>
+
+---
+
+- [List models](https://platform.openai.com/docs/api-reference/models/list)
+
+`GET /platform/v1/models`
+
+---
+
+- [Retrieve model](https://platform.openai.com/docs/api-reference/models/retrieve)
+
+`GET /platform/v1/models/{model}`
+
+---
+
+- [Create completion](https://platform.openai.com/docs/api-reference/completions/create)
+
+`POST /platform/v1/completions`
+
+<details>
+
+```json
+{
+  "model": "text-davinci-003",
+  "prompt": "Say this is a test",
+  "max_tokens": 7,
+  "temperature": 0,
+  "stream": true
+}
+```
+
+</details>
+
+---
+
+- [Create chat completion](https://platform.openai.com/docs/api-reference/chat/create)
+
+`POST /platform/v1/chat/completions`
+
+<details>
+
+```json
+{
+  "messages": [
+    {
+      "role": "user",
+      "content": "Hello World"
+    }
+  ],
+  "model": "gpt-3.5-turbo",
+  "stream": true
+}
+```
+
+</details>
+
+---
+
+- [Create edit](https://platform.openai.com/docs/api-reference/edits/create)
+
+`POST /platform/v1/edits`
+
+<details>
+
+```json
+{
+  "model": "text-davinci-edit-001",
+  "input": "What day of the wek is it?",
+  "instruction": "Fix the spelling mistakes"
+}
+```
+
+</details>
+
+---
+
+- [Create image](https://platform.openai.com/docs/api-reference/images/create)
+
+`POST /platform/v1/images/generations`
+
+<details>
+
+```json
+{
+  "prompt": "A cute dog",
+  "n": 2,
+  "size": "1024x1024"
+}
+```
+
+</details>
+
+---
+
+- [Create embeddings](https://platform.openai.com/docs/api-reference/embeddings/create)
+
+`POST /platform/v1/embeddings`
+
+<details>
+
+```json
+{
+  "model": "text-embedding-ada-002",
+  "input": "The food was delicious and the waiter..."
+}
+```
+
+</details>
+
+---
+
+- [Create moderations](https://platform.openai.com/docs/api-reference/moderations/create)
+
+`POST /platform/v1/moderations`
+
+<details>
+
+```json
+{
+  "model": "text-moderation-stable",
+  "input": "I want to kill them."
+}
+```
+
+</details>
+
+---
+
+- [List files](https://platform.openai.com/docs/api-reference/files/list)
+
+`GET /platform/v1/files`
+
+---
+
+- get `credit grants` (only support `sessionkey`)
+
+`GET /platform/dashboard/billing/credit_grants`
+
+---
+
+- get `subscription` (only support `sessionkey`)
+
+`GET /platform/dashboard/billing/subscription`
+
+---
+
+- get `api keys` (only support `sessionkey`)
+
+`GET /platform/dashboard/user/api_keys`
+
+---
+
+### Configuration
+
+To set a proxy, you can use the environment variable `GO_CHATGPT_API_PROXY`, such
+as `GO_CHATGPT_API_PROXY=http://127.0.0.1:20171` or `GO_CHATGPT_API_PROXY=socks5://127.0.0.1:20170`. If it is commented
+out or left blank, it will not be enabled.
+
+To use with `warp`: `GO_CHATGPT_API_PROXY=socks5://chatgpt-proxy-server-warp:65535`. Since the scenario that requires
+setting up `warp` can directly access the `ChatGPT` website by default, using the same variable will not cause
+conflicts.
+
+---
+
+`docker-compose.yaml`:
+
+```yaml
+services:
+  go-chatgpt-api:
+    container_name: go-chatgpt-api
+    image: linweiyuan/go-chatgpt-api
+    ports:
+      - 8080:8080
+    environment:
+      - GO_CHATGPT_API_PROXY=
+    restart: unless-stopped
+```
+
+I only develop and test on `Arch Linux`, which is a `rolling` release version, meaning that everything on the system is
+`up-to-date`. If you encounter a `yaml` error while using it, you can add `version: '3'` in front of `services:`.
+
+If you encounter an `Access denied` error, but your server is indeed
+in [Supported countries and territories](https://platform.openai.com/docs/supported-countries), try this
+configuration (it is not guaranteed to solve the problem, for example, if your server is in `Zone A`, but `Zone A`
+is not on the list of supported countries, even if you use `warp` to change to a `Cloudflare IP`, the result will still
+be
+`403`):
+
+```yaml
+services:
+  go-chatgpt-api:
+    container_name: go-chatgpt-api
+    image: linweiyuan/go-chatgpt-api
+    ports:
+      - 8080:8080
+    environment:
+      - GO_CHATGPT_API_PROXY=socks5://chatgpt-proxy-server-warp:65535
+    depends_on:
+      - chatgpt-proxy-server-warp
+    restart: unless-stopped
+
+  chatgpt-proxy-server-warp:
+    container_name: chatgpt-proxy-server-warp
+    image: linweiyuan/chatgpt-proxy-server-warp
+    environment:
+      - LOG_LEVEL=OFF
+    restart: unless-stopped
+```
+
+If you know what `teams-enroll-token` is and want to set its value, you can do so through the environment
+variable `TEAMS_ENROLL_TOKEN`.
+
+Run this command to check the result:
+
+`docker-compose exec chatgpt-proxy-server-warp warp-cli --accept-tos account | awk 'NR==1'`
+
+```
+Account type: Free (wrong)
+
+Account type: Team (correct)
+```
+
+---
+
+If you want to make sure the image is always latest, try this:
+
+```yaml
+services:
+  watchtower:
+    container_name: watchtower
+    image: containrrr/watchtower
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    command: --interval 3600
+    restart: unless-stopped
+```
+
+<details>
+
+<summary>AD</summary>
+
+`Vultr` Referral Program: https://www.vultr.com/?ref=7372562
+
+</details>

api/chatgpt/access_token.go

@@ -0,0 +1,176 @@
+package chatgpt
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/PuerkitoBio/goquery"
+	"github.com/linweiyuan/go-chatgpt-api/api"
+
+	http "github.com/bogdanfinn/fhttp"
+)
+
+//goland:noinspection GoUnhandledErrorResult,GoErrorStringFormat
+func (userLogin *UserLogin) GetAuthorizedUrl(csrfToken string) (string, int, error) {
+	params := fmt.Sprintf(
+		"callbackUrl=/&csrfToken=%s&json=true",
+		csrfToken,
+	)
+	req, err := http.NewRequest(http.MethodPost, promptLoginUrl, strings.NewReader(params))
+	req.Header.Set("Content-Type", api.ContentType)
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		return "", http.StatusInternalServerError, err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return "", resp.StatusCode, errors.New(api.GetAuthorizedUrlErrorMessage)
+	}
+
+	responseMap := make(map[string]string)
+	json.NewDecoder(resp.Body).Decode(&responseMap)
+	return responseMap["url"], http.StatusOK, nil
+}
+
+//goland:noinspection GoUnhandledErrorResult,GoErrorStringFormat
+func (userLogin *UserLogin) GetState(authorizedUrl string) (string, int, error) {
+	req, err := http.NewRequest(http.MethodGet, authorizedUrl, nil)
+	req.Header.Set("Content-Type", api.ContentType)
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		return "", http.StatusInternalServerError, err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return "", resp.StatusCode, errors.New(api.GetStateErrorMessage)
+	}
+
+	doc, _ := goquery.NewDocumentFromReader(resp.Body)
+	state, _ := doc.Find("input[name=state]").Attr("value")
+	return state, http.StatusOK, nil
+}
+
+//goland:noinspection GoUnhandledErrorResult,GoErrorStringFormat
+func (userLogin *UserLogin) CheckUsername(state string, username string) (int, error) {
+	formParams := fmt.Sprintf(
+		"state=%s&username=%s&js-available=true&webauthn-available=true&is-brave=false&webauthn-platform-available=false&action=default",
+		state,
+		username,
+	)
+	req, _ := http.NewRequest(http.MethodPost, api.LoginUsernameUrl+state, strings.NewReader(formParams))
+	req.Header.Set("Content-Type", api.ContentType)
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return resp.StatusCode, errors.New(api.EmailInvalidErrorMessage)
+	}
+
+	return http.StatusOK, nil
+}
+
+//goland:noinspection GoUnhandledErrorResult,GoErrorStringFormat
+func (userLogin *UserLogin) CheckPassword(state string, username string, password string) (string, int, error) {
+	formParams := fmt.Sprintf(
+		"state=%s&username=%s&password=%s&action=default",
+		state,
+		username,
+		password,
+	)
+	req, err := http.NewRequest(http.MethodPost, api.LoginPasswordUrl+state, strings.NewReader(formParams))
+	req.Header.Set("Content-Type", api.ContentType)
+	req.Header.Set("User-Agent", api.UserAgent)
+	userLogin.client.SetFollowRedirect(false)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		return "", http.StatusInternalServerError, err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode == http.StatusBadRequest {
+		doc, _ := goquery.NewDocumentFromReader(resp.Body)
+		alert := doc.Find("#prompt-alert").Text()
+		if alert != "" {
+			return "", resp.StatusCode, errors.New(strings.TrimSpace(alert))
+		}
+
+		return "", resp.StatusCode, errors.New(api.EmailOrPasswordInvalidErrorMessage)
+	}
+
+	if resp.StatusCode == http.StatusFound {
+		req, _ := http.NewRequest(http.MethodGet, api.Auth0Url+resp.Header.Get("Location"), nil)
+		req.Header.Set("User-Agent", api.UserAgent)
+		resp, err := userLogin.client.Do(req)
+		if err != nil {
+			return "", http.StatusInternalServerError, err
+		}
+
+		defer resp.Body.Close()
+		if resp.StatusCode == http.StatusFound {
+			location := resp.Header.Get("Location")
+			if strings.HasPrefix(location, "/u/mfa-otp-challenge") {
+				return "", http.StatusBadRequest, errors.New("Login with two-factor authentication enabled is not supported currently.")
+			}
+
+			req, _ := http.NewRequest(http.MethodGet, location, nil)
+			req.Header.Set("User-Agent", api.UserAgent)
+			resp, err := userLogin.client.Do(req)
+			if err != nil {
+				return "", http.StatusInternalServerError, err
+			}
+
+			defer resp.Body.Close()
+			if resp.StatusCode == http.StatusFound {
+				return "", http.StatusOK, nil
+			}
+
+			if resp.StatusCode == http.StatusTemporaryRedirect {
+				errorDescription := req.URL.Query().Get("error_description")
+				if errorDescription != "" {
+					return "", resp.StatusCode, errors.New(errorDescription)
+				}
+			}
+
+			return "", resp.StatusCode, errors.New(api.GetAccessTokenErrorMessage)
+		}
+
+		return "", resp.StatusCode, errors.New(api.EmailOrPasswordInvalidErrorMessage)
+	}
+
+	return "", resp.StatusCode, nil
+}
+
+//goland:noinspection GoUnhandledErrorResult,GoErrorStringFormat,GoUnusedParameter
+func (userLogin *UserLogin) GetAccessToken(code string) (string, int, error) {
+	req, err := http.NewRequest(http.MethodGet, authSessionUrl, nil)
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		return "", http.StatusInternalServerError, err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		if resp.StatusCode == http.StatusTooManyRequests {
+			responseMap := make(map[string]string)
+			json.NewDecoder(resp.Body).Decode(&responseMap)
+			return "", resp.StatusCode, errors.New(responseMap["detail"])
+		}
+
+		return "", resp.StatusCode, errors.New(api.GetAccessTokenErrorMessage)
+	}
+
+	data, _ := io.ReadAll(resp.Body)
+	return string(data), http.StatusOK, nil
+}

api/chatgpt/api.go

@@ -0,0 +1,300 @@
+package chatgpt
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/PuerkitoBio/goquery"
+	"github.com/gin-gonic/gin"
+	"github.com/linweiyuan/go-chatgpt-api/api"
+
+	http "github.com/bogdanfinn/fhttp"
+)
+
+//goland:noinspection GoUnhandledErrorResult
+func GetConversations(c *gin.Context) {
+	offset, ok := c.GetQuery("offset")
+	if !ok {
+		offset = "0"
+	}
+	limit, ok := c.GetQuery("limit")
+	if !ok {
+		limit = "20"
+	}
+	handleGet(c, apiPrefix+"/conversations?offset="+offset+"&limit="+limit, getConversationsErrorMessage)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func CreateConversation(c *gin.Context) {
+	var request CreateConversationRequest
+	if err := c.BindJSON(&request); err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, api.ReturnMessage(parseJsonErrorMessage))
+		return
+	}
+
+	if request.ConversationID == nil || *request.ConversationID == "" {
+		request.ConversationID = nil
+	}
+	if request.Messages[0].Author.Role == "" {
+		request.Messages[0].Author.Role = defaultRole
+	}
+
+	if request.Model == gpt4Model {
+		formParams := fmt.Sprintf(
+			"public_key=%s",
+			gpt4PublicKey,
+		)
+		req, _ := http.NewRequest(http.MethodPost, gpt4TokenUrl, strings.NewReader(formParams))
+		req.Header.Set("Content-Type", api.ContentType)
+		resp, err := api.Client.Do(req)
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusInternalServerError, api.ReturnMessage(err.Error()))
+			return
+		}
+
+		responseMap := make(map[string]string)
+		json.NewDecoder(resp.Body).Decode(&responseMap)
+		request.ArkoseToken = responseMap["token"]
+	}
+
+	jsonBytes, _ := json.Marshal(request)
+	req, _ := http.NewRequest(http.MethodPost, apiPrefix+"/conversation", bytes.NewBuffer(jsonBytes))
+	req.Header.Set("User-Agent", api.UserAgent)
+	req.Header.Set("Authorization", api.GetAccessToken(c.GetHeader(api.AuthorizationHeader)))
+	req.Header.Set("Accept", "text/event-stream")
+	resp, err := api.Client.Do(req)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusInternalServerError, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		responseMap := make(map[string]interface{})
+		json.NewDecoder(resp.Body).Decode(&responseMap)
+		c.AbortWithStatusJSON(resp.StatusCode, responseMap)
+		return
+	}
+
+	api.HandleConversationResponse(c, resp)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func GenerateTitle(c *gin.Context) {
+	var request GenerateTitleRequest
+	if err := c.BindJSON(&request); err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, api.ReturnMessage(parseJsonErrorMessage))
+		return
+	}
+
+	jsonBytes, _ := json.Marshal(request)
+	handlePost(c, apiPrefix+"/conversation/gen_title/"+c.Param("id"), string(jsonBytes), generateTitleErrorMessage)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func GetConversation(c *gin.Context) {
+	handleGet(c, apiPrefix+"/conversation/"+c.Param("id"), getContentErrorMessage)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func UpdateConversation(c *gin.Context) {
+	var request PatchConversationRequest
+	if err := c.BindJSON(&request); err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, api.ReturnMessage(parseJsonErrorMessage))
+		return
+	}
+
+	// bool default to false, then will hide (delete) the conversation
+	if request.Title != nil {
+		request.IsVisible = true
+	}
+	jsonBytes, _ := json.Marshal(request)
+	handlePatch(c, apiPrefix+"/conversation/"+c.Param("id"), string(jsonBytes), updateConversationErrorMessage)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func FeedbackMessage(c *gin.Context) {
+	var request FeedbackMessageRequest
+	if err := c.BindJSON(&request); err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, api.ReturnMessage(parseJsonErrorMessage))
+		return
+	}
+
+	jsonBytes, _ := json.Marshal(request)
+	handlePost(c, apiPrefix+"/conversation/message_feedback", string(jsonBytes), feedbackMessageErrorMessage)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func ClearConversations(c *gin.Context) {
+	jsonBytes, _ := json.Marshal(PatchConversationRequest{
+		IsVisible: false,
+	})
+	handlePatch(c, apiPrefix+"/conversations", string(jsonBytes), clearConversationsErrorMessage)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func GetModels(c *gin.Context) {
+	handleGet(c, apiPrefix+"/models", getModelsErrorMessage)
+}
+
+func GetAccountCheck(c *gin.Context) {
+	handleGet(c, apiPrefix+"/accounts/check", getAccountCheckErrorMessage)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func Login(c *gin.Context) {
+	var loginInfo api.LoginInfo
+	if err := c.ShouldBindJSON(&loginInfo); err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, api.ReturnMessage(api.ParseUserInfoErrorMessage))
+		return
+	}
+
+	userLogin := UserLogin{
+		client: api.NewHttpClient(),
+	}
+
+	// get csrf token
+	req, _ := http.NewRequest(http.MethodGet, csrfUrl, nil)
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusInternalServerError, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		if resp.StatusCode == http.StatusForbidden {
+			doc, _ := goquery.NewDocumentFromReader(resp.Body)
+			alert := doc.Find(".message").Text()
+			if alert != "" {
+				c.AbortWithStatusJSON(resp.StatusCode, api.ReturnMessage(strings.TrimSpace(alert)))
+				return
+			}
+		}
+
+		c.AbortWithStatusJSON(resp.StatusCode, api.ReturnMessage(getCsrfTokenErrorMessage))
+		return
+	}
+
+	// get authorized url
+	responseMap := make(map[string]string)
+	json.NewDecoder(resp.Body).Decode(&responseMap)
+	authorizedUrl, statusCode, err := userLogin.GetAuthorizedUrl(responseMap["csrfToken"])
+	if err != nil {
+		c.AbortWithStatusJSON(statusCode, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	// get state
+	state, statusCode, err := userLogin.GetState(authorizedUrl)
+	if err != nil {
+		c.AbortWithStatusJSON(statusCode, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	// check username
+	statusCode, err = userLogin.CheckUsername(state, loginInfo.Username)
+	if err != nil {
+		c.AbortWithStatusJSON(statusCode, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	// check password
+	_, statusCode, err = userLogin.CheckPassword(state, loginInfo.Username, loginInfo.Password)
+	if err != nil {
+		c.AbortWithStatusJSON(statusCode, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	// get access token
+	accessToken, statusCode, err := userLogin.GetAccessToken("")
+	if err != nil {
+		c.AbortWithStatusJSON(statusCode, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	c.Writer.WriteString(accessToken)
+}
+
+func Fallback(c *gin.Context) {
+	method := c.Request.Method
+	url := apiPrefix + c.Request.URL.Path
+	queryParams := c.Request.URL.Query().Encode()
+	if queryParams != "" {
+		url += "?" + queryParams
+	}
+
+	var requestBody string
+	if c.Request.Method == http.MethodPost || c.Request.Method == http.MethodPatch {
+		body, _ := io.ReadAll(c.Request.Body)
+		requestBody = string(body)
+	}
+
+	c.Status(http.StatusOK)
+
+	switch method {
+	case http.MethodGet:
+		handleGet(c, url, fallbackErrorMessage)
+	case http.MethodPost:
+		handlePost(c, url, requestBody, fallbackErrorMessage)
+	case http.MethodPatch:
+		handlePatch(c, url, requestBody, fallbackErrorMessage)
+	default:
+		c.JSON(http.StatusMethodNotAllowed, gin.H{"message": fallbackMethodNotAllowedMessage})
+	}
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func handleGet(c *gin.Context, url string, errorMessage string) {
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	req.Header.Set("User-Agent", api.UserAgent)
+	req.Header.Set("Authorization", api.GetAccessToken(c.GetHeader(api.AuthorizationHeader)))
+	resp, err := api.Client.Do(req)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusInternalServerError, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		c.AbortWithStatusJSON(resp.StatusCode, api.ReturnMessage(errorMessage))
+		return
+	}
+
+	io.Copy(c.Writer, resp.Body)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func handlePost(c *gin.Context, url string, requestBody string, errorMessage string) {
+	req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(requestBody))
+	handlePostOrPatch(c, req, errorMessage)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func handlePatch(c *gin.Context, url string, requestBody string, errorMessage string) {
+	req, _ := http.NewRequest(http.MethodPatch, url, strings.NewReader(requestBody))
+	handlePostOrPatch(c, req, errorMessage)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func handlePostOrPatch(c *gin.Context, req *http.Request, errorMessage string) {
+	req.Header.Set("User-Agent", api.UserAgent)
+	req.Header.Set("Authorization", api.GetAccessToken(c.GetHeader(api.AuthorizationHeader)))
+	resp, err := api.Client.Do(req)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusInternalServerError, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		c.AbortWithStatusJSON(resp.StatusCode, api.ReturnMessage(errorMessage))
+		return
+	}
+
+	io.Copy(c.Writer, resp.Body)
+}

api/chatgpt/constant.go

@@ -0,0 +1,26 @@
+package chatgpt
+
+const (
+	apiPrefix                       = "https://chat.openai.com/backend-api"
+	defaultRole                     = "user"
+	getConversationsErrorMessage    = "Failed to get conversations."
+	generateTitleErrorMessage       = "Failed to generate title."
+	getContentErrorMessage          = "Failed to get content."
+	updateConversationErrorMessage  = "Failed to update conversation."
+	clearConversationsErrorMessage  = "Failed to clear conversations."
+	feedbackMessageErrorMessage     = "Failed to add feedback."
+	getModelsErrorMessage           = "Failed to get models."
+	getAccountCheckErrorMessage     = "Check failed." // Placeholder. Never encountered.
+	parseJsonErrorMessage           = "Failed to parse json request body."
+	fallbackErrorMessage            = "Fallback failed."
+	fallbackMethodNotAllowedMessage = "Fallback method not allowed."
+
+	csrfUrl                  = "https://chat.openai.com/api/auth/csrf"
+	promptLoginUrl           = "https://chat.openai.com/api/auth/signin/auth0?prompt=login"
+	getCsrfTokenErrorMessage = "Failed to get CSRF token."
+	authSessionUrl           = "https://chat.openai.com/api/auth/session"
+
+	gpt4Model     = "gpt-4"
+	gpt4PublicKey = "35536E1E-65B4-4D96-9D97-6ADB7EFF8147"
+	gpt4TokenUrl  = "https://tcr9i.chat.openai.com/fc/gt2/public_key/" + gpt4PublicKey
+)

api/chatgpt/health_check.go

@@ -0,0 +1,75 @@
+package chatgpt
+
+import (
+	"os"
+	"time"
+
+	"github.com/PuerkitoBio/goquery"
+	"github.com/linweiyuan/go-chatgpt-api/api"
+	"github.com/linweiyuan/go-chatgpt-api/util/logger"
+
+	http "github.com/bogdanfinn/fhttp"
+)
+
+//goland:noinspection SpellCheckingInspection
+const (
+	healthCheckUrl = "https://chat.openai.com/backend-api/accounts/check"
+	readyHint      = "Service go-chatgpt-api is ready."
+	errorHintBlock = "Looks like you have bean blocked -> curl https://chat.openai.com | grep '<p>' | awk '{$1=$1;print}'"
+	errorHint403   = "Failed to handle 403, have a look at https://github.com/linweiyuan/java-chatgpt-api or use other more powerful alternatives (do not raise new issue about 403)."
+	sleepHours     = 8760 // 365 days
+)
+
+//goland:noinspection GoUnhandledErrorResult,SpellCheckingInspection
+func init() {
+	proxyUrl := os.Getenv("GO_CHATGPT_API_PROXY")
+	if proxyUrl != "" {
+		logger.Info("GO_CHATGPT_API_PROXY: " + proxyUrl)
+		api.Client.SetProxy(proxyUrl)
+
+		for {
+			resp, err := healthCheck()
+			if err != nil {
+				// wait for proxy to be ready
+				time.Sleep(time.Second)
+				continue
+			}
+
+			checkHealthCheckStatus(resp)
+			break
+		}
+	} else {
+		resp, err := healthCheck()
+		if err != nil {
+			logger.Error("Health check failed: " + err.Error())
+			os.Exit(1)
+		}
+
+		checkHealthCheckStatus(resp)
+	}
+}
+
+func healthCheck() (resp *http.Response, err error) {
+	req, _ := http.NewRequest(http.MethodGet, healthCheckUrl, nil)
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err = api.Client.Do(req)
+	return
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func checkHealthCheckStatus(resp *http.Response) {
+	defer resp.Body.Close()
+	if resp != nil && resp.StatusCode == http.StatusUnauthorized {
+		logger.Info(readyHint)
+	} else {
+		doc, _ := goquery.NewDocumentFromReader(resp.Body)
+		alert := doc.Find(".message").Text()
+		if alert != "" {
+			logger.Error(errorHintBlock)
+		} else {
+			logger.Error(errorHint403)
+		}
+		time.Sleep(time.Hour * sleepHours)
+		os.Exit(1)
+	}
+}

api/chatgpt/typings.go

@@ -0,0 +1,54 @@
+package chatgpt
+
+//goland:noinspection GoSnakeCaseUsage
+import tls_client "github.com/bogdanfinn/tls-client"
+
+type UserLogin struct {
+	client tls_client.HttpClient
+}
+
+type CreateConversationRequest struct {
+	Action            string    `json:"action"`
+	Messages          []Message `json:"messages"`
+	Model             string    `json:"model"`
+	ParentMessageID   string    `json:"parent_message_id"`
+	ConversationID    *string   `json:"conversation_id"`
+	TimezoneOffsetMin int       `json:"timezone_offset_min"`
+	ArkoseToken       string    `json:"arkose_token"`
+}
+
+type Message struct {
+	Author  Author  `json:"author"`
+	Content Content `json:"content"`
+	ID      string  `json:"id"`
+}
+
+type Author struct {
+	Role string `json:"role"`
+}
+
+type Content struct {
+	ContentType string   `json:"content_type"`
+	Parts       []string `json:"parts"`
+}
+
+type FeedbackMessageRequest struct {
+	MessageID      string `json:"message_id"`
+	ConversationID string `json:"conversation_id"`
+	Rating         string `json:"rating"`
+}
+
+type GenerateTitleRequest struct {
+	MessageID string `json:"message_id"`
+}
+
+type PatchConversationRequest struct {
+	Title     *string `json:"title"`
+	IsVisible bool    `json:"is_visible"`
+}
+
+type Cookie struct {
+	Name   string `json:"name"`
+	Value  string `json:"value"`
+	Expiry int64  `json:"expiry"`
+}

api/common.go

@@ -0,0 +1,110 @@
+package api
+
+//goland:noinspection GoSnakeCaseUsage
+import (
+	"bufio"
+	"os"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	_ "github.com/linweiyuan/go-chatgpt-api/env"
+
+	http "github.com/bogdanfinn/fhttp"
+	tls_client "github.com/bogdanfinn/tls-client"
+)
+
+const (
+	defaultErrorMessageKey             = "errorMessage"
+	AuthorizationHeader                = "Authorization"
+	ContentType                        = "application/x-www-form-urlencoded"
+	UserAgent                          = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"
+	Auth0Url                           = "https://auth0.openai.com"
+	LoginUsernameUrl                   = Auth0Url + "/u/login/identifier?state="
+	LoginPasswordUrl                   = Auth0Url + "/u/login/password?state="
+	ParseUserInfoErrorMessage          = "Failed to parse user login info."
+	GetAuthorizedUrlErrorMessage       = "Failed to get authorized url."
+	GetStateErrorMessage               = "Failed to get state."
+	EmailInvalidErrorMessage           = "Email is not valid."
+	EmailOrPasswordInvalidErrorMessage = "Email or password is not correct."
+	GetAccessTokenErrorMessage         = "Failed to get access token."
+	defaultTimeoutSeconds              = 300 // 5 minutes
+)
+
+var Client tls_client.HttpClient
+
+type LoginInfo struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+type AuthLogin interface {
+	GetAuthorizedUrl(csrfToken string) (string, int, error)
+	GetState(authorizedUrl string) (string, int, error)
+	CheckUsername(state string, username string) (int, error)
+	CheckPassword(state string, username string, password string) (string, int, error)
+	GetAccessToken(code string) (string, int, error)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func init() {
+	Client, _ = tls_client.NewHttpClient(tls_client.NewNoopLogger(), []tls_client.HttpClientOption{
+		tls_client.WithCookieJar(tls_client.NewCookieJar()),
+		tls_client.WithTimeoutSeconds(defaultTimeoutSeconds),
+		tls_client.WithClientProfile(tls_client.Okhttp4Android13),
+	}...)
+}
+
+func ReturnMessage(msg string) gin.H {
+	return gin.H{
+		defaultErrorMessageKey: msg,
+	}
+}
+
+func GetAccessToken(accessToken string) string {
+	if !strings.HasPrefix(accessToken, "Bearer") {
+		return "Bearer " + accessToken
+	}
+	return accessToken
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func HandleConversationResponse(c *gin.Context, resp *http.Response) {
+	c.Writer.Header().Set("Content-Type", "text/event-stream; charset=utf-8")
+
+	reader := bufio.NewReader(resp.Body)
+	for {
+		if c.Request.Context().Err() != nil {
+			break
+		}
+
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			break
+		}
+
+		line = strings.TrimSpace(line)
+		if strings.HasPrefix(line, "event") ||
+			strings.HasPrefix(line, "data: 20") ||
+			line == "" {
+			continue
+		}
+
+		c.Writer.Write([]byte(line + "\n\n"))
+		c.Writer.Flush()
+	}
+}
+
+//goland:noinspection GoUnhandledErrorResult,SpellCheckingInspection
+func NewHttpClient() tls_client.HttpClient {
+	client, _ := tls_client.NewHttpClient(tls_client.NewNoopLogger(), []tls_client.HttpClientOption{
+		tls_client.WithCookieJar(tls_client.NewCookieJar()),
+		tls_client.WithClientProfile(tls_client.Okhttp4Android13),
+	}...)
+
+	proxyUrl := os.Getenv("GO_CHATGPT_API_PROXY")
+	if proxyUrl != "" {
+		client.SetProxy(proxyUrl)
+	}
+
+	return client
+}

api/platform/access_token.go

@@ -0,0 +1,116 @@
+package platform
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/url"
+	"strings"
+
+	"github.com/linweiyuan/go-chatgpt-api/api"
+
+	http "github.com/bogdanfinn/fhttp"
+)
+
+//goland:noinspection GoUnhandledErrorResult,GoErrorStringFormat,GoUnusedParameter
+func (userLogin *UserLogin) GetAuthorizedUrl(csrfToken string) (string, int, error) {
+	urlParams := url.Values{
+		"client_id":     {platformAuthClientID},
+		"audience":      {platformAuthAudience},
+		"redirect_uri":  {platformAuthRedirectURL},
+		"scope":         {platformAuthScope},
+		"response_type": {platformAuthResponseType},
+	}
+	req, _ := http.NewRequest(http.MethodGet, platformAuth0Url+urlParams.Encode(), nil)
+	req.Header.Set("Content-Type", api.ContentType)
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		return "", http.StatusInternalServerError, err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return "", resp.StatusCode, errors.New(api.GetAuthorizedUrlErrorMessage)
+	}
+
+	return resp.Request.URL.String(), http.StatusOK, nil
+}
+
+func (userLogin *UserLogin) GetState(authorizedUrl string) (string, int, error) {
+	split := strings.Split(authorizedUrl, "=")
+	return split[1], http.StatusOK, nil
+}
+
+//goland:noinspection GoUnhandledErrorResult,GoErrorStringFormat
+func (userLogin *UserLogin) CheckUsername(state string, username string) (int, error) {
+	formParams := fmt.Sprintf(
+		"state=%s&username=%s&js-available=true&webauthn-available=true&is-brave=false&webauthn-platform-available=false&action=default",
+		state,
+		username,
+	)
+	req, err := http.NewRequest(http.MethodPost, api.LoginUsernameUrl+state, strings.NewReader(formParams))
+	req.Header.Set("Content-Type", api.ContentType)
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return resp.StatusCode, errors.New(api.EmailInvalidErrorMessage)
+	}
+
+	return http.StatusOK, nil
+}
+
+//goland:noinspection GoUnhandledErrorResult,GoErrorStringFormat
+func (userLogin *UserLogin) CheckPassword(state string, username string, password string) (string, int, error) {
+	formParams := fmt.Sprintf(
+		"state=%s&username=%s&password=%s&action=default",
+		state,
+		username,
+		password,
+	)
+	req, err := http.NewRequest(http.MethodPost, api.LoginPasswordUrl+state, strings.NewReader(formParams))
+	req.Header.Set("Content-Type", api.ContentType)
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		return "", http.StatusInternalServerError, err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return "", resp.StatusCode, errors.New(api.EmailOrPasswordInvalidErrorMessage)
+	}
+
+	return resp.Request.URL.Query().Get("code"), http.StatusOK, nil
+}
+
+//goland:noinspection GoUnhandledErrorResult,GoErrorStringFormat
+func (userLogin *UserLogin) GetAccessToken(code string) (string, int, error) {
+	jsonBytes, _ := json.Marshal(GetAccessTokenRequest{
+		ClientID:    platformAuthClientID,
+		Code:        code,
+		GrantType:   platformAuthGrantType,
+		RedirectURI: platformAuthRedirectURL,
+	})
+	req, err := http.NewRequest(http.MethodPost, getTokenUrl, strings.NewReader(string(jsonBytes)))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", api.UserAgent)
+	resp, err := userLogin.client.Do(req)
+	if err != nil {
+		return "", http.StatusInternalServerError, err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return "", resp.StatusCode, errors.New(api.GetAccessTokenErrorMessage)
+	}
+
+	data, _ := io.ReadAll(resp.Body)
+	return string(data), http.StatusOK, nil
+}

api/platform/api.go

@@ -0,0 +1,224 @@
+package platform
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/linweiyuan/go-chatgpt-api/api"
+
+	http "github.com/bogdanfinn/fhttp"
+)
+
+func ListModels(c *gin.Context) {
+	handleGet(c, apiListModels)
+}
+
+func RetrieveModel(c *gin.Context) {
+	model := c.Param("model")
+	handleGet(c, fmt.Sprintf(apiRetrieveModel, model))
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func CreateCompletions(c *gin.Context) {
+	var request CreateCompletionsRequest
+	c.ShouldBindJSON(&request)
+	data, _ := json.Marshal(request)
+	resp, err := handlePost(c, apiCreateCompletions, data, request.Stream)
+	if err != nil {
+		return
+	}
+
+	defer resp.Body.Close()
+	if request.Stream {
+		api.HandleConversationResponse(c, resp)
+	} else {
+		io.Copy(c.Writer, resp.Body)
+	}
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func CreateChatCompletions(c *gin.Context) {
+	var request ChatCompletionsRequest
+	c.ShouldBindJSON(&request)
+	data, _ := json.Marshal(request)
+	resp, err := handlePost(c, apiCreataeChatCompletions, data, request.Stream)
+	if err != nil {
+		return
+	}
+
+	defer resp.Body.Close()
+	if request.Stream {
+		api.HandleConversationResponse(c, resp)
+	} else {
+		io.Copy(c.Writer, resp.Body)
+	}
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func CreateEdit(c *gin.Context) {
+	var request CreateEditRequest
+	c.ShouldBindJSON(&request)
+	data, _ := json.Marshal(request)
+	resp, err := handlePost(c, apiCreateEdit, data, false)
+	if err != nil {
+		return
+	}
+
+	defer resp.Body.Close()
+	io.Copy(c.Writer, resp.Body)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func CreateImage(c *gin.Context) {
+	var request CreateImageRequest
+	c.ShouldBindJSON(&request)
+	data, _ := json.Marshal(request)
+	resp, err := handlePost(c, apiCreateImage, data, false)
+	if err != nil {
+		return
+	}
+
+	defer resp.Body.Close()
+	io.Copy(c.Writer, resp.Body)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func CreateEmbeddings(c *gin.Context) {
+	var request CreateEmbeddingsRequest
+	c.ShouldBindJSON(&request)
+	data, _ := json.Marshal(request)
+	resp, err := handlePost(c, apiCreateEmbeddings, data, false)
+	if err != nil {
+		return
+	}
+
+	defer resp.Body.Close()
+	io.Copy(c.Writer, resp.Body)
+}
+
+func CreateModeration(c *gin.Context) {
+	var request CreateModerationRequest
+	c.ShouldBindJSON(&request)
+	data, _ := json.Marshal(request)
+	resp, err := handlePost(c, apiCreateModeration, data, false)
+	if err != nil {
+		return
+	}
+
+	defer resp.Body.Close()
+	io.Copy(c.Writer, resp.Body)
+}
+
+func ListFiles(c *gin.Context) {
+	handleGet(c, apiListFiles)
+}
+
+func GetCreditGrants(c *gin.Context) {
+	handleGet(c, apiGetCreditGrants)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func Login(c *gin.Context) {
+	var loginInfo api.LoginInfo
+	if err := c.ShouldBindJSON(&loginInfo); err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, api.ReturnMessage(api.ParseUserInfoErrorMessage))
+		return
+	}
+
+	userLogin := UserLogin{
+		client: api.NewHttpClient(),
+	}
+
+	// hard refresh cookies
+	resp, _ := userLogin.client.Get(auth0LogoutUrl)
+	defer resp.Body.Close()
+
+	// get authorized url
+	authorizedUrl, statusCode, err := userLogin.GetAuthorizedUrl("")
+	if err != nil {
+		c.AbortWithStatusJSON(statusCode, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	// get state
+	state, _, _ := userLogin.GetState(authorizedUrl)
+
+	// check username
+	statusCode, err = userLogin.CheckUsername(state, loginInfo.Username)
+	if err != nil {
+		c.AbortWithStatusJSON(statusCode, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	// check password
+	code, statusCode, err := userLogin.CheckPassword(state, loginInfo.Username, loginInfo.Password)
+	if err != nil {
+		c.AbortWithStatusJSON(statusCode, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	// get access token
+	accessToken, statusCode, err := userLogin.GetAccessToken(code)
+	if err != nil {
+		c.AbortWithStatusJSON(statusCode, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	// get session key
+	var getAccessTokenResponse GetAccessTokenResponse
+	json.Unmarshal([]byte(accessToken), &getAccessTokenResponse)
+	req, _ := http.NewRequest(http.MethodPost, dashboardLoginUrl, strings.NewReader("{}"))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", api.UserAgent)
+	req.Header.Set("Authorization", api.GetAccessToken(getAccessTokenResponse.AccessToken))
+	resp, err = userLogin.client.Do(req)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusInternalServerError, api.ReturnMessage(err.Error()))
+		return
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		c.AbortWithStatusJSON(resp.StatusCode, api.ReturnMessage(getSessionKeyErrorMessage))
+		return
+	}
+
+	io.Copy(c.Writer, resp.Body)
+}
+
+func GetSubscription(c *gin.Context) {
+	handleGet(c, apiGetSubscription)
+}
+
+func GetApiKeys(c *gin.Context) {
+	handleGet(c, apiGetApiKeys)
+}
+
+//goland:noinspection GoUnhandledErrorResult
+func handleGet(c *gin.Context, url string) {
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	req.Header.Set("Authorization", api.GetAccessToken(c.GetHeader(api.AuthorizationHeader)))
+	resp, _ := api.Client.Do(req)
+	defer resp.Body.Close()
+	io.Copy(c.Writer, resp.Body)
+}
+
+func handlePost(c *gin.Context, url string, data []byte, stream bool) (*http.Response, error) {
+	req, _ := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(data))
+	req.Header.Set("Authorization", api.GetAccessToken(c.GetHeader(api.AuthorizationHeader)))
+	if stream {
+		req.Header.Set("Accept", "text/event-stream")
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := api.Client.Do(req)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusInternalServerError, api.ReturnMessage(err.Error()))
+		return nil, err
+	}
+
+	return resp, nil
+}

api/platform/constant.go

@@ -0,0 +1,35 @@
+package platform
+
+import "github.com/linweiyuan/go-chatgpt-api/api"
+
+//goland:noinspection SpellCheckingInspection
+const (
+	apiUrl = "https://api.openai.com"
+
+	apiListModels             = apiUrl + "/v1/models"
+	apiRetrieveModel          = apiUrl + "/v1/models/%s"
+	apiCreateCompletions      = apiUrl + "/v1/completions"
+	apiCreataeChatCompletions = apiUrl + "/v1/chat/completions"
+	apiCreateEdit             = apiUrl + "/v1/edits"
+	apiCreateImage            = apiUrl + "/v1/images/generations"
+	apiCreateEmbeddings       = apiUrl + "/v1/embeddings"
+	apiListFiles              = apiUrl + "/v1/files"
+	apiCreateModeration       = apiUrl + "/v1/moderations"
+
+	apiGetCreditGrants = apiUrl + "/dashboard/billing/credit_grants"
+	apiGetSubscription = apiUrl + "/dashboard/billing/subscription"
+	apiGetApiKeys      = apiUrl + "/dashboard/user/api_keys"
+
+	platformAuthClientID      = "DRivsnm2Mu42T3KOpqdtwB3NYviHYzwD"
+	platformAuthAudience      = "https://api.openai.com/v1"
+	platformAuthRedirectURL   = "https://platform.openai.com/auth/callback"
+	platformAuthScope         = "openid profile email offline_access"
+	platformAuthResponseType  = "code"
+	platformAuthGrantType     = "authorization_code"
+	platformAuth0Url          = api.Auth0Url + "/authorize?"
+	getTokenUrl               = api.Auth0Url + "/oauth/token"
+	auth0Client               = "eyJuYW1lIjoiYXV0aDAtc3BhLWpzIiwidmVyc2lvbiI6IjEuMjEuMCJ9" // '{"name":"auth0-spa-js","version":"1.21.0"}'
+	auth0LogoutUrl            = api.Auth0Url + "/v2/logout?returnTo=https%3A%2F%2Fplatform.openai.com%2Floggedout&client_id=" + platformAuthClientID + "&auth0Client=" + auth0Client
+	dashboardLoginUrl         = "https://api.openai.com/dashboard/onboarding/login"
+	getSessionKeyErrorMessage = "Failed to get session key."
+)

api/platform/typings.go

@@ -0,0 +1,93 @@
+package platform
+
+//goland:noinspection GoSnakeCaseUsage
+import tls_client "github.com/bogdanfinn/tls-client"
+
+type UserLogin struct {
+	client tls_client.HttpClient
+}
+
+type GetAccessTokenRequest struct {
+	ClientID    string `json:"client_id"`
+	GrantType   string `json:"grant_type"`
+	Code        string `json:"code"`
+	RedirectURI string `json:"redirect_uri"`
+}
+
+type GetAccessTokenResponse struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+	IDToken      string `json:"id_token"`
+	Scope        string `json:"scope"`
+	ExpiresIn    int    `json:"expires_in"`
+	TokenType    string `json:"token_type"`
+}
+
+//goland:noinspection SpellCheckingInspection
+type CreateCompletionsRequest struct {
+	Model            string                 `json:"model"`
+	Prompt           string                 `json:"prompt,omitempty"`
+	Suffix           string                 `json:"suffix,omitempty"`
+	MaxTokens        int                    `json:"max_tokens,omitempty"`
+	Temperature      int                    `json:"temperature,omitempty"`
+	TopP             int                    `json:"top_p,omitempty"`
+	N                int                    `json:"n,omitempty"`
+	Stream           bool                   `json:"stream,omitempty"`
+	Logprobs         int                    `json:"logprobs,omitempty"`
+	Echo             bool                   `json:"echo,omitempty"`
+	Stop             string                 `json:"stop,omitempty"`
+	PresencePenalty  int                    `json:"presence_penalty,omitempty"`
+	FrequencyPenalty int                    `json:"frequency_penalty,omitempty"`
+	BestOf           int                    `json:"best_of,omitempty"`
+	LogitBias        map[string]interface{} `json:"logit_bias,omitempty"`
+	User             string                 `json:"user,omitempty"`
+}
+
+type ChatCompletionsRequest struct {
+	Model            string                   `json:"model"`
+	Messages         []ChatCompletionsMessage `json:"messages"`
+	Temperature      int                      `json:"temperature,omitempty"`
+	TopP             int                      `json:"top_p,omitempty"`
+	N                int                      `json:"n,omitempty"`
+	Stream           bool                     `json:"stream,omitempty"`
+	Stop             string                   `json:"stop,omitempty"`
+	MaxTokens        int                      `json:"max_tokens,omitempty"`
+	PresencePenalty  int                      `json:"presence_penalty,omitempty"`
+	FrequencyPenalty int                      `json:"frequency_penalty,omitempty"`
+	LogitBias        map[string]interface{}   `json:"logit_bias,omitempty"`
+	User             string                   `json:"user,omitempty"`
+}
+
+type ChatCompletionsMessage struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+	Name    string `json:"name,omitempty"`
+}
+
+type CreateEditRequest struct {
+	Model       string `json:"model"`
+	Input       string `json:"input"`
+	Instruction string `json:"instruction"`
+	N           int    `json:"n,omitempty"`
+	Temperature int    `json:"temperature,omitempty"`
+	TopP        int    `json:"top_p,omitempty"`
+}
+
+type CreateImageRequest struct {
+	Prompt         string `json:"prompt"`
+	N              int    `json:"n,omitempty"`
+	Size           string `json:"size,omitempty"`
+	ResponseFormat string `json:"response_format,omitempty"`
+	User           string `json:"user,omitempty"`
+}
+
+type CreateEmbeddingsRequest struct {
+	Model string `json:"model"`
+	Input string `json:"input"`
+	User  string `json:"user,omitempty"`
+}
+
+type CreateModerationRequest struct {
+	Model string `json:"model"`
+	Input string `json:"input"`
+}

compose.yaml

@@ -0,0 +1,11 @@
+services:
+  go-chatgpt-api:
+    build: .
+    container_name: go-chatgpt-api
+    image: linweiyuan/go-chatgpt-api
+    ports:
+      - 8080:8080
+    environment:
+      - TZ=Asia/Shanghai
+      - GO_CHATGPT_API_PROXY=
+    restart: unless-stopped

env/env.go

@@ -0,0 +1,10 @@
+package env
+
+import (
+	"github.com/joho/godotenv"
+)
+
+//goland:noinspection GoUnhandledErrorResult
+func init() {
+	godotenv.Load()
+}

example/chatgpt.http

@@ -0,0 +1,54 @@
+### login
+POST http://127.0.0.1:8080/chatgpt/login
+Content-Type: application/json
+
+{
+  "username": "{{username}}",
+  "password": "{{password}}"
+}
+
+### get conversations
+GET http://127.0.0.1:8080/chatgpt/conversations
+Authorization: Bearer {{accessToken}}
+
+### create conversation
+POST http://127.0.0.1:8080/chatgpt/conversation
+Authorization: Bearer {{accessToken}}
+Content-Type: application/json
+Accept: text/event-stream
+
+{
+  "action": "next",
+  "messages": [
+    {
+      "id": "{{$random.uuid}}",
+      "author": {
+        "role": "user"
+      },
+      "content": {
+        "content_type": "text",
+        "parts": [
+          "hello"
+        ]
+      },
+      "metadata": {}
+    }
+  ],
+  "model": "gpt-4",
+  "timezone_offset_min": -480,
+  "history_and_training_disabled": false
+}
+
+> {%
+    response.body.onEachLine((data) => {
+        client.log(data.toString());
+    })
+%}
+
+### get models
+GET http://127.0.0.1:8080/chatgpt/models
+Authorization: Bearer {{accessToken}}
+
+### check account
+GET http://127.0.0.1:8080/chatgpt/accounts/check
+Authorization: Bearer {{accessToken}}

example/http-client.env.json

@@ -0,0 +1,8 @@
+{
+  "dev": {
+    "username": "",
+    "password": "",
+    "accessToken": "",
+    "apiKey": ""
+  }
+}

example/platform.http

@@ -0,0 +1,8 @@
+### login
+POST http://127.0.0.1:8080/platform/login
+Content-Type: application/json
+
+{
+  "username": "{{username}}",
+  "password": "{{password}}"
+}

go.mod

@@ -0,0 +1,44 @@
+module github.com/linweiyuan/go-chatgpt-api
+
+go 1.20
+
+require (
+	github.com/PuerkitoBio/goquery v1.8.1
+	github.com/bogdanfinn/fhttp v0.5.22
+	github.com/bogdanfinn/tls-client v1.3.11
+	github.com/gin-gonic/gin v1.9.1
+	github.com/joho/godotenv v1.5.1
+	github.com/sirupsen/logrus v1.9.0
+)
+
+require (
+	github.com/andybalholm/brotli v1.0.4 // indirect
+	github.com/andybalholm/cascadia v1.3.1 // indirect
+	github.com/bogdanfinn/utls v1.5.16 // indirect
+	github.com/bytedance/sonic v1.9.1 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.15.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/tam7t/hpkp v0.0.0-20160821193359-2b70b4024ed5 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/crypto v0.9.0 // indirect
+	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/sys v0.8.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,136 @@
+github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM=
+github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ=
+github.com/andybalholm/brotli v1.0.4 h1:V7DdXeJtZscaqfNuAdSRuRFzuiKlHSC/Zh3zl9qY3JY=
+github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/andybalholm/cascadia v1.3.1 h1:nhxRkql1kdYCc8Snf7D5/D3spOX+dBgjA6u8x004T2c=
+github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA=
+github.com/bogdanfinn/fhttp v0.5.22 h1:U1jhZRtuaOanWWcm1WdMFnwMvSxUQgvO6berqAVTc5o=
+github.com/bogdanfinn/fhttp v0.5.22/go.mod h1:brqi5woc5eSCVHdKYBV8aZLbO7HGqpwyDLeXW+fT18I=
+github.com/bogdanfinn/tls-client v1.3.11 h1:3rI+ysCEtnLdmDYlL7cPq2kF3Sj+bSvhgaHPmjLbjOE=
+github.com/bogdanfinn/tls-client v1.3.11/go.mod h1:+TLNqnOtUQmYu/qrd/qMuLleoHoTRCcZazkmvNYuiVc=
+github.com/bogdanfinn/utls v1.5.16 h1:NhhWkegEcYETBMj9nvgO4lwvc6NcLH+znrXzO3gnw4M=
+github.com/bogdanfinn/utls v1.5.16/go.mod h1:mHeRCi69cUiEyVBkKONB1cAbLjRcZnlJbGzttmiuK4o=
+github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
+github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
+github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/compress v1.15.12 h1:YClS/PImqYbn+UILDnqxQCZ3RehC9N318SU3kElDUEM=
+github.com/klauspost/compress v1.15.12/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
+github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
+github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
+github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/tam7t/hpkp v0.0.0-20160821193359-2b70b4024ed5 h1:YqAladjX7xpA6BM04leXMWAEjS0mTZ5kUU9KRBriQJc=
+github.com/tam7t/hpkp v0.0.0-20160821193359-2b70b4024ed5/go.mod h1:2JjD2zLQYH5HO74y5+aE3remJQvl6q4Sn6aWA2wD1Ng=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
+golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
+golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
+google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

main.go

@@ -0,0 +1,119 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/linweiyuan/go-chatgpt-api/api/chatgpt"
+	"github.com/linweiyuan/go-chatgpt-api/api/platform"
+	_ "github.com/linweiyuan/go-chatgpt-api/env"
+	"github.com/linweiyuan/go-chatgpt-api/middleware"
+)
+
+func init() {
+	gin.ForceConsoleColor()
+	gin.SetMode(gin.ReleaseMode)
+}
+
+func main() {
+	router := gin.Default()
+	router.Use(middleware.CORSMiddleware())
+	router.Use(middleware.CheckHeaderMiddleware())
+
+	setupChatGPTAPIs(router)
+
+	setupPlatformAPIs(router)
+
+	router.NoRoute(handleFallbackRoute)
+
+	port := os.Getenv("GO_CHATGPT_API_PORT")
+	if port == "" {
+		port = "8080"
+	}
+	err := router.Run(":" + port)
+	if err != nil {
+		log.Fatal("Failed to start server: " + err.Error())
+	}
+}
+
+func setupChatGPTAPIs(router *gin.Engine) {
+	chatgptGroup := router.Group("/chatgpt")
+	{
+		chatgptGroup.POST("/login", chatgpt.Login)
+
+		conversationsGroup := chatgptGroup.Group("/conversations")
+		{
+			conversationsGroup.GET("", chatgpt.GetConversations)
+
+			// PATCH is official method, POST is added for Java support
+			conversationsGroup.PATCH("", chatgpt.ClearConversations)
+			conversationsGroup.POST("", chatgpt.ClearConversations)
+		}
+
+		conversationGroup := chatgptGroup.Group("/conversation")
+		{
+			conversationGroup.POST("", chatgpt.CreateConversation)
+			conversationGroup.POST("/gen_title/:id", chatgpt.GenerateTitle)
+			conversationGroup.GET("/:id", chatgpt.GetConversation)
+
+			// rename or delete conversation use a same API with different parameters
+			conversationGroup.PATCH("/:id", chatgpt.UpdateConversation)
+			conversationGroup.POST("/:id", chatgpt.UpdateConversation)
+
+			conversationGroup.POST("/message_feedback", chatgpt.FeedbackMessage)
+		}
+
+		// misc
+		chatgptGroup.GET("/models", chatgpt.GetModels)
+		chatgptGroup.GET("/accounts/check", chatgpt.GetAccountCheck)
+	}
+}
+
+func setupPlatformAPIs(router *gin.Engine) {
+	platformGroup := router.Group("/platform")
+	{
+		platformGroup.POST("/login", platform.Login)
+
+		apiGroup := platformGroup.Group("/v1")
+		{
+			apiGroup.GET("/models", platform.ListModels)
+			apiGroup.GET("/models/:model", platform.RetrieveModel)
+			apiGroup.POST("/completions", platform.CreateCompletions)
+			apiGroup.POST("/chat/completions", platform.CreateChatCompletions)
+			apiGroup.POST("/edits", platform.CreateEdit)
+			apiGroup.POST("/images/generations", platform.CreateImage)
+			apiGroup.POST("/embeddings", platform.CreateEmbeddings)
+			apiGroup.GET("/files", platform.ListFiles)
+			apiGroup.POST("/moderations", platform.CreateModeration)
+		}
+
+		dashboardGroup := platformGroup.Group("/dashboard")
+		{
+			billingGroup := dashboardGroup.Group("/billing")
+			{
+				billingGroup.GET("/credit_grants", platform.GetCreditGrants)
+				billingGroup.GET("/subscription", platform.GetSubscription)
+			}
+
+			userGroup := dashboardGroup.Group("/user")
+			{
+				userGroup.GET("/api_keys", platform.GetApiKeys)
+			}
+		}
+	}
+}
+
+func handleFallbackRoute(c *gin.Context) {
+	path := c.Request.URL.Path
+
+	if strings.HasPrefix(path, "/chatgpt") {
+		trimmedPath := strings.TrimPrefix(path, "/chatgpt")
+		c.Request.URL.Path = trimmedPath
+		chatgpt.Fallback(c)
+	} else {
+		c.JSON(http.StatusNotFound, gin.H{"message": "Route not found"})
+	}
+}

middleware/check_header.go

@@ -0,0 +1,22 @@
+package middleware
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/linweiyuan/go-chatgpt-api/api"
+)
+
+func CheckHeaderMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if c.GetHeader(api.AuthorizationHeader) == "" &&
+			c.Request.URL.Path != "/chatgpt/login" &&
+			c.Request.URL.Path != "/platform/login" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, api.ReturnMessage("Missing accessToken."))
+			return
+		}
+
+		c.Header("Content-Type", "application/json")
+		c.Next()
+	}
+}

middleware/cors.go

@@ -0,0 +1,22 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+
+	http "github.com/bogdanfinn/fhttp"
+)
+
+func CORSMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
+		c.Writer.Header().Set("Access-Control-Allow-Headers", "*")
+		c.Writer.Header().Set("Access-Control-Allow-Methods", "*")
+
+		if c.Request.Method == http.MethodOptions {
+			c.AbortWithStatus(http.StatusNoContent)
+			return
+		}
+
+		c.Next()
+	}
+}

util/logger/logger.go

@@ -0,0 +1,37 @@
+package logger
+
+import (
+	"fmt"
+
+	"github.com/sirupsen/logrus"
+)
+
+func init() {
+	logrus.SetFormatter(&logrus.TextFormatter{
+		ForceColors: true,
+	})
+}
+
+func Ansi(colorString string) func(...interface{}) string {
+	return func(args ...interface{}) string {
+		return fmt.Sprintf(colorString, fmt.Sprint(args...))
+	}
+}
+
+var (
+	Green  = Ansi("\033[1;32m%s\033[0m")
+	Yellow = Ansi("\033[1;33m%s\033[0m")
+	Red    = Ansi("\033[1;31m%s\033[0m")
+)
+
+func Info(msg string) {
+	logrus.Info(Green(msg))
+}
+
+func Warn(msg string) {
+	logrus.Warn(Yellow(msg))
+}
+
+func Error(msg string) {
+	logrus.Error(Red(msg))
+}