smartbotic/nodes/sdcpp/sdcpp-img2img.js

/**
 * @node sdcpp-img2img
 * @name SD.cpp Image to Image
 * @category sdcpp
 * @version 1.0.0
 * @description Queue an image generation that starts from an existing image
 * @icon images
 */

// The credential this node wants, named so it can be found. It is stored as a
// plain basic credential - that is what decides how it is encrypted - and this
// only says which basic credential is the SD.cpp one. Anything that accepts a
// basic credential still accepts this, and this node still accepts a plain
// basic credential, because the shape is identical.
const credentialTypes = [
    {
        id: 'sdcpp',
        label: 'SD.cpp Server',
        baseType: 'basic',
        description: 'The username and password you sign in to sdcpp-restapi with. The node exchanges them for a token before every call',
        usernameLabel: 'Username',
        passwordLabel: 'Password'
    }
];

const configSchema = {
    type: 'object',
    properties: {
        serverUrl: {
            type: 'string', title: 'Server URL',
            description: 'Base address of the sdcpp-restapi server',
            default: 'http://localhost:8077'
        },
        credentialId: {
            type: 'string', title: 'Credential',
            description: 'A basic credential holding the sdcpp-restapi username and password',
            dynamicOptions: { source: 'credentials', filter: { type: ['sdcpp', 'basic'] } }
        },
        prompt: {
            type: 'string', title: 'Prompt',
            description: 'What to generate. Supports {{variable}} interpolation, <lora:name:weight>, and {a|b|c} dynamic prompts which the server expands into one queue item per variation',
            format: 'textarea'
        },
        negativePrompt: {
            type: 'string', title: 'Negative Prompt',
            description: 'Concepts to exclude. Has no effect on LCM and one-step SDXS models',
            format: 'textarea'
        },
        initImageBase64: {
            type: 'string', title: 'Init Image (base64)',
            description: 'The image to start from, base64 without a data: prefix. Usually {{$json.files[0].data}} from a previous node'
        },
        maskImageBase64: {
            type: 'string', title: 'Mask (base64)',
            description: 'Inpainting mask. White marks the area to regenerate'
        },
        strength: {
            type: 'number', title: 'Strength',
            description: 'How far the result may move from the init image, 0 to 1. Higher changes more'
        },
        width: { type: 'number', title: 'Width', description: 'Leave empty to use the loaded architecture default' },
        height: { type: 'number', title: 'Height', description: 'Leave empty to use the loaded architecture default' },
        steps: { type: 'number', title: 'Steps', description: 'Leave empty for the architecture default - 4 for Flux Schnell and LCM, 20 for most others' },
        cfgScale: { type: 'number', title: 'CFG Scale', description: 'Leave empty for the architecture default. Distilled models such as Flux Schnell, LCM and Z-Image want 1.0' },
        sampler: {
            type: 'string', title: 'Sampler',
            enum: ['', 'euler', 'euler_a', 'heun', 'dpm2', 'dpm++2s_a', 'dpm++2m', 'dpm++2mv2',
                'ipndm', 'ipndm_v', 'lcm', 'ddim_trailing', 'tcd', 'res_multistep', 'res_2s',
                'er_sde', 'euler_cfg_pp', 'euler_a_cfg_pp', 'euler_ge'],
            default: '', description: 'Leave empty to use the architecture default'
        },
        scheduler: {
            type: 'string', title: 'Scheduler',
            enum: ['', 'discrete', 'karras', 'exponential', 'ays', 'gits', 'sgm_uniform',
                'simple', 'smoothstep', 'kl_optimal', 'lcm', 'bong_tangent', 'ltx2'],
            default: '', description: 'Leave empty to use the architecture default'
        },
        seed: { type: 'number', title: 'Seed', description: 'Use -1 for a random seed. Any other value reproduces the same image' },
        batchCount: { type: 'number', title: 'Batch Count', description: 'How many to generate in this one job, all sharing the prompt' },
        clipSkip: { type: 'number', title: 'CLIP Skip', description: 'Skip the last N CLIP layers. Negative means the model default' },
        title: { type: 'string', title: 'Job Title', description: 'Optional label stored with the job, useful for finding it again in the queue' },
        extraOptions: {
            type: 'object', title: 'Extra Options',
            description: 'Any other generation field passed straight through, such as slg_scale, cache_mode or vae_tiling. See /options/generation on the server for the full list'
        },
        timeout: {
            type: 'number', title: 'Timeout (ms)',
            description: 'Applies to queueing the job, not to the render. The call returns as soon as the job is accepted',
            default: 30000
        }
    },
    required: ['credentialId']
};

const inputSchema = { type: 'object', properties: { data: { type: 'any' } } };

const outputSchema = {
    type: 'object',
    properties: {
        jobId: { type: 'string', description: 'Id of the queued job, to pass to SD.cpp Wait For Job' },
        status: { type: 'string', description: 'Queue status when the job was accepted, normally pending' },
        position: { type: 'number', description: 'Place in the queue' },
        request: { type: 'object', description: 'The body actually sent, useful for seeing which defaults were left to the server' }
    }
};

function normalizeServer(url) {
    const value = String(url || '').trim();
    if (!value) {
        throw new Error('SD.cpp: a server URL is required, such as http://localhost:8077');
    }
    return value.replace(/\/+$/, '');
}

function readCredential(credentialId) {
    const auth = smartbotic.credentials.get(credentialId);
    if (!auth || auth.success !== true) {
        throw new Error('SD.cpp: could not read the credential: ' +
            ((auth && auth.error) || 'unknown error'));
    }

    const value = auth.headerValue || '';
    if (value.indexOf('Basic ') !== 0) {
        throw new Error('SD.cpp: the credential must be a basic one, holding the sdcpp-restapi ' +
            'username and password');
    }

    const decoded = smartbotic.utils.base64Decode(value.substring(6));
    const separator = decoded.indexOf(':');
    if (separator < 1) {
        throw new Error('SD.cpp: the credential is malformed, expected a username and a password');
    }

    return {
        username: decoded.substring(0, separator),
        password: decoded.substring(separator + 1)
    };
}

function call(options) {
    const response = smartbotic.http.request(options);

    let body = response.data;
    if (typeof body === 'string' && body.length > 0) {
        try {
            body = JSON.parse(body);
        } catch (e) {
            const snippet = body.substring(0, 200).replace(/\s+/g, ' ');
            throw new Error('SD.cpp: ' + options.what + ' returned HTTP ' + response.status +
                ' with a body that is not JSON: ' + snippet);
        }
    }

    if (response.status < 200 || response.status >= 300) {
        const detail = (body && (body.message || body.error)) || ('HTTP ' + response.status);
        throw new Error('SD.cpp: ' + options.what + ' failed: ' + detail);
    }

    return body || {};
}

function login(server, credential, timeout) {
    const session = call({
        method: 'POST',
        url: server + '/auth/login',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
            username: credential.username,
            password: credential.password
        }),
        timeout: timeout,
        what: 'signing in'
    });

    if (!session.token) {
        throw new Error('SD.cpp: the server accepted the login but returned no token');
    }
    return session.token;
}

// /health is unauthenticated, and it is the only way to find out what is
// already loaded without asking for a token first.
function readHealth(server, timeout) {
    return call({
        method: 'GET',
        url: server + '/health',
        timeout: timeout,
        what: 'reading server health'
    });
}

function putIfSet(target, key, value) {
    if (value === undefined || value === null || value === '') {
        return;
    }
    target[key] = value;
}

// Width, steps, cfg_scale and the rest are architecture defaults: the server
// fills them from the loaded model's preset when the field is absent. Sending an
// empty box as 0 would override that preset with nonsense, so a field the user
// did not fill is left out of the body entirely - and the test is emptiness,
// never truthiness, because seed 0 and clip_skip 0 are legitimate values.

async function execute(config, input, context) {
    const server = normalizeServer(config.serverUrl);
    const timeout = config.timeout || 30000;

    const credential = readCredential(config.credentialId);
    const token = login(server, credential, timeout);

    const body = {};
    putIfSet(body, 'prompt', config.prompt);
    if (!body.prompt) {
        throw new Error('SD.cpp: img2img needs a prompt');
    }
    putIfSet(body, 'negative_prompt', config.negativePrompt);
    putIfSet(body, 'width', config.width);
    putIfSet(body, 'height', config.height);
    putIfSet(body, 'steps', config.steps);
    putIfSet(body, 'cfg_scale', config.cfgScale);
    putIfSet(body, 'sampler', config.sampler);
    putIfSet(body, 'scheduler', config.scheduler);
    putIfSet(body, 'seed', config.seed);
    putIfSet(body, 'batch_count', config.batchCount);
    putIfSet(body, 'clip_skip', config.clipSkip);
    putIfSet(body, 'init_image_base64', config.initImageBase64);
    putIfSet(body, 'mask_image_base64', config.maskImageBase64);
    putIfSet(body, 'strength', config.strength);
    if (!body.init_image_base64) {
        throw new Error('SD.cpp: img2img needs an init image');
    }
    putIfSet(body, 'title', config.title);

    // Anything else the API accepts, passed through, so a new server field does
    // not need a node change to be reachable.
    const extra = config.extraOptions;
    if (extra && typeof extra === 'object') {
        const keys = Object.keys(extra);
        for (let i = 0; i < keys.length; i++) {
            putIfSet(body, keys[i], extra[keys[i]]);
        }
    }

    const queued = call({
        method: 'POST',
        url: server + '/img2img',
        headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
        body: JSON.stringify(body),
        timeout: timeout,
        what: 'queueing the img2img job'
    });

    if (!queued.job_id) {
        throw new Error('SD.cpp: the job was accepted but no job id came back');
    }

    smartbotic.log.info('SD.cpp: queued img2img job ' + queued.job_id);

    return {
        jobId: queued.job_id,
        status: queued.status || 'pending',
        position: queued.position !== undefined ? queued.position : -1,
        request: body
    };
}

module.exports = { configSchema, inputSchema, outputSchema, execute };