@eightstate/escli 0.5.0

package/dist/services/image.js

@@ -0,0 +1,297 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { extname, dirname, resolve, join } from 'node:path';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { EscliError } from '../lib/escli-error.js';
+import { callWithRetry, DEFAULT_ENDPOINT, resolveApiKey, resolveEndpoint } from './credentials.js';
+const DEFAULT_IMAGE_MODEL = 'gpt-image-2';
+const DEFAULT_IMAGE_QUALITY = 'high';
+const DEFAULT_IMAGE_SIZE = '1024x1024';
+const DEFAULT_IMAGE_FORMAT = 'png';
+const DEFAULT_OUT_DIR = '.';
+const SIZE_ALIASES = new Map([
+    ['square', '1024x1024'],
+    ['sq', '1024x1024'],
+    ['1024x1024', '1024x1024'],
+    ['landscape', '1536x1024'],
+    ['land', '1536x1024'],
+    ['ls', '1536x1024'],
+    ['wide', '1536x1024'],
+    ['1536x1024', '1536x1024'],
+    ['portrait', '1024x1536'],
+    ['port', '1024x1536'],
+    ['tall', '1024x1536'],
+    ['1024x1536', '1024x1536'],
+]);
+export async function generateImage(options) {
+    const prompt = options.prompt.trim();
+    if (!prompt)
+        throw new EscliError('prompt required', { code: ErrorCode.ImagePromptRequired, exitCode: ExitCodes.Usage });
+    const started = Date.now();
+    const size = resolveImageSize(options.size ?? envDefault('ESCLI_IMAGE_SIZE', DEFAULT_IMAGE_SIZE));
+    const quality = options.quality ?? envDefault('ESCLI_IMAGE_QUALITY', DEFAULT_IMAGE_QUALITY);
+    const format = options.format ?? envDefault('ESCLI_IMAGE_FORMAT', DEFAULT_IMAGE_FORMAT);
+    const model = options.model ?? envDefault('ESCLI_IMAGE_MODEL', DEFAULT_IMAGE_MODEL);
+    const outputPath = resolveOutputPath(options.output, options.outDir, prompt, format);
+    const body = {
+        model,
+        prompt,
+        size,
+        quality,
+        response_format: 'b64_json',
+    };
+    const extraBody = {};
+    const outputFormat = apiOutputFormat(format);
+    if (outputFormat !== 'png')
+        extraBody.output_format = outputFormat;
+    if (options.compression !== undefined)
+        extraBody.output_compression = options.compression;
+    if (options.background)
+        extraBody.background = options.background;
+    if (options.moderation)
+        extraBody.moderation = options.moderation;
+    if (Object.keys(extraBody).length > 0)
+        body.extra_body = extraBody;
+    const data = await performImageRequest({ path: '/images/generations', body, options });
+    return writeImageResult({ data, outputPath, prompt, model, size, quality, elapsedMs: Date.now() - started });
+}
+export async function editImage(options) {
+    const prompt = options.prompt.trim();
+    if (!prompt)
+        throw new EscliError('prompt required', { code: ErrorCode.ImagePromptRequired, exitCode: ExitCodes.Usage });
+    const inputPath = resolve(options.input);
+    const inputBytes = await readInputImage(inputPath);
+    const started = Date.now();
+    const size = resolveImageSize(options.size ?? envDefault('ESCLI_IMAGE_SIZE', DEFAULT_IMAGE_SIZE));
+    const quality = options.quality ?? envDefault('ESCLI_IMAGE_QUALITY', DEFAULT_IMAGE_QUALITY);
+    const format = options.format ?? envDefault('ESCLI_IMAGE_FORMAT', DEFAULT_IMAGE_FORMAT);
+    const model = options.model ?? envDefault('ESCLI_IMAGE_MODEL', DEFAULT_IMAGE_MODEL);
+    const outputPath = resolveOutputPath(options.output, options.outDir, prompt, format);
+    const outputFormat = apiOutputFormat(format);
+    const body = {
+        model,
+        prompt,
+        images: [{ image_url: `data:${mimeForPath(inputPath)};base64,${Buffer.from(inputBytes).toString('base64')}` }],
+        size,
+        quality,
+        response_format: 'b64_json',
+    };
+    if (outputFormat !== 'png')
+        body.output_format = outputFormat;
+    if (options.compression !== undefined)
+        body.output_compression = options.compression;
+    if (options.fidelity)
+        body.input_fidelity = options.fidelity;
+    const data = await performImageRequest({ path: '/images/edits', body, options });
+    return writeImageResult({ data, outputPath, prompt, inputPath, model, size, quality, elapsedMs: Date.now() - started });
+}
+function resolveImageSize(value) {
+    const resolved = SIZE_ALIASES.get(value.toLowerCase().trim());
+    if (!resolved)
+        throw new EscliError(`invalid size: ${value}`, { code: ErrorCode.ImageSizeInvalid, exitCode: ExitCodes.Usage, details: { size: value } });
+    return resolved;
+}
+async function performImageRequest(input) {
+    const timeoutMs = (input.options.timeoutSeconds ?? 300) * 1000;
+    const explicitKey = resolveApiKey(input.options.apiKey);
+    if (explicitKey) {
+        return requestImageJson({ path: input.path, body: input.body, apiKey: explicitKey, baseUrl: resolveEndpoint(input.options.baseUrl), timeoutMs });
+    }
+    const response = await mapImageErrors(async () => callWithRetry('image', (key) => requestImageJson({
+        path: input.path,
+        body: input.body,
+        apiKey: key.apiKey,
+        baseUrl: key.baseUrl ?? DEFAULT_ENDPOINT,
+        timeoutMs,
+    })));
+    if (response === null) {
+        throw new EscliError('not authenticated', {
+            code: ErrorCode.AuthRequired,
+            exitCode: ExitCodes.Auth,
+            remediation: { command: 'escli auth login' },
+        });
+    }
+    return response;
+}
+async function requestImageJson(options) {
+    return mapImageErrors(async () => {
+        const response = await fetchWithTimeout(`${options.baseUrl.replace(/\/+$/u, '')}${options.path}`, {
+            method: 'POST',
+            headers: { 'authorization': `Bearer ${options.apiKey}`, 'content-type': 'application/json', 'accept': 'application/json' },
+            body: JSON.stringify(options.body),
+        }, options.timeoutMs);
+        const text = await response.text();
+        const body = parseJsonResponse(text);
+        if (!response.ok)
+            throw httpStatusError(response.status, formatHttpError(response.status, body), body);
+        return body;
+    });
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    catch (error) {
+        throw mapNetworkError(error);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function mapImageErrors(fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        if (error instanceof EscliError)
+            throw error;
+        if (isHttpStatusError(error))
+            throw mapHttpStatusError(error);
+        throw mapNetworkError(error);
+    }
+}
+function parseJsonResponse(text) {
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new EscliError(`invalid JSON response: ${error instanceof Error ? error.message : String(error)}`, {
+            code: ErrorCode.GateInvalidResponse,
+            details: text,
+        });
+    }
+}
+async function writeImageResult(input) {
+    const item = firstImageData(input.data);
+    const b64 = stringValue(item.b64_json);
+    if (!b64)
+        throw new EscliError('invalid image response: missing b64_json', { code: ErrorCode.ImageGenerationFailed, details: input.data });
+    const bytes = Buffer.from(b64, 'base64');
+    try {
+        await mkdir(dirname(input.outputPath), { recursive: true });
+        await writeFile(input.outputPath, bytes);
+    }
+    catch (error) {
+        throw new EscliError(`failed to write file: ${input.outputPath}`, { code: ErrorCode.FileWriteFailed, details: error instanceof Error ? error.message : error });
+    }
+    const result = {
+        path: input.outputPath,
+        size_bytes: bytes.length,
+        elapsed_seconds: Math.round(input.elapsedMs / 100) / 10,
+        prompt: input.prompt,
+        model: input.model,
+        image_size: input.size,
+        quality: input.quality,
+    };
+    if (input.inputPath)
+        result.input = input.inputPath;
+    const revisedPrompt = stringValue(item.revised_prompt);
+    if (revisedPrompt && !input.inputPath)
+        result.revised_prompt = revisedPrompt;
+    return result;
+}
+function firstImageData(data) {
+    const first = arrayValue(recordValue(data)?.data)[0];
+    const item = recordValue(first);
+    if (!item)
+        throw new EscliError('invalid image response: missing data', { code: ErrorCode.ImageGenerationFailed, details: data });
+    return item;
+}
+async function readInputImage(path) {
+    try {
+        return await readFile(path);
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === 'ENOENT')
+            throw new EscliError(`file not found: ${path}`, { code: ErrorCode.FileNotFound, details: { path } });
+        throw new EscliError(`failed to read file: ${path}`, { code: ErrorCode.FileReadFailed, details: error instanceof Error ? error.message : error });
+    }
+}
+function mapHttpStatusError(error) {
+    const status = error.status;
+    if (status === 401)
+        return new EscliError(error.message, { code: ErrorCode.ApiUnauthorized, details: error.details });
+    if (status === 403)
+        return new EscliError(error.message, { code: ErrorCode.ApiForbidden, details: error.details });
+    if (status === 429)
+        return new EscliError(error.message, { code: ErrorCode.ApiRateLimited, details: error.details });
+    if (status >= 500)
+        return new EscliError(error.message, { code: ErrorCode.ServiceUnavailable, details: error.details });
+    if (status === 404)
+        return new EscliError(error.message, { code: ErrorCode.ApiError, exitCode: ExitCodes.NotFound, details: error.details });
+    return new EscliError(error.message, { code: ErrorCode.ImageGenerationFailed, details: error.details });
+}
+function mapNetworkError(error) {
+    const isAbort = error instanceof Error && error.name === 'AbortError';
+    return new EscliError(isAbort ? 'Connection timeout.' : 'Connection error.', {
+        code: isAbort ? ErrorCode.NetworkTimeout : ErrorCode.NetworkError,
+        details: error instanceof Error ? error.message : error,
+    });
+}
+function formatHttpError(status, body) {
+    const message = extractErrorMessage(body);
+    return message ? `Error code: ${status} - ${message}` : `Error code: ${status}`;
+}
+function extractErrorMessage(body) {
+    const root = recordValue(body);
+    const error = recordValue(root?.error);
+    return stringValue(error?.message) ?? stringValue(root?.message);
+}
+function httpStatusError(status, message, details) {
+    const error = new Error(message);
+    error.status = status;
+    error.details = details;
+    return error;
+}
+function isHttpStatusError(error) {
+    return error instanceof Error && typeof error.status === 'number';
+}
+function resolveOutputPath(output, outDir, prompt, format) {
+    if (output)
+        return resolve(output);
+    return resolve(join(outDir ?? envDefault('ESCLI_OUT_DIR', DEFAULT_OUT_DIR), autoFilename(prompt, outputExtension(format))));
+}
+function apiOutputFormat(format) {
+    return format === 'jpg' ? 'jpeg' : format;
+}
+function outputExtension(format) {
+    return format === 'jpeg' ? 'jpg' : format;
+}
+function autoFilename(prompt, ext) {
+    const now = new Date();
+    const stamp = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}-${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}`;
+    return `${stamp}-${slugify(prompt)}.${ext}`;
+}
+function slugify(value) {
+    const slug = value.toLowerCase().trim().replace(/[^\p{L}\p{N} ]/gu, '').split(/\s+/u).filter(Boolean).join('-').slice(0, 40);
+    return slug || 'image';
+}
+function mimeForPath(path) {
+    const suffix = extname(path).toLowerCase();
+    if (suffix === '.jpg' || suffix === '.jpeg')
+        return 'image/jpeg';
+    if (suffix === '.webp')
+        return 'image/webp';
+    return 'image/png';
+}
+function envDefault(name, fallback) {
+    return process.env[name] ?? fallback;
+}
+function pad2(value) {
+    return String(value).padStart(2, '0');
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+//# sourceMappingURL=image.js.map

package/dist/services/models.js

@@ -0,0 +1,131 @@
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { EscliError } from '../lib/escli-error.js';
+import { callWithRetry, DEFAULT_ENDPOINT, resolveApiKey, resolveEndpoint } from './credentials.js';
+export async function listModels(options) {
+    const explicitKey = resolveApiKey(options.apiKey);
+    const timeoutMs = (options.timeoutSeconds ?? 30) * 1000;
+    let response;
+    if (explicitKey) {
+        response = await callAndMapErrors(() => requestModels({ apiKey: explicitKey, fingerprint: 'explicit', baseUrl: resolveEndpoint(options.baseUrl) }, timeoutMs));
+    }
+    else {
+        response = await callAndMapErrors(async () => callWithRetry('image', (key) => requestModels(key, timeoutMs)));
+        if (response === null) {
+            throw new EscliError('not authenticated', {
+                code: ErrorCode.AuthRequired,
+                exitCode: ExitCodes.Auth,
+                remediation: { command: 'escli auth login' },
+            });
+        }
+    }
+    const models = parseModelIds(response);
+    return { models, count: models.length };
+}
+async function requestModels(key, timeoutMs) {
+    const baseUrl = key.baseUrl ?? DEFAULT_ENDPOINT;
+    const url = `${baseUrl.replace(/\/+$/u, '')}/models`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: { 'authorization': `Bearer ${key.apiKey}`, 'accept': 'application/json' },
+            signal: controller.signal,
+        });
+        const body = await parseBody(response);
+        if (!response.ok)
+            throw httpStatusError(response.status, formatHttpError(response.status, body), body);
+        return body;
+    }
+    catch (error) {
+        if (isHttpStatusError(error))
+            throw error;
+        throw mapNetworkError(error);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function callAndMapErrors(fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        throw mapApiError(error);
+    }
+}
+async function parseBody(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function parseModelIds(body) {
+    const data = recordValue(body)?.data;
+    if (!Array.isArray(data)) {
+        throw new EscliError('invalid models response', { code: ErrorCode.ModelsListFailed, details: body });
+    }
+    return data.map((item) => stringValue(recordValue(item)?.id)).filter((id) => id !== undefined).sort();
+}
+function mapApiError(error) {
+    if (error instanceof EscliError)
+        return error;
+    const status = extractStatus(error);
+    if (status !== undefined) {
+        const message = error instanceof Error ? error.message : `Error code: ${status}`;
+        const details = recordValue(error)?.details;
+        if (status === 401)
+            return new EscliError(message, { code: ErrorCode.ApiUnauthorized, exitCode: ExitCodes.Auth, details });
+        if (status === 403)
+            return new EscliError(message, { code: ErrorCode.ApiForbidden, exitCode: ExitCodes.Auth, details });
+        if (status === 429)
+            return new EscliError(message, { code: ErrorCode.ApiRateLimited, exitCode: ExitCodes.Transient, details });
+        if (status >= 500)
+            return new EscliError(message, { code: ErrorCode.ServiceUnavailable, exitCode: ExitCodes.Transient, details });
+        return new EscliError(message, { code: ErrorCode.ApiError, details });
+    }
+    if (error instanceof Error)
+        return new EscliError(error.message, { code: ErrorCode.ModelsListFailed });
+    return new EscliError('models list failed', { code: ErrorCode.ModelsListFailed, details: error });
+}
+function mapNetworkError(error) {
+    const message = error instanceof Error && error.name === 'AbortError' ? 'Connection timeout.' : 'Connection error.';
+    const code = error instanceof Error && error.name === 'AbortError' ? ErrorCode.NetworkTimeout : ErrorCode.NetworkError;
+    return new EscliError(message, { code, exitCode: ExitCodes.Transient, details: error instanceof Error ? error.message : error });
+}
+function formatHttpError(status, body) {
+    const message = extractErrorMessage(body);
+    return message ? `Error code: ${status} - ${message}` : `Error code: ${status}`;
+}
+function extractErrorMessage(body) {
+    const root = recordValue(body);
+    const error = recordValue(root?.error);
+    return stringValue(error?.message) ?? stringValue(root?.message);
+}
+function httpStatusError(status, message, details) {
+    const error = new Error(message);
+    error.status = status;
+    error.details = details;
+    return error;
+}
+function isHttpStatusError(error) {
+    return error instanceof Error && typeof error.status === 'number';
+}
+function extractStatus(error) {
+    const value = recordValue(error);
+    const status = value ? value.status ?? value.statusCode ?? value.status_code : undefined;
+    return typeof status === 'number' ? status : undefined;
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+//# sourceMappingURL=models.js.map