molta 1.0.2 → 1.0.3

package/README.en.md

@@ -113,6 +113,15 @@ yarn build
 yarn start
 ```
 
+## SEA build (single executable)
+> Requires Node.js 20+ (22+ recommended)
+
+```bash
+yarn build:sea
+```
+
+Output: `dist/molta-sea` (append `.exe` on Windows). Intermediate files in `dist-sea/`.
+
 ## Project Layout
 - `src/router/chat/completions.ts`: main API logic
 - `src/services/gateway.ts`: Clawd gateway WebSocket client

package/README.md

@@ -113,6 +113,15 @@ yarn build
 yarn start
 ```
 
+## SEA 打包（单文件可执行）
+> 需要 Node.js 20+（推荐 22+）
+
+```bash
+yarn build:sea
+```
+
+产物位于 `dist/molta-sea`（Windows 可自行加 `.exe`），中间产物在 `dist-sea/`。
+
 ## 目录结构
 - `src/router/chat/completions.ts`：主接口逻辑
 - `src/services/gateway.ts`：Clawd 网关 WebSocket 客户端

package/dist/index.js

@@ -13,7 +13,7 @@ elysia
     .use(openapi({
     references: fromTypes()
 }));
-elysia.listen(configObject.port, () => {
+elysia.listen({ hostname: configObject.host, port: configObject.port }, () => {
     logger.info(`Server started on http://${configObject.host}:${configObject.port}`);
 });
 logger.info("Initialized server successfully");

package/dist/router/chat/completions.js

@@ -2,6 +2,7 @@ import { Elysia } from "elysia";
 import { GatewayClient } from "../../services/gateway.js";
 import { config } from "../../services/config.js";
 import { expandRandomString, getOrCreateHttpChatId, renewHttpChatId } from "../../utils/random.js";
+import { Readable } from "node:stream";
 function extractLastUserMessage(messages) {
     if (!Array.isArray(messages))
         return null;
@@ -79,6 +80,46 @@ function createSseResponse(replyText, created) {
         },
     });
 }
+function createSseStreamResponse(streamSource, created) {
+    const encoder = new TextEncoder();
+    const nodeStream = Readable.from((async function* () {
+        let sentRole = false;
+        for await (const chunkText of streamSource) {
+            if (!chunkText)
+                continue;
+            const delta = { content: chunkText };
+            if (!sentRole) {
+                delta.role = "assistant";
+                sentRole = true;
+            }
+            const chunk = {
+                id: `chatcmpl-clawd-${created}`,
+                object: "chat.completion.chunk",
+                created,
+                model: "clawd",
+                choices: [{ index: 0, delta, finish_reason: null }],
+            };
+            yield encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`);
+        }
+        const done = {
+            id: `chatcmpl-clawd-${created}`,
+            object: "chat.completion.chunk",
+            created,
+            model: "clawd",
+            choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+        };
+        yield encoder.encode(`data: ${JSON.stringify(done)}\n\n`);
+        yield encoder.encode("data: [DONE]\n\n");
+    })());
+    const webStream = Readable.toWeb(nodeStream);
+    return new Response(webStream, {
+        headers: {
+            "Content-Type": "text/event-stream; charset=utf-8",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}
 export const completions = new Elysia()
     .use(config)
     .post("/v1/chat/completions", async ({ request, body, set, store }) => {
@@ -111,6 +152,11 @@ export const completions = new Elysia()
         const token = store.config?.clawdToken;
         const gateway = new GatewayClient(host, port, token);
         try {
+            if (payload.stream) {
+                const created = Math.floor(Date.now() / 1000);
+                const source = gateway.askStream(lastUser, sessionKey);
+                return createSseStreamResponse(source, created);
+            }
             replyText = await gateway.ask(lastUser, sessionKey);
         }
         catch (error) {

package/dist/services/gateway.js

@@ -139,4 +139,190 @@ export class GatewayClient {
             };
         }));
     }
+    async *askStream(prompt, session) {
+        const queue = [];
+        let done = false;
+        let error = null;
+        let notify = null;
+        const push = (value) => {
+            if (!value)
+                return;
+            queue.push(value);
+            if (notify) {
+                notify();
+                notify = null;
+            }
+        };
+        const finish = () => {
+            done = true;
+            if (notify) {
+                notify();
+                notify = null;
+            }
+        };
+        const fail = (err) => {
+            error = err;
+            done = true;
+            if (notify) {
+                notify();
+                notify = null;
+            }
+        };
+        const ws = new WebSocket(`ws://${this.host}:${this.port}`);
+        let run_id = null;
+        let settled = false;
+        let lastAssistant = "";
+        const timeout = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            ws.close();
+            fail(new Error("gateway timeout"));
+        }, 60_000);
+        const finalize = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            ws.close();
+            finish();
+        };
+        const finalizeReject = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            ws.close();
+            fail(err);
+        };
+        ws.onmessage = ({ data }) => {
+            let obj;
+            try {
+                obj = JSON.parse(data);
+            }
+            catch (err) {
+                finalizeReject(err instanceof Error ? err : new Error("invalid gateway payload"));
+                return;
+            }
+            if (obj.type === "event" && obj.event === "connect.challenge") {
+                ws.send(JSON.stringify({
+                    "type": "req",
+                    "id": "connect",
+                    "method": "connect",
+                    "params": {
+                        "minProtocol": 3,
+                        "maxProtocol": 3,
+                        "client": {
+                            "id": "gateway-client",
+                            "version": "0.1.0",
+                            "platform": this.platform,
+                            "mode": "backend",
+                        },
+                        "role": "operator",
+                        "scopes": ["operator.read", "operator.write"],
+                        "auth": { "token": this.token },
+                        "locale": "zh-CN",
+                        "userAgent": "openai-clawdbot-bridge",
+                    },
+                }));
+                return;
+            }
+            if (obj["type"] === "res" && obj["id"] === "connect") {
+                if (!(obj["ok"])) {
+                    finalizeReject(new Error((obj["error"] || {})["message"] || "connect failed"));
+                    return;
+                }
+                ws.send(JSON.stringify({
+                    "type": "req",
+                    "id": "agent",
+                    "method": "agent",
+                    "params": {
+                        "message": prompt,
+                        "agentId": "main",
+                        "sessionKey": session,
+                        "deliver": false,
+                        "idempotencyKey": crypto.randomUUID(),
+                    },
+                }));
+                return;
+            }
+            if (obj["type"] === "res" && obj["id"] === "agent") {
+                if (!(obj["ok"])) {
+                    finalizeReject(new Error((obj["error"] ?? {})["message"] || "agent failed"));
+                    return;
+                }
+                const payload = obj["payload"] || {};
+                if (payload["runId"]) {
+                    run_id = payload["runId"];
+                }
+                return;
+            }
+            if (obj["type"] === "event" && obj["event"] === "agent") {
+                const payload = obj["payload"] || {};
+                if (payload["runId"] !== run_id)
+                    return;
+                if (payload["stream"] === "assistant") {
+                    const data = payload["data"] || {};
+                    if (typeof data["text"] === "string") {
+                        const text = data["text"];
+                        let delta = text;
+                        if (text.startsWith(lastAssistant)) {
+                            delta = text.slice(lastAssistant.length);
+                        }
+                        lastAssistant = text;
+                        push(delta);
+                    }
+                }
+                else if (typeof payload["delta"] === "string") {
+                    push(payload["delta"]);
+                }
+                if (payload["stream"] === "lifecycle") {
+                    const phase = (payload["data"] || {})["phase"];
+                    if (phase === "end") {
+                        finalize();
+                    }
+                    else if (phase === "error") {
+                        finalizeReject(new Error((payload["data"] || {})["message"] || "agent failed"));
+                    }
+                }
+            }
+        };
+        ws.onerror = () => {
+            const detail = ws.readyState === WebSocket.CLOSED ? "closed" : `state:${ws.readyState}`;
+            finalizeReject(new Error(`gateway websocket error (${detail}) url=${ws.url}`));
+        };
+        ws.onclose = (event) => {
+            if (settled)
+                return;
+            if (event.wasClean) {
+                finalize();
+                return;
+            }
+            const reason = event.reason ? ` reason=${event.reason}` : "";
+            finalizeReject(new Error(`gateway websocket closed code=${event.code}${reason} url=${ws.url}`));
+        };
+        try {
+            while (true) {
+                if (queue.length) {
+                    yield queue.shift();
+                    continue;
+                }
+                if (done) {
+                    if (error)
+                        throw error;
+                    return;
+                }
+                await new Promise((resolve) => {
+                    notify = resolve;
+                });
+            }
+        }
+        finally {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timeout);
+                ws.close();
+            }
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "molta",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Use MoltBot anywhere",
   "type": "module",
   "packageManager": "yarn@4.12.0",
@@ -11,6 +11,7 @@
   "license": "ISC",
   "scripts": {
     "build": "tsc",
+    "build:sea": "tsc -p tsconfig.sea.json && node -e \"const fs=require('fs');fs.renameSync('dist-sea/index.js','dist-sea/index.cjs')\" && node --build-sea sea-config.json",
     "dev": "tsx src/index.ts",
     "prepublishOnly": "yarn build && node scripts/add-shebang.cjs",
     "start": "node dist/index.js"