Skip to content

Unrestricted Open-source alternative to AI video platforms — Free AI image & video generation studio with 600+ models (Flux, Midjourney, Kling, Sora, Veo). No content filters. Self-hosted, MIT licensed.

Fix local inference overrides and progress reporting

Djordje Stanic1fb6044c5787
diff --git a/electron/lib/localInference.js b/electron/lib/localInference.js
index 0a871075..94e35570 100644
--- a/electron/lib/localInference.js
+++ b/electron/lib/localInference.js
@@ -8,6 +8,11 @@ const {
getBundledBinaryResourceDir,
pickBinaryAssetForPlatform,
} = require('./localInferenceAssets');
+const {
+ parseGenerationProgressChunk,
+ resolveGenerationSteps,
+ resolveGuidanceScale,
+} = require('./localInferenceRuntime');
// ─── Paths ────────────────────────────────────────────────────────────────────
const DATA_DIR = path.join(app.getPath('userData'), 'local-ai');
@@ -414,8 +419,8 @@ async function generate(params, mainWindow) {
const seed = params.seed && params.seed !== -1 ? params.seed : Math.floor(Math.random() * 2147483647);
const outPath = path.join(TMP_DIR, `gen-${Date.now()}.png`);
- const steps = model.defaultSteps || params.steps || 20;
- const cfgScale = model.defaultGuidance !== undefined ? model.defaultGuidance : (params.guidance_scale || 7.5);
+ const steps = resolveGenerationSteps(params, model);
+ const cfgScale = resolveGuidanceScale(params, model);
const sampler = model.sampler || 'euler_a';
// z-image GGUFs are standalone diffusion transformers loaded via --diffusion-model.
@@ -456,23 +461,21 @@ async function generate(params, mainWindow) {
}
return new Promise((resolve, reject) => {
- send({ step: 0, totalSteps: params.steps || model.defaultSteps || 20, status: 'starting' });
+ send({ step: 0, totalSteps: steps, status: 'starting', progress: 0 });
console.log('[sd-cli] command:', BINARY_PATH, args.join(' '));
// DYLD_LIBRARY_PATH lets macOS find libstable-diffusion.dylib next to sd-cli
const spawnEnv = { ...process.env, DYLD_LIBRARY_PATH: BIN_DIR, LD_LIBRARY_PATH: BIN_DIR };
activeProcess = spawn(BINARY_PATH, args, { env: spawnEnv });
- const stepRegex = /step\s+(\d+)\/(\d+)/i;
+ const progressState = { tail: '', lastStep: 0, lastTotalSteps: 0 };
const outputLines = [];
const handleOutput = (data) => {
const line = data.toString();
outputLines.push(line.trimEnd());
- const match = line.match(stepRegex);
- if (match) {
- const step = parseInt(match[1]);
- const total = parseInt(match[2]);
- send({ step, totalSteps: total, status: 'generating', progress: step / total });
+ const progressEvents = parseGenerationProgressChunk(line, progressState);
+ for (const event of progressEvents) {
+ send({ ...event, status: 'generating' });
}
};
@@ -496,7 +499,7 @@ async function generate(params, mainWindow) {
const imgBuffer = fs.readFileSync(outPath);
const dataUrl = `data:image/png;base64,${imgBuffer.toString('base64')}`;
fs.unlinkSync(outPath);
- send({ step: 1, totalSteps: 1, status: 'done', progress: 1 });
+ send({ step: steps, totalSteps: steps, status: 'done', progress: 1 });
resolve({ url: dataUrl, seed });
} catch (err) {
reject(err);
@@ -534,4 +537,6 @@ function register() {
ipcMain.handle('local-ai:cancel-generation', () => cancelGeneration());
}
-module.exports = { register };
+module.exports = {
+ register,
+};
diff --git a/electron/lib/localInferenceRuntime.js b/electron/lib/localInferenceRuntime.js
new file mode 100644
index 00000000..1c066a0e
--- /dev/null
+++ b/electron/lib/localInferenceRuntime.js
@@ -0,0 +1,93 @@
+function coerceFiniteNumber(value) {
+ if (value === null || value === undefined || value === '') return null;
+ const parsed = Number(value);
+ return Number.isFinite(parsed) ? parsed : null;
+}
+
+function resolveGenerationSteps(params, model) {
+ const requested = coerceFiniteNumber(params?.steps);
+ if (requested !== null && requested > 0) {
+ return Math.max(1, Math.round(requested));
+ }
+
+ const modelDefault = coerceFiniteNumber(model?.defaultSteps);
+ if (modelDefault !== null && modelDefault > 0) {
+ return Math.max(1, Math.round(modelDefault));
+ }
+
+ return 20;
+}
+
+function resolveGuidanceScale(params, model) {
+ const requested = coerceFiniteNumber(params?.guidance_scale);
+ if (requested !== null) return requested;
+
+ const modelDefault = coerceFiniteNumber(model?.defaultGuidance);
+ if (modelDefault !== null) return modelDefault;
+
+ return 7.5;
+}
+
+function stripAnsiSequences(text) {
+ return text.replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, '');
+}
+
+function extractProgressEvents(text) {
+ const events = [];
+ const patterns = [
+ /step\s+(\d+)\s*\/\s*(\d+)/ig,
+ /(\d+)\s*\/\s*(\d+)\s*-\s*[\d.]+s\/it/ig,
+ ];
+
+ for (const pattern of patterns) {
+ let match = pattern.exec(text);
+ while (match) {
+ const step = Number.parseInt(match[1], 10);
+ const totalSteps = Number.parseInt(match[2], 10);
+ if (Number.isFinite(step) && Number.isFinite(totalSteps) && totalSteps > 0) {
+ events.push({
+ step,
+ totalSteps,
+ progress: Math.min(1, step / totalSteps),
+ });
+ }
+ match = pattern.exec(text);
+ }
+ }
+
+ events.sort((left, right) => {
+ if (left.totalSteps !== right.totalSteps) return left.totalSteps - right.totalSteps;
+ return left.step - right.step;
+ });
+ return events;
+}
+
+function parseGenerationProgressChunk(chunk, state = { tail: '', lastStep: 0, lastTotalSteps: 0 }) {
+ const normalizedChunk = stripAnsiSequences(String(chunk)).replace(/\r/g, '\n');
+ const combined = `${state.tail}${normalizedChunk}`;
+ const events = extractProgressEvents(combined);
+ const freshEvents = [];
+
+ for (const event of events) {
+ if (event.totalSteps !== state.lastTotalSteps) {
+ state.lastTotalSteps = event.totalSteps;
+ state.lastStep = 0;
+ }
+ if (event.step > state.lastStep) {
+ state.lastStep = event.step;
+ freshEvents.push(event);
+ }
+ }
+
+ state.tail = combined.slice(-1024);
+ return freshEvents;
+}
+
+module.exports = {
+ coerceFiniteNumber,
+ extractProgressEvents,
+ parseGenerationProgressChunk,
+ resolveGenerationSteps,
+ resolveGuidanceScale,
+ stripAnsiSequences,
+};
diff --git a/tests/localInferenceProgress.test.js b/tests/localInferenceProgress.test.js
new file mode 100644
index 00000000..f9ae7802
--- /dev/null
+++ b/tests/localInferenceProgress.test.js
@@ -0,0 +1,58 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+ parseGenerationProgressChunk,
+ resolveGenerationSteps,
+ resolveGuidanceScale,
+ stripAnsiSequences,
+} = require('../electron/lib/localInferenceRuntime');
+
+test('resolveGenerationSteps prefers explicit request over model defaults', () => {
+ const steps = resolveGenerationSteps({ steps: 3 }, { defaultSteps: 20 });
+ assert.equal(steps, 3);
+});
+
+test('resolveGuidanceScale prefers explicit request over model defaults', () => {
+ const guidance = resolveGuidanceScale({ guidance_scale: 5.25 }, { defaultGuidance: 7.5 });
+ assert.equal(guidance, 5.25);
+});
+
+test('stripAnsiSequences removes terminal control codes', () => {
+ const cleaned = stripAnsiSequences('\u001b[32mhello\u001b[0m');
+ assert.equal(cleaned, 'hello');
+});
+
+test('parseGenerationProgressChunk extracts sd-cli sampling progress from carriage-return output', () => {
+ const state = { tail: '', lastStep: 0, lastTotalSteps: 0 };
+ const chunk = '\r |==> | 1/20 - 7.16s/it\u001b[K\r |=====> | 2/20 - 6.98s/it\u001b[K';
+ const events = parseGenerationProgressChunk(chunk, state);
+
+ assert.deepEqual(events, [
+ { step: 1, totalSteps: 20, progress: 0.05 },
+ { step: 2, totalSteps: 20, progress: 0.1 },
+ ]);
+});
+
+test('parseGenerationProgressChunk de-duplicates repeated progress events across chunks', () => {
+ const state = { tail: '', lastStep: 0, lastTotalSteps: 0 };
+ const first = parseGenerationProgressChunk('\r |==> | 1/20 - 7.16s/it\u001b[K', state);
+ const second = parseGenerationProgressChunk('\r |==> | 1/20 - 7.16s/it\u001b[K\r |=====> | 2/20 - 6.98s/it\u001b[K', state);
+
+ assert.deepEqual(first, [{ step: 1, totalSteps: 20, progress: 0.05 }]);
+ assert.deepEqual(second, [{ step: 2, totalSteps: 20, progress: 0.1 }]);
+});
+
+test('parseGenerationProgressChunk does not replay old buffered steps when later chunks include earlier output', () => {
+ const state = { tail: '', lastStep: 0, lastTotalSteps: 0 };
+ const first = parseGenerationProgressChunk('\r |==> | 1/3 - 1.00s/it\u001b[K\r |=====> | 2/3 - 1.00s/it\u001b[K', state);
+ const second = parseGenerationProgressChunk('\r |==> | 1/3 - 1.00s/it\u001b[K\r |=====> | 2/3 - 1.00s/it\u001b[K\r |========> | 3/3 - 1.00s/it\u001b[K', state);
+
+ assert.deepEqual(first, [
+ { step: 1, totalSteps: 3, progress: 1 / 3 },
+ { step: 2, totalSteps: 3, progress: 2 / 3 },
+ ]);
+ assert.deepEqual(second, [
+ { step: 3, totalSteps: 3, progress: 1 },
+ ]);
+});