molta 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Veria
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+<h1 align="center">Molta</h1>
+<h3 align="center">✨ 在任意地方使用 MoltBot 🚀</h3>
+
+Molta 是一个轻量的 HTTP 网关：将类 OpenAI 的 `v1/chat/completions` 请求转发到本地 Clawd 网关（WebSocket），并返回兼容响应，方便你在现有客户端中直接使用 MoltBot。
+
+## 特性
+- OpenAI 风格接口：`/v1/chat/completions`、`/v1/models`
+- 内置鉴权：使用 `TOKEN` 进行 Bearer 校验
+- 支持流式响应（SSE）
+- 会话复用与快速创建新会话指令
+
+## 快速开始
+> 需要 Node.js 20+ 与 Yarn 4.10.x
+
+```bash
+yarn install
+yarn dev
+```
+
+启动后默认监听 `http://127.0.0.1:8090`。
+
+## 环境变量
+项目会读取 `.env` 并校验（见 `schema.json`）。
+
+必填：
+- `TOKEN`：HTTP 接口鉴权 Token
+- `CLAWD_TOKEN`：Clawd 网关鉴权 Token
+
+可选：
+- `HOST`：监听地址，默认 `localhost`
+- `PORT`：监听端口，默认 `8090`
+- `CLAWD_HOST`：Clawd 网关地址，默认 `localhost`，
+  - 如您使用 Docker 部署 MoltBot(Clawd) 以及 Molta，请设置为`<Clawd Container ID>`，
+  - 如您使用NPM Binary部署 MoltBot(Clawd) 以及 Molta，请设置为`localhost`(如果使用 Docker 部署 MoltBot(Clawd) 但使用NPM Binary部署 Molta 也同样设置为此 HOST)
+  - 如您使用 Docker 部署 Molta 但使用NPM Binary部署 MoltBot(Clawd)，请设置为`host.docker.internal`
+- `CLAWD_PORT`：Clawd 网关端口，默认 `18789`
+- `CLAWD_AGENT_ID`：预留字段（当前实现中未使用）
+
+示例：
+```bash
+TOKEN="<Your token>"
+HOST="127.0.0.1"
+PORT=8090
+CLAWD_HOST="127.0.0.1"
+CLAWD_PORT=18789
+CLAWD_TOKEN="<Your Clawd Token>"
+```
+
+## 接口
+### 获取模型列表
+`GET /v1/models`
+
+示例返回（`created` 为当前时间）：
+```json
+{
+  "object": "list",
+  "data": [
+    {
+      "id": "molta",
+      "object": "model",
+      "created": "2025-01-01T00:00:00.000Z",
+      "owned_by": "molta"
+    }
+  ]
+}
+```
+
+### 聊天补全
+`POST /v1/chat/completions`
+
+请求体（兼容 OpenAI）：
+```json
+{
+  "model": "clawd",
+  "messages": [
+    { "role": "user", "content": "你好" }
+  ],
+  "stream": false
+}
+```
+
+鉴权：
+```
+Authorization: Bearer <TOKEN>
+```
+
+流式响应：当 `stream=true` 时返回 SSE。
+
+## 会话说明
+- 会话 ID 基于 `user` 或 `id` 字段生成；未提供则使用 `http`。
+- 发送 `/clawd-new` 或 `clawd-new` 可强制创建新会话。
+
+## 运行与构建
+```bash
+yarn build
+yarn start
+```
+
+安装并启动：
+```bash
+npm i -g molta
+molta
+```
+
+## 目录结构
+- `src/router/chat/completions.ts`：主接口逻辑
+- `src/services/gateway.ts`：Clawd 网关 WebSocket 客户端
+- `schema.json`：环境变量校验规则

package/dist/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { Elysia } from "elysia";
+import { Logger } from "./utils/logger.js";
+import { openapi, fromTypes } from "@elysiajs/openapi";
+import { node } from "@elysiajs/node";
+import { route } from "./router.js";
+import "./utils/env.js";
+import { configObject } from "./services/config.js";
+const elysia = new Elysia({ adapter: node() });
+const logger = new Logger("app");
+elysia
+    .use(route)
+    .use(openapi({
+    references: fromTypes()
+}));
+elysia.listen(configObject.port, () => {
+    logger.info(`Server started on http://${configObject.host}:${configObject.port}`);
+});
+logger.info("Initialized server successfully");

package/dist/middleware/auth.js

@@ -0,0 +1,9 @@
+import { Elysia } from "elysia";
+import { config } from "../services/config.js";
+export const auth = new Elysia()
+    .use(config)
+    .onBeforeHandle({ as: "global" }, ({ headers, store }) => {
+    if (headers["authorization"] !== store.config.token.replace("Bearer ", "")) {
+        return new Response("Unauthorized", { status: 401 });
+    }
+});

package/dist/router/chat/completions.js

@@ -0,0 +1,139 @@
+import { Elysia } from "elysia";
+import { GatewayClient } from "../../services/gateway.js";
+import { config } from "../../services/config.js";
+import { expandRandomString, getOrCreateHttpChatId, renewHttpChatId } from "../../utils/random.js";
+function extractLastUserMessage(messages) {
+    if (!Array.isArray(messages))
+        return null;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== "object")
+            continue;
+        const role = msg.role;
+        if (role !== "user")
+            continue;
+        const content = msg.content;
+        if (typeof content === "string")
+            return content;
+        if (Array.isArray(content)) {
+            for (const item of content) {
+                if (!item || typeof item !== "object")
+                    continue;
+                const text = item.text;
+                if (typeof text === "string")
+                    return text;
+            }
+        }
+    }
+    return null;
+}
+function normalizeClientId(body) {
+    let clientId = typeof body.user === "string" ? body.user : "";
+    if (!clientId.trim() && typeof body.id === "string")
+        clientId = body.id;
+    if (!clientId.trim())
+        clientId = "http";
+    return expandRandomString(clientId.trim());
+}
+function getAuthToken(authorization) {
+    if (!authorization)
+        return null;
+    const value = authorization.trim();
+    if (!value)
+        return null;
+    if (value.toLowerCase().startsWith("bearer "))
+        return value.slice(7).trim();
+    return value;
+}
+function createSseResponse(replyText, created) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            const chunk = {
+                id: `chatcmpl-clawd-${created}`,
+                object: "chat.completion.chunk",
+                created,
+                model: "clawd",
+                choices: [
+                    { index: 0, delta: { role: "assistant", content: replyText }, finish_reason: null },
+                ],
+            };
+            controller.enqueue(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" }],
+            };
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(done)}\n\n`));
+            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            controller.close();
+        },
+    });
+    return new Response(stream, {
+        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 }) => {
+    const payload = (body && typeof body === "object"
+        ? body
+        : await request.json().catch(() => ({})));
+    const token = store.config?.token;
+    const authHeader = request.headers.get("authorization");
+    const providedToken = getAuthToken(authHeader);
+    if (token && (!providedToken || providedToken !== token)) {
+        set.status = 401;
+        return { error: { message: "Unauthorized" } };
+    }
+    const lastUser = extractLastUserMessage(payload.messages);
+    if (!lastUser?.trim()) {
+        set.status = 400;
+        return { error: { message: "No user message found in 'messages'" } };
+    }
+    let clientId = normalizeClientId(payload);
+    let replyText = "";
+    if (lastUser.trim() === "/clawd-new" || lastUser.trim() === "clawd-new") {
+        const newId = renewHttpChatId(clientId);
+        replyText = `[ok] 已创建新会话：${newId}`;
+    }
+    else {
+        const chatId = getOrCreateHttpChatId(clientId);
+        const sessionKey = `openai:${chatId}`;
+        const host = store.config?.clawdHost ?? "127.0.0.1";
+        const port = Number(store.config?.clawdPort ?? 18789);
+        const token = store.config?.clawdToken;
+        const gateway = new GatewayClient(host, port, token);
+        try {
+            replyText = await gateway.ask(lastUser, sessionKey);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            set.status = 502;
+            return { error: { message: `Gateway error: ${message}` } };
+        }
+    }
+    const created = Math.floor(Date.now() / 1000);
+    if (payload.stream)
+        return createSseResponse(replyText, created);
+    return {
+        id: `chatcmpl-clawd-${created}`,
+        object: "chat.completion",
+        created,
+        model: "clawd",
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content: replyText },
+                finish_reason: "stop",
+            },
+        ],
+        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+    };
+});

package/dist/router/models.js

@@ -0,0 +1,15 @@
+import { Elysia } from "elysia";
+export const models = new Elysia()
+    .get("/v1/models", () => {
+    return {
+        object: "list",
+        data: [
+            {
+                id: "molta",
+                object: "model",
+                created: new Date().toISOString(),
+                owned_by: "molta",
+            }
+        ]
+    };
+});

package/dist/router.js

@@ -0,0 +1,6 @@
+import { Elysia } from "elysia";
+import { models } from "./router/models.js";
+import { completions } from "./router/chat/completions.js";
+export const route = new Elysia()
+    .use(completions)
+    .use(models);

package/dist/services/config.js

@@ -0,0 +1,30 @@
+import { Elysia } from "elysia";
+import { Logger } from "../utils/logger.js";
+import { validate } from "../utils/ajv.js";
+import "../utils/env.js";
+const logger = new Logger("ajv");
+const envConfig = {
+    TOKEN: process.env.TOKEN,
+    HOST: process.env.HOST,
+    PORT: process.env.PORT,
+    CLAWD_AGENT_ID: process.env.CLAWD_AGENT_ID,
+    CLAWD_HOST: process.env.CLAWD_HOST,
+    CLAWD_PORT: process.env.CLAWD_PORT,
+    CLAWD_TOKEN: process.env.CLAWD_TOKEN,
+};
+if (!envConfig.TOKEN || !envConfig.TOKEN.trim()) {
+    logger.error("TOKEN is required. Set env var TOKEN and restart.");
+    process.exit(1);
+}
+const validated = validate(envConfig);
+export const configObject = {
+    token: validated.TOKEN,
+    host: validated.HOST,
+    port: validated.PORT,
+    clawdAgentId: validated.CLAWD_AGENT_ID,
+    clawdHost: validated.CLAWD_HOST,
+    clawdPort: validated.CLAWD_PORT,
+    clawdToken: validated.CLAWD_TOKEN
+};
+export const config = new Elysia()
+    .state("config", configObject);

package/dist/services/gateway.js

@@ -0,0 +1,142 @@
+import os from "os";
+export class GatewayClient {
+    host;
+    port;
+    token;
+    platform;
+    constructor(host, port, token) {
+        this.host = host;
+        this.port = port;
+        this.token = token;
+        this.platform = os.platform();
+    }
+    async ask(prompt, session) {
+        return await (new Promise((resolve, reject) => {
+            const ws = new WebSocket(`ws://${this.host}:${this.port}`);
+            let buf = "";
+            let run_id = null;
+            let settled = false;
+            const timeout = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                ws.close();
+                reject(new Error("gateway timeout"));
+            }, 60_000);
+            const finalizeResolve = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                resolve(value);
+                ws.close();
+            };
+            const finalizeReject = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                reject(err);
+                ws.close();
+            };
+            ws.onmessage = ({ data }) => {
+                let obj;
+                try {
+                    obj = JSON.parse(data);
+                }
+                catch (error) {
+                    finalizeReject(error instanceof Error ? error : 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")
+                            buf = data["text"];
+                    }
+                    else if (typeof payload["delta"] === "string")
+                        buf += payload["delta"];
+                    if (payload["stream"] === "lifecycle") {
+                        const phase = (payload["data"] || {})["phase"];
+                        if (phase === "end") {
+                            finalizeResolve(buf.trim());
+                        }
+                        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 || buf.trim()) {
+                    finalizeResolve(buf.trim());
+                    return;
+                }
+                const reason = event.reason ? ` reason=${event.reason}` : "";
+                finalizeReject(new Error(`gateway websocket closed code=${event.code}${reason} url=${ws.url}`));
+            };
+        }));
+    }
+}

package/dist/utils/ajv.js

@@ -0,0 +1,37 @@
+import { Ajv } from 'ajv';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { Logger } from "./logger.js";
+import "./env.js";
+const logger = new Logger("ajv");
+export function validate(obj) {
+    try {
+        const schemaPath = resolve(process.cwd(), 'schema.json');
+        const schema = JSON.parse(readFileSync(schemaPath, 'utf-8'));
+        const ajv = new Ajv({
+            allErrors: true,
+            coerceTypes: true,
+            useDefaults: true
+        });
+        const validate = ajv.compile(schema);
+        const data = { ...obj };
+        if (!validate(data)) {
+            const errors = validate.errors?.map(err => {
+                const path = err.instancePath ? err.instancePath.substring(1) : 'root';
+                return `- ${path}: ${err.message}`;
+            }).join('\n');
+            logger.error(`Validation failed:\n${errors}`);
+            throw new Error(`Validation failed:\n${errors}`);
+        }
+        logger.info("Validation passed");
+        return data;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            const schemaPath = resolve(process.cwd(), 'schema.json');
+            logger.error(`Schema file not found at: ${schemaPath}`);
+            throw new Error(`Schema file not found at: ${schemaPath}`);
+        }
+        throw error;
+    }
+}

package/dist/utils/env.js

@@ -0,0 +1,2 @@
+import { config } from "dotenv";
+config({ path: ".env" });

package/dist/utils/logger.js

@@ -0,0 +1,268 @@
+// @ts-nocheck
+import supportsColor from "supports-color";
+export const Time = {
+    millisecond: 1,
+    second: 1000,
+    minute: 1000 * 60,
+    hour: 1000 * 60 * 60,
+    day: 1000 * 60 * 60 * 24,
+    week: 1000 * 60 * 60 * 24 * 7,
+    timezoneOffset: new Date().getTimezoneOffset(),
+    setTimezoneOffset(offset) {
+        Time.timezoneOffset = offset;
+    },
+    getTimezoneOffset() {
+        return Time.timezoneOffset;
+    },
+    getDateNumber(date = new Date(), offset) {
+        if (typeof date === "number")
+            date = new Date(date);
+        if (offset === undefined)
+            offset = Time.timezoneOffset;
+        return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+    },
+    fromDateNumber(value, offset) {
+        const date = new Date(value * Time.day);
+        if (offset === undefined)
+            offset = Time.timezoneOffset;
+        return new Date(+date + offset * Time.minute);
+    },
+    numeric: /\d+(?:\.\d+)?/.source,
+    get timeRegExp() {
+        return new RegExp(`^${[
+            "w(?:eek(?:s)?)?",
+            "d(?:ay(?:s)?)?",
+            "h(?:our(?:s)?)?",
+            "m(?:in(?:ute)?(?:s)?)?",
+            "s(?:ec(?:ond)?(?:s)?)?",
+        ]
+            .map((unit) => `(${this.numeric}${unit})?`)
+            .join("")}$`);
+    },
+    parseTime(source) {
+        const capture = Time.timeRegExp.exec(source);
+        if (!capture)
+            return 0;
+        return ((Number.parseFloat(capture[1]) * Time.week || 0) +
+            (Number.parseFloat(capture[2]) * Time.day || 0) +
+            (Number.parseFloat(capture[3]) * Time.hour || 0) +
+            (Number.parseFloat(capture[4]) * Time.minute || 0) +
+            (Number.parseFloat(capture[5]) * Time.second || 0));
+    },
+    parseDate(date) {
+        const parsed = Time.parseTime(date);
+        if (parsed) {
+            date = (Date.now() + parsed).toString();
+        }
+        else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+            date = `${new Date().toLocaleDateString()}-${date}`;
+        }
+        else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+            date = `${new Date().getFullYear()}-${date}`;
+        }
+        return date ? new Date(date) : new Date();
+    },
+    format(ms) {
+        const abs = Math.abs(ms);
+        if (abs >= Time.day - Time.hour / 2) {
+            return `${Math.round(ms / Time.day)}d`;
+        }
+        if (abs >= Time.hour - Time.minute / 2) {
+            return `${Math.round(ms / Time.hour)}h`;
+        }
+        if (abs >= Time.minute - Time.second / 2) {
+            return `${Math.round(ms / Time.minute)}m`;
+        }
+        if (abs >= Time.second) {
+            return `${Math.round(ms / Time.second)}s`;
+        }
+        return `${ms}ms`;
+    },
+    toDigits(source, length = 2) {
+        return source.toString().padStart(length, "0");
+    },
+    template(template, time = new Date()) {
+        return template
+            .replace("yyyy", time.getFullYear().toString())
+            .replace("yy", time.getFullYear().toString().slice(2))
+            .replace("MM", Time.toDigits(time.getMonth() + 1))
+            .replace("dd", Time.toDigits(time.getDate()))
+            .replace("hh", Time.toDigits(time.getHours()))
+            .replace("mm", Time.toDigits(time.getMinutes()))
+            .replace("ss", Time.toDigits(time.getSeconds()))
+            .replace("SSS", Time.toDigits(time.getMilliseconds(), 3));
+    },
+};
+const c16 = [6, 2, 3, 4, 5, 1];
+const c256 = [
+    20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68, 69, 74, 75, 76, 77,
+    78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165,
+    166, 167, 168, 169, 170, 171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202,
+    203, 204, 205, 206, 207, 208, 209, 214, 215, 220, 221,
+];
+function isAggregateError(error) {
+    return error instanceof Error && "errors" in error && Array.isArray(error.errors);
+}
+export class Logger {
+    name;
+    meta;
+    namespace;
+    constructor(name, meta, namespace) {
+        this.name = name;
+        this.meta = meta;
+        this.namespace = namespace;
+        this.createMethod("success", Logger.SUCCESS);
+        this.createMethod("error", Logger.ERROR);
+        this.createMethod("info", Logger.INFO);
+        this.createMethod("warn", Logger.WARN);
+        this.createMethod("debug", Logger.DEBUG);
+    }
+    static SILENT = 0;
+    static SUCCESS = 1;
+    static ERROR = 1;
+    static INFO = 2;
+    static WARN = 2;
+    static DEBUG = 3;
+    // Global configuration
+    static id = 0;
+    static targets = [];
+    static formatters = Object.create(null);
+    static levels = {
+        base: 2,
+    };
+    static format(name, formatter) {
+        Logger.formatters[name] = formatter;
+    }
+    static color(target, code, value, decoration = "") {
+        if (!target.colors)
+            return `${value}`;
+        return `\u001b[3${code < 8 ? code : `8;5;${code}`}${target.colors >= 2 ? decoration : ""}m${value}\u001b[0m`;
+    }
+    static code(name, target) {
+        let hash = 0;
+        for (let i = 0; i < name.length; i++) {
+            hash = hash * 8 - hash + name.charCodeAt(i) + 13;
+            hash = Math.trunc(hash);
+        }
+        const colors = !target.colors ? [] : target.colors >= 2 ? c256 : c16;
+        return colors[Math.abs(hash) % colors.length];
+    }
+    static render(target, record) {
+        const prefix = `[${record.type[0].toUpperCase()}]`;
+        const space = " ".repeat(target.label?.margin ?? 1);
+        let indent = 3 + space.length;
+        let output = "";
+        if (target.showTime) {
+            indent += target.showTime.length + space.length;
+            output += Logger.color(target, 8, Time.template(target.showTime)) + space;
+        }
+        const displayName = record.meta?.namespace || record.name;
+        const code = Logger.code(displayName, target);
+        const label = Logger.color(target, code, displayName, ";1");
+        const padLength = (target.label?.width ?? 0) + label.length - displayName.length;
+        if (target.label?.align === "right") {
+            output += label.padStart(padLength) + space + prefix + space;
+            indent += (target.label.width ?? 0) + space.length;
+        }
+        else {
+            output += prefix + space + label.padEnd(padLength) + space;
+        }
+        output += record.content.replace(/\n/g, `\n${" ".repeat(indent)}`);
+        if (target.showDiff && target.timestamp) {
+            const diff = record.timestamp - target.timestamp;
+            output += Logger.color(target, code, ` +${diff}`);
+        }
+        return output;
+    }
+    extend(namespace) {
+        return new Logger(`${this.name}:${namespace}`, this.meta);
+    }
+    createMethod(type, level) {
+        this[type] = (...args) => {
+            if (args.length === 1 && args[0] instanceof Error) {
+                if (args[0].cause) {
+                    this[type](args[0].cause);
+                }
+                else if (isAggregateError(args[0])) {
+                    args[0].errors.forEach((error) => {
+                        this[type](error);
+                    });
+                    return;
+                }
+            }
+            const id = ++Logger.id;
+            const timestamp = Date.now();
+            for (const target of Logger.targets) {
+                if (this.getLevel(target) < level)
+                    continue;
+                const content = this.formatMessage(target, ...args);
+                const record = {
+                    id,
+                    type,
+                    level,
+                    name: this.name,
+                    meta: { ...this.meta, namespace: this.namespace },
+                    content,
+                    timestamp,
+                };
+                if (target.record) {
+                    target.record(record);
+                }
+                else if (target.print) {
+                    target.print(Logger.render(target, record));
+                }
+                target.timestamp = timestamp;
+            }
+        };
+    }
+    formatMessage(target, ...args) {
+        if (args[0] instanceof Error) {
+            args[0] = args[0].stack || args[0].message;
+            args.unshift("%s");
+        }
+        else if (typeof args[0] !== "string") {
+            args.unshift("%o");
+        }
+        let format = args.shift();
+        format = format.replace(/%([a-zA-Z%])/g, (match, char) => {
+            if (match === "%%")
+                return "%";
+            const formatter = Logger.formatters[char];
+            if (typeof formatter === "function") {
+                const value = args.shift();
+                return formatter(value, target, this);
+            }
+            return match;
+        });
+        const { maxLength = 10240 } = target;
+        return format
+            .split(/\r?\n/g)
+            .map((line) => line.slice(0, maxLength) + (line.length > maxLength ? "..." : ""))
+            .join("\n");
+    }
+    getLevel(target) {
+        const paths = this.name.split(":");
+        let config = target?.levels || Logger.levels;
+        do {
+            config = config[paths.shift()] ?? config.base;
+        } while (paths.length && typeof config === "object");
+        return config;
+    }
+}
+Logger.format("s", (value) => value);
+Logger.format("d", (value) => +value);
+Logger.format("j", (value) => JSON.stringify(value));
+Logger.format("c", (value, target, logger) => {
+    return Logger.color(target, Logger.code(logger.name, target), value);
+});
+Logger.format("C", (value, target) => {
+    return Logger.color(target, 15, value, ";1");
+});
+Logger.targets = [];
+Logger.targets.push({
+    showTime: "yyyy-MM-dd hh:mm:ss.SSS",
+    colors: supportsColor.stdout ? supportsColor.stdout.level : 0,
+    print(text) {
+        console.log(text);
+    },
+});

package/dist/utils/random.js

@@ -0,0 +1,31 @@
+import { randomBytes } from "node:crypto";
+const http_chat_ids = {};
+export function randomString(length = 16, chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') {
+    const randomValues = randomBytes(length);
+    const result = [];
+    for (let i = 0; i < length; i++) {
+        const randomIndex = randomValues[i] % chars.length;
+        result.push(chars[randomIndex]);
+    }
+    return result.join('');
+}
+export function getOrCreateHttpChatId(client_id) {
+    const cid = http_chat_ids[client_id];
+    if (cid)
+        return cid;
+    const new_cid = `${client_id}:${randomString(8)}`;
+    http_chat_ids[client_id] = new_cid;
+    return new_cid;
+}
+export function expandRandomString(str) {
+    if (str.includes("randomString")) {
+        return str.replace("randomString", randomString(8));
+    }
+    return str;
+}
+export function renewHttpChatId(client_id) {
+    const rand = randomString(8);
+    const cid = `${client_id}:${rand}`;
+    http_chat_ids[client_id] = cid;
+    return cid;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "molta",
+  "version": "1.0.0",
+  "description": "Use MoltBot anywhere",
+  "type": "module",
+  "packageManager": "yarn@4.12.0",
+  "keywords": [
+    "MoltBot"
+  ],
+  "author": "Sylphy-0xd3ac",
+  "license": "ISC",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "yarn build && node scripts/add-shebang.cjs",
+    "start": "node dist/index.js"
+  },
+  "bin": {
+    "molta": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "schema.json"
+  ],
+  "dependencies": {
+    "@elysiajs/node": "^1.4.3",
+    "@elysiajs/openapi": "^1.4.14",
+    "ajv": "^8.17.1",
+    "dotenv": "^17.2.3",
+    "elysia": "^1.4.22",
+    "js-yaml": "^4.1.1",
+    "supports-color": "^10.2.2",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.21.0"
+  }
+}

package/schema.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Environment Variables",
+  "type": "object",
+  "required": ["TOKEN", "CLAWD_TOKEN"],
+  "properties": {
+    "TOKEN": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Token for authentication"
+    },
+    "HOST": {
+      "type": "string",
+      "minLength": 1,
+      "default": "localhost",
+      "description": "Host for authentication"
+    },
+    "PORT": {
+      "type": "number",
+      "maximum": 65535,
+      "default": 8090,
+      "description": "Port number"
+    },
+    "CLAWD_AGENT_ID": {
+      "type": "string",
+      "default": "main",
+      "description": "Agent ID for Clawd"
+    },
+    "CLAWD_HOST": {
+      "type": "string",
+      "default": "localhost",
+      "description": "Host for Clawd"
+    },
+    "CLAWD_PORT": {
+      "type": "number",
+      "maximum": 65535,
+      "default": 18789,
+      "description": "Port for Clawd"
+    },
+    "CLAWD_TOKEN": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Token for Clawd authentication"
+    }
+  }
+}