@lessie/mcp-server 0.0.8 → 0.1.1

package/README.md

@@ -14,7 +14,7 @@ Claude Desktop
 ┌──────────────────────────────┐
 │  本地 MCP Server             │
 │                              │
-│  本地工具（get_access_token） │
+│  本地工具（authorize）        │
 │          +                   │      Streamable HTTP / SSE
 │  远程工具代理 ───────────────│──────►  远程 MCP Server
 │                              │       Authorization: Bearer <token>

package/SKILL.md

@@ -1,62 +1,51 @@
 ---
 name: lessie-mcp
 description: >-
-  Lessie MCP 代理网关：OAuth 鉴权、远程工具代理。
-  当需要理解本项目结构、鉴权机制或使用 Lessie 工具时使用。
+  Lessie MCP 使用指南：授权流程与工具调用。
+  当需要连接 Lessie 服务或使用 Lessie 工具时参考。
 ---
 
 # Lessie MCP
 
-Lessie MCP 是一个代理网关，连接远程 Lessie 服务并暴露其工具。使用前需要完成 OAuth 授权。
+Lessie MCP 连接远程 Lessie 服务并暴露其工具，使用前需完成 OAuth 授权。
 
-## 快速开始
+## 首次使用
 
-### 1. 授权连接
+首次使用时，Agent 应主动调用 `authorize` 工具发起 OAuth 授权：
 
-首次使用时，调用 `authorize` 工具。如果需要登录，它会返回一个授权链接：
+1. 调用 `authorize` → 获取授权链接
+2. 将授权链接展示给用户，请用户在浏览器中打开完成登录
+3. 用户完成授权后，再次调用 `authorize` 确认连接状态
+4. 授权成功后，通过 `use_lessie` 工具调用远程功能
 
-1. 调用 `authorize`
-2. 将返回的授权链接展示给用户，请用户在浏览器中打开
-3. 用户在浏览器中完成登录授权
-4. 授权完成后，远程工具自动可用，无需再次调用 `authorize`
+如果 `authorize` 返回已授权状态，则跳过上述流程，直接使用 `use_lessie` 或已暴露的远程工具。
 
-已授权时调用 `authorize` 会直接返回当前连接状态和可用工具数量。
+## 异常处理
 
-### 2. 使用远程工具
+`authorize` 工具会返回详细的诊断信息和修复建议，Agent 应按照提示操作：
 
-授权完成后，远程工具会自动出现在工具列表中，直接调用即可。
+- **端口占用**（`port_in_use`）：回调服务器端口被占用。按提示帮用户排查占用进程，然后重新调用 `authorize`。
+- **授权超时**（`timeout`）：2 分钟内未收到浏览器回调。重新调用 `authorize` 生成新链接，提醒用户及时完成授权。
+- **用户拒绝授权**（`auth_denied`）：重新调用 `authorize` 并引导用户在浏览器中允许授权。
+- **等待中**（`waiting`）：授权流程进行中。提醒用户在浏览器中完成操作，无需重新发起。
+- **其他错误**：按返回的具体建议操作，通常重新调用 `authorize` 即可重试。
 
-如果调用远程工具时收到"请先使用 authorize 工具"的错误提示，说明授权已过期，需要重新执行上述授权流程。
+当收到 logging 级别的授权失败通知时，应主动告知用户并建议重新调用 `authorize`。
 
-## 本地工具
-
-| 工具               | 说明                                                               |
-| ------------------ | ------------------------------------------------------------------ |
-| `authorize`        | 发起授权或检查连接状态。未授权时返回授权链接，已连接时返回状态信息 |
-| `get_access_token` | 获取当前 OAuth access token 及剩余有效时间                         |
-
-## 项目架构（开发参考）
-
-### 鉴权：OAuth Authorization Code + PKCE
+## 使用远程工具
 
-`src/auth.ts` 实现 `OAuthClientProvider` 接口：
+授权完成后，通过 `use_lessie` 工具调用所有远程功能：
 
-- 令牌和客户端信息持久化到 `~/.lessie/oauth.json`
-- `redirectToAuthorization(url)` 存储授权 URL（不自动打开浏览器）
-- `waitForCallback()` 在 `127.0.0.1:19836` 监听回调，等待用户完成授权
+1. 调用 `use_lessie`（不传参数）→ 列出所有可用的远程工具及参数说明
+2. 调用 `use_lessie(tool="工具名", arguments={...})` → 调用指定的远程工具
 
-### 连接策略
+如果远程工具直接出现在工具列表中（已授权的回访用户），也可以直接调用，无需通过 `use_lessie`。
 
-`src/remote.ts` 管理远程连接：
+收到"远程 MCP 服务器未连接"错误时，说明授权已过期，需重新调用 `authorize` 完成授权。
 
-- `connectToRemote()` — 启动时静默尝试（用缓存 token），未授权不阻塞
-- `initiateAuth()` — 发起 OAuth 流程，返回授权 URL，后台等待回调自动完成连接
-- `callRemoteTool()` — 授权进行中自动等待；未连接时返回错误引导用户调用 `authorize`
-
-传输层优先使用 Streamable HTTP，不可用时自动降级到 SSE。
-
-### 环境变量
+## 本地工具
 
-| 变量                    | 必填 | 说明                 |
-| ----------------------- | ---- | -------------------- |
-| `LESSIE_REMOTE_MCP_URL` | 否   | 远程 MCP Server 地址 |
+| 工具        | 说明                                                                                       |
+| ----------- | ------------------------------------------------------------------------------------------ |
+| `authorize` | 发起授权或检查连接状态。返回连接状态、授权链接、等待状态或错误诊断信息（含修复建议） |
+| `use_lessie`       | 远程工具统一入口。不传 `tool` 列出所有远程工具；传入 `tool` 和 `arguments` 调用指定工具 |

package/dist/auth.js

@@ -4,9 +4,12 @@
  * 实现 MCP SDK 的 OAuthClientProvider 接口：
  *   1. 首次连接时通过 RFC 7591 动态注册客户端（POST /register）
  *   2. 打开浏览器引导用户到 SaaS 页面登录并授权
- *   3. 在 localhost 临时 HTTP 服务器上接收授权码回调
+ *   3. 在 localhost HTTP 服务器上接收授权码回调
  *   4. SDK 自动用授权码交换 access_token（POST /token）
  *
+ * 端口策略：prepareCallbackServer() 扫描端口范围并创建 HTTP 服务器占住可用端口，
+ * redirectToAuthorization() 直接在该服务器上挂载回调处理逻辑，避免竞争窗口。
+ *
  * 客户端信息和令牌持久化到 ~/.lessie/oauth.json，进程重启后复用，
  * 避免每次都打开浏览器。
  */
@@ -14,12 +17,22 @@ import { createServer } from "node:http";
 import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { OAUTH_SERVER_URL, OAUTH_AUTHORIZATION_ENDPOINT, OAUTH_TOKEN_ENDPOINT, OAUTH_REGISTRATION_ENDPOINT, REMOTE_MCP_URL, } from "./config.js";
-const CALLBACK_PORT = 19836;
-const REDIRECT_URL = `http://127.0.0.1:${CALLBACK_PORT}/callback`;
+export const DEFAULT_CALLBACK_PORT = 19836;
+export const PORT_SCAN_RANGE = 10;
 const STORAGE_DIR = join(homedir(), ".lessie");
 const STORAGE_FILE = join(STORAGE_DIR, "oauth.json");
 const CALLBACK_TIMEOUT_MS = 120_000;
+function tryListenHttp(port) {
+    return new Promise((resolve) => {
+        const srv = createServer((_req, res) => {
+            res.writeHead(404);
+            res.end();
+        });
+        srv.once("error", () => resolve(null));
+        srv.once("listening", () => resolve(srv));
+        srv.listen(port, "127.0.0.1");
+    });
+}
 // JSON 损坏时返回空对象，用户需重新授权（损坏数据无法恢复）
 function loadStorage() {
     try {
@@ -38,24 +51,57 @@ function persistStorage(data) {
 export class LessieAuthProvider {
     _storage;
     _codeVerifier = "";
+    _expectedState = "";
     _callbackPromise = null;
     _httpServer = null;
-    _envDiscoveryState;
+    _callbackTimer = null;
+    _callbackPort;
     /** 等待用户访问的授权 URL；授权完成后清除 */
     pendingAuthUrl = null;
+    /** 回调服务器开始监听的时间戳，用于计算等待时长 */
+    waitingSince = null;
     constructor() {
         this._storage = loadStorage();
-        this._envDiscoveryState = buildEnvDiscoveryState();
+        this._codeVerifier = this._storage.codeVerifier || "";
+        this._callbackPort = this._storage.callbackPort ?? DEFAULT_CALLBACK_PORT;
+    }
+    get callbackPort() {
+        return this._callbackPort;
+    }
+    /**
+     * 扫描端口范围，创建 HTTP 服务器占住可用端口。
+     * redirectToAuthorization 直接复用该服务器，无需释放重听。
+     * 若端口与上次注册时不同，自动清除客户端信息以触发重新注册。
+     */
+    async prepareCallbackServer() {
+        if (this._httpServer?.listening)
+            return;
+        this._cleanupServer();
+        for (let offset = 0; offset < PORT_SCAN_RANGE; offset++) {
+            const port = DEFAULT_CALLBACK_PORT + offset;
+            const server = await tryListenHttp(port);
+            if (server) {
+                if (this._storage.clientInfo && this._storage.callbackPort != null && this._storage.callbackPort !== port) {
+                    delete this._storage.clientInfo;
+                }
+                this._httpServer = server;
+                this._callbackPort = port;
+                this._storage.callbackPort = port;
+                persistStorage(this._storage);
+                return;
+            }
+        }
+        throw new Error(`No available port found in range ${DEFAULT_CALLBACK_PORT}–${DEFAULT_CALLBACK_PORT + PORT_SCAN_RANGE - 1}`);
     }
     get redirectUrl() {
-        return REDIRECT_URL;
+        return `http://127.0.0.1:${this._callbackPort}/callback`;
     }
     get clientMetadata() {
         return {
-            redirect_uris: [REDIRECT_URL],
+            redirect_uris: [this.redirectUrl],
             grant_types: ["authorization_code"],
             response_types: ["code"],
-            client_name: "lessie-mcp",
+            client_name: "Lessie MCP",
             token_endpoint_auth_method: "client_secret_basic",
         };
     }
@@ -72,6 +118,8 @@ export class LessieAuthProvider {
     async saveTokens(tokens) {
         this._storage.tokens = tokens;
         this._storage.tokensSavedAt = Date.now();
+        delete this._storage.codeVerifier;
+        this._codeVerifier = "";
         persistStorage(this._storage);
     }
     /** 当前 access_token 的剩余有效秒数（基于本地时钟估算） */
@@ -83,61 +131,83 @@ export class LessieAuthProvider {
     }
     /**
      * SDK 在需要用户授权时调用此方法。
-     * 启动 localhost 临时 HTTP 服务器接收回调，然后打开浏览器。
+     * 在 prepareCallbackServer() 已监听的 HTTP 服务器上挂载回调处理逻辑，等待浏览器回调。
+     *
+     * 必须先调用 prepareCallbackServer()，否则抛出异常。
      */
     async redirectToAuthorization(url) {
-        if (this._httpServer) {
-            this._httpServer.close();
-            this._httpServer = null;
+        if (!this._httpServer?.listening) {
+            throw new Error("No listening server — prepareCallbackServer() must be called before redirectToAuthorization()");
         }
+        this._expectedState = url.searchParams.get("state") || "";
+        this.waitingSince = null;
+        let resolveCode;
+        let rejectCode;
         this._callbackPromise = new Promise((resolve, reject) => {
-            let timer;
-            const cleanup = () => {
-                clearTimeout(timer);
-                this._httpServer = null;
-                setTimeout(() => server.close(), 500);
-            };
-            const server = createServer((req, res) => {
-                const reqUrl = new URL(req.url, `http://127.0.0.1:${CALLBACK_PORT}`);
-                if (reqUrl.pathname !== "/callback") {
-                    res.writeHead(404);
-                    res.end();
+            resolveCode = resolve;
+            rejectCode = reject;
+        });
+        this._httpServer.removeAllListeners("request");
+        this._httpServer.removeAllListeners("error");
+        this._httpServer.on("error", (err) => {
+            this._cleanupServer();
+            rejectCode(new Error(`Callback server error: ${err.message}`));
+        });
+        this._httpServer.on("request", (req, res) => {
+            const reqUrl = new URL(req.url, `http://127.0.0.1:${this._callbackPort}`);
+            if (reqUrl.pathname !== "/callback") {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            if (this._expectedState) {
+                const callbackState = reqUrl.searchParams.get("state");
+                if (callbackState !== this._expectedState) {
+                    res.writeHead(403, { "Content-Type": "text/plain" });
+                    res.end("Invalid state parameter");
                     return;
                 }
-                const code = reqUrl.searchParams.get("code");
-                if (code) {
-                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-                    res.end("<!DOCTYPE html><html><body>" +
-                        "<h1>授权成功</h1><p>可以关闭此页面，回到 Claude Desktop 继续使用。</p>" +
-                        "</body></html>");
-                    cleanup();
-                    resolve(code);
-                }
-                else {
-                    const error = reqUrl.searchParams.get("error") ?? "unknown_error";
-                    res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
-                    res.end(`<!DOCTYPE html><html><body><h1>授权失败</h1><p>${escapeHtml(error)}</p></body></html>`);
-                    cleanup();
-                    reject(new Error(`Authorization denied: ${error}`));
-                }
-            });
-            server.on("error", (err) => {
-                this._httpServer = null;
-                const msg = err.code === "EADDRINUSE"
-                    ? `Port ${CALLBACK_PORT} is already in use`
-                    : `Callback server error: ${err.message}`;
-                reject(new Error(msg));
-            });
-            server.listen(CALLBACK_PORT, "127.0.0.1");
-            this._httpServer = server;
-            timer = setTimeout(() => {
-                this._httpServer = null;
-                server.close();
-                reject(new Error("Authorization timed out — no callback received within 2 minutes"));
-            }, CALLBACK_TIMEOUT_MS);
+            }
+            const code = reqUrl.searchParams.get("code");
+            if (code) {
+                resolveCode(code);
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<!DOCTYPE html><html><body>" +
+                    "<h1>Authorization Successful</h1>" +
+                    "<p>You may close this page and return to your agent.</p>" +
+                    "</body></html>");
+                this._cleanupServer();
+            }
+            else {
+                const error = reqUrl.searchParams.get("error") ?? "unknown_error";
+                rejectCode(new Error(`Authorization denied: ${error}`));
+                res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<!DOCTYPE html><html><body>" +
+                    "<h1>Authorization Failed</h1>" +
+                    `<p>${escapeHtml(error)}</p>` +
+                    "</body></html>");
+                this._cleanupServer();
+            }
         });
+        this.waitingSince = Date.now();
+        this._callbackTimer = setTimeout(() => {
+            this._cleanupServer();
+            rejectCode(new Error("Authorization timed out — no callback received within 2 minutes"));
+        }, CALLBACK_TIMEOUT_MS);
         this.pendingAuthUrl = url.toString();
     }
+    _cleanupServer() {
+        if (this._callbackTimer) {
+            clearTimeout(this._callbackTimer);
+            this._callbackTimer = null;
+        }
+        if (this._httpServer) {
+            const server = this._httpServer;
+            this._httpServer = null;
+            this.waitingSince = null;
+            setTimeout(() => server.close(), 500);
+        }
+    }
     /**
      * 等待用户在浏览器中完成授权后回调，返回授权码。
      * 必须在 redirectToAuthorization 之后调用。
@@ -149,16 +219,18 @@ export class LessieAuthProvider {
     }
     async saveCodeVerifier(codeVerifier) {
         this._codeVerifier = codeVerifier;
+        this._storage.codeVerifier = codeVerifier;
+        persistStorage(this._storage);
     }
     async codeVerifier() {
-        return this._codeVerifier;
+        return this._codeVerifier || this._storage.codeVerifier || "";
     }
     async saveDiscoveryState(state) {
         this._storage.discoveryState = state;
         persistStorage(this._storage);
     }
     discoveryState() {
-        return this._envDiscoveryState ?? this._storage.discoveryState;
+        return this._storage.discoveryState;
     }
     async invalidateCredentials(scope) {
         if (scope === "all" || scope === "client") {
@@ -180,38 +252,5 @@ export class LessieAuthProvider {
 function escapeHtml(s) {
     return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-/**
- * 从环境变量构建 OAuthDiscoveryState。
- * 至少需要配置 authorization_endpoint 和 token_endpoint 才会生效；
- * 未配置则返回 undefined，由 SDK 自动发现。
- */
-function buildEnvDiscoveryState() {
-    if (!OAUTH_AUTHORIZATION_ENDPOINT || !OAUTH_TOKEN_ENDPOINT)
-        return undefined;
-    const authorizationServerUrl = OAUTH_SERVER_URL || REMOTE_MCP_URL;
-    if (!authorizationServerUrl)
-        return undefined;
-    return {
-        authorizationServerUrl,
-        authorizationServerMetadata: {
-            issuer: authorizationServerUrl,
-            authorization_endpoint: OAUTH_AUTHORIZATION_ENDPOINT,
-            token_endpoint: OAUTH_TOKEN_ENDPOINT,
-            registration_endpoint: OAUTH_REGISTRATION_ENDPOINT,
-            response_types_supported: ["code"],
-            grant_types_supported: ["authorization_code"],
-            code_challenge_methods_supported: ["S256"],
-            token_endpoint_auth_methods_supported: [
-                "client_secret_basic",
-                "client_secret_post",
-                "none",
-            ],
-        },
-        resourceMetadata: {
-            resource: REMOTE_MCP_URL,
-            authorization_servers: [authorizationServerUrl],
-        },
-    };
-}
 /** 全局单例，供 remote / tools 共享 */
 export const authProvider = new LessieAuthProvider();

package/dist/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./index.js";

package/dist/config.js

@@ -5,19 +5,18 @@
  * 避免散落的 process.env 访问。
  */
 import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-export const pkg = require("../package.json");
+function readPkgVersion() {
+    try {
+        const raw = readFileSync(new URL("../package.json", import.meta.url), "utf-8");
+        return JSON.parse(raw).version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export const pkg = { version: readPkgVersion() };
 /** 远程 MCP Server 地址 */
-export const REMOTE_MCP_URL = process.env.LESSIE_REMOTE_MCP_URL || "https://s6.jennie.im/mcp-server/mcp";
-/**
- * OAuth 端点配置（可选）。
- * 未设置时 SDK 通过 RFC 8414 / RFC 9728 自动发现。
- */
-export const OAUTH_SERVER_URL = process.env.LESSIE_OAUTH_SERVER_URL || "https://s1.jennie.im/sit-api/oauth";
-export const OAUTH_AUTHORIZATION_ENDPOINT = process.env.LESSIE_OAUTH_AUTHORIZATION_ENDPOINT || "https://s1.jennie.im/sit-api/oauth/authorize";
-export const OAUTH_TOKEN_ENDPOINT = process.env.LESSIE_OAUTH_TOKEN_ENDPOINT || "https://s1.jennie.im/sit-api/oauth/token";
-export const OAUTH_REGISTRATION_ENDPOINT = process.env.LESSIE_OAUTH_REGISTRATION_ENDPOINT || "https://s1.jennie.im/sit-api/oauth/register";
+export const REMOTE_MCP_URL = process.env.LESSIE_REMOTE_MCP_URL || "https://www.lessie.ai/mcp-server/mcp";
 /** 读取 SKILL.md 作为 MCP instructions，跳过 YAML front-matter */
 export function loadInstructions() {
     try {

package/dist/index.js

@@ -1,38 +1,28 @@
-#!/usr/bin/env node
 /**
- * 入口：创建 MCP Server，注册请求路由，启动 stdio 传输。
- *
- * 使用低级 Server 而非 McpServer，以便手动控制 tools/list 和 tools/call 路由，
- * 将本地工具与远程代理工具合并到同一个工具列表中返回。
+ * 入口：创建 MCP Server，注册工具，启动 stdio 传输。
  *
  * 工具路由策略：
- *   tools/list  → 合并本地工具 + 远程工具
- *   tools/call  → 先匹配本地 handler，未命中则转发到远程 MCP Server
+ *   authorize   → 发起 OAuth 授权流程
+ *   use_lessie  → 代理调用远程 MCP Server 上的工具
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import "./process-handlers.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { REMOTE_MCP_URL, pkg, loadInstructions } from "./config.js";
-import { connectToRemote, listRemoteTools, callRemoteTool, isRemoteConnected, setOnAuthComplete } from "./remote.js";
-import { LOCAL_TOOLS, localHandlers } from "./tools.js";
-const server = new Server({ name: "lessie-mcp", version: pkg.version }, {
-    capabilities: { tools: {} },
+import { connectToRemote, listRemoteTools, isRemoteConnected, setOnAuthComplete, setOnAuthError } from "./remote.js";
+import { registerTools } from "./tools.js";
+console.error("[lessie] Modules loaded");
+const server = new McpServer({ name: "lessie-mcp", version: pkg.version }, {
+    capabilities: { tools: { listChanged: true } },
     instructions: loadInstructions(),
 });
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const remoteTools = await listRemoteTools();
-    return { tools: [...LOCAL_TOOLS, ...remoteTools] };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    const handler = localHandlers.get(name);
-    if (handler)
-        return handler(args ?? {});
-    return callRemoteTool(name, args);
-});
+registerTools(server);
 // ── 启动 ──────────────────────────────────────────────────────────────────────
+console.error("[lessie] Creating transport...");
 const transport = new StdioServerTransport();
+console.error("[lessie] Connecting server...");
 await server.connect(transport);
+console.error("[lessie] Server connected, setting up auth callback...");
 setOnAuthComplete((toolCount) => {
     server.sendLoggingMessage({
         level: "info",
@@ -41,8 +31,22 @@ setOnAuthComplete((toolCount) => {
     });
     server.sendToolListChanged();
 });
+setOnAuthError(({ code, message }) => {
+    const hint = code === "timeout"
+        ? "Please call the 'authorize' tool again to generate a new authorization link."
+        : code === "port_in_use"
+            ? `Port conflict detected. Check for processes using the callback port, then call 'authorize' to retry.`
+            : "Please call the 'authorize' tool to retry.";
+    server.sendLoggingMessage({
+        level: "error",
+        logger: "lessie",
+        data: `Authorization failed: ${message}. ${hint}`,
+    });
+});
+console.error("[lessie] Connecting to remote...");
 try {
     await connectToRemote();
+    console.error("[lessie] connectToRemote() completed, connected:", isRemoteConnected());
     if (isRemoteConnected()) {
         const remoteTools = await listRemoteTools();
         server.sendLoggingMessage({
@@ -60,12 +64,14 @@ try {
     }
 }
 catch (err) {
+    console.error("[lessie] connectToRemote() threw:", err);
     server.sendLoggingMessage({
         level: "error",
         logger: "lessie",
         data: `Failed to connect to remote MCP server: ${err}`,
     });
 }
+console.error("[lessie] Startup complete");
 server.sendLoggingMessage({
     level: "info",
     logger: "lessie",

package/dist/process-handlers.js

@@ -0,0 +1,10 @@
+process.on("uncaughtException", (err) => {
+    console.error("[lessie] Uncaught exception:", err);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error("[lessie] Unhandled rejection:", reason);
+});
+process.on("exit", (code) => {
+    console.error(`[lessie] Process exiting with code ${code}`);
+});
+export {};