@hjd-hitsz/claudex-web 4.1.5 → 4.2.1
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/.env.example +2 -0
- package/CHANGELOG.md +57 -0
- package/README.md +16 -4
- package/bin/auth.mjs +86 -0
- package/bin/claudex-web.mjs +20 -0
- package/bin/p2p.mjs +134 -0
- package/build-info.json +4 -4
- package/client/dist/app.js +154 -122
- package/client/dist/code-highlight-style.js +23 -45
- package/client/dist/document-editor.js +54 -54
- package/client/dist/file-panel.js +5 -5
- package/client/dist/notification-worker.js +2 -1
- package/client/dist/p2p-sw.js +162 -0
- package/client/dist/style.css +1 -1
- package/client/dist/terminal-panel.js +11 -11
- package/docs/architecture/backends.md +11 -2
- package/docs/architecture/behavior.md +173 -59
- package/docs/architecture.md +36 -339
- package/docs/background-tasks.md +32 -26
- package/docs/deployment.md +53 -12
- package/docs/development.md +121 -149
- package/docs/images/desktop-dark.png +0 -0
- package/docs/images/desktop-light.png +0 -0
- package/docs/images/mobile-sidebar.png +0 -0
- package/docs/images/mobile.png +0 -0
- package/docs/releases/v4.2.0.md +15 -0
- package/docs/releases/v4.2.1.md +15 -0
- package/docs/versioning.md +15 -5
- package/package.json +9 -2
- package/packages/background-terminal/LICENSE +674 -0
- package/packages/background-terminal/README.md +17 -0
- package/packages/background-terminal/background-jobs.mjs +457 -0
- package/packages/background-terminal/background-mcp.mjs +79 -0
- package/packages/background-terminal/background-protocol.mjs +90 -0
- package/packages/background-terminal/cli.mjs +14 -0
- package/packages/background-terminal/client.mjs +61 -0
- package/packages/background-terminal/codex.mjs +88 -0
- package/packages/background-terminal/delivery.mjs +194 -0
- package/packages/background-terminal/log.mjs +25 -0
- package/packages/background-terminal/native-watches.mjs +160 -0
- package/packages/background-terminal/package.json +15 -0
- package/packages/background-terminal/service.mjs +126 -0
- package/packages/translation-engine/package.json +1 -1
- package/server/src/application.mjs +82 -10
- package/server/src/auth-http.mjs +187 -0
- package/server/src/auth-login.mjs +144 -0
- package/server/src/auth-totp.mjs +233 -0
- package/server/src/auth.mjs +169 -220
- package/server/src/backends/claude/background-tasks.mjs +88 -35
- package/server/src/backends/claude/messages.mjs +1 -1
- package/server/src/backends/claude/worker-client.mjs +47 -35
- package/server/src/backends/claude/worker-lines.mjs +17 -0
- package/server/src/backends/claude/worker-server.mjs +49 -69
- package/server/src/backends/codex/adapter.mjs +57 -7
- package/server/src/backends/codex/background-service.mjs +85 -0
- package/server/src/backends/codex/background-task-views.mjs +87 -0
- package/server/src/backends/codex/background-terminals.mjs +103 -0
- package/server/src/backends/codex/events.mjs +25 -1
- package/server/src/backends/codex/methods.mjs +1 -0
- package/server/src/backends/codex/native-background-handoff.mjs +72 -0
- package/server/src/backends/codex/requests.mjs +67 -38
- package/server/src/backends/codex/streaming-messages.mjs +50 -0
- package/server/src/backends/codex/subscriptions.mjs +34 -4
- package/server/src/backends/configuration.mjs +8 -0
- package/server/src/backends/manager.mjs +34 -32
- package/server/src/backends/storage.mjs +3 -14
- package/server/src/config.mjs +13 -0
- package/server/src/http/business.mjs +21 -0
- package/server/src/http/router.mjs +12 -25
- package/server/src/p2p/http.mjs +136 -0
- package/server/src/p2p/peers.mjs +132 -0
- package/server/src/p2p/service.mjs +229 -0
- package/server/src/p2p/storage.mjs +45 -0
- package/server/src/p2p/tunnel.mjs +95 -0
- package/server/src/p2p-http.mjs +149 -0
- package/server/src/p2p-peer.mjs +135 -0
- package/server/src/private-file.mjs +14 -0
- package/server/src/summary-translation.mjs +1 -1
- package/server/src/thread-folders.mjs +3 -13
- package/server/src/translation-service.mjs +3 -8
- package/shared/codex-preferences.mjs +9 -0
- package/shared/p2p-wire.mjs +157 -0
|
@@ -0,0 +1,103 @@
|
|
|
1
|
+
import {
|
|
2
|
+
mcpConfig,
|
|
3
|
+
taskRequest,
|
|
4
|
+
} from "../../../../packages/background-terminal/client.mjs";
|
|
5
|
+
import { BACKGROUND_TURN_CONTEXT } from "../../../../packages/background-terminal/background-protocol.mjs";
|
|
6
|
+
import { threadMethods } from "./methods.mjs";
|
|
7
|
+
|
|
8
|
+
const prefix = "claudex-background:";
|
|
9
|
+
export const terminalMethods = new Set([
|
|
10
|
+
"thread/backgroundTerminals/list",
|
|
11
|
+
"thread/backgroundTerminals/clean",
|
|
12
|
+
]);
|
|
13
|
+
|
|
14
|
+
export function backgroundParams(method, params, directory, upstream) {
|
|
15
|
+
if (!directory || !threadMethods.has(method)) return params;
|
|
16
|
+
return {
|
|
17
|
+
...params,
|
|
18
|
+
config: { ...params.config, ...mcpConfig(directory, upstream) },
|
|
19
|
+
};
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
export function backgroundTurnParams(method, params) {
|
|
23
|
+
if (method !== "turn/start" && method !== "turn/steer") return params;
|
|
24
|
+
return {
|
|
25
|
+
...params,
|
|
26
|
+
additionalContext: {
|
|
27
|
+
...params.additionalContext,
|
|
28
|
+
...BACKGROUND_TURN_CONTEXT,
|
|
29
|
+
},
|
|
30
|
+
};
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
export function backgroundTerminals(
|
|
34
|
+
directory,
|
|
35
|
+
upstream,
|
|
36
|
+
nativeCall,
|
|
37
|
+
request = taskRequest,
|
|
38
|
+
enabled = () => true,
|
|
39
|
+
) {
|
|
40
|
+
return async (method, params) => {
|
|
41
|
+
const tool = (name, args = {}) =>
|
|
42
|
+
request(directory, "tool", {
|
|
43
|
+
name,
|
|
44
|
+
args,
|
|
45
|
+
threadId: params.threadId,
|
|
46
|
+
expectedUpstream: new URL(upstream).href,
|
|
47
|
+
});
|
|
48
|
+
const running = async () => {
|
|
49
|
+
try {
|
|
50
|
+
return (await tool("background_list")).jobs.filter(
|
|
51
|
+
(job) => job.status === "running",
|
|
52
|
+
);
|
|
53
|
+
} catch (error) {
|
|
54
|
+
if (!enabled() && ["ENOENT", "ECONNREFUSED"].includes(error.code))
|
|
55
|
+
return [];
|
|
56
|
+
throw error;
|
|
57
|
+
}
|
|
58
|
+
};
|
|
59
|
+
if (method.endsWith("/clean")) {
|
|
60
|
+
const cancel = async () => {
|
|
61
|
+
const results = await Promise.allSettled(
|
|
62
|
+
(await running()).map((job) =>
|
|
63
|
+
tool("background_cancel", { job_id: job.id }),
|
|
64
|
+
),
|
|
65
|
+
);
|
|
66
|
+
for (const result of results)
|
|
67
|
+
if (result.status === "rejected") throw result.reason;
|
|
68
|
+
};
|
|
69
|
+
// Mark tracked tasks as cancelled before Codex emits their terminal events.
|
|
70
|
+
const [extension] = await Promise.allSettled([cancel()]);
|
|
71
|
+
const [native] = await Promise.allSettled([nativeCall(method, params)]);
|
|
72
|
+
if (native.status === "rejected") throw native.reason;
|
|
73
|
+
if (extension.status === "rejected") throw extension.reason;
|
|
74
|
+
return native.value;
|
|
75
|
+
}
|
|
76
|
+
// Native pages retain their own cursors. Extension pages use UUID order and
|
|
77
|
+
// a value cursor so stopping a job between pages cannot skip its neighbour.
|
|
78
|
+
const extensionPage = params.cursor?.startsWith(prefix);
|
|
79
|
+
const native = extensionPage
|
|
80
|
+
? { data: [], nextCursor: null }
|
|
81
|
+
: await nativeCall(method, params);
|
|
82
|
+
if (native.nextCursor) return native;
|
|
83
|
+
const cursor = extensionPage ? params.cursor.slice(prefix.length) : "";
|
|
84
|
+
const jobs = (await running())
|
|
85
|
+
.filter((job) => !job.native && job.id > cursor)
|
|
86
|
+
.sort((a, b) => a.id.localeCompare(b.id));
|
|
87
|
+
const room = Math.max(0, (params.limit || 100) - native.data.length);
|
|
88
|
+
const selected = jobs.slice(0, room);
|
|
89
|
+
return {
|
|
90
|
+
data: [
|
|
91
|
+
...native.data,
|
|
92
|
+
...selected.map((job) => ({
|
|
93
|
+
itemId: job.id,
|
|
94
|
+
processId: job.id,
|
|
95
|
+
command: job.command,
|
|
96
|
+
cwd: job.cwd,
|
|
97
|
+
})),
|
|
98
|
+
],
|
|
99
|
+
nextCursor:
|
|
100
|
+
jobs.length > room ? prefix + (selected.at(-1)?.id ?? cursor) : null,
|
|
101
|
+
};
|
|
102
|
+
};
|
|
103
|
+
}
|
|
@@ -7,7 +7,9 @@ export function createBridgeEvents({
|
|
|
7
7
|
terminals,
|
|
8
8
|
subscriptions,
|
|
9
9
|
unwrittenThreads,
|
|
10
|
+
updateGoal,
|
|
10
11
|
compactions,
|
|
12
|
+
streamingMessages,
|
|
11
13
|
threadNaming,
|
|
12
14
|
send,
|
|
13
15
|
broadcast,
|
|
@@ -40,6 +42,9 @@ export function createBridgeEvents({
|
|
|
40
42
|
if (p.status.type === "active") activeThreads.add(p.threadId);
|
|
41
43
|
else activeThreads.delete(p.threadId);
|
|
42
44
|
}
|
|
45
|
+
if (message.method === "thread/goal/updated")
|
|
46
|
+
updateGoal(p.threadId, p.goal);
|
|
47
|
+
if (message.method === "thread/goal/cleared") updateGoal(p.threadId, null);
|
|
43
48
|
if (
|
|
44
49
|
["thread/closed", "thread/deleted", "thread/archived"].includes(
|
|
45
50
|
message.method,
|
|
@@ -47,6 +52,7 @@ export function createBridgeEvents({
|
|
|
47
52
|
) {
|
|
48
53
|
subscriptions.delete(p.threadId);
|
|
49
54
|
unwrittenThreads.delete(p.threadId);
|
|
55
|
+
updateGoal(p.threadId, null);
|
|
50
56
|
activeThreads.delete(p.threadId);
|
|
51
57
|
activeTurns.delete(p.threadId);
|
|
52
58
|
if (message.method !== "thread/closed")
|
|
@@ -73,6 +79,12 @@ export function createBridgeEvents({
|
|
|
73
79
|
return;
|
|
74
80
|
}
|
|
75
81
|
function onResponse(request, message) {
|
|
82
|
+
if (!message.error && request.threadId) {
|
|
83
|
+
if (request.method === "thread/goal/set" && message.result?.goal)
|
|
84
|
+
updateGoal(request.threadId, message.result.goal);
|
|
85
|
+
if (request.method === "thread/goal/clear")
|
|
86
|
+
updateGoal(request.threadId, null);
|
|
87
|
+
}
|
|
76
88
|
if (message.error && request.method === "thread/compact/start")
|
|
77
89
|
compactions.reject(request.threadId, message.id, message.error.message);
|
|
78
90
|
if (
|
|
@@ -109,7 +121,19 @@ export function createBridgeEvents({
|
|
|
109
121
|
},
|
|
110
122
|
});
|
|
111
123
|
}
|
|
112
|
-
if (!request.timedOut)
|
|
124
|
+
if (!request.timedOut) {
|
|
125
|
+
const streamed = request.includeStreaming
|
|
126
|
+
? streamingMessages.read(request.threadId)
|
|
127
|
+
: [];
|
|
128
|
+
send(request.client, {
|
|
129
|
+
...message,
|
|
130
|
+
id: request.id,
|
|
131
|
+
...(message.result &&
|
|
132
|
+
streamed.length && {
|
|
133
|
+
result: { ...message.result, streamingMessages: streamed },
|
|
134
|
+
}),
|
|
135
|
+
});
|
|
136
|
+
}
|
|
113
137
|
releaseUnusedThreads();
|
|
114
138
|
if (!message.error && !request.timedOut && !request.client?.readOnly) {
|
|
115
139
|
if (request.method === "turn/start")
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
import { taskRequest } from "../../../../packages/background-terminal/client.mjs";
|
|
2
|
+
|
|
3
|
+
export function createNativeBackgroundHandoff({
|
|
4
|
+
background,
|
|
5
|
+
enabled,
|
|
6
|
+
upstream,
|
|
7
|
+
onSettled,
|
|
8
|
+
}) {
|
|
9
|
+
const turns = new Map();
|
|
10
|
+
const pending = new Map();
|
|
11
|
+
const expectedUpstream = new URL(upstream).href;
|
|
12
|
+
|
|
13
|
+
function event({ method, params }) {
|
|
14
|
+
const { threadId, turnId, item, turn } = params ?? {};
|
|
15
|
+
if (method === "item/started" && enabled()) {
|
|
16
|
+
if (
|
|
17
|
+
item?.type !== "commandExecution" ||
|
|
18
|
+
item.source !== "unifiedExecStartup" ||
|
|
19
|
+
!item.processId
|
|
20
|
+
)
|
|
21
|
+
return;
|
|
22
|
+
if (!turns.has(turnId)) turns.set(turnId, { threadId, items: new Map() });
|
|
23
|
+
turns.get(turnId).items.set(item.id, {
|
|
24
|
+
id: item.id,
|
|
25
|
+
processId: item.processId,
|
|
26
|
+
command: item.command,
|
|
27
|
+
cwd: item.cwd,
|
|
28
|
+
startedAtMs: item.startedAtMs ?? params.startedAtMs,
|
|
29
|
+
});
|
|
30
|
+
} else if (method === "item/completed") {
|
|
31
|
+
turns.get(turnId)?.items.delete(item?.id);
|
|
32
|
+
} else if (method === "turn/completed") {
|
|
33
|
+
const record = turns.get(turn.id);
|
|
34
|
+
turns.delete(turn.id);
|
|
35
|
+
if (!record?.items.size || turn.status !== "completed" || !enabled())
|
|
36
|
+
return;
|
|
37
|
+
if (!pending.has(threadId)) pending.set(threadId, new Set());
|
|
38
|
+
const requests = pending.get(threadId);
|
|
39
|
+
const work = background
|
|
40
|
+
.ensure()
|
|
41
|
+
.then((directory) =>
|
|
42
|
+
taskRequest(directory, "watchNative", {
|
|
43
|
+
threadId,
|
|
44
|
+
turnId: turn.id,
|
|
45
|
+
items: [...record.items.values()],
|
|
46
|
+
expectedUpstream,
|
|
47
|
+
}),
|
|
48
|
+
)
|
|
49
|
+
.catch((error) =>
|
|
50
|
+
console.error("订阅 Codex 原生后台终端", threadId, error.message),
|
|
51
|
+
)
|
|
52
|
+
.finally(() => {
|
|
53
|
+
requests.delete(work);
|
|
54
|
+
if (!requests.size) pending.delete(threadId);
|
|
55
|
+
onSettled();
|
|
56
|
+
});
|
|
57
|
+
requests.add(work);
|
|
58
|
+
} else if (
|
|
59
|
+
["thread/closed", "thread/archived", "thread/deleted"].includes(method)
|
|
60
|
+
) {
|
|
61
|
+
for (const [id, record] of turns)
|
|
62
|
+
if (record.threadId === threadId) turns.delete(id);
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
return {
|
|
67
|
+
event,
|
|
68
|
+
pending: (threadId) => pending.has(threadId),
|
|
69
|
+
wait: (threadId) => Promise.all(pending.get(threadId) ?? []),
|
|
70
|
+
disconnected: () => turns.clear(),
|
|
71
|
+
};
|
|
72
|
+
}
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { terminalMethods } from "./background-terminals.mjs";
|
|
1
2
|
import { MAX_RPC_MESSAGE_BYTES } from "../../rpc-transport.mjs";
|
|
2
3
|
import { threadMethods, loadedThreadMethods } from "./methods.mjs";
|
|
3
4
|
import { assertConversationOperation } from "../../bridge/conversation-policy.mjs";
|
|
@@ -13,12 +14,19 @@ export function createRequestHandler({
|
|
|
13
14
|
subscriptions,
|
|
14
15
|
releasing,
|
|
15
16
|
resumeForWrite,
|
|
17
|
+
retainThread,
|
|
16
18
|
releaseUnusedThreads,
|
|
19
|
+
backgroundCall,
|
|
20
|
+
waitForBackgroundHandoff,
|
|
21
|
+
includeBackground,
|
|
17
22
|
offline,
|
|
18
23
|
online,
|
|
19
24
|
send,
|
|
20
25
|
broadcast,
|
|
21
26
|
}) {
|
|
27
|
+
function sendError(client, request, message, code = -32000) {
|
|
28
|
+
send(client, { id: request.id, error: { code, message } });
|
|
29
|
+
}
|
|
22
30
|
async function dispatchLocal(handlers, client, message) {
|
|
23
31
|
const handle = handlers.get(message.method);
|
|
24
32
|
if (!handle) return false;
|
|
@@ -28,10 +36,7 @@ export function createRequestHandler({
|
|
|
28
36
|
result: await handle(message.params || {}),
|
|
29
37
|
});
|
|
30
38
|
} catch (error) {
|
|
31
|
-
|
|
32
|
-
id: message.id,
|
|
33
|
-
error: { code: -32000, message: error.message },
|
|
34
|
-
});
|
|
39
|
+
sendError(client, message, error.message);
|
|
35
40
|
}
|
|
36
41
|
return true;
|
|
37
42
|
}
|
|
@@ -39,13 +44,8 @@ export function createRequestHandler({
|
|
|
39
44
|
if (await dispatchLocal(offline, client, message)) return;
|
|
40
45
|
const threadId = message.params?.threadId;
|
|
41
46
|
if (threadId && releasing.has(threadId)) await releasing.get(threadId);
|
|
42
|
-
if (!transport.ready)
|
|
43
|
-
|
|
44
|
-
id: message.id,
|
|
45
|
-
error: { code: -32000, message: "正在连接 Codex,请稍后重试。" },
|
|
46
|
-
});
|
|
47
|
-
return;
|
|
48
|
-
}
|
|
47
|
+
if (!transport.ready)
|
|
48
|
+
return sendError(client, message, "正在连接 Codex,请稍后重试。");
|
|
49
49
|
if (await dispatchLocal(online, client, message)) return;
|
|
50
50
|
if (message.method) {
|
|
51
51
|
try {
|
|
@@ -60,11 +60,7 @@ export function createRequestHandler({
|
|
|
60
60
|
),
|
|
61
61
|
});
|
|
62
62
|
} catch (error) {
|
|
63
|
-
|
|
64
|
-
id: message.id,
|
|
65
|
-
error: { code: -32000, message: error.message },
|
|
66
|
-
});
|
|
67
|
-
return;
|
|
63
|
+
return sendError(client, message, error.message);
|
|
68
64
|
}
|
|
69
65
|
|
|
70
66
|
if (
|
|
@@ -88,18 +84,50 @@ export function createRequestHandler({
|
|
|
88
84
|
...message.params,
|
|
89
85
|
config: { ...message.params?.config, thread_unload_delay_secs: 0 },
|
|
90
86
|
};
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
87
|
+
if (
|
|
88
|
+
message.method === "thread/list" &&
|
|
89
|
+
message.params?.modelProviders === undefined
|
|
90
|
+
)
|
|
91
|
+
message.params = { ...message.params, modelProviders: [] };
|
|
92
|
+
const includeStreaming =
|
|
93
|
+
Boolean(threadId) &&
|
|
94
|
+
["thread/items/list", "thread/turns/list"].includes(message.method) &&
|
|
95
|
+
!message.params.cursor &&
|
|
96
|
+
message.params.includeStreaming === true;
|
|
97
|
+
if (message.params && Object.hasOwn(message.params, "includeStreaming")) {
|
|
98
|
+
const { includeStreaming: _includeStreaming, ...params } =
|
|
99
|
+
message.params;
|
|
100
|
+
message.params = params;
|
|
101
|
+
}
|
|
102
|
+
if (
|
|
103
|
+
backgroundCall &&
|
|
104
|
+
terminalMethods.has(message.method) &&
|
|
105
|
+
includeBackground()
|
|
106
|
+
) {
|
|
107
|
+
const release = retainThread(threadId);
|
|
108
|
+
try {
|
|
109
|
+
await resumeForWrite(threadId);
|
|
110
|
+
await waitForBackgroundHandoff(threadId);
|
|
111
|
+
send(client, {
|
|
112
|
+
id: message.id,
|
|
113
|
+
result: await backgroundCall(message.method, message.params),
|
|
114
|
+
});
|
|
115
|
+
} catch (error) {
|
|
116
|
+
sendError(client, message, error.message);
|
|
117
|
+
} finally {
|
|
118
|
+
release();
|
|
119
|
+
}
|
|
101
120
|
return;
|
|
102
121
|
}
|
|
122
|
+
const id = transport.nextId();
|
|
123
|
+
const forwarded = JSON.stringify({ ...message, id });
|
|
124
|
+
if (Buffer.byteLength(forwarded) > MAX_RPC_MESSAGE_BYTES)
|
|
125
|
+
return sendError(
|
|
126
|
+
client,
|
|
127
|
+
message,
|
|
128
|
+
"单次消息过大(最多 64 MiB),请减少附件后重试。",
|
|
129
|
+
-32600,
|
|
130
|
+
);
|
|
103
131
|
const processId =
|
|
104
132
|
message.method === "command/exec" && message.params?.processId;
|
|
105
133
|
if (processId) {
|
|
@@ -116,13 +144,11 @@ export function createRequestHandler({
|
|
|
116
144
|
transport.pending.delete(id);
|
|
117
145
|
releaseUnusedThreads();
|
|
118
146
|
}
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
},
|
|
125
|
-
});
|
|
147
|
+
sendError(
|
|
148
|
+
client,
|
|
149
|
+
message,
|
|
150
|
+
"请求等待超时;任务可能仍在继续,请刷新会话查看。",
|
|
151
|
+
);
|
|
126
152
|
}, 120000);
|
|
127
153
|
transport.pending.set(id, {
|
|
128
154
|
client,
|
|
@@ -131,6 +157,7 @@ export function createRequestHandler({
|
|
|
131
157
|
processId,
|
|
132
158
|
method: message.method,
|
|
133
159
|
threadId,
|
|
160
|
+
includeStreaming,
|
|
134
161
|
...(message.method === "thread/resume" && {
|
|
135
162
|
resumeParams: message.params,
|
|
136
163
|
}),
|
|
@@ -146,16 +173,18 @@ export function createRequestHandler({
|
|
|
146
173
|
compactions.start(threadId, id);
|
|
147
174
|
if (threadId && loadedThreadMethods.has(message.method)) {
|
|
148
175
|
try {
|
|
149
|
-
await resumeForWrite(
|
|
176
|
+
await resumeForWrite(
|
|
177
|
+
threadId,
|
|
178
|
+
message.method === "mcpServerStatus/list"
|
|
179
|
+
? { inheritPermissions: true }
|
|
180
|
+
: { cwd: message.params?.cwd },
|
|
181
|
+
);
|
|
150
182
|
} catch (error) {
|
|
151
183
|
if (message.method === "thread/compact/start")
|
|
152
184
|
compactions.reject(threadId, id, error.message);
|
|
153
185
|
clearTimeout(timer);
|
|
154
186
|
if (transport.pending.delete(id))
|
|
155
|
-
|
|
156
|
-
id: message.id,
|
|
157
|
-
error: { code: -32000, message: error.message },
|
|
158
|
-
});
|
|
187
|
+
sendError(client, message, error.message);
|
|
159
188
|
releaseUnusedThreads();
|
|
160
189
|
return;
|
|
161
190
|
}
|
|
@@ -0,0 +1,50 @@
|
|
|
1
|
+
export function createStreamingMessages() {
|
|
2
|
+
const threads = new Map();
|
|
3
|
+
function event({ method, params = {} }) {
|
|
4
|
+
const { threadId, turnId, item, itemId, delta } = params;
|
|
5
|
+
if (
|
|
6
|
+
[
|
|
7
|
+
"thread/closed",
|
|
8
|
+
"thread/archived",
|
|
9
|
+
"thread/deleted",
|
|
10
|
+
"turn/started",
|
|
11
|
+
].includes(method)
|
|
12
|
+
) {
|
|
13
|
+
threads.delete(threadId);
|
|
14
|
+
return;
|
|
15
|
+
}
|
|
16
|
+
const messages = threads.get(threadId);
|
|
17
|
+
if (method === "turn/completed") {
|
|
18
|
+
if (messages?.turnId === params.turn.id) threads.delete(threadId);
|
|
19
|
+
return;
|
|
20
|
+
}
|
|
21
|
+
if (method === "item/completed") {
|
|
22
|
+
if (messages?.turnId === turnId) messages.items.delete(item.id);
|
|
23
|
+
return;
|
|
24
|
+
}
|
|
25
|
+
if (
|
|
26
|
+
method !== "item/agentMessage/delta" &&
|
|
27
|
+
!(method === "item/started" && item.type === "agentMessage")
|
|
28
|
+
)
|
|
29
|
+
return;
|
|
30
|
+
if (!messages || messages.turnId !== turnId)
|
|
31
|
+
threads.set(threadId, { turnId, items: new Map() });
|
|
32
|
+
const { items } = threads.get(threadId);
|
|
33
|
+
if (method === "item/started") {
|
|
34
|
+
items.set(item.id, { ...item, turnId });
|
|
35
|
+
} else {
|
|
36
|
+
const message = items.get(itemId) ?? {
|
|
37
|
+
id: itemId,
|
|
38
|
+
turnId,
|
|
39
|
+
type: "agentMessage",
|
|
40
|
+
text: "",
|
|
41
|
+
};
|
|
42
|
+
items.set(itemId, { ...message, text: message.text + delta });
|
|
43
|
+
}
|
|
44
|
+
}
|
|
45
|
+
return {
|
|
46
|
+
event,
|
|
47
|
+
read: (threadId) => [...(threads.get(threadId)?.items.values() ?? [])],
|
|
48
|
+
clear: () => threads.clear(),
|
|
49
|
+
};
|
|
50
|
+
}
|
|
@@ -3,12 +3,22 @@ export function createSubscriptions({
|
|
|
3
3
|
compactions,
|
|
4
4
|
activeTurns,
|
|
5
5
|
activeThreads,
|
|
6
|
+
backgroundHandoffPending = () => false,
|
|
6
7
|
}) {
|
|
7
8
|
const subscriptions = new Map(),
|
|
8
9
|
releasing = new Map(),
|
|
9
|
-
resuming = new Map()
|
|
10
|
+
resuming = new Map(),
|
|
11
|
+
retained = new Map();
|
|
10
12
|
const unwrittenThreads = new Set();
|
|
11
|
-
|
|
13
|
+
const activeGoals = new Set();
|
|
14
|
+
function updateGoal(threadId, goal) {
|
|
15
|
+
if (goal?.status === "active") activeGoals.add(threadId);
|
|
16
|
+
else activeGoals.delete(threadId);
|
|
17
|
+
}
|
|
18
|
+
async function resumeForWrite(
|
|
19
|
+
threadId,
|
|
20
|
+
{ cwd, inheritPermissions = false } = {},
|
|
21
|
+
) {
|
|
12
22
|
if (subscriptions.has(threadId)) return;
|
|
13
23
|
if (!resuming.has(threadId)) {
|
|
14
24
|
const resume = transport
|
|
@@ -16,8 +26,10 @@ export function createSubscriptions({
|
|
|
16
26
|
threadId,
|
|
17
27
|
...(cwd && { cwd }),
|
|
18
28
|
excludeTurns: true,
|
|
19
|
-
|
|
20
|
-
|
|
29
|
+
...(!inheritPermissions && {
|
|
30
|
+
approvalPolicy: "never",
|
|
31
|
+
sandbox: "danger-full-access",
|
|
32
|
+
}),
|
|
21
33
|
config: { thread_unload_delay_secs: 0 },
|
|
22
34
|
})
|
|
23
35
|
.then(({ thread }) => {
|
|
@@ -35,9 +47,12 @@ export function createSubscriptions({
|
|
|
35
47
|
if (
|
|
36
48
|
!transport.ready ||
|
|
37
49
|
compactions.busy(threadId) ||
|
|
50
|
+
activeGoals.has(threadId) ||
|
|
38
51
|
(unwrittenThreads.has(threadId) && owners.size) ||
|
|
39
52
|
activeTurns.has(threadId) ||
|
|
40
53
|
activeThreads.has(threadId) ||
|
|
54
|
+
backgroundHandoffPending(threadId) ||
|
|
55
|
+
retained.has(threadId) ||
|
|
41
56
|
resuming.has(threadId) ||
|
|
42
57
|
releasing.has(threadId) ||
|
|
43
58
|
[...transport.pending.values()].some(
|
|
@@ -75,8 +90,21 @@ export function createSubscriptions({
|
|
|
75
90
|
releasing,
|
|
76
91
|
resuming,
|
|
77
92
|
unwrittenThreads,
|
|
93
|
+
updateGoal,
|
|
78
94
|
resumeForWrite,
|
|
79
95
|
releaseUnusedThreads,
|
|
96
|
+
retainThread(threadId) {
|
|
97
|
+
if (!retained.has(threadId)) retained.set(threadId, new Set());
|
|
98
|
+
const leases = retained.get(threadId);
|
|
99
|
+
const lease = Symbol();
|
|
100
|
+
leases.add(lease);
|
|
101
|
+
return () => {
|
|
102
|
+
leases.delete(lease);
|
|
103
|
+
if (!leases.size && retained.get(threadId) === leases)
|
|
104
|
+
retained.delete(threadId);
|
|
105
|
+
releaseUnusedThreads();
|
|
106
|
+
};
|
|
107
|
+
},
|
|
80
108
|
releaseClient(client) {
|
|
81
109
|
for (const owners of subscriptions.values()) owners.delete(client);
|
|
82
110
|
releaseUnusedThreads();
|
|
@@ -85,7 +113,9 @@ export function createSubscriptions({
|
|
|
85
113
|
subscriptions.clear();
|
|
86
114
|
releasing.clear();
|
|
87
115
|
resuming.clear();
|
|
116
|
+
retained.clear();
|
|
88
117
|
unwrittenThreads.clear();
|
|
118
|
+
activeGoals.clear();
|
|
89
119
|
},
|
|
90
120
|
};
|
|
91
121
|
}
|
|
@@ -38,6 +38,12 @@ export function validateBackend(input, config) {
|
|
|
38
38
|
].includes(input.subagentEffort)
|
|
39
39
|
)
|
|
40
40
|
throw new Error("子代理思考强度无效");
|
|
41
|
+
if (
|
|
42
|
+
input.backgroundTerminalEnabled !== undefined &&
|
|
43
|
+
(input.type !== "codex" ||
|
|
44
|
+
typeof input.backgroundTerminalEnabled !== "boolean")
|
|
45
|
+
)
|
|
46
|
+
throw new Error("后台终端 MCP 开关仅接受 Codex 的布尔设置");
|
|
41
47
|
const backend = {
|
|
42
48
|
id: input.id,
|
|
43
49
|
name: input.type === "codex" ? "Codex" : "Claude Code",
|
|
@@ -70,6 +76,8 @@ export function validateBackend(input, config) {
|
|
|
70
76
|
)
|
|
71
77
|
throw new Error("跨主机后端必须使用 WSS");
|
|
72
78
|
backend.url = url.href;
|
|
79
|
+
backend.backgroundTerminalEnabled =
|
|
80
|
+
input.backgroundTerminalEnabled ?? Boolean(config.backgroundTaskDir);
|
|
73
81
|
if (
|
|
74
82
|
input.hiddenModels !== undefined &&
|
|
75
83
|
(!Array.isArray(input.hiddenModels) ||
|