Merge branch 'sdcpp-split-generate': one node per kind of generation

nodes/sdcpp/sdcpp-edit.js

@@ -0,0 +1,260 @@
+/**
+ * @node sdcpp-edit
+ * @name SD.cpp Edit Image
+ * @category sdcpp
+ * @version 1.0.0
+ * @description Edit an image by describing the change, for edit models such as Flux Kontext and Qwen Image Edit
+ * @icon wand-2
+ */
+
+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: ['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: 'Image (base64)',
+            description: 'The image to edit, base64 without a data: prefix'
+        },
+        refImages: {
+            type: 'array', title: 'Reference Images (base64)',
+            description: 'Extra images the edit model conditions on. Only edit-capable models use these',
+            items: { type: 'string' }
+        },
+        refImageArgs: {
+            type: 'string', title: 'Reference Image Options',
+            description: 'Comma separated k=v options for the reference images, such as resize_before_vae=0,ref_index_mode=increase'
+        },
+        strength: {
+            type: 'number', title: 'Strength',
+            description: 'How far the result may move from the original, 0 to 1'
+        },
+        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: an edit needs a prompt describing the change');
+    }
+    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, 'strength', config.strength);
+    putIfSet(body, 'ref_image_args', config.refImageArgs);
+    if (Array.isArray(config.refImages) && config.refImages.length > 0) {
+        body.ref_images = config.refImages;
+    }
+    if (!body.init_image_base64 && !body.ref_images) {
+        throw new Error('SD.cpp: an edit needs an image, or at least one reference 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 };

nodes/sdcpp/sdcpp-generate.js

@@ -1,355 +0,0 @@
-/**
- * @node sdcpp-generate
- * @name SD.cpp Generate
- * @category sdcpp
- * @version 1.0.0
- * @description Queue an image or video generation job on an sdcpp-restapi server and return its job id
- * @icon image-plus
- */
-
-const configSchema = {
-    type: 'object',
-    properties: {
-        serverUrl: {
-            type: 'string',
-            title: 'Server URL',
-            description: 'Base address of the sdcpp-restapi server, such as http://localhost:8077. No trailing slash needed',
-            default: 'http://localhost:8077'
-        },
-        credentialId: {
-            type: 'string',
-            title: 'Credential',
-            description: 'A basic credential holding the sdcpp-restapi username and password. Every endpoint except health requires one',
-            dynamicOptions: {
-                source: 'credentials',
-                filter: { type: ['basic'] }
-            }
-        },
-        operation: {
-            type: 'string',
-            title: 'Operation',
-            enum: ['txt2img', 'img2img', 'txt2vid', 'upscale'],
-            default: 'txt2img',
-            description: 'txt2img generates from a prompt alone, img2img and txt2vid start from an image, upscale enlarges one using the separately loaded upscaler'
-        },
-        prompt: {
-            type: 'string',
-            title: 'Prompt',
-            description: 'What to generate. Supports {{variable}} interpolation and <lora:name:weight> syntax. Also supports {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'
-        },
-        width: {
-            type: 'number',
-            title: 'Width',
-            description: 'Leave empty to use the loaded architecture default, such as 1024 for SDXL and Flux'
-        },
-        height: {
-            type: 'number',
-            title: 'Height',
-            description: 'Leave empty to use the loaded architecture default'
-        },
-        steps: {
-            type: 'number',
-            title: 'Steps',
-            description: 'Sampling steps. Leave empty to use the architecture default, which is 4 for Flux Schnell and LCM and 20 for most others'
-        },
-        cfgScale: {
-            type: 'number',
-            title: 'CFG Scale',
-            description: 'Guidance strength. Leave empty to use 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. Leave empty to let the server decide'
-        },
-        batchCount: {
-            type: 'number',
-            title: 'Batch Count',
-            description: 'How many images 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'
-        },
-        initImageBase64: {
-            type: 'string',
-            title: 'Init Image (base64)',
-            description: 'Starting image for img2img and txt2vid, and the image to enlarge for upscale. Base64 without a data: prefix. Usually {{$json.file.data}} from a previous node'
-        },
-        maskImageBase64: {
-            type: 'string',
-            title: 'Mask Image (base64)',
-            description: 'Inpainting mask for img2img. White marks the area to regenerate'
-        },
-        strength: {
-            type: 'number',
-            title: 'Strength',
-            description: 'How far img2img and txt2vid may move from the init image, from 0 to 1. Higher changes more'
-        },
-        upscaleFactor: {
-            type: 'number',
-            title: 'Upscale Factor',
-            description: 'For the upscale operation. The upscaler model must already be loaded'
-        },
-        videoFrames: {
-            type: 'number',
-            title: 'Video Frames',
-            description: 'For txt2vid, how many frames to render'
-        },
-        fps: {
-            type: 'number',
-            title: 'FPS',
-            description: 'For txt2vid, frames per second of the output video'
-        },
-        extraOptions: {
-            type: 'object',
-            title: 'Extra Options',
-            description: 'Any other generation field passed straight through to the server, such as slg_scale, cache_mode, ref_images or vae_tiling. Names must match the API exactly. See /options/generation on the server for the full list with descriptions'
-        },
-        timeout: {
-            type: 'number',
-            title: 'Timeout (ms)',
-            description: 'Applies to queueing the job, not to the render itself. 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 Job Status or Wait' },
-        status: { type: 'string', description: 'Queue status at the moment of accepting, normally pending' },
-        position: { type: 'number', description: 'Place in the queue when it was accepted' },
-        operation: { type: 'string', description: 'Which generation endpoint was called' },
-        request: { type: 'object', description: 'The body actually sent, useful for debugging 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;
-}
-
-// Width, steps, cfg_scale and friends are architecture defaults: the server
-// fills them from the loaded model's preset when the field is absent. Sending
-// an empty box as 0 or "" would override that preset with nonsense, so a field
-// the user did not fill must not appear in the body at all.
-//
-// The test is emptiness, never truthiness. seed 0 and clip_skip 0 are both
-// legitimate values that a truthy check would silently drop.
-function putIfSet(target, key, value) {
-    if (value === undefined || value === null || value === '') {
-        return;
-    }
-    if (typeof value === 'number' && !isFinite(value)) {
-        return;
-    }
-    target[key] = value;
-}
-
-async function execute(config, input, context) {
-    const server = normalizeServer(config.serverUrl);
-    const operation = config.operation || 'txt2img';
-    const timeout = config.timeout || 30000;
-
-    if (['txt2img', 'img2img', 'txt2vid', 'upscale'].indexOf(operation) === -1) {
-        throw new Error('SD.cpp: unknown operation "' + operation + '"');
-    }
-
-    const credential = readCredential(config.credentialId);
-    const token = login(server, credential, timeout);
-
-    const body = {};
-
-    if (operation === 'upscale') {
-        // Upscale is not a generation call - it takes an image and the upscaler
-        // slot, and none of the prompt or sampler fields apply.
-        putIfSet(body, 'image_base64', config.initImageBase64);
-        if (!body.image_base64) {
-            throw new Error('SD.cpp: the upscale operation needs an init image, ' +
-                'given as base64 in the Init Image field');
-        }
-        putIfSet(body, 'upscale_factor', config.upscaleFactor);
-        putIfSet(body, 'title', config.title);
-    } else {
-        putIfSet(body, 'prompt', config.prompt);
-        if (!body.prompt) {
-            throw new Error('SD.cpp: ' + operation + ' 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, 'title', config.title);
-
-        if (operation === 'img2img' || operation === 'txt2vid') {
-            putIfSet(body, 'init_image_base64', config.initImageBase64);
-            putIfSet(body, 'strength', config.strength);
-        }
-        if (operation === 'img2img') {
-            putIfSet(body, 'mask_image_base64', config.maskImageBase64);
-        }
-        if (operation === 'txt2vid') {
-            putIfSet(body, 'video_frames', config.videoFrames);
-            putIfSet(body, 'fps', config.fps);
-        }
-        if (operation === 'img2img' && !body.init_image_base64) {
-            throw new Error('SD.cpp: img2img needs an init image, given as base64 in the ' +
-                'Init Image field');
-        }
-    }
-
-    // The API has around seventy generation fields and this node exposes the
-    // common ones. Anything else the user names here goes straight 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 + '/' + operation,
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': 'Bearer ' + token
-        },
-        body: JSON.stringify(body),
-        timeout: timeout,
-        what: 'queueing the ' + operation + ' job'
-    });
-
-    if (!queued.job_id) {
-        throw new Error('SD.cpp: the ' + operation + ' job was accepted but no job id came back');
-    }
-
-    smartbotic.log.info('SD.cpp: queued ' + operation + ' job ' + queued.job_id +
-        ' at position ' + (queued.position !== undefined ? queued.position : 'unknown'));
-
-    return {
-        jobId: queued.job_id,
-        status: queued.status || 'pending',
-        position: queued.position !== undefined ? queued.position : -1,
-        operation: operation,
-        request: body
-    };
-}
-
-module.exports = { configSchema, inputSchema, outputSchema, execute };

nodes/sdcpp/sdcpp-img2img.js

@@ -0,0 +1,252 @@
+/**
+ * @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
+ */
+
+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: ['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 };

nodes/sdcpp/sdcpp-txt2img.js

@@ -0,0 +1,234 @@
+/**
+ * @node sdcpp-txt2img
+ * @name SD.cpp Text to Image
+ * @category sdcpp
+ * @version 1.0.0
+ * @description Queue an image generation from a prompt
+ * @icon image
+ */
+
+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: ['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'
+        },
+        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: txt2img 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, '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 + '/txt2img',
+        headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
+        body: JSON.stringify(body),
+        timeout: timeout,
+        what: 'queueing the txt2img 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 txt2img 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 };

nodes/sdcpp/sdcpp-txt2vid.js

@@ -0,0 +1,245 @@
+/**
+ * @node sdcpp-txt2vid
+ * @name SD.cpp Text to Video
+ * @category sdcpp
+ * @version 1.0.0
+ * @description Queue a video generation, for video models such as Wan, LTXAV and HunyuanVideo
+ * @icon clapperboard
+ */
+
+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: ['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: 'First Frame (base64)',
+            description: 'Optional image to start the video from'
+        },
+        videoFrames: { type: 'number', title: 'Frames', description: 'How many frames to render' },
+        fps: { type: 'number', title: 'FPS', description: 'Frames per second of the output' },
+        strength: { type: 'number', title: 'Strength', description: 'How far the result may move from the first frame, 0 to 1' },
+        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: txt2vid 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, 'strength', config.strength);
+    putIfSet(body, 'video_frames', config.videoFrames);
+    putIfSet(body, 'fps', config.fps);
+    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 + '/txt2vid',
+        headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
+        body: JSON.stringify(body),
+        timeout: timeout,
+        what: 'queueing the txt2vid 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 txt2vid 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 };

nodes/sdcpp/sdcpp-upscale.js

@@ -0,0 +1,204 @@
+/**
+ * @node sdcpp-upscale
+ * @name SD.cpp Upscale
+ * @category sdcpp
+ * @version 1.0.0
+ * @description Enlarge an image with the loaded upscaler
+ * @icon maximize-2
+ */
+
+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: ['basic'] } }
+        },
+        imageBase64: {
+            type: 'string', title: 'Image (base64)',
+            description: 'The image to enlarge, base64 without a data: prefix'
+        },
+        upscaleFactor: { type: 'number', title: 'Factor', description: 'How much to enlarge by' },
+        repeats: { type: 'number', title: 'Repeats', description: 'Run the upscaler more than once' },
+        tileSize: { type: 'number', title: 'Tile Size', description: 'Tile the work to fit in memory' },
+        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, 'image_base64', config.imageBase64);
+    putIfSet(body, 'upscale_factor', config.upscaleFactor);
+    putIfSet(body, 'repeats', config.repeats);
+    putIfSet(body, 'tile_size', config.tileSize);
+    if (!body.image_base64) {
+        throw new Error('SD.cpp: upscale needs an 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 + '/upscale',
+        headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
+        body: JSON.stringify(body),
+        timeout: timeout,
+        what: 'queueing the upscale 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 upscale 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 };