Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
fix: allow Codex render concurrency above ten
[._.]/ Adam Eivy84a9bdacd699
diff --git a/client/src/components/settings/ImageGenTab.jsx b/client/src/components/settings/ImageGenTab.jsxindex 5052e47e0c..88c829e546 100644--- a/client/src/components/settings/ImageGenTab.jsx+++ b/client/src/components/settings/ImageGenTab.jsx@@ -37,6 +37,7 @@ import { useAgyModels } from '../../hooks/useAgyModels';import { useHfTokenStatus } from '../../hooks/useHfTokenStatus';import useLocalImageModels from '../../hooks/useLocalImageModels';import { effortLevelsForProvider, isCodexSubscriptionProvider, providerModelList } from '../../utils/providers';+import { formatCount } from '../../utils/formatters';const SDAPI_TOOL_ID = 'sdapi';const CODEX_TOOL_ID = 'codex-imagegen';@@ -50,7 +51,7 @@ const normalizeUrl = (url) => (url || '').trim().replace(/\/+$/, '');// Fallback bounds used until /api/settings has been fetched once. The server// is the source of truth (returns `imageGen.codex.parallelLimitBounds` with// the real min/max/default), so these only matter for the first paint.-const PARALLEL_FALLBACK = { min: 1, max: 10, default: 1 };+const PARALLEL_FALLBACK = { min: 1, max: Number.MAX_SAFE_INTEGER, default: 1 };const clampParallel = (n, bounds = PARALLEL_FALLBACK) =>Math.max(bounds.min, Math.min(bounds.max, Math.floor(Number(n) || bounds.default)));@@ -1363,12 +1364,11 @@ export function ImageGenTab() {className="w-24 bg-port-bg border border-port-border rounded-lg px-3 py-2 text-sm text-white focus:outline-none focus:border-port-accent"/><p className="text-xs text-gray-500 mt-1">- How many Codex renders the queue runs in parallel. Default <code>{parallelBounds.default}</code>. Hard capped at <code>{parallelBounds.max}</code>.- Higher values let large batches finish faster but burn OpenAI credits non-linearly — a runaway {parallelBounds.max}-wide- batch can rack up real money in minutes.- {codexParallelLimit > Math.ceil(parallelBounds.max / 2) && (+ How many Codex renders the queue runs in parallel. Default <code>{formatCount(parallelBounds.default)}</code>.+ Higher values let large batches finish faster, subject to your provider's rate limits, and increase simultaneous usage.+ {codexParallelLimit > 5 && (<span className="block mt-1 text-port-warning">- ⚠️ {codexParallelLimit} concurrent renders can burn credits quickly during a long batch. Watch usage.+ ⚠️ {formatCount(codexParallelLimit)} concurrent renders can burn credits quickly during a long batch. Watch usage.</span>)}</p>diff --git a/client/src/components/settings/ImageGenTab.test.jsx b/client/src/components/settings/ImageGenTab.test.jsxindex f9f65290e5..5205232235 100644--- a/client/src/components/settings/ImageGenTab.test.jsx+++ b/client/src/components/settings/ImageGenTab.test.jsx@@ -94,6 +94,25 @@ beforeEach(() => {});describe('ImageGenTab grouped tabs', () => {+ it.each([undefined, { min: 1, max: Number.MAX_SAFE_INTEGER, default: 1 }])(+ 'loads and saves render limits above ten with bounds %j', async (parallelLimitBounds) => {+ getSettings.mockResolvedValue({+ imageGen: {+ mode: 'codex', codex: { enabled: true, parallelLimit: 25, parallelLimitBounds },+ },+ });+ await renderTab(['/media/image?mediaTab=codex']);+ const input = screen.getByLabelText('Parallel render limit');+ expect(input.value).toBe('25');+ fireEvent.change(input, { target: { value: '50' } });+ fireEvent.blur(input);+ expect(input.value).toBe('50');+ fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));+ await waitFor(() => expect(updateSettings).toHaveBeenCalled());+ expect(updateSettings.mock.calls[0][0].imageGen.codex.parallelLimit).toBe(50);+ },+ );+it('renders a pills sub-nav with all media-settings groups', async () => {await renderTab();const tabs = screen.getAllByRole('tab').map((t) => t.textContent);diff --git a/server/services/imageGenEvents.js b/server/services/imageGenEvents.jsindex 61de5d1267..1c7beda51b 100644--- a/server/services/imageGenEvents.js+++ b/server/services/imageGenEvents.js@@ -3,15 +3,11 @@ import { EventEmitter } from 'events';import { makeEmitterFaultIsolating } from '../lib/faultIsolatedEmitter.js';export const imageGenEvents = makeEmitterFaultIsolating(new EventEmitter());-// Each in-flight image job attaches ~6 listeners (progress/status/completed/-// failed + 2 watchdog activity tracers). With CODEX_PARALLEL_MAX = 10 codex-// renders in flight plus a concurrent local image render, that's 60+ live-// listeners — well past Node's default cap of 10. Setting it to 0 disables-// the leak warning entirely; the listener pairs are deterministically detached-// in runJob's terminate() + final detach() so a real leak would surface as-// memory growth in pm2 status, not as the warning. 200 leaves headroom for-// short overlap during job churn.-imageGenEvents.setMaxListeners(200);+// Each in-flight image job attaches progress/status/completion listeners and+// watchdog activity tracers. Cloud concurrency is user-configured, so no fixed+// listener threshold distinguishes a large batch from a leak. runJob detaches+// each job's listeners on termination and again in its final cleanup.+imageGenEvents.setMaxListeners(0);// Async completion listeners own their leases instead of borrowing the provider's.const emit = imageGenEvents.emit;diff --git a/server/services/mediaJobQueue/index.js b/server/services/mediaJobQueue/index.jsindex 19b0a95661..4b2755bcbd 100644--- a/server/services/mediaJobQueue/index.js+++ b/server/services/mediaJobQueue/index.js@@ -272,7 +272,8 @@ const videoHolds = createVideoHolds();export const REMOTE_MEDIA_PARALLEL_LIMIT = 20;export const CODEX_PARALLEL_MIN = 1;-export const CODEX_PARALLEL_MAX = 10;+// Keep counts exactly representable without imposing a provider throughput cap.+export const CODEX_PARALLEL_MAX = Number.MAX_SAFE_INTEGER;export const CODEX_PARALLEL_DEFAULT = 1;let codexParallelLimit = CODEX_PARALLEL_DEFAULT;const clampParallel = (n) => {diff --git a/server/services/mediaJobQueue/index.test.js b/server/services/mediaJobQueue/index.test.jsindex e55467d93f..42fdd198da 100644--- a/server/services/mediaJobQueue/index.test.js+++ b/server/services/mediaJobQueue/index.test.js@@ -1890,6 +1890,33 @@ describe('Audio kind (#1928)', () => {});describe('Codex lane', () => {+ it('runs more than ten renders while enforcing the saved limit and cleaning up listeners', async () => {+ // Kickoff resolves; terminal events keep each render active until completed.+ stubs.generateImageCodex.mockResolvedValue({});+ await mediaJobQueue.initMediaJobQueue();+ mediaJobQueue.setCodexParallelLimit(12);+ const events = ['progress', 'status', 'completed', 'failed'];+ const listenerCounts = () => events.map((event) => imageGenEvents.listenerCount(event));+ const before = listenerCounts();+ const jobs = [];+ for (let i = 0; i < 13; i++) {+ jobs.push(await mediaJobQueue.enqueueJob({+ kind: 'image', params: { prompt: `Example render ${i}`, mode: 'codex' },+ }));+ }+ await waitFor(() => stubs.generateImageCodex.mock.calls.length === 12);+ expect(mediaJobQueue.getQueueCapacity().lanes.cloud.limit).toBe(12);+ expect(mediaJobQueue.getJob(jobs[12].jobId).status).toBe('queued');++ imageGenEvents.emit('completed', { generationId: jobs[0].jobId, filename: 'example.png' });+ await waitFor(() => stubs.generateImageCodex.mock.calls.length === 13);+ for (const job of jobs.slice(1)) {+ imageGenEvents.emit('completed', { generationId: job.jobId, filename: 'example.png' });+ }+ await waitFor(() => jobs.every((job) => mediaJobQueue.getJob(job.jobId).status === 'completed'));+ expect(listenerCounts()).toEqual(before);+ });+it('dispatches a Codex job to imageGen/codex.js#generateImage, not local', async () => {// Allow the codex job to resolve immediately so the worker can settle.stubs.generateImageCodex.mockResolvedValue({ jobId: 'whatever' });