Repository navigation
Expand file tree
/
Copy pathhttp.ts
More file actions
248 lines (239 loc) · 8.13 KB
/
Copy pathhttp.ts
File metadata and controls
248 lines (239 loc) · 8.13 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
import { randomUUID } from "node:crypto";
import { hostname } from "node:os";
import { serve } from "@hono/node-server";
import { createNodeWebSocket } from "@hono/node-ws";
import { Hono } from "hono";
import type { WebSocket } from "ws";
import type { WebSocketServer } from "ws";
import {
Emitter,
VSBuffer,
SocketProtocol,
ChannelServer,
LoggingChannelServer,
type ISocket,
} from "@zcode/rpc";
import {
createZCodeAgentConnectionScope,
IZCodeAgentService,
ServiceCollection,
} from "@zcode/services";
import { createServiceLogger } from "@zcode/services/node";
import {
SERVER_REMOTE_PROTOCOL_VERSION,
ZCODE_RPC_HOST_CAPABILITY_HEADER,
ZCODE_VERSION,
type ServerRemoteInfo,
} from "@zcode/shared";
import { createHostCapabilityStore, type HostCapabilityStore } from "./hostCapability.js";
interface CoreHttpServer {
host: string;
port: number;
close: () => Promise<void>;
}
const WEBSOCKET_DRAIN_TIMEOUT_MS = 250;
const log = createServiceLogger("server-core");
// ── WS 层 ping/pong 死连接清理 ─────────────────────────────────────────────
// 修复依据:这条链路此前零存活探测,
// 半开连接永远占用服务端资源、也无法通过 terminate 触发浏览器侧 close → 软重连。
// 浏览器网络栈自动回 pong(不依赖页面 JS 计时器,后台冻结页也能回);连续 2 个
// 周期无 pong 即 terminate。与 packages/server/src/http.ts 保持同一参数与语义。
const WS_PING_INTERVAL_MS = 30_000;
const WS_PING_MISS_LIMIT = 4;
// 手机 Chrome 对后台页面的 WS ping 响应会被省电策略延迟/停止(实测
// 45-60s 即失联),2 次 miss(65s)会误杀仍可能活着的连接。放宽到 4 次
// (约 2.5 分钟)——页面进程真死时浏览器 close 事件仍会到达(客户端软重连
// 兜底),这里只是不再主动 terminate 还可能活着的连接。
function startWebSocketPingLoop(ws: WebSocket): () => void {
let missedPongs = 0;
let alive = false;
let stopped = false;
const stop = () => {
if (stopped) return;
stopped = true;
clearInterval(timer);
ws.off("pong", onPong);
ws.off("close", stop);
ws.off("error", stop);
};
const onPong = () => {
alive = true;
};
const timer = setInterval(() => {
if (!alive) {
missedPongs += 1;
if (missedPongs >= WS_PING_MISS_LIMIT) {
stop();
ws.terminate();
return;
}
} else {
missedPongs = 0;
}
alive = false;
try {
ws.ping();
} catch {
stop();
ws.terminate();
}
}, WS_PING_INTERVAL_MS);
ws.on("pong", onPong);
ws.on("close", stop);
ws.on("error", stop);
return stop;
}
async function closeWebSocketServer(wss: WebSocketServer): Promise<void> {
for (const client of wss.clients) {
// HTTP server.close() 不会收敛已经 upgrade 的 WebSocket,活跃 desktop
// continuous 连接会让 Core 的 shutdown ack 永远发不出去。先发 close frame 给正常
// 客户端一个短暂排空窗口,再 terminate 兜底,保证 Supervisor 能在预算内释放资源。
client.close(1001, "Server shutting down");
}
const deadline = Date.now() + WEBSOCKET_DRAIN_TIMEOUT_MS;
while (wss.clients.size > 0 && Date.now() < deadline) {
await new Promise<void>((resolve) => setTimeout(resolve, 10));
}
for (const client of wss.clients) client.terminate();
await new Promise<void>((resolve, reject) => {
wss.close((error?: Error) => (error ? reject(error) : resolve()));
});
}
function isLoopbackHost(host: string): boolean {
const normalized = host.trim().toLowerCase();
return normalized === "127.0.0.1" || normalized === "::1" || normalized === "localhost";
}
function wrapWebSocket(ws: WebSocket): ISocket {
const data = new Emitter<VSBuffer>();
const close = new Emitter<void>();
ws.on("message", (raw) =>
data.fire(VSBuffer.wrap(Buffer.isBuffer(raw) ? raw : Buffer.from(raw as ArrayBuffer))),
);
ws.on("close", () => close.fire());
ws.on("error", () => close.fire());
return {
onData: data.event,
onClose: close.event,
onEnd: close.event,
write(buffer) {
if (ws.readyState === ws.OPEN) ws.send(buffer.buffer);
},
end() {
ws.close();
},
drain() {
return Promise.resolve();
},
dispose() {
ws.close();
},
};
}
function exposeWebSocket(
ws: WebSocket,
services: ServiceCollection,
clientMode: "desktop-continuous" | "web-remote-replayable",
): void {
startWebSocketPingLoop(ws);
const socket = wrapWebSocket(ws);
const protocol = new SocketProtocol(socket);
const rawServer = new ChannelServer(protocol, "server");
const server = new LoggingChannelServer(rawServer, (...args) => log.debug(undefined, ...args));
const agentService = services.getOptional(IZCodeAgentService);
const scope = agentService
? createZCodeAgentConnectionScope(agentService, {
connectionId: `server-core-ws-${randomUUID()}`,
clientMode,
role: clientMode === "desktop-continuous" ? "trusted-host-relay" : "terminal-client",
})
: undefined;
services.exposeOnChannelServer(
server,
scope ? new Map([[IZCodeAgentService.channelName, scope.service]]) : new Map(),
);
socket.onClose(() => {
void scope?.dispose();
rawServer.dispose();
});
}
export async function createCoreHttpServer(
services: ServiceCollection,
options: {
host?: string;
port?: number;
serverId?: string;
hostCapabilityStore?: HostCapabilityStore;
} = {},
): Promise<CoreHttpServer> {
const app = new Hono();
const { injectWebSocket, upgradeWebSocket, wss } = createNodeWebSocket({ app });
const host = options.host ?? "127.0.0.1";
if (!isLoopbackHost(host)) {
// 当前只有本机/SSH 隧道入口,Core 尚未接入 token middleware;对外监听必须 fail-closed。
throw new Error(
`Non-loopback host ${host} requires authentication before the server can listen`,
);
}
const info: ServerRemoteInfo = {
serverId: options.serverId ?? hostname() ?? "zcode-server",
version: ZCODE_VERSION,
protocolVersion: SERVER_REMOTE_PROTOCOL_VERSION,
authRequired: false,
workspaces: [],
capabilities: {
desktopContinuous: true,
websocketRpc: true,
processResourceTelemetry: true,
},
};
// 裸 Set 无法落实 expiresAt,未消费的 capability 会一直有效并持续累积。
// 使用与 packages/server 兼容的 TTL 一次性 store,使有效期和消费语义与返回信息一致。
const capabilities = options.hostCapabilityStore ?? createHostCapabilityStore();
app.get("/api/server-info", (context) => context.json(info));
app.get(
"/ws",
upgradeWebSocket(() => ({
onOpen(_event, socket) {
exposeWebSocket(socket.raw as WebSocket, services, "web-remote-replayable");
},
})),
);
app.use("/ws/host", async (context, next) => {
const capability = context.req.header(ZCODE_RPC_HOST_CAPABILITY_HEADER);
if (!capabilities.consume(capability)) {
return context.json({ error: "Invalid or expired host capability" }, 401);
}
await next();
});
app.get(
"/ws/host",
upgradeWebSocket(() => ({
onOpen(_event, socket) {
exposeWebSocket(socket.raw as WebSocket, services, "desktop-continuous");
},
})),
);
app.post("/api/rpc-host-capability", (context) => context.json(capabilities.issue()));
let resolveListening: (value: { port: number }) => void = () => undefined;
const listening = new Promise<{ port: number }>((resolve) => {
resolveListening = resolve;
});
const server = serve({ fetch: app.fetch, hostname: host, port: options.port ?? 0 }, () => {
const address = server.address();
resolveListening({
port: typeof address === "object" && address ? address.port : (options.port ?? 0),
});
});
injectWebSocket(server);
const { port } = await listening;
return {
host,
port,
close: async () => {
await closeWebSocketServer(wss);
await new Promise<void>((resolve, reject) =>
server.close((error?: Error) => (error ? reject(error) : resolve())),
);
},
};
}