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

package/dist/managed-files.js

@@ -1,9 +1,12 @@
 import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, realpath, stat } from "node:fs/promises";
-import { basename, isAbsolute, join, relative, sep } from "node:path";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileTypeFromBuffer } from "file-type";
 export const MAX_MANAGED_IMAGE_BYTES = 30 * 1024 * 1024;
+export const MAX_MANAGED_VIDEO_BYTES = 200 * 1024 * 1024;
+// MCP 服务端单文件上传上限是 100MiB; 本地先拦一次, 避免白传.
+const MAX_MANAGED_VIDEO_UPLOAD_BYTES = 100 * 1024 * 1024;
 const IMAGE_TYPES = new Set([
     "image/png",
     "image/jpeg",
@@ -15,7 +18,8 @@ const IMAGE_TYPES = new Set([
     "image/heif",
     "image/avif",
 ]);
-const PATH_ERROR = "图片不在已授权范围，请从 AI-HIVE 启动器选择图片";
+const VIDEO_TYPES = new Set(["video/mp4", "video/webm", "video/quicktime"]);
+const PATH_ERROR = "文件不在已授权范围，请从 AI-HIVE 启动器选择文件";
 const OUTPUT_ERROR = "结果目录已变化，请从 AI-HIVE 启动器重新打开项目";
 export function safeFilename(value) {
     if (!value ||
@@ -25,7 +29,7 @@ export function safeFilename(value) {
         /[\\/:\x00-\x1f\x7f]/.test(value) ||
         /[. ]$/.test(value) ||
         /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(value)) {
-        throw new Error("请使用结果文件名，图片将保存在项目的 ai-hive-images 文件夹");
+        throw new Error("请使用结果文件名，媒体将保存在项目的 ai-hive-media 文件夹");
     }
     return value;
 }
@@ -39,6 +43,19 @@ export async function inspectImage(bytes) {
     }
     return detected;
 }
+export async function inspectVideo(bytes) {
+    if (!bytes.byteLength || bytes.byteLength > MAX_MANAGED_VIDEO_BYTES) {
+        throw new Error("视频大小超过限制，最大 200MiB");
+    }
+    const detected = await fileTypeFromBuffer(bytes).catch(() => undefined);
+    if (!detected || !VIDEO_TYPES.has(detected.mime)) {
+        throw new Error("暂不支持这个视频，请选择 MP4、WebM 或 MOV 文件");
+    }
+    return detected;
+}
+export function inspectMedia(bytes, kind) {
+    return kind === "VIDEO" ? inspectVideo(bytes) : inspectImage(bytes);
+}
 // 子进程的 cwd 由操作系统固定到目录 inode; 文件写入使用相对路径,
 // 防止校验后父目录被替换导致写入目录外. 不把任何账户密钥传给写入进程.
 const ATOMIC_WRITE_SCRIPT = `
@@ -47,7 +64,7 @@ const [name,dev,ino,overwrite]=process.argv.slice(1);
 const current=fs.statSync('.');
 if(String(current.dev)!==dev||String(current.ino)!==ino){process.stdout.write('DIRECTORY_CHANGED');process.exit(1)}
 let temp='.hive-'+crypto.randomUUID()+'.tmp';let chunks=[];let total=0;
-process.stdin.on('data',chunk=>{total+=chunk.length;if(total>31457280){process.exit(1)}chunks.push(chunk)});
+process.stdin.on('data',chunk=>{total+=chunk.length;if(total>209715200){process.exit(1)}chunks.push(chunk)});
 process.stdin.on('end',()=>{try{
 const fd=fs.openSync(temp,'wx',0o600);try{fs.writeFileSync(fd,Buffer.concat(chunks));fs.fsyncSync(fd)}finally{fs.closeSync(fd)}
 if(overwrite==='true'){try{if(fs.lstatSync(name).isSymbolicLink())throw Error('SYMLINK')}catch(error){if(error.code!=='ENOENT')throw error}fs.renameSync(temp,name)}
@@ -90,7 +107,7 @@ export class ManagedDirectory {
     async writeAtomic(filename, bytes, overwrite = false) {
         safeFilename(filename);
         await this.assertUnchanged();
-        if (bytes.byteLength > MAX_MANAGED_IMAGE_BYTES)
+        if (bytes.byteLength > MAX_MANAGED_VIDEO_BYTES)
             throw new Error("文件过大，请缩小后再试");
         await new Promise((resolve, reject) => {
             const child = spawn(process.execPath, [
@@ -144,32 +161,61 @@ export class ManagedFiles {
     projectRoot;
     projectIdentity;
     extra;
+    outputDirectory;
     output;
-    constructor(projectRoot, projectIdentity, extra, output) {
+    constructor(projectRoot, projectIdentity, extra, outputDirectory) {
         this.projectRoot = projectRoot;
         this.projectIdentity = projectIdentity;
         this.extra = extra;
-        this.output = output;
+        this.outputDirectory = outputDirectory;
     }
     static async create(input) {
         const projectRoot = await realpath(input.projectRoot);
         const information = await stat(projectRoot);
         if (!information.isDirectory())
             throw new Error(PATH_ERROR);
-        const expectedOutput = join(projectRoot, "ai-hive-images");
-        const output = await ManagedDirectory.create(input.outputDirectory);
-        if (output.path !== expectedOutput)
+        // 项目根可能经过 /var -> /private/var 之类的 canonicalize; 输出目录必须按
+        // 原始项目根解析出相对名, 再拼到 canonical 根下.
+        const outputName = relative(resolve(input.projectRoot), resolve(input.outputDirectory));
+        if (outputName !== "ai-hive-media" &&
+            // 旧实例仍在用图片目录; 新配置统一写 ai-hive-media.
+            outputName !== "ai-hive-images")
             throw new Error(OUTPUT_ERROR);
+        const outputDirectory = join(projectRoot, outputName);
         const extra = new Set();
         for (const path of input.extraImagePaths) {
-            const canonical = await realpath(path);
-            if (!(await stat(canonical)).isFile())
-                throw new Error(PATH_ERROR);
-            extra.add(canonical);
+            try {
+                const canonical = await realpath(path);
+                if ((await stat(canonical)).isFile())
+                    extra.add(canonical);
+            }
+            catch {
+                // 配置后文件被移走时跳过; 具体读取会返回授权范围错误, 不影响其他工具启动.
+            }
         }
-        return new ManagedFiles(projectRoot, { dev: information.dev, ino: information.ino }, extra, output);
+        return new ManagedFiles(projectRoot, { dev: information.dev, ino: information.ino }, extra, outputDirectory);
     }
-    async readImage(path) {
+    async mediaOutput() {
+        if (this.output)
+            return this.output;
+        // 启动后项目根可能被删除或替换成符号链接; 懒创建前必须重新核对身份,
+        // 否则 mkdir -p 会跟随新根, 把生成结果写到项目外.
+        await this.assertProjectRoot();
+        const created = await ManagedDirectory.create(this.outputDirectory);
+        await this.assertProjectRoot();
+        this.output = created;
+        return created;
+    }
+    async assertProjectRoot() {
+        const project = await stat(this.projectRoot).catch(() => {
+            throw new Error(PATH_ERROR);
+        });
+        if (project.dev !== this.projectIdentity.dev ||
+            project.ino !== this.projectIdentity.ino ||
+            (await realpath(this.projectRoot).catch(() => "")) !== this.projectRoot)
+            throw new Error(PATH_ERROR);
+    }
+    async readMedia(path, kind) {
         if (!isAbsolute(path))
             throw new Error(PATH_ERROR);
         const project = await stat(this.projectRoot);
@@ -197,22 +243,26 @@ export class ManagedFiles {
                 before.ino !== information.ino ||
                 (await realpath(path)) !== canonical)
                 throw new Error(PATH_ERROR);
-            if (information.size > MAX_MANAGED_IMAGE_BYTES)
-                throw new Error("图片大小超过限制，最大 30MiB");
+            const limit = kind === "VIDEO"
+                ? MAX_MANAGED_VIDEO_UPLOAD_BYTES
+                : MAX_MANAGED_IMAGE_BYTES;
+            const label = kind === "VIDEO" ? "视频" : "图片";
+            if (information.size > limit)
+                throw new Error(`${label}大小超过限制，最大 ${Math.floor(limit / 1024 / 1024)}MiB`);
             const bytes = Buffer.alloc(information.size);
             let offset = 0;
             while (offset < bytes.length) {
                 const read = await file.read(bytes, offset, bytes.length - offset, offset);
                 if (!read.bytesRead)
-                    throw new Error("图片已变化，请重新选择图片");
+                    throw new Error(`${label}已变化，请重新选择`);
                 offset += read.bytesRead;
             }
             const after = await file.stat();
             if (after.size !== information.size ||
                 after.mtimeMs !== information.mtimeMs ||
                 after.ctimeMs !== information.ctimeMs)
-                throw new Error("图片已变化，请重新选择图片");
-            const detected = await inspectImage(bytes);
+                throw new Error(`${label}已变化，请重新选择`);
+            const detected = await inspectMedia(bytes, kind);
             return {
                 filename: basename(path),
                 contentType: detected.mime,
@@ -224,17 +274,39 @@ export class ManagedFiles {
             await file.close();
         }
     }
-    async saveImage(bytes, relativePath) {
-        const detected = await inspectImage(bytes);
-        const filename = safeFilename(relativePath ?? `image-${crypto.randomUUID()}.${detected.ext}`);
+    async readMediaAuto(path) {
+        const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
+        const kind = [
+            ".mp4",
+            ".webm",
+            ".mov",
+            ".m4v",
+        ].includes(extension)
+            ? "VIDEO"
+            : "IMAGE";
+        return this.readMedia(path, kind);
+    }
+    readImage(path) {
+        return this.readMedia(path, "IMAGE");
+    }
+    async saveMedia(bytes, kind, relativePath) {
+        const detected = await inspectMedia(bytes, kind);
+        const prefix = kind === "VIDEO" ? "video" : "image";
+        const filename = safeFilename(relativePath ?? `${prefix}-${crypto.randomUUID()}.${detected.ext}`);
         const extension = filename
             .slice(filename.lastIndexOf(".") + 1)
             .toLowerCase();
         if (!(extension === detected.ext ||
             (detected.ext === "jpg" && extension === "jpeg") ||
             (detected.ext === "tif" && extension === "tiff")))
-            throw new Error("文件名的扩展名需要与图片格式一致");
-        const path = await this.output.writeAtomic(filename, bytes);
+            throw new Error(kind === "VIDEO"
+                ? "文件名的扩展名需要与视频格式一致"
+                : "文件名的扩展名需要与图片格式一致");
+        const output = await this.mediaOutput();
+        const path = await output.writeAtomic(filename, bytes);
         return { path, contentType: detected.mime, sizeBytes: bytes.length };
     }
+    saveImage(bytes, relativePath) {
+        return this.saveMedia(bytes, "IMAGE", relativePath);
+    }
 }

package/dist/managed-images.d.ts

@@ -1,7 +1,9 @@
 import { z } from "zod";
 import { AiHiveApiClient } from "./api-client.js";
+import { type ModelSection } from "./model-response.js";
 import type { BearerTokenProvider } from "./auth-token-provider.js";
 import type { McpManagedConfig } from "./managed-config.js";
+import { type ManagedMediaKind } from "./managed-files.js";
 export declare const managedPrepareShape: {
     publicModelId: z.ZodString;
     routingMode: z.ZodEnum<["COST_FIRST", "SPEED_FIRST", "SUCCESS_FIRST"]>;
@@ -10,8 +12,18 @@ export declare const managedPrepareShape: {
     imageMediaIds: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodNull]>, string[], string[] | null>>;
     params: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>, Record<string, unknown>, Record<string, unknown> | null>>;
 };
-type ImageClient = Pick<AiHiveApiClient, "getUserInfo" | "listModels" | "getModel" | "generateImage" | "getGenerationTask" | "createMediaUpload" | "putUpload" | "completeMediaUpload">;
-export declare class ManagedImages {
+export declare const managedPrepareVideoShape: {
+    publicModelId: z.ZodString;
+    routingMode: z.ZodEnum<["COST_FIRST", "SPEED_FIRST", "SUCCESS_FIRST"]>;
+    prompt: z.ZodEffects<z.ZodString, string, string>;
+    imageMediaIds: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodNull]>, string[], string[] | null>>;
+    videoMediaIds: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodNull]>, string[], string[] | null>>;
+    firstFrameMediaId: z.ZodOptional<z.ZodString>;
+    lastFrameMediaId: z.ZodOptional<z.ZodString>;
+    params: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>, Record<string, unknown>, Record<string, unknown> | null>>;
+};
+type ImageClient = Pick<AiHiveApiClient, "getUserInfo" | "listModels" | "getModel" | "generateImage" | "generateVideo" | "getGenerationTask" | "createMediaUpload" | "putUpload" | "completeMediaUpload">;
+export declare class ManagedMedia {
     private readonly config;
     private readonly client;
     private readonly tokenProvider;
@@ -23,38 +35,70 @@ export declare class ManagedImages {
         config: McpManagedConfig;
         client: ImageClient;
         tokenProvider: BearerTokenProvider;
-        download?: (url: string) => Promise<Uint8Array>;
-    }): Promise<ManagedImages>;
+        download?: (url: string, kind: ManagedMediaKind) => Promise<Uint8Array>;
+    }): Promise<ManagedMedia>;
     getUserInfo(): Promise<Record<string, unknown>>;
-    listModels(input: {
-        detail?: "lite" | "full";
-    }): Promise<any[]>;
-    getModel(publicModelId: string, routingMode?: string): Promise<Record<string, unknown>>;
+    listModels(rawInput: Record<string, unknown>): Promise<any[] | {
+        schemaVersion: 2;
+        notices: {
+            id: string;
+            revision: string;
+            kind: "RECHARGE_PROMOTION" | "ANNOUNCEMENT";
+            message: string;
+            title: string;
+            details: string;
+            expiresAt: string | null;
+            action?: {
+                label: string;
+                url: string;
+            } | undefined;
+        }[];
+        models: {
+            modelType: "TEXT" | "IMAGE" | "VIDEO";
+            publicModelId: string;
+            displayName: string;
+            materialMode: "standard" | "certified";
+        }[];
+        nextCursor: string | null;
+    }>;
+    getModel(publicModelId: string, routingMode?: string, options?: {
+        schemaVersion?: 1 | 2;
+        sections?: ModelSection[];
+    }): Promise<Record<string, unknown>>;
     upload(path: string): Promise<unknown>;
     prepare(input: unknown): Promise<{
         operationId: `${string}-${string}-${string}-${string}-${string}`;
         clientRequestId: `${string}-${string}-${string}-${string}-${string}`;
     }>;
+    prepareVideo(input: unknown): Promise<{
+        operationId: `${string}-${string}-${string}-${string}-${string}`;
+        clientRequestId: `${string}-${string}-${string}-${string}-${string}`;
+    }>;
+    private createPrepared;
     generate(operationId: string): Promise<{
         operationId: string;
     }>;
     recover(operationId: string): Promise<{
         operationId: string;
     }>;
-    getTask(taskId: string): Promise<Record<string, unknown>>;
+    getTask(taskId: string, expectedKind?: ManagedMediaKind): Promise<Record<string, unknown>>;
     list(): Promise<{
-        operationId: string;
-        phase: "UNKNOWN" | "PREPARED" | "SUBMITTING" | "SUBMITTED" | "FAILED";
-        taskId: string | undefined;
-        prompt: string;
-        publicModelId: string;
-        createdAt: string;
-        estimatedReservationMicros: unknown;
-        savedResults: {
-            path: string;
-            itemId: string;
+        operations: {
+            operationId: string;
+            kind: "IMAGE" | "VIDEO";
+            phase: "UNKNOWN" | "PREPARED" | "SUBMITTING" | "SUBMITTED" | "FAILED";
+            taskId: string | undefined;
+            prompt: string;
+            publicModelId: string;
+            createdAt: string;
+            estimatedReservationMicros: unknown;
+            savedResults: {
+                path: string;
+                itemId: string;
+            }[];
         }[];
-    }[]>;
+        skipped: number;
+    }>;
     save(input: unknown): Promise<{
         path: string;
         contentType: string;
@@ -67,4 +111,4 @@ export declare class ManagedImages {
     private writeOperation;
     private withOperationLock;
 }
-export {};
+export { ManagedMedia as ManagedImages };