Upload 17 files

Dockerfile

@@ -0,0 +1,15 @@
+FROM node:20-slim
+
+WORKDIR /app
+
+ENV NODE_ENV=production \
+    PORT=7860
+
+COPY package*.json ./
+RUN npm ci --omit=dev
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["npm", "start"]

package-lock.json

@@ -0,0 +1,912 @@
+{
+  "name": "deepseek-2api",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "deepseek-2api",
+      "version": "1.0.0",
+      "dependencies": {
+        "dotenv": "^16.4.0",
+        "express": "^4.21.0",
+        "ssh2": "^1.17.0"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "license": "MIT"
+    },
+    "node_modules/asn1": {
+      "version": "0.2.6",
+      "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz",
+      "integrity": "sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": "~2.1.0"
+      }
+    },
+    "node_modules/bcrypt-pbkdf": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz",
+      "integrity": "sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tweetnacl": "^0.14.3"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.5",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.5.tgz",
+      "integrity": "sha512-3grm+/2tUOvu2cjJkvsIxrv/wVpfXQW4PsQHYm7yk4vfpu7Ekl6nEsYBoJUL6qDwZUx8wUhQ8tR2qz+ad9c9OA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "~1.2.0",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "on-finished": "~2.4.1",
+        "qs": "~6.15.1",
+        "raw-body": "~2.5.3",
+        "type-is": "~1.6.18",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/buildcheck": {
+      "version": "0.0.7",
+      "resolved": "https://registry.npmjs.org/buildcheck/-/buildcheck-0.0.7.tgz",
+      "integrity": "sha512-lHblz4ahamxpTmnsk+MNTRWsjYKv965MwOrSJyeD588rR3Jcu7swE+0wN5F+PbL5cjgu/9ObkhfzEPuofEMwLA==",
+      "optional": true,
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz",
+      "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==",
+      "license": "MIT"
+    },
+    "node_modules/cpu-features": {
+      "version": "0.0.10",
+      "resolved": "https://registry.npmjs.org/cpu-features/-/cpu-features-0.0.10.tgz",
+      "integrity": "sha512-9IkYqtX3YHPCzoVg1Py+o9057a3i0fp7S530UWokCSaFVTc7CwXPRiOjRjBQQ18ZCNafx78YfnG+HALxtVmOGA==",
+      "hasInstallScript": true,
+      "optional": true,
+      "dependencies": {
+        "buildcheck": "~0.0.6",
+        "nan": "^2.19.0"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.22.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.22.2.tgz",
+      "integrity": "sha512-IuL+Elrou2ZvCFHs18/CIzy2Nzvo25nZ1/D2eIZlz7c+QUayAcYoiM2BthCjs+EBHVpjYjcuLDAiCWgeIX3X1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "~1.20.5",
+        "content-disposition": "~0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "~0.7.1",
+        "cookie-signature": "~1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "~1.3.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "~0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "~6.15.1",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "~0.19.0",
+        "serve-static": "~1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "~2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz",
+      "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "~2.0.2",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.3.tgz",
+      "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/nan": {
+      "version": "2.27.0",
+      "resolved": "https://registry.npmjs.org/nan/-/nan-2.27.0.tgz",
+      "integrity": "sha512-hC+0LidcL3XE4rp1C4H54KujgXKzbfyTngZTwBByQxsOxCEKZT0MPQ4hOKUH2jU1OYstqdDH4onyHPDzcV0XdQ==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.13.tgz",
+      "integrity": "sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==",
+      "license": "MIT"
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.15.2",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.2.tgz",
+      "integrity": "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.3",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz",
+      "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/send": {
+      "version": "0.19.2",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz",
+      "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.1",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "~2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "~2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/serve-static": {
+      "version": "1.16.3",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz",
+      "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "~0.19.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/ssh2": {
+      "version": "1.17.0",
+      "resolved": "https://registry.npmjs.org/ssh2/-/ssh2-1.17.0.tgz",
+      "integrity": "sha512-wPldCk3asibAjQ/kziWQQt1Wh3PgDFpC0XpwclzKcdT1vql6KeYxf5LIt4nlFkUeR8WuphYMKqUA56X4rjbfgQ==",
+      "hasInstallScript": true,
+      "dependencies": {
+        "asn1": "^0.2.6",
+        "bcrypt-pbkdf": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=10.16.0"
+      },
+      "optionalDependencies": {
+        "cpu-features": "~0.0.10",
+        "nan": "^2.23.0"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/tweetnacl": {
+      "version": "0.14.5",
+      "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz",
+      "integrity": "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==",
+      "license": "Unlicense"
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,16 @@
+{
+  "name": "deepseek-2api",
+  "version": "1.0.0",
+  "description": "DeepSeek Web Chat to API proxy (OpenAI + DeepSeek native format)",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --watch src/index.js"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.0",
+    "express": "^4.21.0",
+    "ssh2": "^1.17.0"
+  }
+}

src/admin/index.html

@@ -0,0 +1,655 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>DeepSeek-2API 管理面板</title>
+<style>
+:root {
+  --bg: #1a1a2e;
+  --surface: #16213e;
+  --border: #0f3460;
+  --text: #e0e0e0;
+  --text-dim: #8892a0;
+  --green: #00e676;
+  --yellow: #ffd600;
+  --red: #ff1744;
+  --accent: #00b0ff;
+}
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.6;
+  min-height: 100vh;
+}
+.container {
+  max-width: 960px;
+  margin: 0 auto;
+  padding: 20px;
+}
+header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 16px 20px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  margin-bottom: 20px;
+}
+header h1 {
+  font-size: 1.3em;
+  color: var(--accent);
+}
+header .meta {
+  font-size: 0.85em;
+  color: var(--text-dim);
+}
+.controls {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.controls select, .controls button {
+  background: var(--bg);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  padding: 4px 10px;
+  font-size: 0.85em;
+  cursor: pointer;
+}
+.controls button:hover { border-color: var(--accent); }
+.card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 16px 20px;
+  margin-bottom: 16px;
+}
+.card h2 {
+  font-size: 1.05em;
+  margin-bottom: 12px;
+  color: var(--accent);
+}
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+  gap: 12px;
+}
+.stat-item {
+  background: var(--bg);
+  border-radius: 6px;
+  padding: 12px;
+  text-align: center;
+}
+.stat-item .label {
+  font-size: 0.75em;
+  color: var(--text-dim);
+  margin-bottom: 4px;
+}
+.stat-item .value {
+  font-size: 1.4em;
+  font-weight: 700;
+}
+.status-ok { color: var(--green); }
+.status-warn { color: var(--yellow); }
+.status-err { color: var(--red); }
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.88em;
+}
+th, td {
+  padding: 8px 10px;
+  text-align: left;
+  border-bottom: 1px solid var(--border);
+}
+th {
+  color: var(--text-dim);
+  font-weight: 600;
+  font-size: 0.8em;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+td { font-family: 'SF Mono', 'Consolas', monospace; font-size: 0.85em; }
+.dot {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  margin-right: 6px;
+}
+.dot-green { background: var(--green); }
+.dot-yellow { background: var(--yellow); }
+.dot-red { background: var(--red); }
+
+.bar-wrap {
+  background: var(--bg);
+  border-radius: 4px;
+  height: 22px;
+  overflow: hidden;
+  position: relative;
+}
+.bar-fill {
+  height: 100%;
+  border-radius: 4px;
+  transition: width 0.4s, background 0.4s;
+}
+.bar-label {
+  position: absolute;
+  top: 0; left: 10px; right: 10px;
+  line-height: 22px;
+  font-size: 0.78em;
+  color: var(--text);
+  text-shadow: 0 1px 2px rgba(0,0,0,0.6);
+}
+
+.forms-row {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 16px;
+}
+@media (max-width: 640px) {
+  .forms-row { grid-template-columns: 1fr; }
+}
+.form-group { margin-bottom: 10px; }
+.form-group label {
+  display: block;
+  font-size: 0.82em;
+  color: var(--text-dim);
+  margin-bottom: 4px;
+}
+.form-group input {
+  width: 100%;
+  background: var(--bg);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  padding: 7px 10px;
+  font-size: 0.9em;
+}
+.form-group input:focus { outline: none; border-color: var(--accent); }
+.btn {
+  background: var(--accent);
+  color: #fff;
+  border: none;
+  border-radius: 4px;
+  padding: 7px 18px;
+  font-size: 0.9em;
+  cursor: pointer;
+}
+.btn:hover { opacity: 0.85; }
+.msg {
+  font-size: 0.82em;
+  margin-top: 6px;
+  min-height: 1.4em;
+}
+.msg-ok { color: var(--green); }
+.msg-err { color: var(--red); }
+
+details {
+  margin-bottom: 10px;
+}
+summary {
+  cursor: pointer;
+  color: var(--accent);
+  font-size: 0.92em;
+  padding: 4px 0;
+}
+pre {
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  padding: 10px 12px;
+  font-size: 0.82em;
+  overflow-x: auto;
+  color: var(--text);
+  margin: 6px 0;
+}
+.model-table {
+  width: auto;
+  margin-bottom: 12px;
+}
+.model-table td, .model-table th {
+  padding: 6px 16px;
+}
+
+footer {
+  text-align: center;
+  color: var(--text-dim);
+  font-size: 0.78em;
+  padding: 12px;
+}
+
+.auth-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0,0,0,0.7);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 100;
+}
+.auth-box {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 24px;
+  width: 340px;
+}
+.auth-box h3 { margin-bottom: 12px; color: var(--accent); }
+.auth-box .form-group { margin-bottom: 14px; }
+.auth-box .msg { margin-bottom: 8px; }
+
+.loading { color: var(--text-dim); font-style: italic; }
+</style>
+</head>
+<body>
+<div class="container">
+  <header>
+    <div>
+      <h1>DeepSeek-2API 管理面板</h1>
+      <div class="meta">版本 <span id="version">-</span> · 运行 <span id="uptime">-</span></div>
+    </div>
+    <div class="controls">
+      <select id="interval" title="自动刷新间隔">
+        <option value="5000">5秒</option>
+        <option value="10000" selected>10秒</option>
+        <option value="30000">30秒</option>
+        <option value="0">关闭</option>
+      </select>
+      <button id="refreshBtn">刷新</button>
+    </div>
+  </header>
+
+  <!-- 总览 -->
+  <div class="card">
+    <h2>总览</h2>
+    <div class="stats-grid">
+      <div class="stat-item">
+        <div class="label">状态</div>
+        <div class="value" id="status">-</div>
+      </div>
+      <div class="stat-item">
+        <div class="label">总容量</div>
+        <div class="value" id="capacity">-</div>
+      </div>
+      <div class="stat-item">
+        <div class="label">令牌数</div>
+        <div class="value" id="tokenCount">-</div>
+      </div>
+      <div class="stat-item">
+        <div class="label">会话缓存</div>
+        <div class="value" id="sessionCount">-</div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 请求队列 -->
+  <div class="card">
+    <h2>请求队列</h2>
+    <div class="bar-wrap">
+      <div class="bar-fill" id="queueBar" style="width:0%;background:var(--green)"></div>
+      <div class="bar-label" id="queueLabel">0 / 100</div>
+    </div>
+  </div>
+
+  <!-- 令牌池 -->
+  <div class="card">
+    <h2>令牌池</h2>
+    <div style="overflow-x:auto">
+      <table>
+        <thead>
+          <tr><th>令牌</th><th>视觉能力</th><th>错误数</th><th>活跃/最大</th><th>健康</th></tr>
+        </thead>
+        <tbody id="poolBody">
+          <tr><td colspan="5" class="loading">加载中...</td></tr>
+        </tbody>
+      </table>
+    </div>
+  </div>
+
+  <!-- 会话缓存 -->
+  <div class="card">
+    <h2>会话缓存</h2>
+    <div id="sessionSummary" style="font-size:0.88em;color:var(--text-dim);margin-bottom:8px">-</div>
+    <div style="overflow-x:auto">
+      <table>
+        <thead>
+          <tr><th>缓存键</th><th>模型</th><th>已用时间</th><th>剩余 TTL</th></tr>
+        </thead>
+        <tbody id="sessionBody">
+          <tr><td colspan="4" class="loading">加载中...</td></tr>
+        </tbody>
+      </table>
+    </div>
+  </div>
+
+  <!-- 快速入门 -->
+  <div class="card">
+    <h2>快速入门</h2>
+    <h3 style="font-size:0.92em;margin-bottom:8px">模型映射</h3>
+    <table class="model-table">
+      <thead><tr><th>API 模型名</th><th>DeepSeek 模型类型</th></tr></thead>
+      <tbody>
+        <tr><td>deepseek-v4-flash</td><td>default（默认/免费）</td></tr>
+        <tr><td>deepseek-v4-pro</td><td>expert（深度思考/付费）</td></tr>
+        <tr><td>deepseek-v4-vision</td><td>vision（视觉/图片理解）</td></tr>
+      </tbody>
+    </table>
+
+    <details>
+      <summary>OpenAI 格式 - 非流式请求</summary>
+      <pre>curl http://localhost:3000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -d '{
+    "model": "deepseek-v4-flash",
+    "messages": [{"role":"user","content":"你好"}]
+  }'</pre>
+    </details>
+
+    <details>
+      <summary>OpenAI 格式 - 流式请求（SSE）</summary>
+      <pre>curl http://localhost:3000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -d '{
+    "model": "deepseek-v4-pro",
+    "stream": true,
+    "messages": [{"role":"user","content":"解释量子计算"}]
+  }'</pre>
+    </details>
+
+    <details>
+      <summary>DeepSeek 原生格式</summary>
+      <pre>curl http://localhost:3000/api/v0/chat/completion \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -d '{
+    "model_type": "default",
+    "stream": true,
+    "chat_session_id": "SESSION_ID",
+    "prompt": "你好"
+  }'</pre>
+    </details>
+
+    <details>
+      <summary>查看可用模型</summary>
+      <pre>curl http://localhost:3000/v1/models \
+  -H "Authorization: Bearer YOUR_API_KEY"</pre>
+    </details>
+  </div>
+
+  <!-- 令牌管理 -->
+  <div class="card">
+    <h2>令牌管理</h2>
+    <div class="forms-row">
+      <div>
+        <h3 style="font-size:0.92em;margin-bottom:8px">添加令牌</h3>
+        <form id="addTokenForm">
+          <div class="form-group">
+            <label>令牌字符串</label>
+            <input type="text" id="addTokenInput" placeholder="粘贴 DeepSeek 令牌..." required>
+          </div>
+          <button type="submit" class="btn">添加</button>
+          <div class="msg" id="addTokenMsg"></div>
+        </form>
+      </div>
+      <div>
+        <h3 style="font-size:0.92em;margin-bottom:8px">登录添加</h3>
+        <form id="loginForm">
+          <div class="form-group">
+            <label>邮箱</label>
+            <input type="email" id="loginEmail" placeholder="DeepSeek 账号邮箱" required>
+          </div>
+          <div class="form-group">
+            <label>密码</label>
+            <input type="password" id="loginPassword" placeholder="DeepSeek 账号密码" required>
+          </div>
+          <button type="submit" class="btn">登录</button>
+          <div class="msg" id="loginMsg"></div>
+        </form>
+      </div>
+    </div>
+  </div>
+
+  <footer>上次刷新: <span id="lastRefresh">-</span></footer>
+</div>
+
+<!-- Auth overlay -->
+<div class="auth-overlay" id="authOverlay" style="display:none">
+  <div class="auth-box">
+    <h3>需要 API Key</h3>
+    <p style="font-size:0.85em;color:var(--text-dim);margin-bottom:12px">此服务器已配置 API_KEY 验证，请输入密钥。</p>
+    <div class="form-group">
+      <label>API Key</label>
+      <input type="password" id="authKeyInput" placeholder="输入 API Key...">
+    </div>
+    <button class="btn" id="authSubmitBtn">确认</button>
+    <div class="msg" id="authMsg"></div>
+  </div>
+</div>
+
+<script>
+const $ = id => document.getElementById(id);
+let refreshTimer = null;
+
+function getApiKey() {
+  return sessionStorage.getItem('adminApiKey') || '';
+}
+
+function authHeaders() {
+  const key = getApiKey();
+  return key ? { 'Authorization': 'Bearer ' + key } : {};
+}
+
+async function apiFetch(url, options = {}) {
+  const headers = { ...authHeaders(), ...(options.headers || {}) };
+  const res = await fetch(url, { ...options, headers });
+  if (res.status === 401) {
+    sessionStorage.removeItem('adminApiKey');
+    $('authOverlay').style.display = 'flex';
+    throw new Error('unauthorized');
+  }
+  return res;
+}
+
+function formatUptime(sec) {
+  const d = Math.floor(sec / 86400);
+  const h = Math.floor((sec % 86400) / 3600);
+  const m = Math.floor((sec % 3600) / 60);
+  const s = sec % 60;
+  const parts = [];
+  if (d) parts.push(d + '天');
+  if (h) parts.push(h + '时');
+  if (m) parts.push(m + '分');
+  parts.push(s + '秒');
+  return parts.join(' ');
+}
+
+function formatDuration(sec) {
+  if (sec < 60) return sec + '秒';
+  if (sec < 3600) return Math.floor(sec / 60) + '分' + (sec % 60) + '秒';
+  if (sec < 86400) return Math.floor(sec / 3600) + '时' + Math.floor((sec % 3600) / 60) + '分';
+  return Math.floor(sec / 86400) + '天' + Math.floor((sec % 86400) / 3600) + '时';
+}
+
+function healthDot(errorCount, active, max) {
+  if (errorCount >= 3) return '<span class="dot dot-red"></span>不可用';
+  if (errorCount >= 1) return '<span class="dot dot-yellow"></span>异常';
+  if (active >= max) return '<span class="dot dot-yellow"></span>满载';
+  return '<span class="dot dot-green"></span>正常';
+}
+
+function visionLabel(v) {
+  if (v === true) return '<span style="color:var(--green)">支持</span>';
+  if (v === false) return '<span style="color:var(--text-dim)">不支持</span>';
+  return '<span style="color:var(--yellow)">未知</span>';
+}
+
+function render(data) {
+  $('version').textContent = data.version;
+  $('uptime').textContent = formatUptime(data.uptimeSeconds);
+  $('status').innerHTML = '<span class="status-ok">正常</span>';
+  $('capacity').textContent = data.totalCapacity;
+  $('tokenCount').textContent = data.pool.length;
+  $('sessionCount').textContent = data.sessions.count;
+
+  // Queue bar
+  const q = data.queue.queued;
+  const qMax = data.queue.maxQueueSize;
+  const pct = Math.min(100, (q / qMax) * 100);
+  const qBar = $('queueBar');
+  qBar.style.width = pct + '%';
+  qBar.style.background = pct > 80 ? 'var(--red)' : pct > 50 ? 'var(--yellow)' : 'var(--green)';
+  $('queueLabel').textContent = q + ' / ' + qMax;
+
+  // Token pool
+  const poolBody = $('poolBody');
+  if (data.pool.length === 0) {
+    poolBody.innerHTML = '<tr><td colspan="5" style="color:var(--text-dim)">无令牌</td></tr>';
+  } else {
+    poolBody.innerHTML = data.pool.map(t => `<tr>
+      <td>${t.token}</td>
+      <td>${visionLabel(t.visionCapable)}</td>
+      <td>${t.errorCount}</td>
+      <td>${t.activeRequests} / ${t.maxConcurrent}</td>
+      <td>${healthDot(t.errorCount, t.activeRequests, t.maxConcurrent)}</td>
+    </tr>`).join('');
+  }
+
+  // Sessions
+  const sessions = data.sessions;
+  $('sessionSummary').textContent = sessions.count + ' 个会话已缓存 · TTL: ' + formatDuration(sessions.ttl);
+  const sBody = $('sessionBody');
+  if (sessions.sessions.length === 0) {
+    sBody.innerHTML = '<tr><td colspan="4" style="color:var(--text-dim)">无缓存会话</td></tr>';
+  } else {
+    sBody.innerHTML = sessions.sessions.map(s => {
+      const ttlStyle = s.ttlRemainingSeconds < 3600 ? 'color:var(--yellow)' : '';
+      const expiredStyle = s.ttlRemainingSeconds === 0 ? 'color:var(--red)' : '';
+      return `<tr>
+        <td>${s.key}</td>
+        <td>${s.modelType}</td>
+        <td>${formatDuration(s.ageSeconds)}</td>
+        <td style="${expiredStyle || ttlStyle}">${s.ttlRemainingSeconds === 0 ? '已过期' : formatDuration(s.ttlRemainingSeconds)}</td>
+      </tr>`;
+    }).join('');
+  }
+
+  $('lastRefresh').textContent = new Date().toLocaleTimeString();
+}
+
+async function fetchStats() {
+  try {
+    const res = await apiFetch('/admin/api/stats');
+    if (!res.ok) throw new Error('HTTP ' + res.status);
+    const data = await res.json();
+    render(data);
+  } catch (e) {
+    if (e.message !== 'unauthorized') {
+      console.error('fetchStats error:', e);
+    }
+  }
+}
+
+// Auto-refresh
+function setupRefresh() {
+  if (refreshTimer) clearInterval(refreshTimer);
+  const ms = parseInt($('interval').value);
+  if (ms > 0) {
+    refreshTimer = setInterval(fetchStats, ms);
+  }
+}
+
+$('interval').addEventListener('change', setupRefresh);
+$('refreshBtn').addEventListener('click', fetchStats);
+
+// Auth overlay
+$('authSubmitBtn').addEventListener('click', () => {
+  const key = $('authKeyInput').value.trim();
+  if (!key) {
+    $('authMsg').className = 'msg msg-err';
+    $('authMsg').textContent = '请输入 API Key';
+    return;
+  }
+  sessionStorage.setItem('adminApiKey', key);
+  $('authOverlay').style.display = 'none';
+  $('authMsg').textContent = '';
+  fetchStats();
+});
+
+$('authKeyInput').addEventListener('keydown', e => {
+  if (e.key === 'Enter') $('authSubmitBtn').click();
+});
+
+// Token management forms
+$('addTokenForm').addEventListener('submit', async e => {
+  e.preventDefault();
+  const token = $('addTokenInput').value.trim();
+  const msgEl = $('addTokenMsg');
+  msgEl.textContent = '添加中...';
+  msgEl.className = 'msg';
+  try {
+    const res = await apiFetch('/admin/api/token/add', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ token }),
+    });
+    const data = await res.json();
+    if (data.success) {
+      msgEl.className = 'msg msg-ok';
+      msgEl.textContent = '添加成功！视觉能力: ' + (data.visionCapable === true ? '支持' : data.visionCapable === false ? '不支持' : '未知');
+      $('addTokenInput').value = '';
+      fetchStats();
+    } else {
+      msgEl.className = 'msg msg-err';
+      msgEl.textContent = data.error?.message || '添加失败';
+    }
+  } catch (err) {
+    msgEl.className = 'msg msg-err';
+    msgEl.textContent = err.message === 'unauthorized' ? '认证失败' : '请求失败';
+  }
+});
+
+$('loginForm').addEventListener('submit', async e => {
+  e.preventDefault();
+  const email = $('loginEmail').value.trim();
+  const password = $('loginPassword').value;
+  const msgEl = $('loginMsg');
+  msgEl.textContent = '登录中...';
+  msgEl.className = 'msg';
+  try {
+    const res = await apiFetch('/admin/api/token/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password }),
+    });
+    const data = await res.json();
+    if (data.success) {
+      msgEl.className = 'msg msg-ok';
+      msgEl.textContent = '登录成功！令牌: ' + data.token;
+      $('loginEmail').value = '';
+      $('loginPassword').value = '';
+      fetchStats();
+    } else {
+      msgEl.className = 'msg msg-err';
+      msgEl.textContent = data.error?.message || '登录失败';
+    }
+  } catch (err) {
+    msgEl.className = 'msg msg-err';
+    msgEl.textContent = err.message === 'unauthorized' ? '认证失败' : '请求失败';
+  }
+});
+
+// Init
+fetchStats();
+setupRefresh();
+</script>
+</body>
+</html>

src/auth.js

@@ -0,0 +1,463 @@
+import { config } from 'dotenv';
+config();
+
+const BASE_URL = 'https://chat.deepseek.com';
+
+const MAX_CONCURRENT_PER_TOKEN = 2;
+const TOKEN_DEAD_THRESHOLD = 5;
+
+// Multi-token support: DS_TOKENS=token1,token2,token3 (comma-separated)
+// Fallback: DS_TOKEN=single_token
+// Account support: DS_ACCOUNTS=email1:pass1,email2:pass2 (auto-login to refresh tokens)
+export function loadTokens() {
+  const tokensStr = process.env.DS_TOKENS?.trim();
+  if (tokensStr) {
+    return tokensStr.split(',').map(t => t.trim()).filter(Boolean);
+  }
+  const single = process.env.DS_TOKEN?.trim();
+  if (single) return [single];
+  return [];
+}
+
+export function loadAccounts() {
+  const accounts = [];
+
+  // Keep backward-compatible multi-account support.
+  const accountsStr = process.env.DS_ACCOUNTS?.trim();
+  if (accountsStr) {
+    accounts.push(...accountsStr.split(',').map(entry => {
+      const [email, ...passParts] = entry.trim().split(':');
+      const password = passParts.join(':');
+      return email && password ? { email, password } : null;
+    }).filter(Boolean));
+  }
+
+  // Single-account support requested by deployment envs.
+  // DS_TOKEN/DS_TOKENS has priority: when a token is configured,
+  // DS_EMAIL/DS_PASSWORD are ignored unless DS_ACCOUNTS is explicitly used.
+  const hasToken = Boolean(process.env.DS_TOKENS?.trim() || process.env.DS_TOKEN?.trim());
+  const email = process.env.DS_EMAIL?.trim();
+  const password = process.env.DS_PASSWORD?.trim();
+  if (!hasToken && email && password) {
+    accounts.push({ email, password });
+  }
+
+  return accounts;
+}
+
+const tokens = loadTokens();
+const accounts = loadAccounts();
+
+function generateDeviceId() {
+  const bytes = new Uint8Array(48);
+  for (let i = 0; i < 48; i++) bytes[i] = Math.floor(Math.random() * 256);
+  return Buffer.from(bytes).toString('base64').replace(/=/g, '') + '==';
+}
+
+if (tokens.length === 0 && accounts.length === 0) {
+  throw new Error('No DS_TOKEN/DS_TOKENS or DS_EMAIL+DS_PASSWORD/DS_ACCOUNTS configured');
+}
+
+// DS_ACCOUNTS_EXTENDED=email:password:token_prefix — links existing tokens to accounts
+function loadAccountTokens() {
+  const extStr = process.env.DS_ACCOUNTS_EXTENDED?.trim();
+  if (!extStr) return [];
+  return extStr.split(',').map(entry => {
+    const parts = entry.trim().split(':');
+    if (parts.length >= 3) return { email: parts[0], password: parts[1], tokenPrefix: parts[2] };
+    return null;
+  }).filter(Boolean);
+}
+
+const accountTokenMap = loadAccountTokens();
+
+// Token metadata: { token, email, password, visionCapable, lastUsed, errorCount, activeRequests, dead }
+const tokenPool = tokens.map(t => ({
+  token: t,
+  email: null,
+  password: null,
+  visionCapable: null,
+  lastUsed: 0,
+  errorCount: 0,
+  activeRequests: 0,
+  dead: false,
+}));
+
+// Link existing tokens to accounts via token prefix
+for (const entry of tokenPool) {
+  if (!entry.token) continue;
+  const prefix = entry.token.slice(0, 12);
+  const match = accountTokenMap.find(a => a.tokenPrefix === prefix);
+  if (match) {
+    entry.email = match.email;
+    entry.password = match.password;
+  }
+}
+
+// Create pool entries for accounts without matching tokens (will login on init)
+for (const acct of accounts) {
+  const alreadyLinked = tokenPool.some(t => t.email === acct.email);
+  if (!alreadyLinked) {
+    tokenPool.push({
+      token: null,
+      email: acct.email,
+      password: acct.password,
+      visionCapable: null,
+      lastUsed: 0,
+      errorCount: 0,
+      activeRequests: 0,
+      dead: false,
+    });
+  }
+}
+
+import { loginHeaders, getHeaders, getDeviceId, proxiedFetch, getDeviceIdForToken } from './headers.js';
+
+async function login(email, password) {
+  // Use a fresh deviceId for login — real browser gets it from portal101.cn device fingerprint
+  const loginDeviceId = 'B' + generateDeviceId();
+
+  const res = await proxiedFetch(`${BASE_URL}/api/v0/users/login`, {
+    method: 'POST',
+    headers: loginHeaders(),
+    body: JSON.stringify({ email, mobile: '', password, area_code: '', device_id: loginDeviceId, os: 'web' }),
+  });
+
+  // AWS WAF returns 202 with empty body — can't login from this IP
+  if (res.status === 202) {
+    throw new Error('WAF challenge (202) — login blocked from this IP, use external refresh');
+  }
+
+  const text = await res.text();
+  if (!text) throw new Error('Empty response from login endpoint');
+
+  const json = JSON.parse(text);
+  if (json.code !== 0) throw new Error(`Login failed for ${email}: ${json.msg || JSON.stringify(json)}`);
+
+  const bizCode = json.data?.biz_code;
+  if (bizCode === 10) {
+    throw new Error(`Account banned: ${email}`);
+  }
+  if (bizCode === 11) {
+    throw new Error(`Account requires verification: ${email}`);
+  }
+
+  const token = json.data?.biz_data?.user?.token;
+  if (!token) throw new Error(`Login succeeded but no token returned for ${email}`);
+  return token;
+}
+
+async function checkVisionCapability(token) {
+  try {
+    const res = await proxiedFetch(`${BASE_URL}/api/v0/client/settings?did=${getDeviceId()}&scope=model`, {
+      headers: await getHeaders(token),
+    });
+    const json = await res.json();
+    const configs = json.data?.biz_data?.settings?.model_configs?.value || [];
+    const visionConfig = configs.find(c => c.model_type === 'vision');
+    if (visionConfig) {
+      return visionConfig.switchable === true;
+    }
+    return false;
+  } catch {
+    return null;
+  }
+}
+
+// Check if a token is still valid — uses /users/current which actually validates the token
+// (unlike /client/settings which returns code:0 even for invalid tokens)
+async function validateToken(token) {
+  try {
+    const res = await proxiedFetch(`${BASE_URL}/api/v0/users/current`, {
+      headers: await getHeaders(token),
+    });
+    const json = await res.json();
+    return json.code === 0;
+  } catch {
+    return false;
+  }
+}
+
+// Refresh a dead token entry — login if account credentials exist
+async function refreshToken(entry) {
+  if (!entry.password) return false;
+  try {
+    const newToken = await login(entry.email, entry.password);
+    entry.token = newToken;
+    entry.errorCount = 0;
+    entry.dead = false;
+    const vision = await checkVisionCapability(newToken);
+    entry.visionCapable = vision;
+    console.log(`  Refreshed token for ${entry.email}: ${newToken.slice(0, 12)}... vision=${vision}`);
+    return true;
+  } catch (err) {
+    console.warn(`  Refresh failed for ${entry.email}: ${err.message}`);
+    // If account is banned, mark dead permanently
+    if (err.message.includes('banned')) {
+      entry.dead = true;
+      entry.errorCount = TOKEN_DEAD_THRESHOLD;
+    }
+    return false;
+  }
+}
+
+export async function initTokenPool() {
+  console.log(`Token pool: ${tokenPool.length} entries (${tokens.length} tokens + ${accounts.length} accounts), max ${MAX_CONCURRENT_PER_TOKEN} concurrent each`);
+
+  // Validate existing tokens, mark dead ones (auto-refresh if account linked)
+  for (const entry of tokenPool) {
+    if (entry.token) {
+      const valid = await validateToken(entry.token);
+      if (!valid) {
+        console.log(`  ${entry.token.slice(0, 12)}... INVALID — ${entry.password ? 'attempting refresh' : 'no account to refresh'}`);
+        if (entry.password) {
+          const ok = await refreshToken(entry);
+          if (ok) {
+            // Remove duplicate account-only entries that now have same email
+            const dupIdx = tokenPool.findIndex(t => t !== entry && t.email === entry.email && !t.token);
+            if (dupIdx !== -1) {
+              console.log(`  Removing duplicate account entry for ${entry.email}`);
+              tokenPool.splice(dupIdx, 1);
+            }
+          }
+        } else {
+          entry.dead = true;
+          entry.errorCount = TOKEN_DEAD_THRESHOLD;
+        }
+      }
+    }
+  }
+
+  // Login account-only entries (no token yet) — remove if banned/WAF-blocked
+  for (let i = tokenPool.length - 1; i >= 0; i--) {
+    const entry = tokenPool[i];
+    if (!entry.token && entry.password) {
+      const ok = await refreshToken(entry);
+      if (!ok && entry.dead) {
+        // Banned or permanently failed — remove from pool
+        console.log(`  Removing banned/failed account entry for ${entry.email}`);
+        tokenPool.splice(i, 1);
+      }
+    }
+  }
+
+  // Also remove account entries with no token and no password (stale NONE entries)
+  for (let i = tokenPool.length - 1; i >= 0; i--) {
+    if (!tokenPool[i].token && !tokenPool[i].password) {
+      console.log(`  Removing stale NONE entry at index ${i}`);
+      tokenPool.splice(i, 1);
+    }
+  }
+
+  // Check vision capability for valid tokens
+  for (const entry of tokenPool) {
+    if (entry.token && !entry.dead) {
+      const vision = await checkVisionCapability(entry.token);
+      entry.visionCapable = vision;
+      const label = vision === true ? 'vision=YES' : vision === false ? 'vision=NO' : 'vision=UNKNOWN';
+      console.log(`  ${entry.token.slice(0, 12)}... ${label} ${entry.email ? `(${entry.email})` : ''}`);
+    }
+  }
+
+  const alive = tokenPool.filter(t => !t.dead).length;
+  console.log(`Pool ready: ${alive}/${tokenPool.length} tokens alive`);
+}
+
+export function acquireToken(preferVision = false) {
+  let candidates = tokenPool.filter(t => !t.dead && t.activeRequests < MAX_CONCURRENT_PER_TOKEN && t.token);
+
+  if (preferVision) {
+    const visionTokens = candidates.filter(t => t.visionCapable === true);
+    if (visionTokens.length > 0) candidates = visionTokens;
+  } else {
+    const nonVisionTokens = candidates.filter(t => t.visionCapable !== true);
+    if (nonVisionTokens.length > 0) candidates = nonVisionTokens;
+  }
+
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  candidates.sort((a, b) => a.activeRequests - b.activeRequests);
+  const chosen = candidates[0];
+  chosen.activeRequests++;
+  chosen.lastUsed = Date.now();
+
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    chosen.activeRequests = Math.max(0, chosen.activeRequests - 1);
+  };
+
+  return { token: chosen.token, account: chosen, release };
+}
+
+export function reportTokenError(token) {
+  const entry = tokenPool.find(t => t.token === token);
+  if (!entry) return;
+  entry.errorCount++;
+
+  if (entry.errorCount >= TOKEN_DEAD_THRESHOLD) {
+    entry.dead = true;
+    console.warn(`Token ${token.slice(0, 12)}... marked DEAD (errorCount=${entry.errorCount})`);
+
+    // Try auto-refresh if account credentials exist
+    if (entry.password) {
+      refreshToken(entry).then(ok => {
+        if (ok) {
+          invalidateTokenSessions(token);
+        }
+      });
+    }
+  }
+}
+
+export function reportTokenSuccess(token) {
+  const entry = tokenPool.find(t => t.token === token);
+  if (!entry) return;
+  entry.errorCount = 0;
+  entry.lastUsed = Date.now();
+  if (entry.dead) {
+    entry.dead = false;
+    console.log(`Token ${token.slice(0, 12)}... revived (was dead, now working)`);
+  }
+}
+
+// Invalidate cached sessions for a token (after refresh)
+function invalidateTokenSessions(token) {
+  const prefix = token.slice(0, 12);
+  // Dynamic import to avoid circular dependency
+  import('./session.js').then(m => m.invalidateTokenSessions(prefix)).catch(() => {});
+}
+
+// Legacy: pickToken returns just the token string
+let tokenIndex = 0;
+export function pickToken(preferVision = false) {
+  let candidates = tokenPool.filter(t => !t.dead && t.token);
+
+  if (preferVision) {
+    const visionTokens = candidates.filter(t => t.visionCapable === true);
+    if (visionTokens.length > 0) candidates = visionTokens;
+  } else {
+    const nonVisionTokens = candidates.filter(t => t.visionCapable !== true);
+    if (nonVisionTokens.length > 0) candidates = nonVisionTokens;
+  }
+
+  if (candidates.length === 0) {
+    // Absolute fallback — use any token with a token string
+    candidates = tokenPool.filter(t => t.token);
+    if (candidates.length === 0) throw new Error('No tokens available in pool');
+  }
+
+  const idx = tokenIndex % candidates.length;
+  const chosen = candidates[idx];
+  tokenIndex++;
+  return chosen.token;
+}
+
+// Legacy: sticky per-request token
+let currentRequestToken = null;
+
+export function setRequestToken(token) {
+  currentRequestToken = token;
+}
+
+export function getRequestToken() {
+  return currentRequestToken;
+}
+
+export async function getToken(preferVision = false) {
+  if (currentRequestToken) return currentRequestToken;
+  return pickToken(preferVision);
+}
+
+// Legacy: email/password login (adds to pool dynamically)
+export async function loginAndAddToken(email, password) {
+  const token = await login(email, password);
+  const existing = tokenPool.find(t => t.token === token);
+  if (!existing) {
+    const vision = await checkVisionCapability(token);
+    tokenPool.push({ token, email, password, visionCapable: vision, lastUsed: 0, errorCount: 0, activeRequests: 0, dead: false });
+  }
+  return token;
+}
+
+export async function addTokenToPool(tokenStr) {
+  const trimmed = tokenStr.trim();
+  const existing = tokenPool.find(t => t.token === trimmed);
+  if (existing) return existing;
+  const vision = await checkVisionCapability(trimmed);
+  const entry = { token: trimmed, email: null, password: null, visionCapable: vision, lastUsed: 0, errorCount: 0, activeRequests: 0, dead: false };
+  tokenPool.push(entry);
+  return entry;
+}
+
+// Periodic health check — validate alive tokens and detect banned accounts early
+// Only checks tokens that haven't been used recently (idle tokens) to reduce request volume
+const HEALTH_CHECK_INTERVAL = 10 * 60 * 1000; // 10 minutes
+const IDLE_THRESHOLD = 30 * 60 * 1000; // 30 minutes — only check tokens idle for 30+ min
+
+async function healthCheck() {
+  const now = Date.now();
+  // Only check idle tokens — recently used ones are assumed valid
+  const idle = tokenPool.filter(t => !t.dead && t.token && (now - t.lastUsed) > IDLE_THRESHOLD);
+  if (idle.length === 0) return;
+
+  console.log(`Health check: ${idle.length} idle tokens (of ${tokenPool.filter(t => !t.dead).length} alive)`);
+
+  for (const entry of idle) {
+    const valid = await validateToken(entry.token);
+    if (!valid) {
+      console.log(`Health check: ${entry.token.slice(0, 12)}... INVALID — ${entry.password ? 'refreshing' : 'marking dead'}`);
+      if (entry.password) {
+        const ok = await refreshToken(entry);
+        if (!ok && entry.dead) {
+          console.log(`Health check: ${entry.email} is BANNED, removing from pool`);
+          const idx = tokenPool.indexOf(entry);
+          if (idx !== -1) tokenPool.splice(idx, 1);
+        }
+      } else {
+        entry.dead = true;
+        entry.errorCount = TOKEN_DEAD_THRESHOLD;
+      }
+    } else {
+      entry.lastUsed = now; // reset idle timer on successful check
+    }
+  }
+}
+
+let healthCheckTimer = null;
+
+export function startHealthCheck() {
+  if (healthCheckTimer) return;
+  healthCheckTimer = setInterval(healthCheck, HEALTH_CHECK_INTERVAL);
+  console.log(`Health check enabled: every ${HEALTH_CHECK_INTERVAL / 1000}s`);
+}
+
+export function stopHealthCheck() {
+  if (healthCheckTimer) {
+    clearInterval(healthCheckTimer);
+    healthCheckTimer = null;
+  }
+}
+
+export function getPoolInfo() {
+  return tokenPool.filter(t => !t.dead).map(t => ({
+    token: t.token ? t.token.slice(0, 12) + '...' : 'NONE',
+    email: t.email || null,
+    visionCapable: t.visionCapable,
+    errorCount: t.errorCount,
+    activeRequests: t.activeRequests,
+    dead: t.dead,
+    maxConcurrent: MAX_CONCURRENT_PER_TOKEN,
+  }));
+}
+
+export function getAliveTokens() {
+  return tokenPool.filter(t => !t.dead && t.token).map(t => t.token);
+}
+
+export function getTotalCapacity() {
+  return tokenPool.filter(t => !t.dead).length * MAX_CONCURRENT_PER_TOKEN;
+}

src/chat.js

@@ -0,0 +1,177 @@
+import { setRequestToken, reportTokenError, reportTokenSuccess } from './auth.js';
+import { solvePowChallengeWithToken } from './pow.js';
+import { getSession } from './session.js';
+import { streamHeaders, proxiedFetch } from './headers.js';
+import { enqueueRequest, dispatchQueued } from './queue.js';
+
+const BASE_URL = 'https://chat.deepseek.com';
+
+export async function completion({ modelType, prompt, thinkingEnabled = false, searchEnabled = false, parentMessageId = null, refFileIds = [], preferVision = false }) {
+  // Step 1: Acquire token slot first — PoW and completion must use the same token
+  const slot = await enqueueRequest(preferVision);
+
+  try {
+    // Step 2: Solve PoW using the same token
+    const { powResponse } = await solvePowChallengeWithToken(slot.token);
+
+    setRequestToken(slot.token);
+    const session = await getSession(slot.token, modelType);
+    setRequestToken(null);
+
+    const body = {
+      chat_session_id: session.id,
+      parent_message_id: parentMessageId,
+      model_type: modelType,
+      prompt,
+      ref_file_ids: refFileIds,
+      thinking_enabled: thinkingEnabled,
+      search_enabled: searchEnabled,
+      action: null,
+      preempt: false,
+    };
+
+    const res = await proxiedFetch(`${BASE_URL}/api/v0/chat/completion`, {
+      method: 'POST',
+      headers: await streamHeaders(slot.token, powResponse),
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      // Check for specific DeepSeek error codes
+      try {
+        const errJson = JSON.parse(text);
+        const code = errJson.code;
+        // 40003 = invalid/expired token
+        if (code === 40003) {
+          reportTokenError(slot.token);
+          throw new Error('Token invalid (40003)');
+        }
+        // 40004 = account banned
+        if (code === 40004) {
+          reportTokenError(slot.token);
+          const entry = (await import('./auth.js')).getPoolInfo().find(t => slot.token.startsWith(t.token.replace('...', '')));
+          console.error(`Account BANNED during completion: ${entry?.email || slot.token.slice(0, 12)}...`);
+          throw new Error('Account banned (40004)');
+        }
+      } catch (parseErr) {
+        if (parseErr.message.includes('Token invalid') || parseErr.message.includes('Account banned')) throw parseErr;
+      }
+      reportTokenError(slot.token);
+      throw new Error(`Completion request failed: ${res.status} ${text}`);
+    }
+
+    reportTokenSuccess(slot.token);
+    return { body: res.body, slot };
+  } catch (err) {
+    slot.release();
+    dispatchQueued();
+    throw err;
+  }
+}
+
+export async function* parseSSEStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let messageIds = {};
+  let currentFragmentType = null;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (line.startsWith('event:')) {
+          if (line.slice(6).trim() === 'close') return;
+          continue;
+        }
+        if (!line.startsWith('data:')) continue;
+        const data = line.slice(5).trim();
+        if (!data) continue;
+
+        try {
+          const parsed = JSON.parse(data);
+
+          // Check for error codes mid-stream
+          if (parsed.code === 40003) {
+            yield { type: 'error', code: 40003, message: 'Token invalid' };
+            return;
+          }
+          if (parsed.code === 40004) {
+            yield { type: 'error', code: 40004, message: 'Account banned' };
+            return;
+          }
+
+          if (parsed.request_message_id != null) {
+            messageIds.requestMessageId = parsed.request_message_id;
+            messageIds.responseMessageId = parsed.response_message_id;
+          }
+
+          if (parsed.v?.response?.fragments) {
+            for (const frag of parsed.v.response.fragments) {
+              if (frag.type === 'THINK' && frag.content) {
+                currentFragmentType = 'THINK';
+                yield { type: 'thinking', content: frag.content, messageIds };
+              } else if (frag.type === 'RESPONSE' && frag.content) {
+                currentFragmentType = 'RESPONSE';
+                yield { type: 'content', content: frag.content, messageIds };
+              }
+            }
+            if (parsed.v.response.accumulated_token_usage != null) {
+              yield { type: 'usage', usage: parsed.v.response.accumulated_token_usage, messageIds };
+            }
+          }
+
+          if (parsed.p && parsed.o) {
+            if (parsed.p === 'response/fragments/-1/content' && parsed.o === 'APPEND' && typeof parsed.v === 'string') {
+              yield { type: currentFragmentType === 'THINK' ? 'thinking' : 'content', content: parsed.v, messageIds };
+            } else if (parsed.p === 'response/fragments/-1/content' && !parsed.o && typeof parsed.v === 'string') {
+              yield { type: currentFragmentType === 'THINK' ? 'thinking' : 'content', content: parsed.v, messageIds };
+            } else if (parsed.p === 'response/status' && parsed.v === 'FINISHED') {
+              yield { type: 'done', messageIds };
+            } else if (parsed.p === 'response' && parsed.o === 'BATCH' && Array.isArray(parsed.v)) {
+              for (const item of parsed.v) {
+                if (item.p === 'accumulated_token_usage') {
+                  yield { type: 'usage', usage: item.v, messageIds };
+                }
+              }
+            } else if (parsed.p === 'response/fragments' && parsed.o === 'APPEND' && Array.isArray(parsed.v)) {
+              for (const frag of parsed.v) {
+                if (frag.type === 'RESPONSE' && frag.content) {
+                  currentFragmentType = 'RESPONSE';
+                  yield { type: 'content', content: frag.content, messageIds };
+                } else if (frag.type === 'THINK' && frag.content) {
+                  currentFragmentType = 'THINK';
+                  yield { type: 'thinking', content: frag.content, messageIds };
+                }
+              }
+            }
+            continue;
+          }
+
+          if (typeof parsed.v === 'string') {
+            yield { type: currentFragmentType === 'THINK' ? 'thinking' : 'content', content: parsed.v, messageIds };
+          }
+
+          if (Array.isArray(parsed.v)) {
+            for (const item of parsed.v) {
+              if (item.p === 'accumulated_token_usage') {
+                yield { type: 'usage', usage: item.v, messageIds };
+              }
+            }
+          }
+        } catch {
+          // skip unparseable lines
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}

src/deepseek.js

@@ -0,0 +1,57 @@
+import { completion, parseSSEStream } from './chat.js';
+import { pickToken } from './auth.js';
+import { dispatchQueued } from './queue.js';
+
+const MODEL_MAP = {
+  'deepseek-v4-flash': 'default',
+  'deepseek-v4-pro': 'expert',
+  'deepseek-v4-vision': 'vision',
+  'deepseek-v4-flash[1m]': 'default',
+  'deepseek-v4-pro[1m]': 'expert',
+  'deepseek-v4-vision[1m]': 'vision',
+};
+
+export async function handleDeepSeekCompletion(req, res) {
+  const body = req.body;
+  const modelType = body.model_type || MODEL_MAP[body.model] || 'default';
+  const prompt = body.prompt || '';
+  const thinkingEnabled = body.thinking_enabled ?? false;
+  const searchEnabled = body.search_enabled ?? false;
+  const parentMessageId = body.parent_message_id ?? null;
+  const refFileIds = body.ref_file_ids ?? [];
+
+  if (!prompt) {
+    return res.status(400).json({ code: 1, msg: 'prompt is required' });
+  }
+
+  try {
+    const { body: streamBody, slot } = await completion({ modelType, prompt, thinkingEnabled, searchEnabled, parentMessageId, refFileIds });
+
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream; charset=utf-8',
+      'Cache-Control': 'no-cache',
+    });
+
+    const reader = streamBody.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        res.write(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    res.end();
+  } catch (err) {
+    console.error('DeepSeek completion error:', err.message);
+    if (!res.headersSent) {
+      res.status(500).json({ code: 1, msg: err.message });
+    } else {
+      res.end();
+    }
+  } finally {
+    slot.release();
+    dispatchQueued();
+  }
+}

src/headers.js

@@ -0,0 +1,226 @@
+// Mimic real Chrome 120 browser session
+const UA_VERSION = '120.0.0.0';
+const UA_MAJOR = '120';
+
+const BROWSER_HEADERS = {
+  'user-agent': `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${UA_VERSION} Safari/537.36`,
+  'accept-language': 'zh-CN,zh;q=0.9',
+  'accept-encoding': 'gzip, deflate, br',
+  'origin': 'https://chat.deepseek.com',
+  'referer': 'https://chat.deepseek.com/',
+  'sec-ch-ua': `"Not_A Brand";v="8", "Chromium";v="${UA_MAJOR}", "Google Chrome";v="${UA_MAJOR}"`,
+  'sec-ch-ua-mobile': '?0',
+  'sec-ch-ua-platform': '"Windows"',
+  'sec-fetch-dest': 'empty',
+  'sec-fetch-mode': 'cors',
+  'sec-fetch-site': 'same-origin',
+  'x-client-timezone-offset': '28800',
+};
+
+// Per-token cookie jar: smidV2, HWWAFSESTIME, HWWAFSESID, ds_session_id, thumbcache
+const tokenCookies = new Map();
+
+function randomHex(len) {
+  const chars = '0123456789abcdef';
+  let s = '';
+  for (let i = 0; i < len; i++) s += chars[Math.floor(Math.random() * 16)];
+  return s;
+}
+
+function randomAlphaNum(len) {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  let s = '';
+  for (let i = 0; i < len; i++) s += chars[Math.floor(Math.random() * chars.length)];
+  return s;
+}
+
+function ensureCookies(token) {
+  if (tokenCookies.has(token)) return tokenCookies.get(token);
+  const smidV2 = `20260520${randomAlphaNum(10)}${randomHex(24)}`;
+  const HWWAFSESTIME = `${Date.now()}`;
+  const HWWAFSESID = `${randomAlphaNum(4)}${randomHex(12)}`;
+  const dsSessionId = `${randomHex(32)}`;
+  const thumbcacheKey = randomHex(32);
+  const deviceId = generateDeviceId();
+  const thumbcacheValue = deviceId;
+  const cookie = `smidV2=${smidV2}; HWWAFSESTIME=${HWWAFSESTIME}; HWWAFSESID=${HWWAFSESID}; ds_session_id=${dsSessionId}; .thumbcache_${thumbcacheKey}=${encodeURIComponent(thumbcacheValue)}`;
+  tokenCookies.set(token, { cookie, deviceId });
+  return tokenCookies.get(token);
+}
+
+// Generate deviceId from fp-it-acc.portal101.cn format (base64-like)
+function generateDeviceId() {
+  const bytes = new Uint8Array(48);
+  for (let i = 0; i < 48; i++) bytes[i] = Math.floor(Math.random() * 256);
+  return Buffer.from(bytes).toString('base64').replace(/=/g, '') + '==';
+}
+
+export function getDeviceIdForToken(token) {
+  const cached = tokenCookies.get(token);
+  return cached?.deviceId || null;
+}
+
+// HIF (Hidden Integration Feature) token management
+// DeepSeek uses hif-leim and hif-dliq headers for request validation
+// These are fetched from hif-leim.deepseek.com/query and hif-dliq.deepseek.com/query
+const HIF_BASE = 'https://hif-leim.deepseek.com/query';
+const HIF_DLIQ_BASE = 'https://hif-dliq.deepseek.com/query';
+
+const hifCache = new Map(); // key: token, value: { leim, dliq, expiresAt }
+
+async function fetchHifToken(url, token) {
+  const headers = {
+    'user-agent': BROWSER_HEADERS['user-agent'],
+    'accept': '*/*',
+    'accept-language': 'zh-CN,zh;q=0.9',
+    'accept-encoding': 'gzip, deflate, br',
+    'origin': 'https://chat.deepseek.com',
+    'referer': 'https://chat.deepseek.com/',
+  };
+  if (token) {
+    headers['authorization'] = `Bearer ${token}`;
+  }
+  const res = await proxiedFetch(url, { headers });
+  const json = await res.json();
+  const value = json.data?.biz_data?.value;
+  const ttl = parseInt(res.headers.get('x-hif-ttl') || '600', 10);
+  return { value, ttl };
+}
+
+async function refreshHifTokens(token) {
+  try {
+    const [leimResult, dliqResult] = await Promise.all([
+      fetchHifToken(HIF_BASE, token),
+      fetchHifToken(HIF_DLIQ_BASE, token),
+    ]);
+
+    if (leimResult.value && dliqResult.value) {
+      const ttl = Math.min(leimResult.ttl, dliqResult.ttl);
+      hifCache.set(token, {
+        leim: leimResult.value,
+        dliq: dliqResult.value,
+        expiresAt: Date.now() + ttl * 1000,
+      });
+    }
+  } catch (e) {
+    // HIF fetch failed — requests will proceed without it
+  }
+}
+
+async function getHifHeaders(token) {
+  const cached = hifCache.get(token);
+  if (cached && cached.expiresAt > Date.now()) {
+    return { 'x-hif-leim': cached.leim, 'x-hif-dliq': cached.dliq };
+  }
+
+  await refreshHifTokens(token);
+  const refreshed = hifCache.get(token);
+  if (refreshed) {
+    return { 'x-hif-leim': refreshed.leim, 'x-hif-dliq': refreshed.dliq };
+  }
+  return {};
+}
+
+// Proxy dispatcher for bypassing IP-based rate limits
+let proxyDispatcher = null;
+
+export async function getDispatcher() {
+  if (proxyDispatcher !== null) return proxyDispatcher;
+  const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+  if (!proxyUrl) {
+    proxyDispatcher = false;
+    return false;
+  }
+  try {
+    const { ProxyAgent } = await import('undici');
+    proxyDispatcher = new ProxyAgent(proxyUrl);
+    console.log(`Proxy enabled: ${proxyUrl}`);
+    return proxyDispatcher;
+  } catch (e) {
+    console.warn(`Failed to init proxy (${proxyUrl}): ${e.message}`);
+    proxyDispatcher = false;
+    return false;
+  }
+}
+
+// Common headers for API requests
+export async function apiHeaders(token, extra = {}) {
+  const cookieData = ensureCookies(token);
+  const hifHeaders = await getHifHeaders(token);
+  return {
+    'authorization': `Bearer ${token}`,
+    'content-type': 'application/json',
+    'accept': '*/*',
+    'x-app-version': '2.0.0',
+    'x-client-version': '2.0.0',
+    'x-client-platform': 'web',
+    'x-client-locale': 'zh_CN',
+    'cookie': cookieData.cookie,
+    ...BROWSER_HEADERS,
+    ...hifHeaders,
+    ...extra,
+  };
+}
+
+// Headers for SSE streaming requests
+export async function streamHeaders(token, powResponse, extra = {}) {
+  const cookieData = ensureCookies(token);
+  const hifHeaders = await getHifHeaders(token);
+  return {
+    'authorization': `Bearer ${token}`,
+    'content-type': 'application/json',
+    'x-ds-pow-response': powResponse,
+    'accept': 'text/event-stream',
+    'x-app-version': '2.0.0',
+    'x-client-version': '2.0.0',
+    'x-client-platform': 'web',
+    'x-client-locale': 'zh_CN',
+    'cookie': cookieData.cookie,
+    ...BROWSER_HEADERS,
+    ...hifHeaders,
+    ...extra,
+  };
+}
+
+// Headers for GET requests (no content-type)
+export async function getHeaders(token, extra = {}) {
+  const cookieData = ensureCookies(token);
+  return {
+    'authorization': `Bearer ${token}`,
+    'accept': '*/*',
+    'x-app-version': '2.0.0',
+    'x-client-version': '2.0.0',
+    'x-client-platform': 'web',
+    'x-client-locale': 'zh_CN',
+    'cookie': cookieData.cookie,
+    ...BROWSER_HEADERS,
+    ...extra,
+  };
+}
+
+// Headers for login (no token)
+export function loginHeaders(extra = {}) {
+  return {
+    'content-type': 'application/json',
+    'accept': '*/*',
+    'x-app-version': '2.0.0',
+    'x-client-version': '2.0.0',
+    'x-client-platform': 'web',
+    'x-client-locale': 'zh_CN',
+    ...BROWSER_HEADERS,
+    ...extra,
+  };
+}
+
+// Persistent device ID (per process lifetime) — used for settings endpoint
+const deviceId = randomHex(8) + '-' + randomHex(4) + '-' + randomHex(4) + '-' + randomHex(4) + '-' + randomHex(12);
+export function getDeviceId() { return deviceId; }
+
+// Wrap fetch to use proxy dispatcher when available
+export async function proxiedFetch(url, options = {}) {
+  const dispatcher = await getDispatcher();
+  if (dispatcher) {
+    options.dispatcher = dispatcher;
+  }
+  return fetch(url, options);
+}

src/index.js

@@ -0,0 +1,118 @@
+import { config } from 'dotenv';
+config();
+
+import express from 'express';
+import { initTokenPool, getPoolInfo, getTotalCapacity, addTokenToPool, loginAndAddToken, getAliveTokens, startHealthCheck } from './auth.js';
+import { prewarmSessions, getSessionInfo } from './session.js';
+import { handleOpenAICompletion, handleOpenAIModels } from './openai.js';
+import { handleDeepSeekCompletion } from './deepseek.js';
+import { getQueueInfo } from './queue.js';
+import { requestLogger, getRecentLogs, getLogStats } from './logger.js';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const startTime = Date.now();
+
+const app = express();
+const PORT = Number(process.env.PORT || 7860);
+
+app.use(express.json({ limit: '50mb' }));
+
+// Request logging
+app.use(requestLogger);
+
+// API Key auth middleware
+app.use((req, res, next) => {
+  const apiKey = process.env.API_KEY;
+  if (!apiKey) return next();
+  if (req.path.startsWith('/admin')) return next();
+
+  const auth = req.headers['authorization'];
+  if (auth === `Bearer ${apiKey}`) return next();
+
+  res.status(401).json({ error: { message: 'Invalid API key' } });
+});
+
+// OpenAI format
+app.post('/v1/chat/completions', handleOpenAICompletion);
+app.get('/v1/models', handleOpenAIModels);
+
+// DeepSeek native format
+app.post('/api/v0/chat/completion', handleDeepSeekCompletion);
+
+// Health check + pool info
+app.get('/', (req, res) => {
+  res.json({
+    status: 'ok',
+    version: '2.0.0',
+    pool: getPoolInfo(),
+    totalCapacity: getTotalCapacity(),
+    queue: getQueueInfo(),
+  });
+});
+
+// Admin panel
+app.get('/admin', (req, res) => {
+  res.sendFile(join(__dirname, 'admin', 'index.html'));
+});
+
+app.get('/admin/api/stats', (req, res) => {
+  const uptimeSeconds = Math.floor((Date.now() - startTime) / 1000);
+  res.json({
+    status: 'ok',
+    version: '2.0.0',
+    uptimeSeconds,
+    pool: getPoolInfo(),
+    totalCapacity: getTotalCapacity(),
+    queue: getQueueInfo(),
+    sessions: getSessionInfo(),
+    logStats: getLogStats(),
+  });
+});
+
+app.get('/admin/api/logs', (req, res) => {
+  const count = Math.min(parseInt(req.query.count) || 50, 200);
+  res.json({ logs: getRecentLogs(count), stats: getLogStats() });
+});
+
+app.post('/admin/api/token/add', async (req, res) => {
+  const { token } = req.body;
+  if (!token || typeof token !== 'string') {
+    return res.status(400).json({ error: { message: 'token required' } });
+  }
+  try {
+    const added = await addTokenToPool(token);
+    res.json({ success: true, visionCapable: added.visionCapable });
+  } catch (err) {
+    res.status(500).json({ error: { message: err.message } });
+  }
+});
+
+app.post('/admin/api/token/login', async (req, res) => {
+  const { email, password } = req.body;
+  if (!email || !password) {
+    return res.status(400).json({ error: { message: 'email and password required' } });
+  }
+  try {
+    const token = await loginAndAddToken(email, password);
+    res.json({ success: true, token: token.slice(0, 12) + '...' });
+  } catch (err) {
+    res.status(500).json({ error: { message: err.message } });
+  }
+});
+
+app.listen(PORT, async () => {
+  console.log(`DeepSeek 2API running on http://localhost:${PORT}`);
+  console.log(`OpenAI format:  POST /v1/chat/completions`);
+  console.log(`DeepSeek format: POST /api/v0/chat/completion`);
+  console.log(`Models: GET /v1/models`);
+  console.log(`Admin panel: http://localhost:${PORT}/admin`);
+
+  await initTokenPool();
+
+  const aliveTokens = getAliveTokens();
+  await prewarmSessions(aliveTokens);
+
+  startHealthCheck();
+});

src/logger.js

@@ -0,0 +1,48 @@
+// Request logger middleware — structured log for every API request
+// Usage: import { requestLogger, getRecentLogs } from './logger.js'; app.use(requestLogger);
+
+const MAX_LOGS = 1000;
+const recentLogs = [];
+
+export function requestLogger(req, res, next) {
+  const start = Date.now();
+  const model = req.body?.model || '-';
+
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    const entry = {
+      time: new Date().toISOString(),
+      method: req.method,
+      path: req.path,
+      model,
+      status: res.statusCode,
+      duration,
+    };
+
+    console.log(`[${entry.time}] ${entry.method} ${entry.path} model=${entry.model} ${entry.status} ${entry.duration}ms`);
+
+    if (recentLogs.length >= MAX_LOGS) recentLogs.shift();
+    recentLogs.push(entry);
+  });
+
+  next();
+}
+
+export function getRecentLogs(count = 50) {
+  return recentLogs.slice(-count);
+}
+
+export function getLogStats() {
+  const now = Date.now();
+  const last5min = recentLogs.filter(e => now - new Date(e.time).getTime() < 300000);
+  const errors = last5min.filter(e => e.status >= 400);
+  const avgDuration = last5min.length
+    ? Math.round(last5min.reduce((s, e) => s + e.duration, 0) / last5min.length)
+    : 0;
+  return {
+    totalRequests: recentLogs.length,
+    last5min: last5min.length,
+    errors5min: errors.length,
+    avgDuration5min: avgDuration,
+  };
+}

src/openai.js

@@ -0,0 +1,234 @@
+import { completion, parseSSEStream } from './chat.js';
+import { resolveImageToRefId } from './upload.js';
+import { enqueueRequest, dispatchQueued } from './queue.js';
+
+const MODEL_MAP = {
+  'deepseek-v4-flash': 'default',
+  'deepseek-v4-pro': 'expert',
+  'deepseek-v4-vision': 'vision',
+  'deepseek-v4-flash[1m]': 'default',
+  'deepseek-v4-pro[1m]': 'expert',
+  'deepseek-v4-vision[1m]': 'vision',
+};
+
+function mapModel(model) {
+  const mapped = MODEL_MAP[model];
+  if (!mapped) throw new Error(`Unknown model: ${model}. Available: ${Object.keys(MODEL_MAP).join(', ')}`);
+  return mapped;
+}
+
+async function extractImages(messages, token) {
+  const refFileIds = [];
+  for (const msg of messages) {
+    if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === 'image_url' && part.image_url?.url) {
+          try {
+            const fileId = await resolveImageToRefId(part.image_url.url, token);
+            refFileIds.push(fileId);
+          } catch (err) {
+            console.error('Image upload failed:', err.message);
+          }
+        }
+      }
+    }
+  }
+  return refFileIds;
+}
+
+function buildPrompt(messages) {
+  let prompt = '';
+  for (const msg of messages) {
+    if (msg.role === 'system') {
+      prompt += `[System]: ${msg.content}\n\n`;
+    } else if (msg.role === 'user') {
+      if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (part.type === 'text') {
+            prompt += `[User]: ${part.text}\n\n`;
+          }
+        }
+      } else {
+        prompt += `[User]: ${msg.content}\n\n`;
+      }
+    } else if (msg.role === 'assistant') {
+      prompt += `[Assistant]: ${msg.content}\n\n`;
+    }
+  }
+  return prompt.trim();
+}
+
+export async function handleOpenAICompletion(req, res) {
+  const { model, messages, stream = false, max_tokens } = req.body;
+
+  if (!model || !messages || !messages.length) {
+    return res.status(400).json({ error: { message: 'model and messages are required' } });
+  }
+
+  const modelType = mapModel(model);
+  const prompt = buildPrompt(messages);
+  const thinkingEnabled = req.body.thinking_enabled ?? true;
+  const searchEnabled = req.body.search_enabled ?? (modelType !== 'vision');
+  // Merge reasoning_content into content with <think> tags so CLI tools can see it
+  const mergeThinking = req.body.merge_thinking ?? (process.env.MERGE_THINKING !== 'false');
+
+  const requestId = `chatcmpl-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  let result;
+
+  try {
+    let refFileIds = [];
+    let uploadSlot = null;
+    if (modelType === 'vision') {
+      uploadSlot = await enqueueRequest(true);
+      try {
+        refFileIds = await extractImages(messages, uploadSlot.token);
+      } finally {
+        uploadSlot.release();
+        dispatchQueued();
+      }
+    }
+
+    result = await completion({ modelType, prompt, thinkingEnabled, searchEnabled, refFileIds, preferVision: modelType === 'vision' });
+  } catch (err) {
+    console.error('Completion error:', err.message);
+    return res.status(500).json({ error: { message: err.message } });
+  }
+
+  const { body: streamBody, slot } = result;
+
+  try {
+    if (stream) {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+      });
+
+      res.write(`data: ${JSON.stringify({
+        id: requestId,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
+      })}\n\n`);
+
+      let inThinkingPhase = thinkingEnabled;
+
+      for await (const event of parseSSEStream(streamBody)) {
+        if (event.type === 'error') {
+          if (event.code === 40004) {
+            console.error(`Account BANNED in stream: ${slot.token.slice(0, 12)}...`);
+          }
+          throw new Error(event.message || `DeepSeek error ${event.code}`);
+        }
+        if (event.type === 'content') {
+          inThinkingPhase = false;
+          res.write(`data: ${JSON.stringify({
+            id: requestId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [{ index: 0, delta: { content: event.content }, finish_reason: null }],
+          })}\n\n`);
+        } else if (event.type === 'thinking' && inThinkingPhase) {
+          if (mergeThinking) {
+            res.write(`data: ${JSON.stringify({
+              id: requestId,
+              object: 'chat.completion.chunk',
+              created: Math.floor(Date.now() / 1000),
+              model,
+              choices: [{ index: 0, delta: { content: event.content }, finish_reason: null }],
+            })}\n\n`);
+          } else {
+            res.write(`data: ${JSON.stringify({
+              id: requestId,
+              object: 'chat.completion.chunk',
+              created: Math.floor(Date.now() / 1000),
+              model,
+              choices: [{ index: 0, delta: { reasoning_content: event.content }, finish_reason: null }],
+            })}\n\n`);
+          }
+        } else if (event.type === 'done') {
+          if (mergeThinking && inThinkingPhase) {
+            // No thinking was ever emitted as content — nothing extra needed
+          }
+          res.write(`data: ${JSON.stringify({
+            id: requestId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+          })}\n\n`);
+          res.write('data: [DONE]\n\n');
+        }
+      }
+      res.end();
+    } else {
+      let fullContent = '';
+      let fullThinking = '';
+      let usage = 0;
+      let inThinkingPhase = thinkingEnabled;
+
+      for await (const event of parseSSEStream(streamBody)) {
+        if (event.type === 'error') {
+          if (event.code === 40004) {
+            console.error(`Account BANNED in stream: ${slot.token.slice(0, 12)}...`);
+          }
+          throw new Error(event.message || `DeepSeek error ${event.code}`);
+        }
+        if (event.type === 'content') {
+          fullContent += event.content;
+          inThinkingPhase = false;
+        } else if (event.type === 'thinking' && inThinkingPhase) {
+          fullThinking += event.content;
+        } else if (event.type === 'usage') usage = event.usage;
+      }
+
+      const response = {
+        id: requestId,
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [{
+          index: 0,
+          message: {
+            role: 'assistant',
+            content: mergeThinking && fullThinking
+              ? fullThinking + (fullContent ? '\n' + fullContent : '')
+              : fullContent,
+            ...((!mergeThinking && fullThinking) ? { reasoning_content: fullThinking } : {}),
+          },
+          finish_reason: 'stop',
+        }],
+        usage: {
+          prompt_tokens: 0,
+          completion_tokens: usage,
+          total_tokens: usage,
+        },
+      };
+      res.json(response);
+    }
+  } catch (err) {
+    console.error('Stream error:', err.message);
+    if (!res.headersSent) {
+      res.status(500).json({ error: { message: err.message } });
+    } else {
+      res.end();
+    }
+  } finally {
+    slot.release();
+    dispatchQueued();
+  }
+}
+
+export function handleOpenAIModels(req, res) {
+  res.json({
+    object: 'list',
+    data: Object.keys(MODEL_MAP).map((id, i) => ({
+      id,
+      object: 'model',
+      created: 1700000000,
+      owned_by: 'deepseek',
+    })),
+  });
+}

src/pow.js

@@ -0,0 +1,220 @@
+import { pickToken } from './auth.js';
+import { apiHeaders, proxiedFetch } from './headers.js';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const BASE_URL = 'https://chat.deepseek.com';
+
+// Load and instantiate WASM sha3 module (one-time init)
+let wasmInstance = null;
+
+async function getWasm() {
+  if (wasmInstance) return wasmInstance;
+  const wasmPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'sha3_wasm_bg.wasm');
+  const wasmBuf = readFileSync(wasmPath);
+  const { instance } = await WebAssembly.instantiate(wasmBuf, { wbg: {} });
+  wasmInstance = instance;
+  return instance;
+}
+
+const encoder = new TextEncoder();
+
+function passStringToWasm(instance, str) {
+  const { memory, __wbindgen_export_0 } = instance.exports;
+  const encoded = encoder.encode(str);
+  const ptr = __wbindgen_export_0(encoded.length, 1) >>> 0;
+  new Uint8Array(memory.buffer).set(encoded, ptr);
+  return [ptr, encoded.length];
+}
+
+function wasmSolve(instance, challengeHex, prefix, difficulty) {
+  const { memory, wasm_solve, __wbindgen_add_to_stack_pointer } = instance.exports;
+  const [chPtr, chLen] = passStringToWasm(instance, challengeHex);
+  const [pfPtr, pfLen] = passStringToWasm(instance, prefix);
+
+  const st = __wbindgen_add_to_stack_pointer(-16);
+  wasm_solve(st, chPtr, chLen, pfPtr, pfLen, difficulty);
+  const v = new DataView(memory.buffer);
+  const found = v.getInt32(st, true);
+  const answer = v.getFloat64(st + 8, true);
+  __wbindgen_add_to_stack_pointer(16);
+
+  if (!found) throw new Error('PoW solve failed: no solution within difficulty');
+  return answer;
+}
+
+// BigInt fallback
+const RC = [
+  0x0000000000000001n, 0x0000000000008082n, 0x800000000000808an, 0x8000000080008000n,
+  0x000000000000808bn, 0x0000000080000001n, 0x8000000080008081n, 0x8000000000008009n,
+  0x000000000000008an, 0x0000000000000088n, 0x0000000080008009n, 0x000000008000000an,
+  0x000000008000808bn, 0x800000000000008bn, 0x8000000000008089n, 0x8000000000008003n,
+  0x8000000000008002n, 0x8000000000000080n, 0x000000000000800an, 0x800000008000000an,
+  0x8000000080008081n, 0x8000000000008080n, 0x0000000080000001n, 0x8000000080008008n,
+];
+const MASK = 0xffffffffffffffffn;
+const RATE = 136;
+
+function rotl64(v, k) { return ((v << BigInt(k)) | (v >> BigInt(64 - k))) & MASK; }
+
+function keccakF23(s) {
+  let a = s.slice();
+  for (let r = 1; r < 24; r++) {
+    const c = [a[0]^a[5]^a[10]^a[15]^a[20], a[1]^a[6]^a[11]^a[16]^a[21], a[2]^a[7]^a[12]^a[17]^a[22],
+               a[3]^a[8]^a[13]^a[18]^a[23], a[4]^a[9]^a[14]^a[19]^a[24]];
+    const d = [c[4]^rotl64(c[1],1), c[0]^rotl64(c[2],1), c[1]^rotl64(c[3],1), c[2]^rotl64(c[4],1), c[3]^rotl64(c[0],1)];
+    for (let i = 0; i < 25; i++) a[i] = (a[i] ^ d[i%5]) & MASK;
+    const b = new Array(25);
+    b[0]=a[0];b[10]=rotl64(a[1],1);b[20]=rotl64(a[2],62);b[5]=rotl64(a[3],28);b[15]=rotl64(a[4],27);
+    b[16]=rotl64(a[5],36);b[1]=rotl64(a[6],44);b[11]=rotl64(a[7],6);b[21]=rotl64(a[8],55);b[6]=rotl64(a[9],20);
+    b[7]=rotl64(a[10],3);b[17]=rotl64(a[11],10);b[2]=rotl64(a[12],43);b[12]=rotl64(a[13],25);b[22]=rotl64(a[14],39);
+    b[23]=rotl64(a[15],41);b[8]=rotl64(a[16],45);b[18]=rotl64(a[17],15);b[3]=rotl64(a[18],21);b[13]=rotl64(a[19],8);
+    b[14]=rotl64(a[20],18);b[24]=rotl64(a[21],2);b[9]=rotl64(a[22],61);b[19]=rotl64(a[23],56);b[4]=rotl64(a[24],14);
+    for (let y = 0; y < 5; y++) {
+      const t = [b[y*5], b[y*5+1], b[y*5+2], b[y*5+3], b[y*5+4]];
+      for (let x = 0; x < 5; x++) a[y*5+x] = (t[x] ^ ((t[(x+1)%5] ^ MASK) & t[(x+2)%5])) & MASK;
+    }
+    a[0] = (a[0] ^ RC[r]) & MASK;
+  }
+  for (let i = 0; i < 25; i++) s[i] = a[i];
+}
+
+function readU64LE(buf, off) {
+  let v = 0n;
+  for (let i = 0; i < 8; i++) v |= BigInt(buf[off + i]) << BigInt(i * 8);
+  return v & MASK;
+}
+
+function writeU64LE(val, buf, off) {
+  const v = val & MASK;
+  for (let i = 0; i < 8; i++) buf[off + i] = Number((v >> BigInt(i * 8)) & 0xffn);
+}
+
+function preAbsorbPrefix(prefix) {
+  const s = new Array(25).fill(0n);
+  const buf = Buffer.from(prefix);
+  let off = 0;
+  while (off + RATE <= buf.length) {
+    for (let i = 0; i < RATE / 8; i++) s[i] = (s[i] ^ readU64LE(buf, off + i * 8)) & MASK;
+    keccakF23(s);
+    off += RATE;
+  }
+  const tailLen = buf.length - off;
+  const tail = Buffer.alloc(RATE);
+  buf.copy(tail, 0, off);
+  return { s, tail, tailLen };
+}
+
+function solvePowBigInt(challengeHex, salt, expireAt, difficulty) {
+  if (challengeHex.length !== 64) throw new Error('pow: challenge must be 64 hex chars');
+  const target = Buffer.from(challengeHex, 'hex');
+  const t0 = readU64LE(target, 0);
+  const t1 = readU64LE(target, 8);
+  const t2 = readU64LE(target, 16);
+  const t3 = readU64LE(target, 24);
+  const prefix = `${salt}_${expireAt}_`;
+  const { s: baseState, tail, tailLen } = preAbsorbPrefix(prefix);
+
+  for (let n = 0; n < difficulty; n++) {
+    const nonceStr = n.toString();
+    const nonceBuf = Buffer.from(nonceStr);
+    const totalTail = tailLen + nonceBuf.length;
+    const s = baseState.slice();
+
+    if (totalTail < RATE) {
+      const buf = Buffer.alloc(RATE);
+      tail.copy(buf, 0, 0, tailLen);
+      nonceBuf.copy(buf, tailLen);
+      buf[totalTail] = 0x06;
+      buf[RATE - 1] |= 0x80;
+      for (let i = 0; i < RATE / 8; i++) s[i] = (s[i] ^ readU64LE(buf, i * 8)) & MASK;
+      keccakF23(s);
+    } else {
+      const buf1 = Buffer.alloc(RATE);
+      tail.copy(buf1, 0, 0, tailLen);
+      nonceBuf.copy(buf1, tailLen, 0, RATE - tailLen);
+      for (let i = 0; i < RATE / 8; i++) s[i] = (s[i] ^ readU64LE(buf1, i * 8)) & MASK;
+      keccakF23(s);
+      const rem = totalTail - RATE;
+      const buf2 = Buffer.alloc(RATE);
+      nonceBuf.copy(buf2, 0, RATE - tailLen, RATE - tailLen + rem);
+      buf2[rem] = 0x06;
+      buf2[RATE - 1] |= 0x80;
+      for (let i = 0; i < RATE / 8; i++) s[i] = (s[i] ^ readU64LE(buf2, i * 8)) & MASK;
+      keccakF23(s);
+    }
+
+    if (s[0] === t0 && s[1] === t1 && s[2] === t2 && s[3] === t3) return n;
+  }
+
+  throw new Error('PoW solve failed: no solution within difficulty');
+}
+
+let useWasm = true;
+
+async function solvePowInternal(token, targetPath = '/api/v0/chat/completion') {
+  const res = await proxiedFetch(`${BASE_URL}/api/v0/chat/create_pow_challenge`, {
+    method: 'POST',
+    headers: await apiHeaders(token),
+    body: JSON.stringify({ target_path: targetPath }),
+  });
+
+  if (res.status === 202) {
+    throw new Error('PoW challenge: WAF blocked (202)');
+  }
+
+  const text = await res.text();
+  if (!text) throw new Error('PoW challenge: empty response');
+
+  const json = JSON.parse(text);
+  const c = json.data?.biz_data?.challenge;
+  if (!c) throw new Error('PoW challenge failed: no challenge returned');
+  if (c.algorithm !== 'DeepSeekHashV1') throw new Error(`Unsupported PoW algorithm: ${c.algorithm}`);
+
+  const difficulty = c.difficulty || 144000;
+  const prefix = `${c.salt}_${c.expire_at}_`;
+  let answer;
+
+  if (useWasm) {
+    try {
+      const instance = await getWasm();
+      answer = wasmSolve(instance, c.challenge, prefix, difficulty);
+    } catch (e) {
+      console.warn('WASM PoW failed, falling back to BigInt:', e.message);
+      useWasm = false;
+      answer = solvePowBigInt(c.challenge, c.salt, c.expire_at, difficulty);
+    }
+  } else {
+    answer = solvePowBigInt(c.challenge, c.salt, c.expire_at, difficulty);
+  }
+
+  const powResponse = {
+    algorithm: c.algorithm,
+    challenge: c.challenge,
+    salt: c.salt,
+    answer,
+    signature: c.signature,
+    target_path: c.target_path,
+  };
+
+  return Buffer.from(JSON.stringify(powResponse)).toString('base64');
+}
+
+// For chat.js — takes explicit token (same token used for PoW and completion)
+export async function solvePowChallengeWithToken(token, targetPath = '/api/v0/chat/completion') {
+  const powResponse = await solvePowInternal(token, targetPath);
+  return { powResponse };
+}
+
+// Legacy: picks a token automatically (used by upload.js)
+export async function solvePowChallenge(preferVision = false) {
+  const token = pickToken(preferVision);
+  const powResponse = await solvePowInternal(token, '/api/v0/chat/completion');
+  return { powResponse, token };
+}
+
+// For upload.js — takes explicit token
+export async function solvePowChallengeForUpload(token) {
+  return solvePowInternal(token, '/api/v0/file/upload_file');
+}

src/queue.js

@@ -0,0 +1,45 @@
+import { acquireToken } from './auth.js';
+
+const MAX_QUEUE_SIZE = 100;
+const queue = [];
+
+export function enqueueRequest(preferVision, timeoutMs = 30000) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      const idx = queue.findIndex(e => e.resolve === resolve);
+      if (idx !== -1) queue.splice(idx, 1);
+      reject(new Error('Request timed out waiting for available token'));
+    }, timeoutMs);
+
+    // Try immediate acquire first
+    const slot = acquireToken(preferVision);
+    if (slot) {
+      clearTimeout(timer);
+      resolve(slot);
+      return;
+    }
+
+    if (queue.length >= MAX_QUEUE_SIZE) {
+      clearTimeout(timer);
+      reject(new Error('Too many queued requests, try again later'));
+      return;
+    }
+
+    queue.push({ preferVision, resolve: (slot) => { clearTimeout(timer); resolve(slot); }, reject: (err) => { clearTimeout(timer); reject(err); } });
+  });
+}
+
+// Call when a token is released — try to dispatch queued request
+export function dispatchQueued() {
+  while (queue.length > 0) {
+    const next = queue[0];
+    const slot = acquireToken(next.preferVision);
+    if (!slot) break; // No token available yet
+    queue.shift();
+    next.resolve(slot);
+  }
+}
+
+export function getQueueInfo() {
+  return { queued: queue.length, maxQueueSize: MAX_QUEUE_SIZE };
+}

src/session.js

@@ -0,0 +1,99 @@
+import { reportTokenError, reportTokenSuccess, setRequestToken, getRequestToken } from './auth.js';
+import { apiHeaders, proxiedFetch } from './headers.js';
+
+const BASE_URL = 'https://chat.deepseek.com';
+const SESSION_TTL = 259200; // 3 days in seconds
+
+const sessionPool = new Map(); // key: token:model_type, value: { id, model_type, createdAt, token }
+
+export async function createSession(token, modelType = 'default') {
+  const res = await proxiedFetch(`${BASE_URL}/api/v0/chat_session/create`, {
+    method: 'POST',
+    headers: await apiHeaders(token),
+    body: JSON.stringify({}),
+  });
+  const json = await res.json();
+
+  // Token invalid — report error so auth.js can mark it dead
+  if (json.code === 40003) {
+    reportTokenError(token);
+    throw new Error('Token invalid (40003)');
+  }
+
+  const session = json.data?.biz_data?.chat_session;
+  if (!session) {
+    reportTokenError(token);
+    throw new Error(`Session create failed: ${json.msg || JSON.stringify(json)}`);
+  }
+
+  reportTokenSuccess(token);
+  return session;
+}
+
+export async function getSession(token, modelType) {
+  const cacheKey = `${token.slice(0, 12)}:${modelType}`;
+  const now = Date.now() / 1000;
+  const cached = sessionPool.get(cacheKey);
+
+  if (cached && (now - cached.createdAt) < SESSION_TTL) {
+    return cached;
+  }
+
+  const session = await createSession(token, modelType);
+  session.createdAt = now;
+  session.token = token;
+  sessionPool.set(cacheKey, session);
+  return session;
+}
+
+// Remove cached sessions for a specific token prefix (used after token refresh)
+export function invalidateTokenSessions(tokenPrefix) {
+  for (const key of sessionPool.keys()) {
+    if (key.startsWith(tokenPrefix + ':')) {
+      sessionPool.delete(key);
+    }
+  }
+}
+
+export function getSessionInfo() {
+  const now = Date.now() / 1000;
+  const entries = [];
+  for (const [key, val] of sessionPool) {
+    const age = now - val.createdAt;
+    entries.push({
+      key,
+      modelType: val.model_type,
+      ageSeconds: Math.floor(age),
+      ttlRemainingSeconds: Math.max(0, Math.floor(SESSION_TTL - age)),
+    });
+  }
+  return { count: sessionPool.size, ttl: SESSION_TTL, sessions: entries };
+}
+
+export async function prewarmSessions(tokens, modelTypes = ['default', 'expert']) {
+  const { getPoolInfo } = await import('./auth.js');
+  const poolInfo = getPoolInfo();
+  const alivePrefixes = poolInfo.filter(t => !t.dead && t.token !== 'NONE').map(t => t.token.replace('...', ''));
+
+  console.log(`Pre-warming sessions for ${alivePrefixes.length} alive tokens × ${modelTypes.length} model types...`);
+  const promises = [];
+  for (const token of tokens) {
+    const prefix = token.slice(0, 12);
+    if (!alivePrefixes.includes(prefix)) continue;
+    for (const modelType of modelTypes) {
+      const cacheKey = `${prefix}:${modelType}`;
+      if (!sessionPool.has(cacheKey)) {
+        promises.push(
+          getSession(token, modelType).catch(() => {})
+        );
+      }
+    }
+    if (promises.length >= 6) {
+      await Promise.allSettled(promises.splice(0));
+    }
+  }
+  if (promises.length > 0) {
+    await Promise.allSettled(promises);
+  }
+  console.log(`Session pool: ${sessionPool.size} cached sessions`);
+}

src/upload.js

@@ -0,0 +1,107 @@
+import { pickToken, setRequestToken } from './auth.js';
+import { solvePowChallengeForUpload } from './pow.js';
+import { apiHeaders, getHeaders, proxiedFetch } from './headers.js';
+
+const BASE_URL = 'https://chat.deepseek.com';
+
+export async function uploadFile(fileBuffer, filename, mimeType, token) {
+  const powResponse = await solvePowChallengeForUpload(token);
+
+  const boundary = `----FormBoundary${Date.now()}`;
+  const header = Buffer.from(
+    `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${filename}"\r\nContent-Type: ${mimeType}\r\n\r\n`
+  );
+  const footer = Buffer.from(`\r\n--${boundary}--\r\n`);
+  const body = Buffer.concat([header, fileBuffer, footer]);
+
+  const res = await proxiedFetch(`${BASE_URL}/api/v0/file/upload_file`, {
+    method: 'POST',
+    headers: {
+      ...await apiHeaders(token, {
+        'x-ds-pow-response': powResponse,
+        'x-file-size': body.length.toString(),
+        'x-model-type': 'vision',
+        'content-type': `multipart/form-data; boundary=${boundary}`,
+      }),
+    },
+    body,
+  });
+
+  const json = await res.json();
+  const fileId = json.data?.biz_data?.id;
+  if (!fileId) throw new Error(`File upload failed: ${JSON.stringify(json)}`);
+
+  return fileId;
+}
+
+export async function waitForFileReady(fileId, token, maxAttempts = 30, intervalMs = 2000) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const res = await proxiedFetch(`${BASE_URL}/api/v0/file/fetch_files?file_ids=${fileId}`, {
+      headers: await getHeaders(token),
+    });
+    const json = await res.json();
+    const files = json.data?.biz_data?.files;
+    if (files && files.length > 0) {
+      const status = files[0].status?.toUpperCase();
+      if (status === 'SUCCESS' || status === 'PROCESSED' || status === 'READY' || status === 'DONE') {
+        return files[0];
+      }
+      if (status === 'FAILED') {
+        throw new Error(`File processing failed: ${files[0].error_code || 'unknown'}`);
+      }
+    }
+
+    await new Promise(r => setTimeout(r, intervalMs));
+  }
+
+  throw new Error(`File not ready after ${maxAttempts * intervalMs / 1000}s`);
+}
+
+export async function uploadImageFromFile(fileBuffer, filename, mimeType, token) {
+  const fileId = await uploadFile(fileBuffer, filename, mimeType, token);
+  await waitForFileReady(fileId, token);
+  return fileId;
+}
+
+const MIME_MAP = {
+  'jpg': 'image/jpeg',
+  'jpeg': 'image/jpeg',
+  'png': 'image/png',
+  'gif': 'image/gif',
+  'webp': 'image/webp',
+  'svg': 'image/svg+xml',
+  'bmp': 'image/bmp',
+};
+
+function extFromDataUrl(dataUrl) {
+  const match = dataUrl.match(/^data:(image\/\w+);/);
+  if (!match) return { ext: 'png', mime: 'image/png' };
+  const mime = match[1];
+  const ext = mime.split('/')[1] || 'png';
+  return { ext: ext === 'jpeg' ? 'jpg' : ext, mime };
+}
+
+export async function resolveImageToRefId(imageUrl, token) {
+  let buffer, filename, mimeType;
+
+  if (imageUrl.startsWith('data:')) {
+    const { ext, mime } = extFromDataUrl(imageUrl);
+    const base64 = imageUrl.split(',')[1];
+    if (!base64) throw new Error('Invalid data URL: no base64 data');
+    buffer = Buffer.from(base64, 'base64');
+    filename = `image.${ext}`;
+    mimeType = mime;
+  } else {
+    const res = await proxiedFetch(imageUrl);
+    if (!res.ok) throw new Error(`Failed to download image: ${res.status}`);
+    const contentType = res.headers.get('content-type') || 'image/png';
+    buffer = Buffer.from(await res.arrayBuffer());
+    const urlPath = new URL(imageUrl).pathname;
+    const ext = urlPath.split('.').pop()?.toLowerCase() || 'png';
+    const mappedMime = MIME_MAP[ext] || contentType;
+    filename = `image.${mappedMime.split('/')[1] === 'jpeg' ? 'jpg' : (mappedMime.split('/')[1] || 'png')}`;
+    mimeType = mappedMime;
+  }
+
+  return uploadImageFromFile(buffer, filename, mimeType, token);
+}

test_single_flow.mjs

@@ -0,0 +1,145 @@
+const token = 'jzP1DfT7dlWGJ/h4imBWbVB6zGdYLBWB0hRqne6WxMFGFarEPkfj7MRcOiw3inKj';
+
+// Inline the PoW solver to test independently
+const RC = [
+  0x0000000000000001n, 0x0000000000008082n, 0x800000000000808an, 0x8000000080008000n,
+  0x000000000000808bn, 0x0000000080000001n, 0x8000000080008081n, 0x8000000000008009n,
+  0x000000000000008an, 0x0000000000000088n, 0x0000000080008009n, 0x000000008000000an,
+  0x000000008000808bn, 0x800000000000008bn, 0x8000000000008089n, 0x8000000000008003n,
+  0x8000000000008002n, 0x8000000000000080n, 0x000000000000800an, 0x800000008000000an,
+  0x8000000080008081n, 0x8000000000008080n, 0x0000000080000001n, 0x8000000080008008n,
+];
+const MASK = 0xffffffffffffffffn;
+const RATE = 136;
+
+function rotl64(v, k) { return ((v << BigInt(k)) | (v >> BigInt(64 - k))) & MASK; }
+function keccakF23(s) {
+  let a = s.slice();
+  for (let r = 1; r < 24; r++) {
+    const c = [a[0]^a[5]^a[10]^a[15]^a[20], a[1]^a[6]^a[11]^a[16]^a[21], a[2]^a[7]^a[12]^a[17]^a[22],
+               a[3]^a[8]^a[13]^a[18]^a[23], a[4]^a[9]^a[14]^a[19]^a[24]];
+    const d = [c[4]^rotl64(c[1],1), c[0]^rotl64(c[2],1), c[1]^rotl64(c[3],1), c[2]^rotl64(c[4],1), c[3]^rotl64(c[0],1)];
+    for (let i = 0; i < 25; i++) a[i] = (a[i] ^ d[i%5]) & MASK;
+    const b = new Array(25);
+    b[0]=a[0];b[10]=rotl64(a[1],1);b[20]=rotl64(a[2],62);b[5]=rotl64(a[3],28);b[15]=rotl64(a[4],27);
+    b[16]=rotl64(a[5],36);b[1]=rotl64(a[6],44);b[11]=rotl64(a[7],6);b[21]=rotl64(a[8],55);b[6]=rotl64(a[9],20);
+    b[7]=rotl64(a[10],3);b[17]=rotl64(a[11],10);b[2]=rotl64(a[12],43);b[12]=rotl64(a[13],25);b[22]=rotl64(a[14],39);
+    b[23]=rotl64(a[15],41);b[8]=rotl64(a[16],45);b[18]=rotl64(a[17],15);b[3]=rotl64(a[18],21);b[13]=rotl64(a[19],8);
+    b[14]=rotl64(a[20],18);b[24]=rotl64(a[21],2);b[9]=rotl64(a[22],61);b[19]=rotl64(a[23],56);b[4]=rotl64(a[24],14);
+    for (let y = 0; y < 5; y++) {
+      const t = [b[y*5], b[y*5+1], b[y*5+2], b[y*5+3], b[y*5+4]];
+      for (let x = 0; x < 5; x++) a[y*5+x] = (t[x] ^ ((t[(x+1)%5] ^ MASK) & t[(x+2)%5])) & MASK;
+    }
+    a[0] = (a[0] ^ RC[r]) & MASK;
+  }
+  for (let i = 0; i < 25; i++) s[i] = a[i];
+}
+function readU64LE(buf, off) { let v = 0n; for (let i = 0; i < 8; i++) v |= BigInt(buf[off + i]) << BigInt(i * 8); return v & MASK; }
+function writeU64LE(val, buf, off) { const v = val & MASK; for (let i = 0; i < 8; i++) buf[off + i] = Number((v >> BigInt(i * 8)) & 0xffn); }
+
+function deepSeekHashV1(data) {
+  const s = new Array(25).fill(0n);
+  const buf = Buffer.from(data);
+  let off = 0;
+  while (off + RATE <= buf.length) { for (let i = 0; i < RATE / 8; i++) s[i] = (s[i] ^ readU64LE(buf, off + i * 8)) & MASK; keccakF23(s); off += RATE; }
+  const tail = Buffer.alloc(RATE); buf.copy(tail, 0, off); tail[buf.length - off] = 0x06; tail[RATE - 1] |= 0x80;
+  for (let i = 0; i < RATE / 8; i++) s[i] = (s[i] ^ readU64LE(tail, i * 8)) & MASK; keccakF23(s);
+  const out = Buffer.alloc(32); for (let i = 0; i < 4; i++) writeU64LE(s[i], out, i * 8); return out;
+}
+
+function solvePow(challengeHex, salt, expireAt, difficulty) {
+  const target = Buffer.from(challengeHex, 'hex');
+  const prefix = `${salt}_${expireAt}_`;
+  console.log('Solving PoW, prefix:', prefix);
+  const t0 = Date.now();
+  for (let n = 0; n < difficulty; n++) {
+    const hash = deepSeekHashV1(prefix + n.toString());
+    if (hash.equals(target)) {
+      console.log('Found nonce:', n, 'in', Date.now() - t0, 'ms');
+      return n;
+    }
+  }
+  throw new Error('PoW failed');
+}
+
+async function test() {
+  // Step 1: Get challenge ONCE
+  const r1 = await fetch('https://chat.deepseek.com/api/v0/chat/create_pow_challenge', {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'authorization': 'Bearer ' + token,
+      'x-app-version': '2.0.0',
+      'x-client-version': '2.0.0',
+      'x-client-platform': 'web',
+    },
+    body: JSON.stringify({ target_path: '/api/v0/chat/completion' }),
+  });
+  const j1 = await r1.json();
+  const c = j1.data.biz_data.challenge;
+  console.log('Challenge:', c.challenge.slice(0, 20), 'difficulty:', c.difficulty);
+
+  // Step 2: Solve
+  const answer = solvePow(c.challenge, c.salt, c.expire_at, c.difficulty);
+  const powResponse = Buffer.from(JSON.stringify({
+    algorithm: c.algorithm,
+    challenge: c.challenge,
+    salt: c.salt,
+    answer: answer,
+    signature: c.signature,
+    target_path: c.target_path,
+  })).toString('base64');
+  console.log('PoW b64 (first 50):', powResponse.slice(0, 50));
+
+  // Verify: decode and check challenge matches
+  const decoded = JSON.parse(Buffer.from(powResponse, 'base64').toString());
+  console.log('Decoded challenge matches:', decoded.challenge === c.challenge);
+  console.log('Decoded answer:', decoded.answer);
+
+  // Step 3: Create session
+  const r2 = await fetch('https://chat.deepseek.com/api/v0/chat_session/create', {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'authorization': 'Bearer ' + token,
+      'x-app-version': '2.0.0',
+      'x-client-version': '2.0.0',
+      'x-client-platform': 'web',
+    },
+    body: JSON.stringify({}),
+  });
+  const j2 = await r2.json();
+  const sid = j2.data.biz_data.chat_session.id;
+  console.log('Session:', sid);
+
+  // Step 4: Call completion WITH PoW
+  const r3 = await fetch('https://chat.deepseek.com/api/v0/chat/completion', {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'authorization': 'Bearer ' + token,
+      'x-ds-pow-response': powResponse,
+      'x-app-version': '2.0.0',
+      'x-client-version': '2.0.0',
+      'x-client-platform': 'web',
+      'x-client-locale': 'zh_CN',
+      'accept': 'text/event-stream',
+    },
+    body: JSON.stringify({
+      chat_session_id: sid,
+      parent_message_id: null,
+      model_type: 'default',
+      prompt: '1+1=?',
+      ref_file_ids: [],
+      thinking_enabled: false,
+      search_enabled: false,
+      preempt: false,
+    }),
+  });
+  console.log('Status:', r3.status);
+  console.log('CT:', r3.headers.get('content-type'));
+  const text = await r3.text();
+  console.log('Response:', text.slice(0, 800));
+}
+
+test().catch(e => console.error('Error:', e.message));

test_waf.js

@@ -0,0 +1,31 @@
+// The guest challenge doesn't work with these paths. Let me look at the JS bundle more carefully
+// for what the actual auth flow looks like now.
+
+// Key finding from the bundle analysis:
+// - AWS WAF captcha SDK is loaded: "https://a0fea896111e.edge.captcha-sdk.awswaf.com/a0fea896111e/jsapi.js"
+// - There's a silent WAF challenge: "https://a0fea896111e.edge.sdk.awswaf.com/a0fea896111e/3a8b889b892b/challenge.js"
+// - This means the WAF requires solving a challenge to get a token/cookie
+// - The 40003 might be because we're missing the WAF token cookie
+
+// Let's check what cookies the WAF sets
+async function testWAF() {
+  const r = await fetch('https://chat.deepseek.com/', {
+    headers: {
+      'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    },
+  });
+
+  // Check Set-Cookie headers
+  const setCookies = r.headers.getSetCookie?.() || [];
+  console.log('Set-Cookie headers:', setCookies.length);
+  for (const c of setCookies) {
+    console.log('Cookie:', c.slice(0, 200));
+  }
+
+  // Check if there's a WAF challenge in the response
+  const html = await r.text();
+  const wafRefs = html.match(/awswaf|captcha-sdk|challenge\.js/gi);
+  console.log('WAF refs in HTML:', wafRefs);
+}
+
+testWAF().catch(e => console.error(e));