Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
21 changes: 21 additions & 0 deletions packages/quwork/LICENSE
Original file line number Diff line number Diff line change
@@ -0,0 +1,21 @@
MIT License

Copyright (c) 2026 kshu06537-bot

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
41 changes: 41 additions & 0 deletions packages/quwork/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,41 @@
# QuWork for Magpie

社区供应商 `quwork`。插件会打开专用 Chrome/Edge 窗口,在 QuWork 官网完成登录;也会读取官网登录态中的账号 token,并尝试取得模型凭据。插件内置 10 个模型条目,实际可用模型由 QuWork 和账号权益决定。

## 安装与使用

在 Magpie 的「插件 → 添加插件」选择本地插件目录,或在社区仓库根目录运行 `magpie plugin add ./packages/quwork`。

1. 在「供应商 → QuWork → 登录」选择「官网浏览器登录(自动读取登录态)」。
2. 在弹出的专用浏览器窗口里打开 QuWork 官网,点「注册 / 登录」,选择短信验证码或微信登录。手机号和验证码只在官网页面填写。
3. 登录成功后,Magpie 会读取官网 localStorage 中的 `quwork_web_token`,并尝试从登录响应中取得 `llm_token`。如果上游没有返回模型凭据,登录菜单里仍可填写 QuWork 授权用于第三方接入的 `sk-` 模型密钥。

## 每日签到

插件实现了 Magpie 的 `auth.checkin` 钩子,签到由 Magpie 原生调度,不会在插件后台自行循环请求。

1. **自动签到**:打开 **设置 → 用量 → 插件 → QuWork → 每日签到**(该开关默认关闭)。Magpie 会按北京时间每天检查一次;失败后会在当天稍后重试。
2. **手动签到**:在 **供应商 → QuWork → 账号用量卡片** 点「立即签到」。签到成功会显示获得的积分;今日已签到会显示完成状态。
3. 签到使用官网浏览器登录保存的账号 token。只填写 `sk-` 模型密钥的账号不能签到,需要先重新用「官网浏览器登录」建立账号凭据。
4. 插件不会伪造签到结果:上游未确认时会返回失败或未签到状态,请以 QuWork 官网记录为准。

签到钩子只在 Magpie 中生效;OpenCode 2.x 的适配层不提供签到。

## 降低账号风险

任何第三方客户端、自动签到或代调用都无法保证账号不会被限制。插件能做的只是把请求量压到最低:

- 自动签到默认关闭;建议先在官网手动签到一次,确认账号和入口正常,再决定是否打开自动签到。
- 登录失效、429 限流、网络错误或上游未明确确认时,插件本次不自动重试,避免 Magpie 每 30 分钟反复请求;请稍后手动签到并在官网核对。
- 只使用自己的单账号;不要共享、出租、代签、批量注册,不要用代理轮换地区,也不要在多个客户端同时高频使用同一账号。
- 如果 QuWork 协议或客服没有明确允许第三方客户端/自动签到,最保守的做法是只用 `sk-` 模型密钥调用模型,积分和签到都在官网手动完成。

## 积分余额

模型密钥用于模型调用,个人账号积分请在 QuWork 官方入口查看。已有有效旧版积分凭据的账号仍可在 Magpie 的「额度(Quota)」页查看总余额、限时积分和永久积分,具体字段以上游返回为准。也可运行 `magpie quota quwork`。

官网登录读取的是 QuWork 官网自己写入的登录态;积分查询和模型调用仍受 QuWork 使用规则约束。官方协议第 2.3.2 条规定未明示授权的权利需另获书面许可,第 8.2 条允许对违规行为暂停或终止服务。[Clawork 软件许可及服务协议](https://llm.rrzu.com/claw-agreement)

## 开发验证

在插件目录运行 `node --test index.test.mjs`。测试覆盖官网入口、模型密钥校验和旧版余额兼容,使用模拟凭据。社区仓库从根目录运行 `bun scripts/check.mjs quwork`。社区代码采用 MIT 许可。
267 changes: 267 additions & 0 deletions packages/quwork/browser.mjs
Original file line number Diff line number Diff line change
@@ -0,0 +1,267 @@
import { spawn } from "node:child_process"
import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs"
import { createServer } from "node:net"
import { tmpdir } from "node:os"
import { join } from "node:path"

const activeBrowsers = new Set()
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

process.once("exit", () => {
for (const child of activeBrowsers) {
try {
child.kill("SIGKILL")
} catch {}
}
})

export function findBrowser(platform = process.platform, env = process.env) {
if (env.QUWORK_BROWSER && existsSync(env.QUWORK_BROWSER)) return env.QUWORK_BROWSER
const candidates =
platform === "darwin"
? [
"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
"/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
"/Applications/Chromium.app/Contents/MacOS/Chromium",
]
: platform === "win32"
? [
join(env.PROGRAMFILES || "", "Google/Chrome/Application/chrome.exe"),
join(env["PROGRAMFILES(X86)"] || "", "Google/Chrome/Application/chrome.exe"),
join(env.LOCALAPPDATA || "", "Google/Chrome/Application/chrome.exe"),
join(env.PROGRAMFILES || "", "Microsoft/Edge/Application/msedge.exe"),
join(env["PROGRAMFILES(X86)"] || "", "Microsoft/Edge/Application/msedge.exe"),
]
: [
"/usr/bin/google-chrome",
"/usr/bin/google-chrome-stable",
"/usr/bin/chromium",
"/usr/bin/chromium-browser",
"/usr/bin/microsoft-edge",
]
return candidates.find((candidate) => candidate && existsSync(candidate)) ?? ""
}

function browserArgs(profile, port, url) {
return [
`--user-data-dir=${profile}`,
`--remote-debugging-port=${port}`,
"--remote-debugging-address=127.0.0.1",
"--no-first-run",
"--no-default-browser-check",
"--disable-sync",
"--disable-default-apps",
"--disable-background-mode",
"--new-window",
url,
]
}

function freePort() {
return new Promise((resolve, reject) => {
const server = createServer()
server.once("error", reject)
server.listen(0, "127.0.0.1", () => {
const port = server.address().port
server.close(() => resolve(port))
})
})
}

function waitForExit(child, timeoutMs) {
if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve()
return new Promise((resolve) => {
const timer = setTimeout(resolve, timeoutMs)
child.once("exit", () => {
clearTimeout(timer)
resolve()
})
})
}

async function cdpTarget(port, targetPrefix) {
const deadline = Date.now() + 15_000
while (Date.now() < deadline) {
try {
const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(1200) })
const list = await response.json()
const target = list.find(
(item) =>
item?.type === "page" &&
typeof item.url === "string" &&
item.url.startsWith(targetPrefix) &&
item.webSocketDebuggerUrl,
)
if (target) return target
} catch {}
await sleep(200)
}
return null
}

class CDP {
constructor(webSocketUrl) {
this.socket = new WebSocket(webSocketUrl)
this.nextId = 1
this.pending = new Map()
this.listeners = new Map()
this.closed = false
this.opened = new Promise((resolve, reject) => {
this.socket.onopen = resolve
this.socket.onerror = () => reject(new Error("无法连接浏览器调试接口"))
})
this.socket.onmessage = (event) => {
let message
try {
message = JSON.parse(String(event.data))
} catch {
return
}
if (message.id) {
const pending = this.pending.get(message.id)
if (!pending) return
this.pending.delete(message.id)
if (message.error) pending.reject(new Error(message.error.message || "浏览器命令失败"))
else pending.resolve(message.result ?? {})
return
}
for (const listener of this.listeners.get(message.method) ?? []) {
listener(message.params ?? {})
}
}
this.socket.onclose = () => {
this.closed = true
for (const pending of this.pending.values()) pending.reject(new Error("浏览器调试连接已关闭"))
this.pending.clear()
}
}

async send(method, params = {}) {
await this.opened
if (this.closed) throw new Error("浏览器调试连接已关闭")
const id = this.nextId++
return new Promise((resolve, reject) => {
this.pending.set(id, { resolve, reject })
this.socket.send(JSON.stringify({ id, method, params }))
})
}

on(method, listener) {
const listeners = this.listeners.get(method) ?? []
listeners.push(listener)
this.listeners.set(method, listeners)
}

close() {
try {
this.socket.close()
} catch {}
}
}

function captureLoginResponses(client) {
const captured = { webToken: "", llmToken: "" }
const pending = new Set()
client.on("Network.responseReceived", ({ requestId, response }) => {
if (typeof response?.url !== "string") return
if (/\/api\/user\/client\/login|\/api\/oauth\/wechat\/share\/exchange/.test(response.url)) {
pending.add(requestId)
}
})
client.on("Network.loadingFinished", async ({ requestId }) => {
if (!pending.delete(requestId)) return
try {
const body = await client.send("Network.getResponseBody", { requestId })
const text = body.base64Encoded
? Buffer.from(body.body, "base64").toString("utf8")
: body.body
const payload = JSON.parse(text)
const data = payload?.data ?? payload
if (typeof data?.token === "string" && data.token.trim()) captured.webToken = data.token.trim()
if (typeof data?.llm_token === "string" && data.llm_token.trim()) captured.llmToken = data.llm_token.trim()
} catch {}
})
return captured
}

export async function openChromeSession(url, { targetPrefix = "https://quwork.cn/" } = {}) {
const browser = findBrowser()
if (!browser) throw new Error("没有找到 Chrome 或 Edge;请安装浏览器后重试")
const profile = mkdtempSync(join(tmpdir(), "magpie-quwork-browser-"))
mkdirSync(profile, { recursive: true, mode: 0o700 })
try {
chmodSync(profile, 0o700)
} catch {}
const port = await freePort()
const child = spawn(browser, browserArgs(profile, port, url), { stdio: "ignore", detached: false })
activeBrowsers.add(child)
let spawnError = ""
child.once("error", (error) => {
spawnError = String(error?.message ?? error)
})

const target = await cdpTarget(port, targetPrefix)
if (!target) {
child.kill("SIGKILL")
rmSync(profile, { recursive: true, force: true })
throw new Error("浏览器没有打开 QuWork 官网")
}
const client = new CDP(target.webSocketDebuggerUrl)
await client.send("Network.enable").catch(() => {})
const captured = captureLoginResponses(client)
let closed = false
let closing = null

async function evaluate(expression) {
const result = await client.send("Runtime.evaluate", {
expression,
returnByValue: true,
})
if (result.exceptionDetails) throw new Error("无法读取 QuWork 官网登录态")
return result.result?.value
}

async function credentials(timeoutMs) {
const deadline = Date.now() + timeoutMs
let webSeenAt = 0
while (Date.now() < deadline && !closed) {
if (spawnError) throw new Error(`浏览器无法启动:${spawnError}`)
if (!captured.webToken) {
try {
const value = await evaluate('localStorage.getItem("quwork_web_token")')
if (typeof value === "string" && value.trim()) captured.webToken = value.trim()
} catch {}
}
if (captured.webToken && !webSeenAt) webSeenAt = Date.now()
if (captured.llmToken) return { ...captured }
if (captured.webToken && Date.now() - webSeenAt > 3000) return { ...captured }
await sleep(500)
}
return captured.webToken ? { ...captured } : null
}

function close() {
if (closing) return closing
closed = true
closing = (async () => {
activeBrowsers.delete(child)
client.close()
if (child.exitCode === null && child.signalCode === null) {
try {
child.kill("SIGTERM")
} catch {}
await waitForExit(child, 2000)
}
if (child.exitCode === null && child.signalCode === null) {
try {
child.kill("SIGKILL")
} catch {}
await waitForExit(child, 1000)
}
rmSync(profile, { recursive: true, force: true })
})()
return closing
}

return { evaluate, credentials, close }
}
Loading