@botlearn-course/daemon 0.0.2 → 0.0.3

package/dist/websocket-client.js

@@ -0,0 +1,320 @@
+import { createHash, randomBytes } from "node:crypto";
+import { EventEmitter } from "node:events";
+import net from "node:net";
+import tls from "node:tls";
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSING = 2;
+const CLOSED = 3;
+const HANDSHAKE_MAX_BYTES = 16 * 1024;
+const WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+function framePayload(opcode, payload) {
+    const mask = randomBytes(4);
+    let header;
+    if (payload.length < 126) {
+        header = Buffer.allocUnsafe(2);
+        header[1] = 0x80 | payload.length;
+    }
+    else if (payload.length <= 0xffff) {
+        header = Buffer.allocUnsafe(4);
+        header[1] = 0x80 | 126;
+        header.writeUInt16BE(payload.length, 2);
+    }
+    else {
+        header = Buffer.allocUnsafe(10);
+        header[1] = 0x80 | 127;
+        header.writeBigUInt64BE(BigInt(payload.length), 2);
+    }
+    header[0] = 0x80 | opcode;
+    const masked = Buffer.allocUnsafe(payload.length);
+    for (let index = 0; index < payload.length; index += 1) {
+        masked[index] = payload[index] ^ mask[index % 4];
+    }
+    return Buffer.concat([header, mask, masked]);
+}
+/**
+ * Narrow RFC 6455 client for the daemon control plane.
+ *
+ * It intentionally supports only text/control frames, no extensions, and one configured
+ * subprotocol. Keeping this transport on Node built-ins preserves the daemon's zero
+ * production-dependency release invariant.
+ */
+export class WebSocketClient extends EventEmitter {
+    options;
+    static CONNECTING = CONNECTING;
+    static OPEN = OPEN;
+    static CLOSING = CLOSING;
+    static CLOSED = CLOSED;
+    url;
+    requestedProtocol;
+    maxPayload;
+    protocol = "";
+    readyState = CONNECTING;
+    socket = null;
+    handshakeBuffer = Buffer.alloc(0);
+    frameBuffer = Buffer.alloc(0);
+    fragmentedOpcode = null;
+    fragmentedChunks = [];
+    fragmentedBytes = 0;
+    closeEmitted = false;
+    closeSent = false;
+    constructor(rawUrl, protocol, options = {}) {
+        super();
+        this.options = options;
+        this.url = new URL(rawUrl);
+        if (!["ws:", "wss:"].includes(this.url.protocol)) {
+            throw new Error("WebSocket URL must use ws:// or wss://");
+        }
+        if (!protocol || /[,\s]/.test(protocol)) {
+            throw new Error("WebSocket subprotocol is invalid");
+        }
+        this.requestedProtocol = protocol;
+        this.maxPayload = options.maxPayload ?? 262_144;
+        queueMicrotask(() => this.connect());
+    }
+    send(data, callback) {
+        if (this.readyState !== OPEN || !this.socket) {
+            callback?.(new Error("WebSocket is not open"));
+            return;
+        }
+        const payload = Buffer.from(data, "utf8");
+        if (payload.length > this.maxPayload) {
+            callback?.(new Error("WebSocket payload exceeds configured limit"));
+            return;
+        }
+        this.socket.write(framePayload(0x1, payload), (error) => callback?.(error ?? undefined));
+    }
+    close(code = 1000, reason = "") {
+        if (this.readyState === CLOSED)
+            return;
+        if (this.readyState === CONNECTING) {
+            this.readyState = CLOSING;
+            this.socket?.destroy();
+            return;
+        }
+        if (this.readyState === OPEN && this.socket && !this.closeSent) {
+            const reasonBytes = Buffer.from(reason, "utf8").subarray(0, 123);
+            const payload = Buffer.allocUnsafe(2 + reasonBytes.length);
+            payload.writeUInt16BE(code, 0);
+            reasonBytes.copy(payload, 2);
+            this.closeSent = true;
+            this.readyState = CLOSING;
+            this.socket.write(framePayload(0x8, payload));
+            const timer = setTimeout(() => this.socket?.end(), 1_000);
+            timer.unref();
+        }
+    }
+    connect() {
+        const secure = this.url.protocol === "wss:";
+        const port = Number(this.url.port || (secure ? 443 : 80));
+        const host = this.url.hostname;
+        const onConnect = () => this.sendHandshake();
+        const socket = secure
+            ? tls.connect({ host, port, servername: host }, onConnect)
+            : net.connect({ host, port }, onConnect);
+        this.socket = socket;
+        socket.on("data", (chunk) => this.onData(Buffer.from(chunk)));
+        socket.on("error", (error) => this.emit("error", error));
+        socket.on("close", () => this.emitClose(1006, "connection_closed"));
+    }
+    sendHandshake() {
+        if (!this.socket || this.readyState !== CONNECTING)
+            return;
+        const key = randomBytes(16).toString("base64");
+        const requestPath = `${this.url.pathname || "/"}${this.url.search}`;
+        const host = this.url.port ? `${this.url.hostname}:${this.url.port}` : this.url.hostname;
+        const headers = {
+            Host: host,
+            Upgrade: "websocket",
+            Connection: "Upgrade",
+            "Sec-WebSocket-Key": key,
+            "Sec-WebSocket-Version": "13",
+            "Sec-WebSocket-Protocol": this.requestedProtocol,
+            ...this.options.headers,
+        };
+        const expectedAccept = createHash("sha1")
+            .update(`${key}${WEBSOCKET_GUID}`)
+            .digest("base64");
+        this.once("handshake", (responseHeaders) => {
+            if (responseHeaders["sec-websocket-accept"] !== expectedAccept) {
+                this.failProtocol("invalid Sec-WebSocket-Accept");
+            }
+        });
+        const lines = [
+            `GET ${requestPath} HTTP/1.1`,
+            ...Object.entries(headers).map(([name, value]) => `${name}: ${value}`),
+            "",
+            "",
+        ];
+        this.socket.write(lines.join("\r\n"));
+    }
+    onData(chunk) {
+        if (this.readyState === CONNECTING) {
+            this.handshakeBuffer = Buffer.concat([this.handshakeBuffer, chunk]);
+            if (this.handshakeBuffer.length > HANDSHAKE_MAX_BYTES) {
+                this.failProtocol("WebSocket upgrade response is too large");
+                return;
+            }
+            const boundary = this.handshakeBuffer.indexOf("\r\n\r\n");
+            if (boundary < 0)
+                return;
+            const head = this.handshakeBuffer.subarray(0, boundary).toString("latin1");
+            const rest = this.handshakeBuffer.subarray(boundary + 4);
+            this.handshakeBuffer = Buffer.alloc(0);
+            const lines = head.split("\r\n");
+            const match = /^HTTP\/1\.[01] (\d{3})/.exec(lines.shift() ?? "");
+            const statusCode = Number(match?.[1] ?? 0);
+            const headers = {};
+            for (const line of lines) {
+                const separator = line.indexOf(":");
+                if (separator <= 0)
+                    continue;
+                headers[line.slice(0, separator).trim().toLowerCase()] = line
+                    .slice(separator + 1)
+                    .trim();
+            }
+            if (statusCode !== 101) {
+                this.emit("unexpected-response", null, { statusCode });
+                this.socket?.destroy();
+                return;
+            }
+            if (headers.upgrade?.toLowerCase() !== "websocket") {
+                this.failProtocol("invalid WebSocket Upgrade header");
+                return;
+            }
+            if (!headers.connection
+                ?.split(",")
+                .some((value) => value.trim().toLowerCase() === "upgrade")) {
+                this.failProtocol("invalid WebSocket Connection header");
+                return;
+            }
+            if (headers["sec-websocket-protocol"] !== this.requestedProtocol) {
+                this.failProtocol("WebSocket subprotocol mismatch");
+                return;
+            }
+            this.protocol = headers["sec-websocket-protocol"];
+            this.emit("handshake", headers);
+            if (!this.socket || this.socket.destroyed)
+                return;
+            this.readyState = OPEN;
+            this.emit("open");
+            if (rest.length > 0)
+                this.consumeFrames(rest);
+            return;
+        }
+        this.consumeFrames(chunk);
+    }
+    consumeFrames(chunk) {
+        this.frameBuffer = Buffer.concat([this.frameBuffer, chunk]);
+        while (this.frameBuffer.length >= 2) {
+            const first = this.frameBuffer[0];
+            const second = this.frameBuffer[1];
+            const fin = (first & 0x80) !== 0;
+            const rsv = first & 0x70;
+            const opcode = first & 0x0f;
+            const masked = (second & 0x80) !== 0;
+            let payloadLength = second & 0x7f;
+            let offset = 2;
+            if (rsv !== 0 || masked) {
+                this.failProtocol("unsupported or masked server WebSocket frame");
+                return;
+            }
+            if (payloadLength === 126) {
+                if (this.frameBuffer.length < 4)
+                    return;
+                payloadLength = this.frameBuffer.readUInt16BE(2);
+                offset = 4;
+            }
+            else if (payloadLength === 127) {
+                if (this.frameBuffer.length < 10)
+                    return;
+                const longLength = this.frameBuffer.readBigUInt64BE(2);
+                if (longLength > BigInt(Number.MAX_SAFE_INTEGER)) {
+                    this.failProtocol("WebSocket frame length is unsafe");
+                    return;
+                }
+                payloadLength = Number(longLength);
+                offset = 10;
+            }
+            if (payloadLength > this.maxPayload || this.fragmentedBytes + payloadLength > this.maxPayload) {
+                this.failProtocol("WebSocket payload exceeds configured limit");
+                return;
+            }
+            if (this.frameBuffer.length < offset + payloadLength)
+                return;
+            const payload = this.frameBuffer.subarray(offset, offset + payloadLength);
+            this.frameBuffer = this.frameBuffer.subarray(offset + payloadLength);
+            if (opcode >= 0x8 && (!fin || payloadLength > 125)) {
+                this.failProtocol("invalid WebSocket control frame");
+                return;
+            }
+            if (opcode === 0x8) {
+                const code = payload.length >= 2 ? payload.readUInt16BE(0) : 1000;
+                const reason = payload.length > 2 ? payload.subarray(2).toString("utf8") : "closed";
+                if (!this.closeSent && this.socket) {
+                    this.closeSent = true;
+                    this.socket.write(framePayload(0x8, payload));
+                }
+                this.socket?.end();
+                this.emitClose(code, reason);
+                return;
+            }
+            if (opcode === 0x9) {
+                this.socket?.write(framePayload(0xA, payload));
+                continue;
+            }
+            if (opcode === 0xA)
+                continue;
+            if (opcode === 0x0) {
+                if (this.fragmentedOpcode === null) {
+                    this.failProtocol("unexpected WebSocket continuation frame");
+                    return;
+                }
+                this.fragmentedChunks.push(Buffer.from(payload));
+                this.fragmentedBytes += payload.length;
+                if (fin)
+                    this.emitFragmentedMessage();
+                continue;
+            }
+            if (opcode !== 0x1 && opcode !== 0x2) {
+                this.failProtocol("unsupported WebSocket data opcode");
+                return;
+            }
+            if (this.fragmentedOpcode !== null) {
+                this.failProtocol("interleaved fragmented WebSocket message");
+                return;
+            }
+            if (fin) {
+                this.emit("message", Buffer.from(payload), opcode === 0x2);
+            }
+            else {
+                this.fragmentedOpcode = opcode;
+                this.fragmentedChunks = [Buffer.from(payload)];
+                this.fragmentedBytes = payload.length;
+            }
+        }
+    }
+    emitFragmentedMessage() {
+        const opcode = this.fragmentedOpcode;
+        const payload = Buffer.concat(this.fragmentedChunks);
+        this.fragmentedOpcode = null;
+        this.fragmentedChunks = [];
+        this.fragmentedBytes = 0;
+        this.emit("message", payload, opcode === 0x2);
+    }
+    failProtocol(reason) {
+        const error = new Error(reason);
+        this.emit("error", error);
+        if (this.readyState === OPEN)
+            this.close(1002, "protocol_error");
+        else
+            this.socket?.destroy();
+    }
+    emitClose(code, reason) {
+        if (this.closeEmitted)
+            return;
+        this.closeEmitted = true;
+        this.readyState = CLOSED;
+        this.emit("close", code, Buffer.from(reason, "utf8"));
+    }
+}

package/dist/workspace.d.ts

@@ -17,7 +17,16 @@ export declare function runRootDir(agentRunId: string): string;
 export declare function runWorkspaceDir(agentRunId: string): string;
 export declare function transcriptPath(agentRunId: string): string;
 export declare function runtimeProfileDir(agentRunId: string): string;
+export declare function runtimeProfileRunRootDir(agentRunId: string): string;
+export declare function runtimeSessionRootDir(runtimeSessionId: string, sessionGeneration: number): string;
+export declare function runtimeSessionWorkspaceDir(runtimeSessionId: string, sessionGeneration: number): string;
+export declare function runtimeSessionTranscriptPath(runtimeSessionId: string, sessionGeneration: number, agentRunId: string): string;
 export declare function ensureRunWorkspace(agentRunId: string): {
     rootDir: string;
     workspaceDir: string;
 };
+export declare function ensureRuntimeSessionWorkspace(runtimeSessionId: string, sessionGeneration: number, agentRunId: string): {
+    rootDir: string;
+    workspaceDir: string;
+    transcriptFile: string;
+};

package/dist/workspace.js

@@ -1,4 +1,4 @@
-import { chmodSync, mkdirSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { daemonHome } from "./auth-store.js";
 /**
@@ -33,7 +33,32 @@ export function transcriptPath(agentRunId) {
     return path.join(runRootDir(agentRunId), "transcript.jsonl");
 }
 export function runtimeProfileDir(agentRunId) {
-    return path.join(runRootDir(agentRunId), "runtime-profile");
+    assertSafeId(agentRunId, "agent_run_id");
+    const managedRoot = process.env.BOTLEARN_AGENT_SERVICE_PROFILE_ROOT?.trim();
+    return managedRoot
+        ? path.join(managedRoot, agentRunId, "runtime-profile")
+        : path.join(runRootDir(agentRunId), "runtime-profile");
+}
+export function runtimeProfileRunRootDir(agentRunId) {
+    return path.dirname(runtimeProfileDir(agentRunId));
+}
+export function runtimeSessionRootDir(runtimeSessionId, sessionGeneration) {
+    assertSafeId(runtimeSessionId, "runtime_session_id");
+    if (!Number.isInteger(sessionGeneration) || sessionGeneration < 1) {
+        throw new Error("unsafe session_generation: expected a positive integer");
+    }
+    return path.join(daemonHome(), "agent-service-sessions", runtimeSessionId, `generation-${sessionGeneration}`);
+}
+export function runtimeSessionWorkspaceDir(runtimeSessionId, sessionGeneration) {
+    const managedRoot = process.env.BOTLEARN_AGENT_SERVICE_WORKSPACE_ROOT?.trim();
+    if (managedRoot) {
+        return path.join(managedRoot, runtimeSessionId, `generation-${sessionGeneration}`);
+    }
+    return path.join(runtimeSessionRootDir(runtimeSessionId, sessionGeneration), "workspace");
+}
+export function runtimeSessionTranscriptPath(runtimeSessionId, sessionGeneration, agentRunId) {
+    assertSafeId(agentRunId, "agent_run_id");
+    return path.join(runtimeSessionRootDir(runtimeSessionId, sessionGeneration), "transcripts", `${agentRunId}.jsonl`);
 }
 // recursive mkdir 只对新建目录生效 mode，已存在目录需 best-effort 收紧。
 function mkdirTolerant(dir) {
@@ -52,3 +77,19 @@ export function ensureRunWorkspace(agentRunId) {
     mkdirTolerant(workspaceDir);
     return { rootDir, workspaceDir };
 }
+export function ensureRuntimeSessionWorkspace(runtimeSessionId, sessionGeneration, agentRunId) {
+    const rootDir = runtimeSessionRootDir(runtimeSessionId, sessionGeneration);
+    const workspaceDir = runtimeSessionWorkspaceDir(runtimeSessionId, sessionGeneration);
+    const transcriptFile = runtimeSessionTranscriptPath(runtimeSessionId, sessionGeneration, agentRunId);
+    mkdirTolerant(rootDir);
+    if (process.env.BOTLEARN_AGENT_SERVICE_WORKSPACE_ROOT?.trim()) {
+        if (!existsSync(workspaceDir)) {
+            throw new Error("managed runtime session workspace was not prepared by the supervisor");
+        }
+    }
+    else {
+        mkdirTolerant(workspaceDir);
+    }
+    mkdirTolerant(path.dirname(transcriptFile));
+    return { rootDir, workspaceDir, transcriptFile };
+}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@botlearn-course/daemon",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Lightweight BotLearn Course daemon: run course tasks on your own machine with your own agent runtime (BYOA).",
   "type": "module",
   "bin": {
-    "botlearn-course-daemon": "dist/cli.js"
+    "botlearn-course-daemon": "dist/cli.js",
+    "botlearn-sandbox-supervisor": "dist/sandbox-supervisor.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",