@infimind-next/ai-hive-mcp 0.1.1 → 0.2.1

package/dist/workbuddy-loopback.js

@@ -0,0 +1,214 @@
+import { createServer, } from "node:http";
+export function listenForWorkBuddyCallback(_input) {
+    const input = _input;
+    return new Promise((resolve, reject) => {
+        let claimed = false;
+        let settled = false;
+        let timeout;
+        let closePromise;
+        let resolveCompletion;
+        let rejectCompletion;
+        const completion = new Promise((completionResolve, completionReject) => {
+            resolveCompletion = completionResolve;
+            rejectCompletion = completionReject;
+        });
+        void completion.catch(() => undefined);
+        const server = createServer((request, response) => {
+            void handleRequest(request, response).catch(() => {
+                void handleUnexpectedRequestFailure(response).catch(() => {
+                    response.destroy();
+                });
+            });
+        });
+        const clearDeadline = () => {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+        };
+        const closeServer = (force = false) => {
+            if (closePromise) {
+                return closePromise;
+            }
+            closePromise = new Promise((closeResolve) => {
+                if (!server.listening) {
+                    closeResolve();
+                    return;
+                }
+                server.close(() => closeResolve());
+                if (force) {
+                    server.closeAllConnections();
+                }
+                else {
+                    server.closeIdleConnections();
+                }
+            });
+            return closePromise;
+        };
+        const finishSuccess = async () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearDeadline();
+            await closeServer();
+            resolveCompletion();
+        };
+        const finishFailure = async (message, force = false) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            claimed = true;
+            clearDeadline();
+            await closeServer(force);
+            rejectCompletion(new Error(message));
+        };
+        async function handleRequest(request, response) {
+            let url;
+            try {
+                url = new URL(request.url ?? "/", "http://127.0.0.1");
+            }
+            catch {
+                sendHtml(response, 400, failureHtml());
+                return;
+            }
+            if (url.pathname !== "/oauth/callback") {
+                sendHtml(response, 404, failureHtml());
+                return;
+            }
+            if (request.method !== "GET") {
+                sendHtml(response, 405, failureHtml());
+                return;
+            }
+            const states = url.searchParams.getAll("state");
+            const codes = url.searchParams.getAll("code");
+            if (states.length !== 1 ||
+                codes.length !== 1 ||
+                !states[0] ||
+                !codes[0] ||
+                states[0] !== input.expectedState) {
+                sendHtml(response, 400, failureHtml());
+                return;
+            }
+            if (claimed) {
+                sendHtml(response, 409, failureHtml());
+                return;
+            }
+            claimed = true;
+            clearDeadline();
+            try {
+                await input.onCode(codes[0]);
+            }
+            catch {
+                if (!settled) {
+                    await sendHtmlAndWait(response, 500, failureHtml());
+                    await finishFailure("WorkBuddy 授权失败，请重新连接");
+                }
+                return;
+            }
+            if (settled) {
+                response.destroy();
+                return;
+            }
+            await sendHtmlAndWait(response, 200, successHtml());
+            await finishSuccess();
+        }
+        async function handleUnexpectedRequestFailure(response) {
+            if (!response.headersSent && !response.destroyed) {
+                await sendHtmlAndWait(response, 500, failureHtml());
+            }
+            else {
+                response.destroy();
+            }
+            if (claimed) {
+                await finishFailure("WorkBuddy 授权失败，请重新连接", true);
+            }
+        }
+        server.once("error", (error) => {
+            clearDeadline();
+            if (!server.listening) {
+                reject(error);
+                return;
+            }
+            void finishFailure("WorkBuddy 回调监听失败", true);
+        });
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                void finishFailure("WorkBuddy 回调监听失败", true);
+                reject(new Error("WorkBuddy 回调监听失败"));
+                return;
+            }
+            timeout = setTimeout(() => {
+                void finishFailure("WorkBuddy 授权等待超时", true);
+            }, input.timeoutMs);
+            resolve({
+                redirectUri: `http://127.0.0.1:${address.port}/oauth/callback`,
+                completion,
+                close: async () => {
+                    if (!settled) {
+                        settled = true;
+                        claimed = true;
+                        clearDeadline();
+                        await closeServer(true);
+                        rejectCompletion(new Error("WorkBuddy 回调监听已关闭"));
+                        return;
+                    }
+                    await closeServer(true);
+                },
+            });
+        });
+    });
+}
+function sendHtml(response, status, body) {
+    response.writeHead(status, {
+        "Cache-Control": "no-store",
+        Connection: "close",
+        "Content-Type": "text/html; charset=utf-8",
+    });
+    response.end(body);
+}
+function sendHtmlAndWait(response, status, body) {
+    return new Promise((resolve) => {
+        response.writeHead(status, {
+            "Cache-Control": "no-store",
+            Connection: "close",
+            "Content-Type": "text/html; charset=utf-8",
+        });
+        response.end(body, resolve);
+    });
+}
+function page(title, content) {
+    return `<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="referrer" content="no-referrer">
+    <title>${title} - AI-HIVE</title>
+    <style>
+      body { margin: 0; min-height: 100vh; display: grid; place-items: center; font-family: sans-serif; background: #f8fafc; color: #0f172a; }
+      main { width: min(420px, calc(100% - 48px)); padding: 32px; border: 1px solid #e2e8f0; border-radius: 16px; background: white; box-shadow: 0 16px 40px rgb(15 23 42 / 8%); }
+      h1 { margin-top: 0; }
+      button { border: 0; border-radius: 8px; padding: 10px 16px; background: #2563eb; color: white; cursor: pointer; }
+    </style>
+  </head>
+  <body>
+    <main>${content}</main>
+  </body>
+</html>`;
+}
+function successHtml() {
+    return page("授权成功", `<h1>授权成功</h1>
+<p>请返回 WorkBuddy 继续使用。</p>
+<p>页面将尝试自动关闭；如果没有关闭，请手动关闭。</p>
+<button type="button" onclick="window.close()">关闭页面</button>
+<script>
+  window.setTimeout(() => window.close(), 300);
+</script>`);
+}
+function failureHtml() {
+    return page("授权失败", `<h1>授权失败</h1>
+<p>请返回 WorkBuddy 后重新连接。</p>`);
+}

package/dist/workbuddy-oauth-client.d.ts

@@ -0,0 +1,31 @@
+export type WorkBuddyTokenPayload = {
+    tokenType: "Bearer";
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: 3600;
+    refreshExpiresIn: 2592000;
+};
+declare class WorkBuddyOAuthError extends Error {
+}
+export declare function isWorkBuddyOAuthError(error: unknown): error is WorkBuddyOAuthError;
+export declare class WorkBuddyOAuthClient {
+    private readonly apiEndpoint;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    constructor(input: {
+        apiEndpoint: string;
+        timeoutMs: number;
+        fetchImpl?: typeof fetch;
+    });
+    exchangeAuthorizationCode(input: {
+        code: string;
+        redirectUri: string;
+        codeVerifier: string;
+    }): Promise<WorkBuddyTokenPayload>;
+    refreshToken(refreshToken: string): Promise<WorkBuddyTokenPayload>;
+    revoke(refreshToken: string): Promise<void>;
+    private requestToken;
+    private post;
+    private withTimeout;
+}
+export {};

package/dist/workbuddy-oauth-client.js

@@ -0,0 +1,126 @@
+import { z } from "zod";
+const tokenPayloadSchema = z
+    .object({
+    tokenType: z.literal("Bearer"),
+    accessToken: z.string().startsWith("wb-at-"),
+    refreshToken: z.string().startsWith("wb-rt-"),
+    expiresIn: z.literal(3600),
+    refreshExpiresIn: z.literal(2592000),
+})
+    .strict();
+const revokeResponseSchema = z.object({ ok: z.literal(true) }).strict();
+class WorkBuddyOAuthError extends Error {
+}
+export function isWorkBuddyOAuthError(error) {
+    return error instanceof WorkBuddyOAuthError;
+}
+function timeoutError() {
+    return new WorkBuddyOAuthError("WorkBuddy 认证请求超时，请稍后重试");
+}
+function requestError() {
+    return new WorkBuddyOAuthError("WorkBuddy 认证请求失败，请稍后重试");
+}
+function responseError() {
+    return new WorkBuddyOAuthError("WorkBuddy 认证响应无效");
+}
+async function discardResponseBody(response) {
+    try {
+        await response.body?.cancel();
+    }
+    catch {
+        return;
+    }
+}
+export class WorkBuddyOAuthClient {
+    apiEndpoint;
+    timeoutMs;
+    fetchImpl;
+    constructor(input) {
+        this.apiEndpoint = input.apiEndpoint.replace(/\/+$/, "");
+        this.timeoutMs = input.timeoutMs;
+        this.fetchImpl = input.fetchImpl ?? fetch;
+    }
+    async exchangeAuthorizationCode(input) {
+        return this.requestToken({
+            grantType: "authorization_code",
+            code: input.code,
+            redirectUri: input.redirectUri,
+            codeVerifier: input.codeVerifier,
+        });
+    }
+    async refreshToken(refreshToken) {
+        return this.requestToken({
+            grantType: "refresh_token",
+            refreshToken,
+        });
+    }
+    async revoke(refreshToken) {
+        const body = await this.post("/workbuddy/oauth/revoke", {
+            refreshToken,
+        });
+        if (!revokeResponseSchema.safeParse(body).success) {
+            throw responseError();
+        }
+    }
+    async requestToken(body) {
+        const responseBody = await this.post("/workbuddy/oauth/token", body);
+        const parsed = tokenPayloadSchema.safeParse(responseBody);
+        if (!parsed.success) {
+            throw responseError();
+        }
+        return parsed.data;
+    }
+    async post(path, body) {
+        return this.withTimeout(async (signal) => {
+            let response;
+            try {
+                response = await this.fetchImpl(`${this.apiEndpoint}${path}`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(body),
+                    signal,
+                });
+            }
+            catch {
+                if (signal.aborted) {
+                    throw timeoutError();
+                }
+                throw requestError();
+            }
+            if (!response.ok) {
+                await discardResponseBody(response);
+                throw new WorkBuddyOAuthError("WorkBuddy 认证失败，请重新连接");
+            }
+            try {
+                return await response.json();
+            }
+            catch {
+                throw responseError();
+            }
+        });
+    }
+    async withTimeout(operation) {
+        const controller = new AbortController();
+        let timeout;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeout = setTimeout(() => {
+                controller.abort();
+                reject(timeoutError());
+            }, this.timeoutMs);
+        });
+        try {
+            return await Promise.race([operation(controller.signal), timeoutPromise]);
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                throw timeoutError();
+            }
+            throw error;
+        }
+        finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        }
+    }
+}

package/dist/workbuddy-pkce.d.ts

@@ -0,0 +1,6 @@
+export type WorkBuddyPkcePair = {
+    state: string;
+    codeVerifier: string;
+    codeChallenge: string;
+};
+export declare function createPkcePair(): WorkBuddyPkcePair;

package/dist/workbuddy-pkce.js

@@ -0,0 +1,11 @@
+import { createHash, randomBytes } from "node:crypto";
+export function createPkcePair() {
+    const codeVerifier = randomBytes(32).toString("base64url");
+    return {
+        state: randomBytes(32).toString("base64url"),
+        codeVerifier,
+        codeChallenge: createHash("sha256")
+            .update(codeVerifier)
+            .digest("base64url"),
+    };
+}

package/package.json

@@ -1,28 +1,32 @@
 {
   "name": "@infimind-next/ai-hive-mcp",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "private": false,
   "type": "module",
+  "engines": {
+    "node": ">=20.19.0"
+  },
   "bin": {
     "ai-hive-mcp": "dist/index.js"
   },
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
-    "lint": "eslint \"src/**/*.ts\"",
-    "prepack": "pnpm run build",
-    "test": "vitest run"
-  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "file-type": "^22.0.1",
+    "file-type": "^21.3.4",
     "zod": "^3.24.0"
   },
   "devDependencies": {
+    "eslint": "^9.0.0",
     "typescript": "^5.0.0",
+    "typescript-eslint": "^8.0.0",
     "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
+    "lint": "eslint \"src/**/*.ts\"",
+    "test": "vitest run"
   }
-}
+}