@hjd-hitsz/claudex-web 4.0.1 → 4.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +46 -0
- package/README.md +33 -55
- package/build-info.json +4 -4
- package/client/dist/app.js +81 -82
- package/client/dist/style.css +1 -1
- package/docs/architecture/backends.md +2 -0
- package/docs/architecture/behavior.md +23 -1
- package/docs/architecture.md +33 -4
- package/docs/deployment.md +34 -14
- package/docs/development.md +14 -3
- package/docs/releases/v4.1.0.md +21 -0
- package/docs/versioning.md +10 -0
- package/package.json +24 -7
- package/packages/translation-engine/LICENSE +674 -0
- package/packages/translation-engine/README.md +69 -0
- package/packages/translation-engine/bin/tokenizer-linux-x64 +0 -0
- package/packages/translation-engine/bin/translate.mjs +29 -0
- package/packages/translation-engine/native/build.mjs +15 -0
- package/packages/translation-engine/native/tokenizer.c +73 -0
- package/packages/translation-engine/package.json +29 -0
- package/packages/translation-engine/src/catalog.mjs +103 -0
- package/packages/translation-engine/src/cpu-runtime.mjs +90 -0
- package/packages/translation-engine/src/download.mjs +94 -0
- package/packages/translation-engine/src/index.mjs +70 -0
- package/packages/translation-engine/src/inference.mjs +177 -0
- package/packages/translation-engine/src/model-store.mjs +197 -0
- package/packages/translation-engine/src/tokenizer.mjs +77 -0
- package/packages/translation-engine/src/worker.mjs +83 -0
- package/scripts/install-services.mjs +5 -4
- package/server/src/application.mjs +40 -5
- package/server/src/backends/claude/catalogue.mjs +5 -3
- package/server/src/backends/claude/execution-session.mjs +7 -1
- package/server/src/backends/claude/messages.mjs +2 -1
- package/server/src/backends/claude/provider-environment.mjs +6 -4
- package/server/src/backends/claude/sessions.mjs +1 -0
- package/server/src/backends/claude/worker-client.mjs +13 -6
- package/server/src/backends/claude/worker-location.mjs +12 -0
- package/server/src/backends/codex/adapter.mjs +2 -0
- package/server/src/backends/codex/events.mjs +1 -1
- package/server/src/backends/codex/token-usage.mjs +140 -0
- package/server/src/backends/manager.mjs +87 -21
- package/server/src/backends/provider-presets.mjs +1 -1
- package/server/src/backends/providers.mjs +6 -3
- package/server/src/backends/storage.mjs +7 -3
- package/server/src/config.mjs +7 -0
- package/server/src/http/maintenance.mjs +28 -0
- package/server/src/http/router.mjs +20 -2
- package/server/src/server.mjs +9 -0
- package/server/src/service-maintenance-worker.mjs +124 -0
- package/server/src/service-maintenance.mjs +222 -0
- package/server/src/summary-translation.mjs +42 -53
- package/server/src/token-usage-reconciliation.mjs +105 -0
- package/server/src/token-usage.mjs +208 -0
- package/server/src/translation-service.mjs +133 -0
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
import { X509Certificate } from "node:crypto";
|
|
2
|
+
// 此入口复制到配置目录后由独立 systemd 单元执行,更新期间保持可运行。
|
|
3
|
+
import { execFile } from "node:child_process";
|
|
4
|
+
import { promisify } from "node:util";
|
|
5
|
+
import { mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
|
|
6
|
+
import { join } from "node:path";
|
|
7
|
+
import https from "node:https";
|
|
8
|
+
const execute = promisify(execFile);
|
|
9
|
+
const job = JSON.parse(await readFile(process.argv[2], "utf8"));
|
|
10
|
+
const save = async (state, error = "") => {
|
|
11
|
+
await writeFile(
|
|
12
|
+
job.statusFile + ".tmp",
|
|
13
|
+
JSON.stringify({ ...job.task, state, error }),
|
|
14
|
+
{ mode: 0o600 },
|
|
15
|
+
);
|
|
16
|
+
await rename(job.statusFile + ".tmp", job.statusFile);
|
|
17
|
+
};
|
|
18
|
+
const health = async () => {
|
|
19
|
+
const ca = await readFile(job.cert);
|
|
20
|
+
return new Promise((resolve) => {
|
|
21
|
+
const request = https.get(
|
|
22
|
+
{
|
|
23
|
+
hostname: "127.0.0.1",
|
|
24
|
+
port: job.port,
|
|
25
|
+
path: "/healthz",
|
|
26
|
+
ca,
|
|
27
|
+
allowPartialTrustChain: true,
|
|
28
|
+
checkServerIdentity(_hostname, peer) {
|
|
29
|
+
if (peer.fingerprint256 !== new X509Certificate(ca).fingerprint256)
|
|
30
|
+
return new Error("本机服务证书与配置不匹配");
|
|
31
|
+
},
|
|
32
|
+
},
|
|
33
|
+
(response) => {
|
|
34
|
+
let body = "";
|
|
35
|
+
response.on("data", (chunk) => {
|
|
36
|
+
body += chunk;
|
|
37
|
+
});
|
|
38
|
+
response.on("end", () => {
|
|
39
|
+
try {
|
|
40
|
+
resolve(JSON.parse(body));
|
|
41
|
+
} catch {
|
|
42
|
+
resolve(null);
|
|
43
|
+
}
|
|
44
|
+
});
|
|
45
|
+
},
|
|
46
|
+
);
|
|
47
|
+
request.setTimeout(3000, () => request.destroy());
|
|
48
|
+
request.on("error", () => resolve(null));
|
|
49
|
+
});
|
|
50
|
+
};
|
|
51
|
+
let stage,
|
|
52
|
+
backup,
|
|
53
|
+
replaced = false;
|
|
54
|
+
try {
|
|
55
|
+
// 留出 HTTP 确认响应和浏览器开始轮询的时间。
|
|
56
|
+
await new Promise((resolve) => setTimeout(resolve, 1500));
|
|
57
|
+
if (job.action === "update") {
|
|
58
|
+
stage = await mkdtemp(join(job.prefix, ".claudex-update-"));
|
|
59
|
+
await execute(
|
|
60
|
+
"npm",
|
|
61
|
+
[
|
|
62
|
+
"install",
|
|
63
|
+
"--global",
|
|
64
|
+
"--prefix",
|
|
65
|
+
stage,
|
|
66
|
+
`${job.packageName}@${job.task.target}`,
|
|
67
|
+
"--registry=https://registry.npmjs.org",
|
|
68
|
+
"--engine-strict",
|
|
69
|
+
],
|
|
70
|
+
{ timeout: 600000, maxBuffer: 4 * 1024 * 1024 },
|
|
71
|
+
);
|
|
72
|
+
const installed = join(stage, "lib/node_modules", job.packageName);
|
|
73
|
+
const manifest = JSON.parse(
|
|
74
|
+
await readFile(join(installed, "package.json"), "utf8"),
|
|
75
|
+
);
|
|
76
|
+
if (manifest.version !== job.task.target)
|
|
77
|
+
throw new Error("安装包版本校验失败");
|
|
78
|
+
await readFile(join(installed, "client/dist/index.html"));
|
|
79
|
+
backup = job.root + ".maintenance-backup";
|
|
80
|
+
await rename(job.root, backup);
|
|
81
|
+
try {
|
|
82
|
+
await rename(installed, job.root);
|
|
83
|
+
replaced = true;
|
|
84
|
+
} catch (error) {
|
|
85
|
+
await rename(backup, job.root);
|
|
86
|
+
backup = null;
|
|
87
|
+
throw error;
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
await save("restarting");
|
|
91
|
+
await execute("systemctl", ["--user", "restart", "claudex-web.service"], {
|
|
92
|
+
timeout: 90000,
|
|
93
|
+
});
|
|
94
|
+
let healthy = false;
|
|
95
|
+
for (let attempt = 0; attempt < 60; attempt++) {
|
|
96
|
+
const status = await health();
|
|
97
|
+
if (status?.version?.version === job.task.target) {
|
|
98
|
+
healthy = true;
|
|
99
|
+
break;
|
|
100
|
+
}
|
|
101
|
+
await new Promise((resolve) => setTimeout(resolve, 1000));
|
|
102
|
+
}
|
|
103
|
+
if (!healthy)
|
|
104
|
+
throw new Error(
|
|
105
|
+
"服务启动检查超时,请查看 journalctl --user -u claudex-web.service",
|
|
106
|
+
);
|
|
107
|
+
await save("completed");
|
|
108
|
+
replaced = false;
|
|
109
|
+
if (backup) await rm(backup, { recursive: true, force: true });
|
|
110
|
+
} catch (error) {
|
|
111
|
+
if (replaced) {
|
|
112
|
+
await rm(job.root, { recursive: true, force: true });
|
|
113
|
+
await rename(backup, job.root);
|
|
114
|
+
await execute("systemctl", [
|
|
115
|
+
"--user",
|
|
116
|
+
"restart",
|
|
117
|
+
"claudex-web.service",
|
|
118
|
+
]).catch(() => {});
|
|
119
|
+
}
|
|
120
|
+
await save("failed", error.message);
|
|
121
|
+
process.exitCode = 1;
|
|
122
|
+
} finally {
|
|
123
|
+
if (stage) await rm(stage, { recursive: true, force: true });
|
|
124
|
+
}
|
|
@@ -0,0 +1,222 @@
|
|
|
1
|
+
import { execFile } from "node:child_process";
|
|
2
|
+
import { promisify } from "node:util";
|
|
3
|
+
import {
|
|
4
|
+
access,
|
|
5
|
+
copyFile,
|
|
6
|
+
mkdir,
|
|
7
|
+
readFile,
|
|
8
|
+
writeFile,
|
|
9
|
+
rename,
|
|
10
|
+
} from "node:fs/promises";
|
|
11
|
+
import { constants } from "node:fs";
|
|
12
|
+
import { join, resolve } from "node:path";
|
|
13
|
+
import { fileURLToPath } from "node:url";
|
|
14
|
+
|
|
15
|
+
const execute = promisify(execFile);
|
|
16
|
+
const root = fileURLToPath(new URL("../../", import.meta.url));
|
|
17
|
+
const packageName = "@hjd-hitsz/claudex-web";
|
|
18
|
+
export function createServiceMaintenance({
|
|
19
|
+
config,
|
|
20
|
+
version,
|
|
21
|
+
isBusy = () => false,
|
|
22
|
+
run = execute,
|
|
23
|
+
fetchVersion = async () => {
|
|
24
|
+
const response = await fetch(
|
|
25
|
+
`https://registry.npmjs.org/${packageName}/latest`,
|
|
26
|
+
{ signal: AbortSignal.timeout(15000) },
|
|
27
|
+
);
|
|
28
|
+
if (!response.ok) throw new Error(`npm 版本查询失败(${response.status})`);
|
|
29
|
+
return (await response.json()).version;
|
|
30
|
+
},
|
|
31
|
+
}) {
|
|
32
|
+
const directory = join(config.configDir, "maintenance");
|
|
33
|
+
const statusFile = join(directory, "status.json");
|
|
34
|
+
let latest = null,
|
|
35
|
+
error = "",
|
|
36
|
+
checkedAt = null,
|
|
37
|
+
checking,
|
|
38
|
+
submitting = false,
|
|
39
|
+
timer,
|
|
40
|
+
switching = false;
|
|
41
|
+
const suffix = "/lib/node_modules/" + packageName;
|
|
42
|
+
const npmInstalled = root.replace(/\/$/, "").endsWith(suffix);
|
|
43
|
+
const prefix = npmInstalled
|
|
44
|
+
? root.replace(/\/$/, "").slice(0, -suffix.length)
|
|
45
|
+
: null;
|
|
46
|
+
async function check() {
|
|
47
|
+
if (checking) return checking;
|
|
48
|
+
checking = (async () => {
|
|
49
|
+
try {
|
|
50
|
+
const value = await fetchVersion();
|
|
51
|
+
if (!/^\d+\.\d+\.\d+$/.test(value))
|
|
52
|
+
throw new Error("npm 返回了无效的稳定版本");
|
|
53
|
+
latest = value;
|
|
54
|
+
checkedAt = new Date().toISOString();
|
|
55
|
+
error = "";
|
|
56
|
+
} catch (failure) {
|
|
57
|
+
error = failure.message;
|
|
58
|
+
}
|
|
59
|
+
})().finally(() => {
|
|
60
|
+
checking = null;
|
|
61
|
+
});
|
|
62
|
+
return checking;
|
|
63
|
+
}
|
|
64
|
+
async function status() {
|
|
65
|
+
let task = null;
|
|
66
|
+
try {
|
|
67
|
+
task = JSON.parse(await readFile(statusFile, "utf8"));
|
|
68
|
+
} catch (failure) {
|
|
69
|
+
if (failure.code !== "ENOENT") throw failure;
|
|
70
|
+
}
|
|
71
|
+
if (
|
|
72
|
+
["updating", "restarting"].includes(task?.state) &&
|
|
73
|
+
Date.now() - Date.parse(task.startedAt) > 30000
|
|
74
|
+
) {
|
|
75
|
+
try {
|
|
76
|
+
await run("systemctl", [
|
|
77
|
+
"--user",
|
|
78
|
+
"is-active",
|
|
79
|
+
"--quiet",
|
|
80
|
+
"claudex-web-maintenance.service",
|
|
81
|
+
]);
|
|
82
|
+
} catch {
|
|
83
|
+
task = {
|
|
84
|
+
...task,
|
|
85
|
+
state: "failed",
|
|
86
|
+
error: "维护任务已退出,请查看维护日志并重试",
|
|
87
|
+
};
|
|
88
|
+
await writeFile(statusFile + ".tmp", JSON.stringify(task), {
|
|
89
|
+
mode: 0o600,
|
|
90
|
+
});
|
|
91
|
+
await rename(statusFile + ".tmp", statusFile);
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
if (task?.state === "failed") switching = false;
|
|
95
|
+
let managed = false;
|
|
96
|
+
try {
|
|
97
|
+
const { stdout } = await run("systemctl", [
|
|
98
|
+
"--user",
|
|
99
|
+
"show",
|
|
100
|
+
"claudex-web.service",
|
|
101
|
+
"--property=MainPID",
|
|
102
|
+
"--value",
|
|
103
|
+
]);
|
|
104
|
+
managed = Number(stdout.trim()) === process.pid;
|
|
105
|
+
} catch {
|
|
106
|
+
/* 服务管理能力由当前进程归属决定。 */
|
|
107
|
+
}
|
|
108
|
+
const updateAvailable =
|
|
109
|
+
latest &&
|
|
110
|
+
latest.localeCompare(version.version, undefined, { numeric: true }) > 0;
|
|
111
|
+
return {
|
|
112
|
+
current: version.version,
|
|
113
|
+
latest,
|
|
114
|
+
checkedAt,
|
|
115
|
+
error,
|
|
116
|
+
npmInstalled,
|
|
117
|
+
managed,
|
|
118
|
+
updateAvailable: Boolean(updateAvailable),
|
|
119
|
+
task,
|
|
120
|
+
};
|
|
121
|
+
}
|
|
122
|
+
async function start(action) {
|
|
123
|
+
if (submitting) return status();
|
|
124
|
+
submitting = true;
|
|
125
|
+
try {
|
|
126
|
+
const current = await status();
|
|
127
|
+
if (["updating", "restarting"].includes(current.task?.state))
|
|
128
|
+
return current;
|
|
129
|
+
if (isBusy()) throw new Error("任务仍在运行,请结束后重试。");
|
|
130
|
+
if (!current.managed)
|
|
131
|
+
throw new Error(
|
|
132
|
+
"请通过 claudex-web service install 安装并启动 systemd 用户服务后重试",
|
|
133
|
+
);
|
|
134
|
+
if (action === "update") {
|
|
135
|
+
await check();
|
|
136
|
+
if (error) throw new Error(error);
|
|
137
|
+
if (!npmInstalled)
|
|
138
|
+
throw new Error(
|
|
139
|
+
"网页更新适用于 npm 全局安装。源码部署请先更新源码并构建,再使用重启服务",
|
|
140
|
+
);
|
|
141
|
+
if (!(await status()).updateAvailable)
|
|
142
|
+
throw new Error("当前已是最新版本");
|
|
143
|
+
await access(resolve(root, ".."), constants.W_OK);
|
|
144
|
+
}
|
|
145
|
+
await mkdir(directory, { recursive: true, mode: 0o700 });
|
|
146
|
+
await copyFile(
|
|
147
|
+
new URL("./service-maintenance-worker.mjs", import.meta.url),
|
|
148
|
+
join(directory, "worker.mjs"),
|
|
149
|
+
);
|
|
150
|
+
const task = {
|
|
151
|
+
action,
|
|
152
|
+
state: action === "update" ? "updating" : "restarting",
|
|
153
|
+
target: action === "update" ? latest : version.version,
|
|
154
|
+
startedAt: new Date().toISOString(),
|
|
155
|
+
};
|
|
156
|
+
const job = {
|
|
157
|
+
action,
|
|
158
|
+
root: resolve(root),
|
|
159
|
+
prefix,
|
|
160
|
+
packageName,
|
|
161
|
+
task,
|
|
162
|
+
statusFile,
|
|
163
|
+
port: config.port,
|
|
164
|
+
cert: config.tlsCert || join(config.configDir, "tls/certificate.pem"),
|
|
165
|
+
};
|
|
166
|
+
await writeFile(join(directory, "job.json"), JSON.stringify(job), {
|
|
167
|
+
mode: 0o600,
|
|
168
|
+
});
|
|
169
|
+
await writeFile(statusFile + ".tmp", JSON.stringify(task), {
|
|
170
|
+
mode: 0o600,
|
|
171
|
+
});
|
|
172
|
+
await rename(statusFile + ".tmp", statusFile);
|
|
173
|
+
if (isBusy()) {
|
|
174
|
+
await writeFile(
|
|
175
|
+
statusFile,
|
|
176
|
+
JSON.stringify({ ...task, state: "cancelled" }),
|
|
177
|
+
{ mode: 0o600 },
|
|
178
|
+
);
|
|
179
|
+
throw new Error("任务仍在运行,请结束后重试。");
|
|
180
|
+
}
|
|
181
|
+
switching = true;
|
|
182
|
+
try {
|
|
183
|
+
await run("systemd-run", [
|
|
184
|
+
"--user",
|
|
185
|
+
"--collect",
|
|
186
|
+
"--unit=claudex-web-maintenance",
|
|
187
|
+
"--property=Type=exec",
|
|
188
|
+
"--",
|
|
189
|
+
process.execPath,
|
|
190
|
+
join(directory, "worker.mjs"),
|
|
191
|
+
join(directory, "job.json"),
|
|
192
|
+
]);
|
|
193
|
+
} catch (failure) {
|
|
194
|
+
await writeFile(
|
|
195
|
+
statusFile,
|
|
196
|
+
JSON.stringify({ ...task, state: "failed", error: failure.message }),
|
|
197
|
+
{ mode: 0o600 },
|
|
198
|
+
);
|
|
199
|
+
throw failure;
|
|
200
|
+
}
|
|
201
|
+
return status();
|
|
202
|
+
} finally {
|
|
203
|
+
submitting = false;
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
return {
|
|
207
|
+
get switching() {
|
|
208
|
+
return switching;
|
|
209
|
+
},
|
|
210
|
+
check,
|
|
211
|
+
status,
|
|
212
|
+
start,
|
|
213
|
+
initialize() {
|
|
214
|
+
void check();
|
|
215
|
+
timer = setInterval(() => void check(), 3600000);
|
|
216
|
+
timer.unref();
|
|
217
|
+
},
|
|
218
|
+
close() {
|
|
219
|
+
clearInterval(timer);
|
|
220
|
+
},
|
|
221
|
+
};
|
|
222
|
+
}
|
|
@@ -1,63 +1,26 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
const
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
body: JSON.stringify({
|
|
11
|
-
header: {
|
|
12
|
-
fn: "auto_translation",
|
|
13
|
-
client_key: clientKey,
|
|
14
|
-
user: "",
|
|
15
|
-
session: "",
|
|
16
|
-
},
|
|
17
|
-
type: "plain",
|
|
18
|
-
model_category: "normal",
|
|
19
|
-
source: { lang: "en", text_list: texts },
|
|
20
|
-
target: { lang: "zh" },
|
|
21
|
-
}),
|
|
22
|
-
signal: AbortSignal.timeout(10000),
|
|
23
|
-
});
|
|
24
|
-
if (!response.ok) throw new Error("翻译服务请求失败,请重试");
|
|
25
|
-
const data = await response.json();
|
|
26
|
-
if (data.header?.ret_code !== "succ")
|
|
27
|
-
throw new Error("翻译服务暂不可用,请重试");
|
|
28
|
-
if (
|
|
29
|
-
!Array.isArray(data.auto_translation) ||
|
|
30
|
-
data.auto_translation.length !== texts.length ||
|
|
31
|
-
data.auto_translation.some(
|
|
32
|
-
(text) => typeof text !== "string" || !text.trim(),
|
|
33
|
-
)
|
|
34
|
-
)
|
|
35
|
-
throw new Error("翻译结果不完整");
|
|
36
|
-
return data.auto_translation;
|
|
1
|
+
export async function readTranslationInput(request) {
|
|
2
|
+
const chunks = [];
|
|
3
|
+
let size = 0;
|
|
4
|
+
for await (const chunk of request) {
|
|
5
|
+
size += chunk.length;
|
|
6
|
+
if (size > 256 * 1024) throw new Error("翻译文本过长,请缩短后重试");
|
|
7
|
+
chunks.push(chunk);
|
|
8
|
+
}
|
|
9
|
+
return JSON.parse(Buffer.concat(chunks).toString("utf8"));
|
|
37
10
|
}
|
|
38
11
|
|
|
39
|
-
export function createSummaryTranslationHandler(
|
|
40
|
-
translate = translateWithTransmart,
|
|
41
|
-
) {
|
|
12
|
+
export function createSummaryTranslationHandler(translate) {
|
|
42
13
|
return async (request, response) => {
|
|
43
14
|
response.setHeader("Content-Type", "application/json; charset=utf-8");
|
|
44
15
|
response.setHeader("Cache-Control", "no-store");
|
|
45
16
|
if (request.method !== "POST") {
|
|
46
|
-
response.
|
|
47
|
-
response.writeHead(405);
|
|
17
|
+
response.writeHead(405, { Allow: "POST" });
|
|
48
18
|
response.end(JSON.stringify({ error: "翻译接口使用 POST 请求" }));
|
|
49
19
|
return;
|
|
50
20
|
}
|
|
51
21
|
let texts;
|
|
52
22
|
try {
|
|
53
|
-
|
|
54
|
-
let size = 0;
|
|
55
|
-
for await (const chunk of request) {
|
|
56
|
-
size += chunk.length;
|
|
57
|
-
if (size <= 256 * 1024) chunks.push(chunk);
|
|
58
|
-
}
|
|
59
|
-
if (size > 256 * 1024) throw new Error("翻译文本过长,请缩短后重试");
|
|
60
|
-
texts = JSON.parse(Buffer.concat(chunks).toString("utf8")).texts;
|
|
23
|
+
({ texts } = await readTranslationInput(request));
|
|
61
24
|
if (
|
|
62
25
|
!Array.isArray(texts) ||
|
|
63
26
|
!texts.length ||
|
|
@@ -67,16 +30,42 @@ export function createSummaryTranslationHandler(
|
|
|
67
30
|
throw new Error("翻译请求需包含 1 到 24 条有效文本");
|
|
68
31
|
} catch (error) {
|
|
69
32
|
response.writeHead(400);
|
|
70
|
-
response.end(JSON.stringify({ error:
|
|
33
|
+
response.end(JSON.stringify({ error: error.message }));
|
|
71
34
|
return;
|
|
72
35
|
}
|
|
73
36
|
try {
|
|
74
37
|
const translations = await translate(texts);
|
|
75
38
|
response.writeHead(200);
|
|
76
39
|
response.end(JSON.stringify({ translations }));
|
|
77
|
-
} catch {
|
|
78
|
-
response.writeHead(
|
|
79
|
-
response.end(
|
|
40
|
+
} catch (error) {
|
|
41
|
+
response.writeHead(503);
|
|
42
|
+
response.end(
|
|
43
|
+
JSON.stringify({ error: error.message || "翻译失败,请重试" }),
|
|
44
|
+
);
|
|
45
|
+
}
|
|
46
|
+
};
|
|
47
|
+
}
|
|
48
|
+
export function createTranslationSettingsHandler(service) {
|
|
49
|
+
return async (request, response) => {
|
|
50
|
+
response.setHeader("Content-Type", "application/json; charset=utf-8");
|
|
51
|
+
response.setHeader("Cache-Control", "no-store");
|
|
52
|
+
try {
|
|
53
|
+
let result;
|
|
54
|
+
if (request.method === "GET") result = await service.status();
|
|
55
|
+
else if (request.method === "PUT") {
|
|
56
|
+
const { enabled } = await readTranslationInput(request);
|
|
57
|
+
if (typeof enabled !== "boolean") throw new Error("请提供翻译开关状态");
|
|
58
|
+
result = await service.setEnabled(enabled);
|
|
59
|
+
} else {
|
|
60
|
+
response.writeHead(405, { Allow: "GET, PUT" });
|
|
61
|
+
response.end(JSON.stringify({ error: "翻译设置使用 GET 或 PUT 请求" }));
|
|
62
|
+
return;
|
|
63
|
+
}
|
|
64
|
+
response.writeHead(200);
|
|
65
|
+
response.end(JSON.stringify(result));
|
|
66
|
+
} catch (error) {
|
|
67
|
+
response.writeHead(400);
|
|
68
|
+
response.end(JSON.stringify({ error: error.message }));
|
|
80
69
|
}
|
|
81
70
|
};
|
|
82
71
|
}
|
|
@@ -0,0 +1,105 @@
|
|
|
1
|
+
import { resourceTarget } from "../../shared/backend-identity.mjs";
|
|
2
|
+
|
|
3
|
+
export function createTokenUsageReconciliation({ store, call, current }) {
|
|
4
|
+
const jobs = new Map();
|
|
5
|
+
async function run(entry, status, signal) {
|
|
6
|
+
let archiveCursor;
|
|
7
|
+
do {
|
|
8
|
+
const revisions = store.revisions();
|
|
9
|
+
const page = await call(
|
|
10
|
+
entry,
|
|
11
|
+
"thread/list",
|
|
12
|
+
{
|
|
13
|
+
archived: true,
|
|
14
|
+
limit: 100,
|
|
15
|
+
...(archiveCursor && { cursor: archiveCursor }),
|
|
16
|
+
},
|
|
17
|
+
{ signal },
|
|
18
|
+
);
|
|
19
|
+
for (const thread of page.data || []) {
|
|
20
|
+
if (!current(entry) || signal.aborted) return;
|
|
21
|
+
if (store.revision(thread.id) === (revisions.get(thread.id) ?? 0))
|
|
22
|
+
store.archive(thread.id);
|
|
23
|
+
status.archived++;
|
|
24
|
+
}
|
|
25
|
+
archiveCursor = page.nextCursor;
|
|
26
|
+
} while (archiveCursor && current(entry) && !signal.aborted);
|
|
27
|
+
let cursor;
|
|
28
|
+
do {
|
|
29
|
+
const page = await call(
|
|
30
|
+
entry,
|
|
31
|
+
"thread/list",
|
|
32
|
+
{
|
|
33
|
+
archived: false,
|
|
34
|
+
limit: 100,
|
|
35
|
+
...(cursor && { cursor }),
|
|
36
|
+
},
|
|
37
|
+
{ signal },
|
|
38
|
+
);
|
|
39
|
+
for (const thread of page.data || []) {
|
|
40
|
+
if (!current(entry) || signal.aborted) return;
|
|
41
|
+
if (thread.path?.includes("/archived_sessions/")) continue;
|
|
42
|
+
status.checked++;
|
|
43
|
+
try {
|
|
44
|
+
if (await store.read(thread.id)) continue;
|
|
45
|
+
const result = await call(
|
|
46
|
+
entry,
|
|
47
|
+
"thread/read",
|
|
48
|
+
{
|
|
49
|
+
threadId: resourceTarget(thread.id, entry.backend.id).nativeId,
|
|
50
|
+
includeTurns: false,
|
|
51
|
+
},
|
|
52
|
+
{ signal },
|
|
53
|
+
);
|
|
54
|
+
if (result.thread?.tokenUsage) status.imported++;
|
|
55
|
+
else status.unavailable++;
|
|
56
|
+
} catch (error) {
|
|
57
|
+
status.failed++;
|
|
58
|
+
status.error = error.message;
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
cursor = page.nextCursor;
|
|
62
|
+
} while (cursor && current(entry) && !signal.aborted);
|
|
63
|
+
await store.flush();
|
|
64
|
+
}
|
|
65
|
+
return {
|
|
66
|
+
start(entry) {
|
|
67
|
+
if (
|
|
68
|
+
!current(entry) ||
|
|
69
|
+
!entry.adapter?.ready ||
|
|
70
|
+
jobs.get(entry.backend.id)?.entry === entry
|
|
71
|
+
)
|
|
72
|
+
return;
|
|
73
|
+
const status = {
|
|
74
|
+
status: "running",
|
|
75
|
+
checked: 0,
|
|
76
|
+
archived: 0,
|
|
77
|
+
imported: 0,
|
|
78
|
+
unavailable: 0,
|
|
79
|
+
failed: 0,
|
|
80
|
+
error: null,
|
|
81
|
+
};
|
|
82
|
+
const controller = new AbortController();
|
|
83
|
+
const promise = run(entry, status, controller.signal)
|
|
84
|
+
.then(() => {
|
|
85
|
+
status.status = current(entry) ? "completed" : "stopped";
|
|
86
|
+
})
|
|
87
|
+
.catch((error) => {
|
|
88
|
+
status.status = controller.signal.aborted ? "stopped" : "failed";
|
|
89
|
+
status.error = controller.signal.aborted ? null : error.message;
|
|
90
|
+
})
|
|
91
|
+
.finally(() =>
|
|
92
|
+
console.log(
|
|
93
|
+
`后端 ${entry.backend.id} token 用量启动核对:${JSON.stringify(status)}`,
|
|
94
|
+
),
|
|
95
|
+
);
|
|
96
|
+
jobs.set(entry.backend.id, { entry, status, promise, controller });
|
|
97
|
+
},
|
|
98
|
+
snapshot: () =>
|
|
99
|
+
Object.fromEntries([...jobs].map(([id, job]) => [id, { ...job.status }])),
|
|
100
|
+
flush: () => Promise.all([...jobs.values()].map((job) => job.promise)),
|
|
101
|
+
stop: () => {
|
|
102
|
+
for (const job of jobs.values()) job.controller.abort();
|
|
103
|
+
},
|
|
104
|
+
};
|
|
105
|
+
}
|