@infimind-next/ai-hive-mcp 0.3.3 → 0.4.1

package/dist/managed-images.js

@@ -0,0 +1,449 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { link, lstat, open, readdir, realpath, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { AiHiveApiError } from "./api-client.js";
+import { downloadGeneratedImage } from "./managed-download.js";
+import { ManagedDirectory, ManagedFiles } from "./managed-files.js";
+import { generateImageShape, mcpCreateMediaUploadOutputSchema, } from "./schemas.js";
+export const managedPrepareShape = {
+    publicModelId: generateImageShape.publicModelId,
+    routingMode: generateImageShape.routingMode,
+    prompt: generateImageShape.prompt,
+    batchSize: generateImageShape.batchSize,
+    imageMediaIds: generateImageShape.imageMediaIds,
+    params: generateImageShape.params,
+};
+const prepareSchema = z.object(managedPrepareShape).strict();
+const pricingSchema = z
+    .object({
+    publicModelId: z.string(),
+    routingMode: z.string(),
+    billingRuleSnapshot: z.record(z.unknown()),
+})
+    .strict();
+const formalSchema = prepareSchema
+    .extend({
+    clientRequestId: z.string().uuid(),
+    pricingSnapshot: pricingSchema,
+})
+    .strict();
+const operationSchema = z
+    .object({
+    version: z.literal(1),
+    userId: z.string(),
+    operationId: z.string().uuid(),
+    phase: z.enum(["PREPARED", "SUBMITTING", "UNKNOWN", "SUBMITTED", "FAILED"]),
+    request: formalSchema,
+    preflight: z.record(z.unknown()),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    taskId: z.string().optional(),
+    savedResults: z
+        .array(z.object({ itemId: z.string(), path: z.string() }).strict())
+        .default([]),
+})
+    .strict();
+const saveSchema = z
+    .object({
+    taskId: z.string().min(1),
+    itemId: z.string().min(1),
+    relativePath: z.string().min(1).optional(),
+})
+    .strict();
+const bindingSchema = z
+    .object({
+    version: z.literal(1),
+    userId: z.string(),
+    projectRoot: z.string(),
+    apiBaseUrl: z.string(),
+})
+    .strict();
+const TASK_ERROR = "这项结果不是当前账户的图片任务，请查询原图片任务";
+const UNKNOWN_ERROR = "提交结果暂未确认，请恢复原任务，不要重新生成";
+const STATE_ERROR = "图片任务记录不可用，请从 AI-HIVE 启动器检查原任务";
+function object(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("图片服务暂不可用，请稍后再试");
+    return value;
+}
+export class ManagedImages {
+    config;
+    client;
+    tokenProvider;
+    files;
+    state;
+    download;
+    constructor(config, client, tokenProvider, files, state, download) {
+        this.config = config;
+        this.client = client;
+        this.tokenProvider = tokenProvider;
+        this.files = files;
+        this.state = state;
+        this.download = download;
+    }
+    static async create(input) {
+        const files = await ManagedFiles.create(input.config);
+        const state = await ManagedDirectory.create(input.config.stateDirectory);
+        const binding = {
+            version: 1,
+            userId: input.config.userId,
+            projectRoot: await realpath(input.config.projectRoot),
+            apiBaseUrl: input.config.apiBaseUrl.replace(/\/+$/, ""),
+        };
+        try {
+            await state.writeAtomic("binding.json", Buffer.from(JSON.stringify(binding)));
+        }
+        catch (error) {
+            if (!(error instanceof Error) ||
+                error.message !== "文件已存在，请换一个文件名")
+                throw error;
+            try {
+                const existing = bindingSchema.parse(JSON.parse((await state.read("binding.json")).toString()));
+                if (JSON.stringify(existing) !== JSON.stringify(binding))
+                    throw new Error();
+            }
+            catch {
+                throw new Error("图片工具连接已变化，请从 AI-HIVE 启动器重新打开项目");
+            }
+        }
+        return new ManagedImages(input.config, input.client, input.tokenProvider, files, state, input.download ?? downloadGeneratedImage);
+    }
+    async getUserInfo() {
+        const result = object(await this.client.getUserInfo());
+        if (result.userId !== this.config.userId)
+            throw new Error("图片工具账户已变化，请回到 AI-HIVE 启动器重新登录");
+        return result;
+    }
+    async listModels(input) {
+        await this.getUserInfo();
+        const result = await this.client.listModels({ modelType: "IMAGE", ...input }, { announcements: true });
+        if (!Array.isArray(result))
+            throw new Error("图片模型暂不可用，请稍后再试");
+        return result.filter((model) => object(model).modelType === "IMAGE");
+    }
+    async getModel(publicModelId, routingMode) {
+        await this.getUserInfo();
+        const result = object(await this.client.getModel(publicModelId, routingMode, {
+            announcements: true,
+        }));
+        if (result.modelType !== "IMAGE")
+            throw new Error("请从图片模型列表选择模型");
+        return result;
+    }
+    async upload(path) {
+        await this.getUserInfo();
+        const image = await this.files.readImage(path);
+        const upload = mcpCreateMediaUploadOutputSchema.parse(await this.client.createMediaUpload({
+            filename: image.filename,
+            contentType: image.contentType,
+            sizeBytes: image.sizeBytes,
+        }, { announcements: false }));
+        if (upload.mediaType !== "IMAGE" ||
+            upload.mimeType !== image.contentType ||
+            upload.sizeBytes !== image.sizeBytes ||
+            new URL(upload.upload.url).protocol !== "https:" ||
+            Object.keys(upload.upload.headers).some((key) => /authorization|cookie/i.test(key))) {
+            throw new Error("图片上传暂不可用，请稍后重试");
+        }
+        await this.tokenProvider.getToken();
+        await this.client.putUpload({ ...upload.upload, body: image.body });
+        return this.client.completeMediaUpload(upload.mediaId, {
+            announcements: true,
+        });
+    }
+    async prepare(input) {
+        const request = prepareSchema.parse(input);
+        await this.getUserInfo();
+        const preflight = object(await this.client.generateImage({ ...request, dryRun: true }, { announcements: false }));
+        const snapshot = pricingSchema.parse(preflight.pricingSnapshot);
+        const resolvedParams = z
+            .record(z.unknown())
+            .safeParse(preflight.resolvedParams);
+        if (!resolvedParams.success)
+            throw new Error("图片预检暂不可用，请重新检查原方案");
+        if (snapshot.publicModelId !== request.publicModelId ||
+            snapshot.routingMode !== request.routingMode ||
+            preflight.mode !== "DRY_RUN" ||
+            preflight.wouldCreateTask !== false ||
+            (request.imageMediaIds.length > 0 &&
+                Object.prototype.hasOwnProperty.call(resolvedParams.data, "imageUrls")))
+            throw new Error("图片预检暂不可用，请重新检查原方案");
+        const operationId = randomUUID();
+        const timestamp = new Date().toISOString();
+        const operation = {
+            version: 1,
+            userId: this.config.userId,
+            operationId,
+            phase: "PREPARED",
+            request: {
+                ...request,
+                // 模型默认值可能在确认后变化; 正式提交与恢复沿用已预检的非瞬态参数.
+                params: resolvedParams.data,
+                clientRequestId: operationId,
+                pricingSnapshot: snapshot,
+            },
+            preflight,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            savedResults: [],
+        };
+        await this.writeOperation(operation, false);
+        return { ...preflight, operationId, clientRequestId: operationId };
+    }
+    async generate(operationId) {
+        await this.getUserInfo();
+        return this.withOperationLock(operationId, async () => {
+            const operation = await this.readOperation(operationId);
+            if (operation.taskId)
+                return { ...object(await this.getTask(operation.taskId)), operationId };
+            if (operation.phase === "FAILED")
+                throw new Error("原任务未能提交，请确认原记录后重新预检");
+            if (operation.preflight.readyToGenerate !== true ||
+                operation.preflight.estimatedReservationMicros == null)
+                throw new Error("图片预检尚未完成，请补齐素材后重新检查");
+            await this.writeOperation({ ...operation, phase: "SUBMITTING" });
+            let result;
+            try {
+                result = object(await this.client.generateImage(operation.request, {
+                    announcements: true,
+                }));
+            }
+            catch (error) {
+                const definitive = error instanceof AiHiveApiError &&
+                    error.status !== undefined &&
+                    error.status >= 400 &&
+                    error.status < 500 &&
+                    ![401, 403, 408, 409, 429].includes(error.status);
+                await this.writeOperation({
+                    ...operation,
+                    phase: definitive ? "FAILED" : "UNKNOWN",
+                });
+                if (definitive ||
+                    (error instanceof AiHiveApiError &&
+                        [401, 403].includes(error.status ?? 0)))
+                    throw error;
+                throw new Error(UNKNOWN_ERROR);
+            }
+            if (typeof result.taskId !== "string" || result.taskType !== "IMAGE") {
+                await this.writeOperation({ ...operation, phase: "UNKNOWN" });
+                throw new Error(UNKNOWN_ERROR);
+            }
+            await this.writeOperation({
+                ...operation,
+                phase: "SUBMITTED",
+                taskId: result.taskId,
+            });
+            return { ...result, operationId };
+        });
+    }
+    async recover(operationId) {
+        await this.getUserInfo();
+        const operation = await this.readOperation(operationId);
+        if (operation.phase === "PREPARED")
+            throw new Error("这项图片方案尚未提交，请确认方案和费用后生成");
+        return this.generate(operationId);
+    }
+    async getTask(taskId) {
+        await this.getUserInfo();
+        const task = object(await this.client.getGenerationTask({ taskId }, { announcements: true }));
+        if (task.taskType !== "IMAGE" || task.taskId !== taskId)
+            throw new Error(TASK_ERROR);
+        return task;
+    }
+    async list() {
+        await this.getUserInfo();
+        await this.state.assertUnchanged();
+        const names = await readdir(this.state.path);
+        const operations = await Promise.all(names
+            .filter((name) => /^operation-[0-9a-f-]{36}\.json$/.test(name))
+            .map((name) => this.readOperation(name.slice(10, -5))));
+        return operations
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+            .map((operation) => ({
+            operationId: operation.operationId,
+            phase: operation.phase,
+            taskId: operation.taskId,
+            prompt: operation.request.prompt,
+            publicModelId: operation.request.publicModelId,
+            createdAt: operation.createdAt,
+            estimatedReservationMicros: operation.preflight.estimatedReservationMicros,
+            savedResults: operation.savedResults,
+        }));
+    }
+    async save(input) {
+        const { taskId, itemId, relativePath } = saveSchema.parse(input);
+        const task = await this.getTask(taskId);
+        const item = Array.isArray(task.items)
+            ? task.items.find((item) => object(item).id === itemId)
+            : undefined;
+        const result = item ? object(item) : undefined;
+        if (!result ||
+            result.status !== "COMPLETED" ||
+            typeof result.resultUrl !== "string" ||
+            result.settlementPending === true)
+            throw new Error("图片结果尚不可用，请稍后查询原任务");
+        await this.tokenProvider.getToken();
+        const saved = await this.files.saveImage(await this.download(result.resultUrl), relativePath);
+        await this.recordSavedResult(taskId, itemId, saved.path);
+        return { taskId, itemId, ...saved };
+    }
+    async recordSavedResult(taskId, itemId, path) {
+        // 图片已确认落盘; 后续本地记录失败不能让调用方误以为保存失败而重试.
+        try {
+            await this.state.assertUnchanged();
+            const names = await readdir(this.state.path);
+            for (const name of names) {
+                if (!/^operation-[0-9a-f-]{36}\.json$/.test(name))
+                    continue;
+                try {
+                    const operation = await this.readOperation(name.slice(10, -5));
+                    if (operation.taskId !== taskId)
+                        continue;
+                    await this.withOperationLock(operation.operationId, async () => {
+                        const current = await this.readOperation(operation.operationId);
+                        if (current.taskId !== taskId)
+                            return;
+                        await this.writeOperation({
+                            ...current,
+                            savedResults: [...current.savedResults, { itemId, path }],
+                        });
+                    });
+                }
+                catch {
+                    // 跳过单条不可用记录, 保留原任务用于查询和恢复.
+                }
+            }
+        }
+        catch {
+            // 记录目录暂不可用时仍返回已保存的路径, 不改变文件和任务状态.
+        }
+    }
+    async readOperation(operationId) {
+        try {
+            z.string().uuid().parse(operationId);
+            const operation = operationSchema.parse(JSON.parse((await this.state.read(`operation-${operationId}.json`)).toString()));
+            if (operation.userId !== this.config.userId ||
+                operation.operationId !== operationId ||
+                operation.request.clientRequestId !== operationId ||
+                JSON.stringify(operation.preflight.pricingSnapshot) !==
+                    JSON.stringify(operation.request.pricingSnapshot))
+                throw new Error();
+            return operation;
+        }
+        catch {
+            throw new Error(STATE_ERROR);
+        }
+    }
+    writeOperation(operation, overwrite = true) {
+        return this.state.writeAtomic(`operation-${operation.operationId}.json`, Buffer.from(JSON.stringify({ ...operation, updatedAt: new Date().toISOString() })), overwrite);
+    }
+    async withOperationLock(operationId, action) {
+        z.string().uuid().parse(operationId);
+        await this.state.assertUnchanged();
+        const lockPath = join(this.state.path, `operation-${operationId}.lock`);
+        const temporaryPath = await this.state.writeAtomic(`.operation-${operationId}-${randomUUID()}.lock.tmp`, Buffer.from(JSON.stringify({ pid: process.pid })));
+        const temporary = await open(temporaryPath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const identity = await temporary.stat();
+        const matchesIdentity = (value) => value.isFile() &&
+            !value.isSymbolicLink() &&
+            value.dev === identity.dev &&
+            value.ino === identity.ino;
+        let ownsLock = false;
+        const removeOwned = async (path) => {
+            await this.state.assertUnchanged();
+            const current = await lstat(path).catch((error) => {
+                if (error &&
+                    typeof error === "object" &&
+                    "code" in error &&
+                    error.code === "ENOENT")
+                    return null;
+                throw error;
+            });
+            if (current && matchesIdentity(current))
+                await unlink(path);
+        };
+        const acquire = async () => {
+            await this.state.assertUnchanged();
+            if (!matchesIdentity(await lstat(temporaryPath)))
+                throw new Error(STATE_ERROR);
+            // 先写完整 owner, 再发布硬链接; 崩溃不会留下无法判断归属的空锁.
+            await link(temporaryPath, lockPath);
+            ownsLock = true;
+            await this.state.assertUnchanged();
+            if (!matchesIdentity(await lstat(lockPath)))
+                throw new Error(STATE_ERROR);
+        };
+        try {
+            try {
+                await acquire();
+            }
+            catch (error) {
+                if (!(error &&
+                    typeof error === "object" &&
+                    "code" in error &&
+                    error.code === "EEXIST"))
+                    throw new Error(STATE_ERROR);
+                try {
+                    const before = await lstat(lockPath);
+                    if (!before.isFile() || before.isSymbolicLink())
+                        throw new Error();
+                    const stale = await open(lockPath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+                    try {
+                        const information = await stale.stat();
+                        if (information.dev !== before.dev ||
+                            information.ino !== before.ino ||
+                            information.size > 4096)
+                            throw new Error();
+                        const value = JSON.parse((await stale.readFile()).toString());
+                        if (typeof value.pid !== "number" ||
+                            !Number.isSafeInteger(value.pid) ||
+                            value.pid <= 0)
+                            throw new Error();
+                        let alive = true;
+                        try {
+                            process.kill(value.pid, 0);
+                        }
+                        catch (cause) {
+                            if (cause &&
+                                typeof cause === "object" &&
+                                "code" in cause &&
+                                cause.code === "ESRCH")
+                                alive = false;
+                        }
+                        if (alive)
+                            throw new Error();
+                        await this.state.assertUnchanged();
+                        const after = await lstat(lockPath);
+                        if (!after.isFile() ||
+                            after.isSymbolicLink() ||
+                            before.ino !== after.ino ||
+                            before.dev !== after.dev)
+                            throw new Error();
+                        await unlink(lockPath);
+                    }
+                    finally {
+                        await stale.close();
+                    }
+                    await acquire();
+                }
+                catch {
+                    throw new Error("原任务正在处理，请稍后查询原记录");
+                }
+            }
+            await removeOwned(temporaryPath);
+            return await action();
+        }
+        finally {
+            try {
+                if (ownsLock)
+                    await removeOwned(lockPath);
+                await removeOwned(temporaryPath);
+            }
+            finally {
+                await temporary.close();
+            }
+        }
+    }
+}

package/dist/managed-server.d.ts

@@ -0,0 +1,15 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { BearerTokenProvider } from "./auth-token-provider.js";
+import type { McpManagedConfig } from "./managed-config.js";
+export declare function createManagedServer(input: {
+    config: McpManagedConfig;
+    timeoutMs: number;
+    tokenProvider?: BearerTokenProvider;
+    fetchImpl?: typeof fetch;
+}): Promise<McpServer>;
+export declare function registerManagedProcess(config: McpManagedConfig, managedConfigPath: string): Promise<() => Promise<void>>;
+export declare function runManagedServer(input: {
+    config: McpManagedConfig;
+    timeoutMs: number;
+    managedConfigPath: string;
+}): Promise<void>;

package/dist/managed-server.js

@@ -0,0 +1,195 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { AiHiveApiClient, AiHiveApiError } from "./api-client.js";
+import { ManagedDirectory } from "./managed-files.js";
+import { ManagedImages, managedPrepareShape } from "./managed-images.js";
+import { ManagedBearerTokenProvider } from "./managed-token-provider.js";
+import { readMcpClientInfo } from "./client-info.js";
+import { SERVER_VERSION } from "./server.js";
+import { toolResultContent } from "./user-notices.js";
+const INSTRUCTIONS = [
+    "AI-HIVE 图片工具仅用于当前蜂巢账户和当前项目。先选择图片模型并读取模型契约，再免费预检准备方案。",
+    "prepare_image_generation 返回的 operationId 代表已持久化的原方案和费用。用户确认方案和费用后再调用 generate_image；正式生成只传原 operationId，不更换请求编号或修改原方案。费用或素材变化时重新预检并取得用户确认。",
+    "预检仅校验参数和素材，不执行内容审核，也不保证生成成功。估价为空或 readyToGenerate=false 时补齐素材再预检。",
+    "提交结果未知时调用 recover_image_generation 恢复原请求；已收到 taskId 时仅查询原任务。FAILED 记录不自动重新付费；先核查原任务。停止工具或关闭启动器只停止本地等待，已受理的服务器任务可能继续生成和结算。",
+    "本地图片只能来自当前项目或启动器明确选择的单个图片。结果通过 save_generation_result(taskId,itemId,relativePath?) 保存，relativePath 仅为文件名，目录固定为项目的 ai-hive-images，已有文件不覆盖。不要传入下载 URL。",
+    "同账户重新登录后可查询 list_image_operations 恢复原记录。新登录会使旧连接失效；账户变化后返回启动器重新打开项目。",
+    "向用户说明结果、费用和下一步；不要展示密钥、内部诊断或重试机制。余额不足时使用账户结果的充值链接；不擅自切换模型或继续付费。",
+].join("\n");
+function resultContent(value) {
+    return {
+        content: toolResultContent(value),
+        structuredContent: Object.fromEntries(Object.entries(value).filter(([key]) => key !== "userNotices")),
+    };
+}
+export async function createManagedServer(input) {
+    const server = new McpServer({ name: "ai-hive-images", version: SERVER_VERSION }, { instructions: INSTRUCTIONS });
+    const tokenProvider = input.tokenProvider ??
+        new ManagedBearerTokenProvider(input.config.credentialHelper);
+    const client = new AiHiveApiClient({
+        endpoint: input.config.apiBaseUrl,
+        clientKind: "codex-launcher",
+        tokenProvider,
+        timeoutMs: input.timeoutMs,
+        fetchImpl: input.fetchImpl,
+        clientInfoProvider: () => readMcpClientInfo(server),
+    });
+    const images = await ManagedImages.create({
+        config: input.config,
+        client,
+        tokenProvider,
+    });
+    const tools = [
+        {
+            name: "get_user_info",
+            description: "查看你的蜂巢账户资料、蜂蜜余额和充值入口。",
+            schema: {},
+            handler: () => images.getUserInfo(),
+        },
+        {
+            name: "list_models",
+            description: "查询可用图片模型和价格；detail=lite 用于选型，full 返回完整信息。",
+            schema: { detail: z.enum(["lite", "full"]).optional() },
+            handler: async (args) => ({
+                models: await images.listModels(args),
+            }),
+        },
+        {
+            name: "get_model",
+            description: "查询所选图片模型的参数、素材要求和费用。",
+            schema: {
+                publicModelId: z.string().min(1),
+                routingMode: z
+                    .enum(["COST_FIRST", "SPEED_FIRST", "SUCCESS_FIRST"])
+                    .optional(),
+            },
+            handler: (args) => images.getModel(String(args.publicModelId), args.routingMode),
+        },
+        {
+            name: "upload_media_from_path",
+            description: "上传项目或启动器明确选择的本地图片，返回 mediaId。仅接收绝对路径，按实际图片内容识别格式，最大 30MiB；同时受模型与服务端限制。",
+            schema: { path: z.string().min(1) },
+            handler: async (args) => (await images.upload(String(args.path))),
+        },
+        {
+            name: "prepare_image_generation",
+            description: "免费检查图片方案和已上传素材，返回预估费用及 operationId，不创建生成任务；保留原方案供用户确认后提交。",
+            schema: managedPrepareShape,
+            handler: (args) => images.prepare(args),
+        },
+        {
+            name: "generate_image",
+            description: "用户确认方案和费用后，按免费预检保存的 operationId 正式生成图片。仅接受原编号，不接收新参数。提交未知时恢复原请求，避免重复创建。",
+            schema: { operationId: z.string().uuid() },
+            handler: (args) => images.generate(String(args.operationId)),
+        },
+        {
+            name: "get_generation_task",
+            description: "查询当前账户的原图片任务。已获得 taskId 后查询结果，不重复生成。",
+            schema: { taskId: z.string().min(1) },
+            handler: (args) => images.getTask(String(args.taskId)),
+        },
+        {
+            name: "recover_image_generation",
+            description: "恢复提交结果未知的原图片请求，保持原方案、报价和幂等编号；已有 taskId 时只查询，不重新生成。",
+            schema: { operationId: z.string().uuid() },
+            handler: (args) => images.recover(String(args.operationId)),
+        },
+        {
+            name: "list_image_operations",
+            description: "列出当前账户和项目已保存的图片方案、提交状态、原任务和本地结果。",
+            schema: {},
+            handler: async () => ({ operations: await images.list() }),
+        },
+        {
+            name: "save_generation_result",
+            description: "查询原图片任务并将已完成的指定结果安全保存到项目 ai-hive-images。relativePath 只接收文件名，已有文件不覆盖；不接收 URL。",
+            schema: {
+                taskId: z.string().min(1),
+                itemId: z.string().min(1),
+                relativePath: z.string().min(1).optional(),
+            },
+            handler: (args) => images.save(args),
+        },
+    ];
+    for (const tool of tools) {
+        server.registerTool(tool.name, {
+            description: tool.description,
+            inputSchema: z.object(tool.schema).strict(),
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                openWorldHint: true,
+            },
+        }, async (args) => {
+            try {
+                return resultContent(await tool.handler(args));
+            }
+            catch (error) {
+                const message = error instanceof AiHiveApiError
+                    ? error.message
+                    : error instanceof z.ZodError
+                        ? "图片方案暂不可用，请检查所选模型和素材"
+                        : error instanceof Error &&
+                            /^[\u4e00-\u9fff]/.test(error.message) &&
+                            !/[\r\n]/.test(error.message)
+                            ? error.message
+                            : "图片操作暂不可用，请稍后查询原任务";
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: message }],
+                };
+            }
+        });
+    }
+    return server;
+}
+export async function registerManagedProcess(config, managedConfigPath) {
+    const state = await ManagedDirectory.create(config.stateDirectory);
+    const filename = `process-${process.pid}.json`;
+    await state.writeAtomic(filename, Buffer.from(JSON.stringify({
+        version: 1,
+        activationId: config.activationId,
+        userId: config.userId,
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        managedConfigPath,
+    })), true);
+    return async () => {
+        await state.assertUnchanged();
+        await unlink(join(state.path, filename)).catch(() => { });
+    };
+}
+export async function runManagedServer(input) {
+    const server = await createManagedServer(input);
+    const unregister = await registerManagedProcess(input.config, input.managedConfigPath);
+    let cleanupPromise;
+    // close 与 signal 回调可能同时开始清理; 两条路径都必须等待同一个删除操作.
+    const cleanup = () => {
+        cleanupPromise ??= unregister().catch(() => { });
+        return cleanupPromise;
+    };
+    const stop = () => {
+        void server.close().finally(async () => {
+            await cleanup();
+            process.exit(0);
+        });
+    };
+    process.once("SIGTERM", stop);
+    process.once("SIGINT", stop);
+    server.server.onclose = () => {
+        void cleanup();
+        process.removeListener("SIGTERM", stop);
+        process.removeListener("SIGINT", stop);
+    };
+    try {
+        await server.connect(new StdioServerTransport());
+    }
+    catch (error) {
+        await cleanup();
+        throw error;
+    }
+}

package/dist/managed-token-provider.d.ts

@@ -0,0 +1,11 @@
+import type { BearerTokenProvider } from "./auth-token-provider.js";
+export declare const MANAGED_AUTH_ERROR = "\u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u56DE\u5230 AI-HIVE \u542F\u52A8\u5668\u91CD\u65B0\u767B\u5F55";
+export declare class ManagedBearerTokenProvider implements BearerTokenProvider {
+    private readonly helper;
+    constructor(helper: {
+        command: string;
+        args: string[];
+    });
+    getToken(): Promise<string>;
+    refreshAfterUnauthorized(): Promise<string>;
+}