kie-ai-cli 1.0.0

package/dist/image.js

@@ -0,0 +1,233 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createJob, getJobInfo, pollJob } from './job.js';
+import { buildImageTaskInput, formatImageModelLabel, resolveImageModel, } from './image-models.js';
+import { IMAGE_DOWNLOAD_TIMEOUT_MS, isAbortError } from './kie-http.js';
+function formatDownloadSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/** 流式下载，带超时与进度回调 */
+async function downloadUrlToBuffer(url, onProgress) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), IMAGE_DOWNLOAD_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, {
+            signal: ac.signal,
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (compatible; kie-cli/1.0)',
+                Accept: 'image/*,*/*;q=0.8',
+            },
+            redirect: 'follow',
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} ${response.statusText || ''}`.trim());
+        }
+        const total = Number(response.headers.get('content-length')) || 0;
+        const body = response.body;
+        if (!body) {
+            onProgress?.('正在读取响应…');
+            return Buffer.from(await response.arrayBuffer());
+        }
+        const reader = body.getReader();
+        const chunks = [];
+        let received = 0;
+        let lastTick = 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = Buffer.from(value);
+            chunks.push(chunk);
+            received += chunk.length;
+            const now = Date.now();
+            if (onProgress && now - lastTick >= 400) {
+                lastTick = now;
+                const pct = total > 0 ? ` ${Math.min(100, Math.round((received / total) * 100))}%` : '';
+                const totalPart = total > 0 ? ` / ${formatDownloadSize(total)}` : '';
+                onProgress(`正在下载 ${formatDownloadSize(received)}${totalPart}${pct}`);
+            }
+        }
+        if (received === 0) {
+            throw new Error('响应体为空');
+        }
+        return Buffer.concat(chunks);
+    }
+    catch (err) {
+        if (isAbortError(err)) {
+            throw new Error(`下载超时（${IMAGE_DOWNLOAD_TIMEOUT_MS / 1000}s）。可改用 --no-download 仅保留链接，或浏览器直接打开 URL`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function parseResultUrls(resultJson) {
+    if (!resultJson)
+        return [];
+    try {
+        const result = JSON.parse(resultJson);
+        if (Array.isArray(result.resultUrls) && result.resultUrls.length > 0) {
+            return result.resultUrls;
+        }
+        if (typeof result.resultUrl === 'string')
+            return [result.resultUrl];
+        if (typeof result.url === 'string')
+            return [result.url];
+    }
+    catch {
+        /* ignore */
+    }
+    return [];
+}
+export async function downloadResultImages(urls, outputDir) {
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    const saved = [];
+    let imgIndex = 1;
+    for (const url of urls) {
+        console.log(chalk.cyan(`  🔗 ${url}`));
+        try {
+            const spinnerDl = ora({
+                text: '正在连接…',
+                discardStdin: false,
+            }).start();
+            const buffer = await downloadUrlToBuffer(url, (label) => {
+                spinnerDl.text = label;
+            });
+            const ext = url.split('.').pop()?.split('?')[0].toLowerCase() || 'png';
+            const safeExt = ['png', 'jpg', 'jpeg', 'webp', 'gif'].includes(ext) ? ext : 'png';
+            const fileName = `kie_img_${Date.now()}_${imgIndex}.${safeExt}`;
+            const filePath = path.join(outputDir, fileName);
+            fs.writeFileSync(filePath, buffer);
+            spinnerDl.succeed(`已保存: ${filePath} (${formatDownloadSize(buffer.length)})`);
+            saved.push(filePath);
+            imgIndex++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(chalk.red(`  ⚠️ 下载失败: ${msg}`));
+            console.log(chalk.gray(`     可手动打开: ${url}`));
+        }
+    }
+    return saved;
+}
+export function printJobStatus(info, taskId) {
+    console.log(chalk.cyan('\n任务详情:\n'));
+    console.log(`  任务 ID: ${chalk.bold(taskId)}`);
+    console.log(`  状态:   ${chalk.bold(info.state)}`);
+    console.log(`  进度:   ${info.progress ?? 0}%`);
+    if (info.model)
+        console.log(`  模型:   ${info.model}`);
+    if (info.failMsg)
+        console.log(chalk.red(`  失败:   ${info.failMsg}`));
+    const urls = parseResultUrls(info.resultJson);
+    if (urls.length > 0) {
+        console.log(chalk.green('\n  结果链接:'));
+        urls.forEach((u) => console.log(chalk.cyan(`    ${u}`)));
+    }
+    console.log();
+}
+/** 提交任务 → 轮询 → 可选下载 */
+export async function runImageGeneration(options) {
+    const { config, apiKey, baseUrl, prompt, aspectRatio, quality, imageUrls, download = true, signal, onTaskCreated, } = options;
+    const model = resolveImageModel(config, options.model);
+    const input = buildImageTaskInput(model, {
+        prompt,
+        aspectRatio,
+        quality,
+        imageUrls,
+    });
+    const spinner = ora({
+        text: `正在提交任务 (${formatImageModelLabel(model)})...`,
+        discardStdin: false,
+    }).start();
+    try {
+        const taskId = await createJob({
+            apiKey,
+            baseUrl,
+            model,
+            input,
+            signal,
+        });
+        onTaskCreated?.(taskId);
+        spinner.text = `任务已提交 (${taskId})，等待处理...`;
+        const finalJob = await pollJob({
+            apiKey,
+            baseUrl,
+            taskId,
+            signal,
+            onProgress: (progress, state) => {
+                spinner.text = `处理中… 状态: ${state} | 进度: ${progress}%`;
+            },
+        });
+        spinner.succeed('图片生成成功！');
+        const urls = parseResultUrls(finalJob.resultJson);
+        const outputDir = options.outputDir ?? path.join(process.cwd(), 'kie-image');
+        let savedPaths = [];
+        if (urls.length === 0) {
+            console.log(chalk.yellow('\n任务成功，但未在 resultJson 中找到图片链接。\n'));
+        }
+        else if (download) {
+            console.log(chalk.green(`\n🎨 共 ${urls.length} 张图片，保存到 ${outputDir}:\n`));
+            savedPaths = await downloadResultImages(urls, outputDir);
+        }
+        else {
+            console.log(chalk.green('\n🎨 生成结果:\n'));
+            urls.forEach((u) => console.log(chalk.cyan(`  ${u}`)));
+            console.log();
+        }
+        return { taskId, job: finalJob, urls, savedPaths };
+    }
+    catch (err) {
+        spinner.fail('图片任务失败');
+        throw err;
+    }
+}
+/** 仅查询一次任务状态 */
+export async function queryImageTask(apiKey, baseUrl, taskId) {
+    return getJobInfo(apiKey, baseUrl, taskId);
+}
+/** 等待已有任务完成并下载 */
+export async function waitImageTask(options) {
+    const spinner = ora({
+        text: `等待任务 ${options.taskId}...`,
+        discardStdin: false,
+    }).start();
+    try {
+        const finalJob = await pollJob({
+            apiKey: options.apiKey,
+            baseUrl: options.baseUrl,
+            taskId: options.taskId,
+            signal: options.signal,
+            onProgress: (progress, state) => {
+                spinner.text = `处理中… 状态: ${state} | 进度: ${progress}%`;
+            },
+        });
+        spinner.succeed('任务完成！');
+        const urls = parseResultUrls(finalJob.resultJson);
+        const outputDir = options.outputDir ?? path.join(process.cwd(), 'kie-image');
+        let savedPaths = [];
+        if (urls.length > 0 && options.download !== false) {
+            console.log(chalk.green(`\n🎨 下载到 ${outputDir}:\n`));
+            savedPaths = await downloadResultImages(urls, outputDir);
+        }
+        else if (urls.length > 0) {
+            console.log(chalk.green('\n🎨 结果链接:\n'));
+            urls.forEach((u) => console.log(chalk.cyan(`  ${u}`)));
+            console.log();
+        }
+        return { job: finalJob, urls, savedPaths };
+    }
+    catch (err) {
+        spinner.fail('任务失败');
+        throw err;
+    }
+}

package/dist/index.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import Conf from 'conf';
+const config = new Conf({ projectName: 'kie-cli' });
+const program = new Command();
+program
+    .name('kie')
+    .description('Kie 内部 AI 命令行调用工具')
+    .version('1.0.0')
+    .addHelpText('before', `
+\x1b[38;5;33m   _  __   ___   _____   \x1b[38;5;39m____ _     ___ 
+\x1b[38;5;33m  | |/ /  |_ _| | ____|  \x1b[38;5;39m/ ___| |   |_ _|
+\x1b[38;5;33m  |   <    | |  |  _|    \x1b[38;5;39m| |   | |    | | 
+\x1b[38;5;33m  | |\\ \\   | |  | |___   \x1b[38;5;39m| |___| |___ | | 
+\x1b[38;5;33m  |_| \\_\\ |___| |_____|  \x1b[38;5;39m \\____|_____|___|
+  \x1b[38;5;244mAdvanced Coding Intelligence CLI\x1b[0m
+  `);
+async function readStdin() {
+    return new Promise((resolve) => {
+        let data = '';
+        if (process.stdin.isTTY) {
+            resolve(data);
+            return;
+        }
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (chunk) => (data += chunk));
+        process.stdin.on('end', () => resolve(data.trim()));
+    });
+}
+program
+    .command('config')
+    .description('设置全局配置参数 (apiKey / baseUrl / 模型)')
+    .option('--set-api-key <key>', '设置 API 密钥')
+    .option('--set-base-url <url>', '设置 API BaseURL')
+    .option('--set-model <model>', '设置默认对话模型 (Claude model id)')
+    .option('--set-image-model <model>', '设置默认图片生成模型')
+    .option('--set-image-assist-model <model>', '设置 image 工作台助手模型')
+    .action(async (options) => {
+    const { configAction } = await import('./commands/config.js');
+    await configAction(options, config);
+});
+program
+    .command('sessions')
+    .description('列出本地保存的对话会话')
+    .action(async () => {
+    const { sessionsAction } = await import('./commands/config.js');
+    await sessionsAction(config);
+});
+program
+    .command('models')
+    .description('选择或列出对话 Chat 模型')
+    .option('--list', '仅打印列表')
+    .option('--set', '保存为默认模型')
+    .action(async (options) => {
+    const { modelsAction } = await import('./commands/config.js');
+    await modelsAction(options, config);
+});
+program
+    .command('chat')
+    .description('与 AI 进行流式对话 (支持连续对话和管道输入)')
+    .argument('[message]', '发送给 AI 的消息内容')
+    .option('--new', '开始新会话')
+    .option('--resume [id]', '恢复指定会话')
+    .option('-m, --model <model>', '指定对话模型')
+    .action(async (message, options) => {
+    const { chatAction } = await import('./commands/chat.js');
+    await chatAction(message, options, config, readStdin);
+});
+program
+    .command('image')
+    .description('生成 AI 图片')
+    .argument('[prompt]', '提示词')
+    .option('-m, --model <model>', '图片模型')
+    .option('-r, --ratio <ratio>', '图片纵横比 (1:1 / 16:9 / 4:3等)')
+    .option('-q, --quality <quality>', '生成质量 (standard / hd)')
+    .option('-i, --image-url <url...>', '参考图 URL 或本地图片文件路径 (本地文件会自动上传)')
+    .option('--no-wait', '不等待任务生成结束')
+    .option('--seed <number>', '生成随机种子 (Seed)')
+    .option('-d, --download <dir>', '生成成功后自动下载到指定目录')
+    .action(async (prompt, options) => {
+    const { imageAction } = await import('./commands/image.js');
+    await imageAction(prompt, options, config);
+});
+program
+    .command('image-models')
+    .description('选择或列出图片模型')
+    .option('--list', '仅打印列表')
+    .option('--set', '保存为默认')
+    .action(async (options) => {
+    const { imageModelsAction } = await import('./commands/image.js');
+    await imageModelsAction(options, config);
+});
+program
+    .command('job')
+    .description('查询异步任务状态')
+    .argument('<jobId>', '任务 ID')
+    .option('--json', 'JSON 输出')
+    .action(async (jobId, options) => {
+    const { jobAction } = await import('./commands/job.js');
+    await jobAction(jobId, options, config);
+});
+program
+    .command('upload')
+    .description('上传本地图片或文件并获取临时下载 URL')
+    .argument('<filepath>', '本地文件路径')
+    .option('--path <uploadPath>', '服务器上的上传路径', 'images/user-uploads')
+    .action(async (filepath, options) => {
+    const { uploadAction } = await import('./commands/upload.js');
+    await uploadAction(filepath, options, config);
+});
+program
+    .command('code')
+    .description('代码模式')
+    .argument('[task]', '任务描述')
+    .option('-m, --model <model>', '指定代码模型')
+    .option('--cwd <dir>', '代码工作目录')
+    .option('--init', '初始化当前 code 工作目录')
+    .option('--run <cmd>', '先执行命令并注入上下文', (val, prev) => [...prev, val], [])
+    .option('--agent', '启用自动执行代理循环')
+    .option('--chat', '切换为纯对话模式')
+    .option('--route <mode>', '模型路由')
+    .option('--max-steps <n>', 'agent 最大执行轮数', '25')
+    .option('-y, --yes', 'agent 模式自动确认执行命令')
+    .option('--session <id>', '使用指定 code 会话')
+    .option('--new-session', '创建新的 code 会话')
+    .option('-f, --file <path>', '附加文件内容', (val, prev) => [...prev, val], [])
+    .option('--no-tree', '不附带项目结构摘要')
+    .option('--tree-limit <n>', '项目结构最大条目数', '120')
+    .option('--file-max-chars <n>', '每个附加文件最大字符数', '8000')
+    .allowUnknownOption()
+    .action(async (task, options, cmd) => {
+    const { codeAction } = await import('./commands/code-command.js');
+    await codeAction(task, cmd.opts(), config, readStdin);
+});
+program.parse(process.argv);

package/dist/job.js

@@ -0,0 +1,121 @@
+import { ofetch } from 'ofetch';
+import { formatKieError, isAbortError } from './kie-http.js';
+/**
+ * 提交异步任务
+ */
+export async function createJob(options) {
+    const { apiKey, baseUrl, model, input, callBackUrl, signal } = options;
+    const endpoint = `${baseUrl.replace(/\/+$/, '')}/api/v1/jobs/createTask`;
+    let response;
+    try {
+        response = await ofetch(endpoint, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: {
+                model,
+                input,
+                ...(callBackUrl ? { callBackUrl } : {}),
+            },
+            signal,
+            retry: 0,
+        });
+    }
+    catch (error) {
+        if (isAbortError(error))
+            throw error;
+        throw new Error(formatKieError(error));
+    }
+    if (response.code === 200 && response.data?.taskId) {
+        return response.data.taskId;
+    }
+    throw new Error(`创建任务失败: ${response.msg || JSON.stringify(response)}`);
+}
+/**
+ * 获取任务详情
+ */
+export async function getJobInfo(apiKey, baseUrl, taskId, signal) {
+    const endpoint = `${baseUrl.replace(/\/+$/, '')}/api/v1/jobs/recordInfo?taskId=${encodeURIComponent(taskId)}`;
+    let response;
+    try {
+        response = await ofetch(endpoint, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            signal,
+            retry: 0,
+        });
+    }
+    catch (error) {
+        if (isAbortError(error))
+            throw error;
+        throw new Error(formatKieError(error));
+    }
+    if ((response.code === 200 || response.code === 505) && response.data) {
+        return response.data;
+    }
+    throw new Error(`获取任务详情失败: ${response.msg || JSON.stringify(response)}`);
+}
+/**
+ * 轮询任务直至完成
+ */
+export async function pollJob(options) {
+    const { apiKey, baseUrl, taskId, onProgress, intervalMs = 2000, timeoutMs = 600_000, signal, } = options;
+    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+        let timer = null;
+        const cleanup = () => {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+        };
+        const onAbort = () => {
+            cleanup();
+            reject(new DOMException('The operation was aborted.', 'AbortError'));
+        };
+        if (signal?.aborted) {
+            onAbort();
+            return;
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+        timer = setInterval(async () => {
+            if (signal?.aborted) {
+                onAbort();
+                return;
+            }
+            try {
+                if (Date.now() - startTime > timeoutMs) {
+                    cleanup();
+                    signal?.removeEventListener('abort', onAbort);
+                    reject(new Error('任务轮询超时'));
+                    return;
+                }
+                const info = await getJobInfo(apiKey, baseUrl, taskId, signal);
+                if (onProgress) {
+                    onProgress(info.progress || 0, info.state);
+                }
+                if (info.state === 'success') {
+                    cleanup();
+                    signal?.removeEventListener('abort', onAbort);
+                    resolve(info);
+                }
+                else if (info.state === 'failed' || info.state === 'error') {
+                    cleanup();
+                    signal?.removeEventListener('abort', onAbort);
+                    reject(new Error(`任务执行失败: ${info.failMsg || '未知原因'}`));
+                }
+            }
+            catch (err) {
+                if (isAbortError(err)) {
+                    onAbort();
+                    return;
+                }
+                // 网络抖动：继续轮询
+            }
+        }, intervalMs);
+    });
+}

package/dist/kie-http.js

@@ -0,0 +1,182 @@
+import { ofetch } from 'ofetch';
+import chalk from 'chalk';
+/** 单次对话请求超时（毫秒） */
+export const KIE_REQUEST_TIMEOUT_MS = 120_000;
+/** 结果图片 CDN 下载超时（毫秒） */
+export const IMAGE_DOWNLOAD_TIMEOUT_MS = 180_000;
+function extractErrorDetail(data, fallback) {
+    if (typeof data === 'string' && data.trim()) {
+        return data.trim().slice(0, 500);
+    }
+    if (data && typeof data === 'object') {
+        const obj = data;
+        const msg = obj.msg ?? obj.message ?? obj.error ?? obj.failMsg ?? obj.detail;
+        if (typeof msg === 'string' && msg.trim())
+            return msg.trim();
+        if (typeof msg === 'object' && msg !== null) {
+            return JSON.stringify(msg).slice(0, 500);
+        }
+    }
+    return fallback;
+}
+/** 将 ofetch / 网络错误转为可读信息 */
+export function isAbortError(error) {
+    if (error instanceof Error && error.name === 'AbortError')
+        return true;
+    if (typeof DOMException !== 'undefined' && error instanceof DOMException) {
+        return error.name === 'AbortError';
+    }
+    const msg = error instanceof Error ? error.message : String(error);
+    return /aborted|AbortError/i.test(msg);
+}
+export function formatKieError(error) {
+    if (error && typeof error === 'object' && 'name' in error && error.name === 'FetchError') {
+        const fe = error;
+        const status = fe.response?.status;
+        const detail = extractErrorDetail(fe.data, fe.message || '请求失败');
+        if (status)
+            return `HTTP ${status}: ${detail}`;
+        if (fe.message?.includes('timeout') || fe.message?.includes('aborted')) {
+            return `请求超时（${KIE_REQUEST_TIMEOUT_MS / 1000}s），中转站可能已无响应`;
+        }
+        return detail;
+    }
+    if (error instanceof Error) {
+        if (error.message.includes('timeout') || error.message.includes('aborted')) {
+            return `请求超时（${KIE_REQUEST_TIMEOUT_MS / 1000}s），中转站可能已无响应`;
+        }
+        return error.message;
+    }
+    return String(error);
+}
+export async function kiePostJson(url, init) {
+    try {
+        return await ofetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${init.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: init.body,
+            signal: init.signal,
+            timeout: KIE_REQUEST_TIMEOUT_MS,
+            retry: 3,
+            retryDelay: 1000,
+            onResponseError({ response }) {
+                // Log or handle specific errors if needed
+                if (response.status === 429) {
+                    console.warn(chalk.yellow('\n⚠️ Rate limited by server, retrying...'));
+                }
+            }
+        });
+    }
+    catch (error) {
+        if (isAbortError(error))
+            throw error;
+        throw new Error(formatKieError(error));
+    }
+}
+export async function kiePostStream(url, init, maxRetries = 3) {
+    let attempt = 0;
+    while (true) {
+        try {
+            const response = await ofetch.raw(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${init.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: init.body,
+                signal: init.signal,
+                timeout: KIE_REQUEST_TIMEOUT_MS,
+                retry: 0,
+            });
+            if (!response.ok) {
+                let detail = '';
+                try {
+                    const text = await response.text();
+                    try {
+                        detail = extractErrorDetail(JSON.parse(text), text);
+                    }
+                    catch {
+                        detail = text.trim().slice(0, 500);
+                    }
+                }
+                catch {
+                    detail = response.statusText || '未知错误';
+                }
+                if ((response.status >= 500 || response.status === 429) && attempt < maxRetries) {
+                    throw new Error(`Retryable HTTP ${response.status}: ${detail}`);
+                }
+                throw new Error(`HTTP ${response.status}: ${detail}`);
+            }
+            if (!response.body) {
+                throw new Error(`HTTP ${response.status}: 响应体为空`);
+            }
+            return response.body;
+        }
+        catch (error) {
+            if (isAbortError(error))
+                throw error;
+            const isRetryable = error instanceof Error && (error.message.includes('timeout') ||
+                error.message.includes('Retryable HTTP') ||
+                error.name === 'FetchError' ||
+                error.message.includes('ECONNRESET') ||
+                error.message.includes('ENOTFOUND') ||
+                error.message.includes('ETIMEDOUT'));
+            if (!isRetryable || attempt >= maxRetries) {
+                throw new Error(formatKieError(error));
+            }
+            attempt++;
+            const delayMs = Math.min(1000 * Math.pow(2, attempt - 1) + Math.random() * 500, 10000);
+            console.warn(chalk.yellow(`\n⚠️ 网络请求异常，等待 ${Math.round(delayMs)}ms 后进行第 ${attempt} 次重试...`));
+            await new Promise(resolve => setTimeout(resolve, delayMs));
+        }
+    }
+}
+export async function kieUploadFile(url, init) {
+    const fs = await import('fs');
+    const path = await import('path');
+    const resolvedPath = path.resolve(init.filePath);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`文件不存在: ${init.filePath}`);
+    }
+    const fileName = path.basename(resolvedPath);
+    const fileBuffer = fs.readFileSync(resolvedPath);
+    // Guess mimeType based on extension
+    const ext = path.extname(fileName).toLowerCase();
+    let mimeType = 'application/octet-stream';
+    if (ext === '.png')
+        mimeType = 'image/png';
+    else if (ext === '.jpg' || ext === '.jpeg')
+        mimeType = 'image/jpeg';
+    else if (ext === '.gif')
+        mimeType = 'image/gif';
+    else if (ext === '.webp')
+        mimeType = 'image/webp';
+    else if (ext === '.svg')
+        mimeType = 'image/svg+xml';
+    else if (ext === '.bmp')
+        mimeType = 'image/bmp';
+    const formData = new FormData();
+    // Node 18+ Globals: Blob & FormData
+    const blob = new Blob([fileBuffer], { type: mimeType });
+    formData.append('file', blob, fileName);
+    formData.append('uploadPath', init.uploadPath || 'images/user-uploads');
+    formData.append('fileName', fileName);
+    try {
+        return await ofetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${init.apiKey}`,
+            },
+            body: formData,
+            timeout: KIE_REQUEST_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        if (isAbortError(error))
+            throw error;
+        throw new Error(formatKieError(error));
+    }
+}