@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
|
@@ -11,6 +11,7 @@ export function claudeRuntimeEnvironment(backend) {
|
|
|
11
11
|
}
|
|
12
12
|
|
|
13
13
|
export function providerModelEnvironment(provider, model, effort) {
|
|
14
|
+
const selectedModel = model || provider.models[0];
|
|
14
15
|
const rules = Object.entries(provider.modelCapabilities || {}).flatMap(
|
|
15
16
|
([name, metadata]) => {
|
|
16
17
|
const capabilities = [];
|
|
@@ -33,9 +34,13 @@ export function providerModelEnvironment(provider, model, effort) {
|
|
|
33
34
|
},
|
|
34
35
|
);
|
|
35
36
|
return {
|
|
37
|
+
ANTHROPIC_MODEL: selectedModel,
|
|
38
|
+
ANTHROPIC_DEFAULT_OPUS_MODEL: selectedModel,
|
|
39
|
+
ANTHROPIC_DEFAULT_SONNET_MODEL: selectedModel,
|
|
40
|
+
ANTHROPIC_DEFAULT_HAIKU_MODEL: selectedModel,
|
|
36
41
|
CLAUDE_CODE_MODEL_CAPABILITIES: rules.join(";"),
|
|
37
42
|
CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(
|
|
38
|
-
provider.modelCapabilities?.[
|
|
43
|
+
provider.modelCapabilities?.[selectedModel]?.contextWindow || "",
|
|
39
44
|
),
|
|
40
45
|
...((provider.protocol || "messages") === "messages" && {
|
|
41
46
|
CLAUDE_CODE_EFFORT_LEVEL: effort || "unset",
|
|
@@ -66,9 +71,6 @@ export function providerRuntimeEnvironment(
|
|
|
66
71
|
);
|
|
67
72
|
env.ANTHROPIC_BASE_URL = proxy?.url || provider.baseUrl;
|
|
68
73
|
env.ANTHROPIC_API_KEY = proxy?.token || provider.apiKey;
|
|
69
|
-
env.ANTHROPIC_MODEL = model || provider.models[0];
|
|
70
|
-
for (const level of ["OPUS", "SONNET", "HAIKU"])
|
|
71
|
-
env[`ANTHROPIC_DEFAULT_${level}_MODEL`] = env.ANTHROPIC_MODEL;
|
|
72
74
|
return env;
|
|
73
75
|
}
|
|
74
76
|
|
|
@@ -15,6 +15,7 @@ import {
|
|
|
15
15
|
import {
|
|
16
16
|
prepareWorkerDirectory,
|
|
17
17
|
verifyWorkerSocket,
|
|
18
|
+
workerConnectionError,
|
|
18
19
|
} from "./worker-location.mjs";
|
|
19
20
|
|
|
20
21
|
export function createClaudeWorkerAdapter({
|
|
@@ -147,12 +148,17 @@ export function createClaudeWorkerAdapter({
|
|
|
147
148
|
async function open() {
|
|
148
149
|
stopping = false;
|
|
149
150
|
await prepareWorkerDirectory(location.directory);
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
connection.
|
|
154
|
-
|
|
155
|
-
|
|
151
|
+
let connection;
|
|
152
|
+
try {
|
|
153
|
+
await verifyWorkerSocket(location.socket);
|
|
154
|
+
connection = net.connect(location.socket);
|
|
155
|
+
await new Promise((resolve, reject) => {
|
|
156
|
+
connection.once("connect", resolve);
|
|
157
|
+
connection.once("error", reject);
|
|
158
|
+
});
|
|
159
|
+
} catch (error) {
|
|
160
|
+
throw workerConnectionError(error);
|
|
161
|
+
}
|
|
156
162
|
socket = connection;
|
|
157
163
|
let input = "";
|
|
158
164
|
connection.setEncoding("utf8");
|
|
@@ -265,6 +271,7 @@ export function createClaudeWorkerAdapter({
|
|
|
265
271
|
try {
|
|
266
272
|
await connecting;
|
|
267
273
|
} catch (error) {
|
|
274
|
+
if (error.cause) console.error("Claude 后台服务连接失败:", error.cause);
|
|
268
275
|
snapshot = {
|
|
269
276
|
...snapshot,
|
|
270
277
|
params: { ...snapshot.params, ready: false, error: error.message },
|
|
@@ -29,3 +29,15 @@ export async function verifyWorkerSocket(path) {
|
|
|
29
29
|
if (!info.isSocket() || info.uid !== process.getuid() || info.mode & 0o077)
|
|
30
30
|
throw new Error("Claude IPC socket 必须由当前用户持有并使用0600权限。");
|
|
31
31
|
}
|
|
32
|
+
|
|
33
|
+
export function workerConnectionError(error) {
|
|
34
|
+
if (!["ENOENT", "ECONNREFUSED", "ECONNRESET", "EACCES"].includes(error.code))
|
|
35
|
+
return error;
|
|
36
|
+
const message =
|
|
37
|
+
error.code === "EACCES"
|
|
38
|
+
? "Claude 后台访问被拒绝,请检查服务权限。"
|
|
39
|
+
: "Claude 后台连接失败,正在重试";
|
|
40
|
+
const result = new Error(message, { cause: error });
|
|
41
|
+
result.code = error.code;
|
|
42
|
+
return result;
|
|
43
|
+
}
|
|
@@ -10,6 +10,7 @@ import { createCompactionRecovery } from "./compaction-recovery.mjs";
|
|
|
10
10
|
import { createBridgeEvents } from "./events.mjs";
|
|
11
11
|
import { createRequestHandler } from "./requests.mjs";
|
|
12
12
|
import { createProductMethods } from "../../bridge/product-methods.mjs";
|
|
13
|
+
import { readCodexTokenUsage } from "./token-usage.mjs";
|
|
13
14
|
|
|
14
15
|
export function createCodexAdapter({
|
|
15
16
|
backend,
|
|
@@ -127,6 +128,7 @@ export function createCodexAdapter({
|
|
|
127
128
|
}
|
|
128
129
|
return {
|
|
129
130
|
capabilities: codexCapabilities,
|
|
131
|
+
readTokenUsage: (thread) => readCodexTokenUsage(thread, transport.call),
|
|
130
132
|
workspaceOwner: "backend",
|
|
131
133
|
state,
|
|
132
134
|
receive(client, message) {
|
|
@@ -111,7 +111,7 @@ export function createBridgeEvents({
|
|
|
111
111
|
}
|
|
112
112
|
if (!request.timedOut) send(request.client, { ...message, id: request.id });
|
|
113
113
|
releaseUnusedThreads();
|
|
114
|
-
if (!message.error && !request.timedOut) {
|
|
114
|
+
if (!message.error && !request.timedOut && !request.client?.readOnly) {
|
|
115
115
|
if (request.method === "turn/start")
|
|
116
116
|
threadNaming.schedule(
|
|
117
117
|
{ id: request.threadId },
|
|
@@ -0,0 +1,140 @@
|
|
|
1
|
+
import { open } from "node:fs/promises";
|
|
2
|
+
import { createReadStream } from "node:fs";
|
|
3
|
+
import { createZstdDecompress } from "node:zlib";
|
|
4
|
+
|
|
5
|
+
function parse(line) {
|
|
6
|
+
if (!line.includes('"token_count"') && !line.includes('"session_meta"'))
|
|
7
|
+
return null;
|
|
8
|
+
try {
|
|
9
|
+
return JSON.parse(line.toString("utf8"));
|
|
10
|
+
} catch {
|
|
11
|
+
return null;
|
|
12
|
+
}
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
// 分页分支的正文保存在祖先 rollout 中,读取范围由原生 history_base 指定。
|
|
16
|
+
// 每次从末尾读取 64 KiB,命中用量即停止,完整拼接记录后才解码 UTF-8。
|
|
17
|
+
async function scan(path, endByteOffset) {
|
|
18
|
+
const file = await open(path, "r");
|
|
19
|
+
try {
|
|
20
|
+
let position = (await file.stat()).size;
|
|
21
|
+
if (endByteOffset != null) position = Math.min(position, endByteOffset);
|
|
22
|
+
let remainder = Buffer.alloc(0);
|
|
23
|
+
let base = null;
|
|
24
|
+
function visit(line) {
|
|
25
|
+
const result = extract(parse(line));
|
|
26
|
+
if (result.base) base = result.base;
|
|
27
|
+
return result.tokenUsage ? result : null;
|
|
28
|
+
}
|
|
29
|
+
while (position > 0) {
|
|
30
|
+
const length = Math.min(position, 64 * 1024);
|
|
31
|
+
position -= length;
|
|
32
|
+
const buffer = Buffer.alloc(length);
|
|
33
|
+
const { bytesRead } = await file.read(buffer, 0, length, position);
|
|
34
|
+
const data = Buffer.concat([buffer.subarray(0, bytesRead), remainder]);
|
|
35
|
+
let end = data.length;
|
|
36
|
+
for (let index = data.length - 1; index >= 0; index--) {
|
|
37
|
+
if (data[index] !== 10) continue;
|
|
38
|
+
const usage = visit(data.subarray(index + 1, end));
|
|
39
|
+
if (usage) return usage;
|
|
40
|
+
end = index;
|
|
41
|
+
}
|
|
42
|
+
remainder = data.subarray(0, end);
|
|
43
|
+
}
|
|
44
|
+
return visit(remainder) || { base };
|
|
45
|
+
} finally {
|
|
46
|
+
await file.close();
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
function extract(record) {
|
|
51
|
+
const info =
|
|
52
|
+
record?.type === "event_msg" &&
|
|
53
|
+
record.payload?.type === "token_count" &&
|
|
54
|
+
record.payload.info;
|
|
55
|
+
if (!info?.last_token_usage || !info.total_token_usage)
|
|
56
|
+
return {
|
|
57
|
+
base:
|
|
58
|
+
record?.type === "session_meta" ? record.payload?.history_base : null,
|
|
59
|
+
};
|
|
60
|
+
const breakdown = (usage) => ({
|
|
61
|
+
totalTokens: usage.total_tokens,
|
|
62
|
+
inputTokens: usage.input_tokens,
|
|
63
|
+
cachedInputTokens: usage.cached_input_tokens,
|
|
64
|
+
cacheWriteInputTokens: usage.cache_write_input_tokens ?? 0,
|
|
65
|
+
outputTokens: usage.output_tokens,
|
|
66
|
+
reasoningOutputTokens: usage.reasoning_output_tokens,
|
|
67
|
+
});
|
|
68
|
+
return {
|
|
69
|
+
tokenUsage: {
|
|
70
|
+
total: breakdown(info.total_token_usage),
|
|
71
|
+
last: breakdown(info.last_token_usage),
|
|
72
|
+
modelContextWindow: info.model_context_window,
|
|
73
|
+
},
|
|
74
|
+
};
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
async function scanCompressed(path, endByteOffset) {
|
|
78
|
+
const source = createReadStream(path);
|
|
79
|
+
const stream = source.pipe(createZstdDecompress());
|
|
80
|
+
source.on("error", (error) => stream.destroy(error));
|
|
81
|
+
let remaining = endByteOffset ?? Infinity;
|
|
82
|
+
let remainder = Buffer.alloc(0);
|
|
83
|
+
let result = {};
|
|
84
|
+
function visit(line) {
|
|
85
|
+
const next = extract(parse(line));
|
|
86
|
+
if (next.tokenUsage || next.base) result = next;
|
|
87
|
+
}
|
|
88
|
+
try {
|
|
89
|
+
for await (const chunk of stream) {
|
|
90
|
+
const part = chunk.subarray(0, Math.min(remaining, chunk.length));
|
|
91
|
+
remaining -= part.length;
|
|
92
|
+
const data = Buffer.concat([remainder, part]);
|
|
93
|
+
let start = 0;
|
|
94
|
+
for (let index = 0; index < data.length; index++) {
|
|
95
|
+
if (data[index] !== 10) continue;
|
|
96
|
+
visit(data.subarray(start, index));
|
|
97
|
+
start = index + 1;
|
|
98
|
+
}
|
|
99
|
+
remainder = data.subarray(start);
|
|
100
|
+
if (remaining === 0) break;
|
|
101
|
+
}
|
|
102
|
+
visit(remainder);
|
|
103
|
+
return result;
|
|
104
|
+
} finally {
|
|
105
|
+
source.destroy();
|
|
106
|
+
stream.destroy();
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
async function readRollout(path, endByteOffset) {
|
|
111
|
+
if (path.endsWith(".zst")) return scanCompressed(path, endByteOffset);
|
|
112
|
+
try {
|
|
113
|
+
return await scan(path, endByteOffset);
|
|
114
|
+
} catch (error) {
|
|
115
|
+
if (error.code !== "ENOENT") throw error;
|
|
116
|
+
return scanCompressed(path + ".zst", endByteOffset);
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
export async function readCodexTokenUsage(thread, call) {
|
|
121
|
+
const visited = new Set();
|
|
122
|
+
async function read(thread, endByteOffset) {
|
|
123
|
+
if (!thread?.path || visited.has(thread.id)) return null;
|
|
124
|
+
visited.add(thread.id);
|
|
125
|
+
const result = await readRollout(thread.path, endByteOffset);
|
|
126
|
+
if (result.tokenUsage) return result;
|
|
127
|
+
if (
|
|
128
|
+
!result.base?.thread_id ||
|
|
129
|
+
!Number.isSafeInteger(result.base.end_byte_offset) ||
|
|
130
|
+
result.base.end_byte_offset < 0
|
|
131
|
+
)
|
|
132
|
+
return null;
|
|
133
|
+
const parent = await call("thread/read", {
|
|
134
|
+
threadId: result.base.thread_id,
|
|
135
|
+
includeTurns: false,
|
|
136
|
+
});
|
|
137
|
+
return read(parent.thread, result.base.end_byte_offset);
|
|
138
|
+
}
|
|
139
|
+
return read(thread);
|
|
140
|
+
}
|
|
@@ -1,4 +1,6 @@
|
|
|
1
1
|
import { createThreadFolders } from "../thread-folders.mjs";
|
|
2
|
+
import { createTokenUsageStore } from "../token-usage.mjs";
|
|
3
|
+
import { createTokenUsageReconciliation } from "../token-usage-reconciliation.mjs";
|
|
2
4
|
import { createCliInstallation } from "./cli-installation.mjs";
|
|
3
5
|
import { join } from "node:path";
|
|
4
6
|
import { readProjectlessDirectories } from "../thread-projects.mjs";
|
|
@@ -30,6 +32,7 @@ export function createBackendManager({
|
|
|
30
32
|
factories = {},
|
|
31
33
|
}) {
|
|
32
34
|
const folders = createThreadFolders(config.configDir);
|
|
35
|
+
const tokenUsage = createTokenUsageStore(config.configDir);
|
|
33
36
|
const workspace = createWorkspace({ broadcast, configDir: config.configDir });
|
|
34
37
|
const configuration = createBackendConfiguration(config);
|
|
35
38
|
const providers = createProviders(configuration);
|
|
@@ -47,6 +50,11 @@ export function createBackendManager({
|
|
|
47
50
|
closed = false,
|
|
48
51
|
sequence = 0;
|
|
49
52
|
let changing = Promise.resolve();
|
|
53
|
+
const usageReconciliation = createTokenUsageReconciliation({
|
|
54
|
+
store: tokenUsage,
|
|
55
|
+
call,
|
|
56
|
+
current: (entry) => !closed && instances.get(entry.backend.id) === entry,
|
|
57
|
+
});
|
|
50
58
|
const publicBackends = () =>
|
|
51
59
|
[...instances.values()].map(({ backend, adapter, error }) => ({
|
|
52
60
|
...backend,
|
|
@@ -119,18 +127,25 @@ export function createBackendManager({
|
|
|
119
127
|
},
|
|
120
128
|
broadcast(message) {
|
|
121
129
|
if (instances.get(backend.id) !== entry || closed) return;
|
|
122
|
-
if (message.method === "lan/state")
|
|
123
|
-
|
|
130
|
+
if (message.method === "lan/state") {
|
|
131
|
+
if (entry.adapter?.ready) entry.error = null;
|
|
132
|
+
usageReconciliation.start(entry);
|
|
133
|
+
return emitState();
|
|
134
|
+
}
|
|
135
|
+
const notification = {
|
|
124
136
|
...message,
|
|
125
137
|
...(backend.id !== "codex" && { backendId: backend.id }),
|
|
126
138
|
...(message.id !== undefined && {
|
|
127
139
|
id: resourceId(backend.id, message.id),
|
|
128
140
|
}),
|
|
129
141
|
params: mapResult(message.params, backend.id, message.method),
|
|
130
|
-
}
|
|
142
|
+
};
|
|
143
|
+
tokenUsage.observe(notification);
|
|
144
|
+
broadcast(notification);
|
|
131
145
|
},
|
|
132
146
|
});
|
|
133
147
|
await entry.adapter.connect();
|
|
148
|
+
usageReconciliation.start(entry);
|
|
134
149
|
} catch (error) {
|
|
135
150
|
entry.error = error.message;
|
|
136
151
|
}
|
|
@@ -158,15 +173,28 @@ export function createBackendManager({
|
|
|
158
173
|
return client.readyState;
|
|
159
174
|
},
|
|
160
175
|
methods,
|
|
161
|
-
deliver(message) {
|
|
162
|
-
const method =
|
|
176
|
+
async deliver(message) {
|
|
177
|
+
const { method, threadId, usageRevision, forkUsage } =
|
|
178
|
+
methods.get(message.id) || {};
|
|
163
179
|
methods.delete(message.id);
|
|
180
|
+
if (!message.error && method === "thread/delete")
|
|
181
|
+
tokenUsage.remove(threadId);
|
|
182
|
+
if (!message.error && method === "thread/archive")
|
|
183
|
+
tokenUsage.archive(threadId);
|
|
184
|
+
if (!message.error && method === "thread/unarchive")
|
|
185
|
+
tokenUsage.archive(threadId, false);
|
|
164
186
|
send(client, {
|
|
165
187
|
...message,
|
|
166
188
|
...(message.result && {
|
|
167
|
-
result:
|
|
168
|
-
|
|
189
|
+
result: await tokenUsage.result(
|
|
190
|
+
folders.result(
|
|
191
|
+
mapResult(message.result, entry.backend.id, method),
|
|
192
|
+
method,
|
|
193
|
+
),
|
|
169
194
|
method,
|
|
195
|
+
usageRevision,
|
|
196
|
+
forkUsage,
|
|
197
|
+
entry.adapter.readTokenUsage,
|
|
170
198
|
),
|
|
171
199
|
}),
|
|
172
200
|
});
|
|
@@ -175,29 +203,52 @@ export function createBackendManager({
|
|
|
175
203
|
}
|
|
176
204
|
return entry.proxies.get(client);
|
|
177
205
|
}
|
|
178
|
-
function call(entry, method, params) {
|
|
206
|
+
function call(entry, method, params, { signal } = {}) {
|
|
207
|
+
if (signal?.aborted) return Promise.reject(signal.reason);
|
|
208
|
+
const usageRevision = tokenUsage.revision(
|
|
209
|
+
params.threadId && resourceId(entry.backend.id, params.threadId),
|
|
210
|
+
);
|
|
179
211
|
return new Promise((resolve, reject) => {
|
|
180
212
|
const id = `manager-${++sequence}`;
|
|
181
|
-
const
|
|
213
|
+
const fail = (error) => {
|
|
214
|
+
clearTimeout(timer);
|
|
215
|
+
signal?.removeEventListener("abort", abort);
|
|
216
|
+
reject(error);
|
|
217
|
+
};
|
|
218
|
+
const abort = () => fail(signal.reason);
|
|
219
|
+
const timer = setTimeout(() => fail(new Error("后端读取超时")), 120000);
|
|
220
|
+
signal?.addEventListener("abort", abort, { once: true });
|
|
182
221
|
const client = {
|
|
183
222
|
readyState: 3,
|
|
184
|
-
|
|
223
|
+
readOnly: Boolean(signal),
|
|
224
|
+
async deliver(message) {
|
|
185
225
|
clearTimeout(timer);
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
226
|
+
signal?.removeEventListener("abort", abort);
|
|
227
|
+
if (signal?.aborted) return;
|
|
228
|
+
try {
|
|
229
|
+
if (message.error) reject(new Error(message.error.message));
|
|
230
|
+
else
|
|
231
|
+
resolve(
|
|
232
|
+
await tokenUsage.result(
|
|
233
|
+
folders.result(
|
|
234
|
+
mapResult(message.result, entry.backend.id, method),
|
|
235
|
+
method,
|
|
236
|
+
),
|
|
237
|
+
method,
|
|
238
|
+
usageRevision,
|
|
239
|
+
undefined,
|
|
240
|
+
entry.adapter.readTokenUsage,
|
|
241
|
+
),
|
|
242
|
+
);
|
|
243
|
+
} catch (error) {
|
|
244
|
+
reject(error);
|
|
245
|
+
}
|
|
194
246
|
},
|
|
195
247
|
};
|
|
196
248
|
Promise.resolve(
|
|
197
249
|
entry.adapter.receive(client, { id, method, params }),
|
|
198
250
|
).catch((error) => {
|
|
199
|
-
|
|
200
|
-
reject(error);
|
|
251
|
+
fail(error);
|
|
201
252
|
});
|
|
202
253
|
});
|
|
203
254
|
}
|
|
@@ -364,7 +415,19 @@ export function createBackendManager({
|
|
|
364
415
|
if (workspace.handles(method) && entry.adapter.workspaceOwner === "bridge")
|
|
365
416
|
return reply(await workspace.request(method, params));
|
|
366
417
|
const recipient = proxy(entry, client);
|
|
367
|
-
|
|
418
|
+
if (method === "thread/fork" && !(await tokenUsage.forkSource(params)))
|
|
419
|
+
await call(entry, "thread/read", {
|
|
420
|
+
threadId: target.nativeId,
|
|
421
|
+
includeTurns: false,
|
|
422
|
+
});
|
|
423
|
+
recipient.methods.set(message.id, {
|
|
424
|
+
method,
|
|
425
|
+
threadId: params.threadId,
|
|
426
|
+
usageRevision: tokenUsage.revision(params.threadId),
|
|
427
|
+
...(method === "thread/fork" && {
|
|
428
|
+
forkUsage: await tokenUsage.forkSource(params),
|
|
429
|
+
}),
|
|
430
|
+
});
|
|
368
431
|
await entry.adapter.receive(recipient, {
|
|
369
432
|
...message,
|
|
370
433
|
...(!method && { id: target.nativeId }),
|
|
@@ -396,14 +459,17 @@ export function createBackendManager({
|
|
|
396
459
|
ready: initialized,
|
|
397
460
|
activeTurns: params.activeTurns,
|
|
398
461
|
compactions: params.compactions,
|
|
462
|
+
tokenUsageReconciliation: usageReconciliation.snapshot(),
|
|
399
463
|
},
|
|
400
464
|
};
|
|
401
465
|
},
|
|
402
466
|
close() {
|
|
403
467
|
closed = true;
|
|
468
|
+
usageReconciliation.stop();
|
|
404
469
|
cli.close?.();
|
|
405
470
|
workspace.close();
|
|
406
471
|
for (const i of instances.values()) i.adapter?.close();
|
|
472
|
+
return usageReconciliation.flush().then(() => tokenUsage.flush());
|
|
407
473
|
},
|
|
408
474
|
get ready() {
|
|
409
475
|
return state().params.ready;
|
|
@@ -4,6 +4,7 @@ import { configuredProviders, providerPresets } from "./provider-presets.mjs";
|
|
|
4
4
|
export function createProviders(configuration) {
|
|
5
5
|
const publicProvider = ({ apiKey, ...provider }) => ({
|
|
6
6
|
...provider,
|
|
7
|
+
protocol: provider.protocol || "messages",
|
|
7
8
|
hasApiKey: Boolean(apiKey),
|
|
8
9
|
});
|
|
9
10
|
async function list(backendId, { includeDisabled = false } = {}) {
|
|
@@ -45,8 +46,7 @@ export function createProviders(configuration) {
|
|
|
45
46
|
)
|
|
46
47
|
throw new Error("请填写有效的 API 地址");
|
|
47
48
|
if (!input.name?.trim()) throw new Error("请填写供应商名称");
|
|
48
|
-
|
|
49
|
-
if (!["messages", "anthropic"].includes(protocol))
|
|
49
|
+
if (input.protocol && !["messages", "anthropic"].includes(input.protocol))
|
|
50
50
|
throw new Error("请选择支持的 API 协议");
|
|
51
51
|
const models = (input.models || []).map((m) =>
|
|
52
52
|
typeof m === "string" ? m.trim() : m.id?.trim(),
|
|
@@ -90,7 +90,10 @@ export function createProviders(configuration) {
|
|
|
90
90
|
id,
|
|
91
91
|
backendId: backend.id,
|
|
92
92
|
name: input.name.trim(),
|
|
93
|
-
protocol
|
|
93
|
+
protocol:
|
|
94
|
+
input.protocol ||
|
|
95
|
+
previous?.protocol ||
|
|
96
|
+
(previous ? "messages" : "anthropic"),
|
|
94
97
|
baseUrl: url.href.replace(/\/$/, ""),
|
|
95
98
|
models,
|
|
96
99
|
modelAliases:
|
|
@@ -12,9 +12,9 @@ export function createStorage(path, initial) {
|
|
|
12
12
|
throw error;
|
|
13
13
|
}
|
|
14
14
|
}
|
|
15
|
-
function update(change) {
|
|
15
|
+
function update(change, readCurrent = true) {
|
|
16
16
|
const operation = writing.then(async () => {
|
|
17
|
-
const next = await change(await read());
|
|
17
|
+
const next = await change(readCurrent ? await read() : undefined);
|
|
18
18
|
await mkdir(dirname(path), { recursive: true, mode: 0o700 });
|
|
19
19
|
const temporary = `${path}.${randomUUID()}.tmp`;
|
|
20
20
|
try {
|
|
@@ -31,5 +31,9 @@ export function createStorage(path, initial) {
|
|
|
31
31
|
writing = operation.catch(() => {});
|
|
32
32
|
return operation;
|
|
33
33
|
}
|
|
34
|
-
return {
|
|
34
|
+
return {
|
|
35
|
+
read: () => writing.then(read),
|
|
36
|
+
update,
|
|
37
|
+
replace: (value) => update(() => value, false),
|
|
38
|
+
};
|
|
35
39
|
}
|
package/server/src/config.mjs
CHANGED
|
@@ -34,6 +34,13 @@ export function readConfig(env = process.env) {
|
|
|
34
34
|
backendsFile: env.CLAUDEX_WEB_BACKENDS_FILE
|
|
35
35
|
? resolve(env.CLAUDEX_WEB_BACKENDS_FILE)
|
|
36
36
|
: join(configDir, "backends.json"),
|
|
37
|
+
translationModelDir: join(
|
|
38
|
+
homedir(),
|
|
39
|
+
".local",
|
|
40
|
+
"share",
|
|
41
|
+
"claudex-web",
|
|
42
|
+
"models",
|
|
43
|
+
),
|
|
37
44
|
sessionDays,
|
|
38
45
|
pamService,
|
|
39
46
|
pamtesterPath: env.AUTH_PAMTESTER
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
export function createMaintenanceHandler(service) {
|
|
2
|
+
return async (request, response, path) => {
|
|
3
|
+
response.setHeader("Content-Type", "application/json; charset=utf-8");
|
|
4
|
+
try {
|
|
5
|
+
let result;
|
|
6
|
+
if (path === "/api/maintenance" && request.method === "GET")
|
|
7
|
+
result = await service.status();
|
|
8
|
+
else if (request.method === "POST" && path === "/api/maintenance/check") {
|
|
9
|
+
await service.check();
|
|
10
|
+
result = await service.status();
|
|
11
|
+
} else if (
|
|
12
|
+
request.method === "POST" &&
|
|
13
|
+
["/api/maintenance/update", "/api/maintenance/restart"].includes(path)
|
|
14
|
+
) {
|
|
15
|
+
result = await service.start(path.split("/").at(-1));
|
|
16
|
+
} else {
|
|
17
|
+
response.writeHead(405);
|
|
18
|
+
response.end(JSON.stringify({ error: "请求方法或维护操作无效" }));
|
|
19
|
+
return;
|
|
20
|
+
}
|
|
21
|
+
response.writeHead(200);
|
|
22
|
+
response.end(JSON.stringify(result));
|
|
23
|
+
} catch (error) {
|
|
24
|
+
response.writeHead(409);
|
|
25
|
+
response.end(JSON.stringify({ error: error.message }));
|
|
26
|
+
}
|
|
27
|
+
};
|
|
28
|
+
}
|
|
@@ -1,5 +1,9 @@
|
|
|
1
|
+
import { createMaintenanceHandler } from "./maintenance.mjs";
|
|
1
2
|
import { X509Certificate } from "node:crypto";
|
|
2
|
-
import {
|
|
3
|
+
import {
|
|
4
|
+
createSummaryTranslationHandler,
|
|
5
|
+
createTranslationSettingsHandler,
|
|
6
|
+
} from "../summary-translation.mjs";
|
|
3
7
|
import { serveFile } from "../file-content.mjs";
|
|
4
8
|
import { createStaticHandler } from "./static.mjs";
|
|
5
9
|
export function createHttpHandler({
|
|
@@ -8,9 +12,15 @@ export function createHttpHandler({
|
|
|
8
12
|
authentication,
|
|
9
13
|
version,
|
|
10
14
|
isReady,
|
|
15
|
+
translation,
|
|
16
|
+
maintenance,
|
|
11
17
|
}) {
|
|
18
|
+
const handleMaintenance = createMaintenanceHandler(maintenance);
|
|
12
19
|
const publicCertificate = new X509Certificate(tls.cert);
|
|
13
|
-
const translateSummary = createSummaryTranslationHandler(
|
|
20
|
+
const translateSummary = createSummaryTranslationHandler(
|
|
21
|
+
translation.translate,
|
|
22
|
+
);
|
|
23
|
+
const translationSettings = createTranslationSettingsHandler(translation);
|
|
14
24
|
const serveStatic = createStaticHandler(config.staticDir);
|
|
15
25
|
return async function handleHttp(request, response) {
|
|
16
26
|
const ready = isReady();
|
|
@@ -58,10 +68,18 @@ export function createHttpHandler({
|
|
|
58
68
|
!authentication.authorize(request, response)
|
|
59
69
|
)
|
|
60
70
|
return;
|
|
71
|
+
if (path.startsWith("/api/maintenance")) {
|
|
72
|
+
await handleMaintenance(request, response, path);
|
|
73
|
+
return;
|
|
74
|
+
}
|
|
61
75
|
if (["/api/files", "/api/media"].includes(path)) {
|
|
62
76
|
await serveFile(request, response);
|
|
63
77
|
return;
|
|
64
78
|
}
|
|
79
|
+
if (path === "/api/translation") {
|
|
80
|
+
await translationSettings(request, response);
|
|
81
|
+
return;
|
|
82
|
+
}
|
|
65
83
|
if (path === "/api/translate") {
|
|
66
84
|
await translateSummary(request, response);
|
|
67
85
|
return;
|
package/server/src/server.mjs
CHANGED
|
@@ -15,6 +15,15 @@ const application = createWebApplication({
|
|
|
15
15
|
version: readVersion(),
|
|
16
16
|
});
|
|
17
17
|
await application.start();
|
|
18
|
+
let closing;
|
|
19
|
+
function shutdown() {
|
|
20
|
+
closing ||= application.close().catch((error) => {
|
|
21
|
+
console.error(error);
|
|
22
|
+
process.exitCode = 1;
|
|
23
|
+
});
|
|
24
|
+
}
|
|
25
|
+
process.once("SIGTERM", shutdown);
|
|
26
|
+
process.once("SIGINT", shutdown);
|
|
18
27
|
console.log(
|
|
19
28
|
`Claudex Web listening on https://${config.host}:${application.server.address().port}`,
|
|
20
29
|
);
|