Skip to content

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

fix: route socket validation errors to each domain's error channel and validate shell:start (#11764)

[._.]/ Adam Eivyca25fdcbd1ee
diff --git a/client/src/hooks/useProcessLogs.js b/client/src/hooks/useProcessLogs.js
index e21c7d299c..f49e18560a 100644
--- a/client/src/hooks/useProcessLogs.js
+++ b/client/src/hooks/useProcessLogs.js
@@ -89,6 +89,15 @@ socket.on('logs:subscribed', (data) => {
});
socket.on('logs:error', (data) => {
+ // A subscribe whose processName failed validation echoes an empty name that
+ // no entry owns; fail the streams still waiting on their ack instead of
+ // leaving them in 'connecting'.
+ if (data.code === 'VALIDATION_ERROR' && !data.processName) {
+ registry.forEach((pending) => {
+ if (pending.status === CONNECTING) setEntryStatus(pending, ERROR, String(data.error));
+ });
+ return;
+ }
const entry = registry.get(data.processName);
if (!entry) return;
appendToEntry(entry, { line: `Error: ${data.error}`, type: 'stderr', timestamp: Date.now() });
diff --git a/client/src/hooks/useProcessLogs.test.jsx b/client/src/hooks/useProcessLogs.test.jsx
index baa303b0ba..e858cba61c 100644
--- a/client/src/hooks/useProcessLogs.test.jsx
+++ b/client/src/hooks/useProcessLogs.test.jsx
@@ -362,6 +362,14 @@ describe('useProcessLogs', () => {
expect(result.current.statusDetail).toBe('pm2 unreachable');
});
+ it('a validation error with no process name fails a stream still connecting', () => {
+ const { result } = renderHook(() => useProcessLogs('game'));
+ fire('logs:error', { processName: '', code: 'VALIDATION_ERROR', error: 'processName is required' });
+
+ expect(result.current.status).toBe('error');
+ expect(result.current.statusDetail).toBe('processName is required');
+ });
+
it('ignores close/error frames for another process', () => {
const { result } = renderHook(() => useProcessLogs('game'));
fire('logs:subscribed', { processName: 'game' });
diff --git a/server/lib/socketValidation.js b/server/lib/socketValidation.js
index 517e67f3bd..d0cbfc1486 100644
--- a/server/lib/socketValidation.js
+++ b/server/lib/socketValidation.js
@@ -69,6 +69,15 @@ export const shellSessionIdSchema = z.object({
sessionId: z.string().min(1, 'sessionId is required')
});
+// shell:start — every field optional. `providerId` is resolved server-side to a
+// launch command; `cwd` / `initialCommand` must be strings so a malformed
+// payload never reaches createShellSession or the deferred submit.
+export const shellStartSchema = z.object({
+ cwd: z.string().max(1000).optional(),
+ initialCommand: z.string().max(10000).optional(),
+ providerId: z.string().max(200).optional()
+}).nullish();
+
// shell:attach — session id + optional claim flag.
// `claim: true` means "attach only if currently unattached or already mine" — used by
// auto-pick paths so a multi-tab race doesn't displace another tab. Default (false)
@@ -127,22 +136,40 @@ export const appDeploySchema = z.object({
// VALIDATION HELPER
// =============================================================================
+const optionalString = (v) => (typeof v === 'string' ? v : undefined);
+
+// Domain error channels the client actually subscribes to. Each builder returns
+// [channel, payload-extras]; `error`/`message`/`code`/`details` are shared.
+const DOMAIN_ERROR_CHANNELS = [
+ ['shell:', 'shell:error', (d) => ({ sessionId: optionalString(d?.sessionId) })],
+ ['iterm:', 'iterm:error', (d) => ({ id: optionalString(d?.id) })],
+ ['logs:', 'logs:error', (d) => ({ processName: optionalString(d?.processName) ?? '' })],
+ ['detect:start', 'detect:complete', () => ({ success: false })],
+ ['standardize:start', 'standardize:complete', () => ({ success: false })],
+ ['app:', null, (d) => ({ appId: optionalString(d?.appId) })]
+];
+
/**
* Validate socket event data against a Zod schema.
- * Emits `${event}:error` on failure and returns null.
- * Returns the parsed (and defaulted) data on success.
+ * On failure emits the validation error on the event's domain error channel
+ * (the one its client hook listens to; `${event}:error` otherwise) and returns
+ * null. Returns the parsed (and defaulted) data on success.
*/
export function validateSocketData(schema, data, socket, event) {
const result = schema.safeParse(data);
- if (!result.success) {
- socket.emit(`${event}:error`, {
- message: 'Validation failed',
- details: result.error.issues.map(i => ({
- path: i.path.join('.'),
- message: i.message
- }))
- });
- return null;
- }
- return result.data;
+ if (result.success) return result.data;
+ const details = result.error.issues.map(i => ({
+ path: i.path.join('.'),
+ message: i.message
+ }));
+ const route = DOMAIN_ERROR_CHANNELS.find(([prefix]) => event.startsWith(prefix));
+ const channel = route?.[1] ?? `${event}:error`;
+ socket.emit(channel, {
+ ...(route ? route[2](data) : {}),
+ error: details[0]?.message || 'Validation failed',
+ message: 'Validation failed',
+ code: 'VALIDATION_ERROR',
+ details
+ });
+ return null;
}
diff --git a/server/lib/socketValidation.test.js b/server/lib/socketValidation.test.js
index 9f9cdaf139..f80459a0c0 100644
--- a/server/lib/socketValidation.test.js
+++ b/server/lib/socketValidation.test.js
@@ -10,6 +10,8 @@ import {
shellResizeSchema,
shellSessionIdSchema,
shellStopSchema,
+ shellStartSchema,
+ itermSessionRefSchema,
appUpdateSchema,
appStandardizeSchema,
appDeploySchema,
@@ -238,7 +240,10 @@ describe('validateSocketData helper', () => {
expect(result).toBeNull();
expect(socket.emit).toHaveBeenCalledTimes(1);
const [event, payload] = socket.emit.mock.calls[0];
- expect(event).toBe('detect:start:error');
+ expect(event).toBe('detect:complete');
+ expect(payload.success).toBe(false);
+ expect(payload.code).toBe('VALIDATION_ERROR');
+ expect(payload.error).toEqual(expect.any(String));
expect(payload.message).toBe('Validation failed');
expect(Array.isArray(payload.details)).toBe(true);
expect(payload.details[0]).toEqual(
@@ -258,4 +263,38 @@ describe('validateSocketData helper', () => {
const [, payload] = socket.emit.mock.calls[0];
expect(payload.details.some(d => d.path === 'rows')).toBe(true);
});
+
+ it.each([
+ ['shell:resize', shellResizeSchema, { sessionId: 's1', cols: 80, rows: 9999 }, 'shell:error', { sessionId: 's1' }],
+ ['iterm:attach', itermSessionRefSchema, { id: 'bad id' }, 'iterm:error', { id: 'bad id' }],
+ ['logs:subscribe', logsSubscribeSchema, { processName: '' }, 'logs:error', { processName: '' }],
+ ['logs:subscribe', logsSubscribeSchema, { processName: 42 }, 'logs:error', { processName: '' }],
+ ['standardize:start', standardizeStartSchema, { path: '' }, 'standardize:complete', { success: false }],
+ ['app:update', appUpdateSchema, { appId: 7 }, 'app:update:error', { appId: undefined }],
+ ['app:standardize', appStandardizeSchema, { appId: 'a', overwriteEcosystem: 'x' }, 'app:standardize:error', { appId: 'a' }]
+ ])('routes %s failures to %s', (event, schema, input, channel, extras) => {
+ const socket = makeSocket();
+ expect(validateSocketData(schema, input, socket, event)).toBeNull();
+ const [emitted, payload] = socket.emit.mock.calls[0];
+ expect(emitted).toBe(channel);
+ expect(payload).toEqual(expect.objectContaining({
+ ...extras,
+ error: payload.details[0].message,
+ message: 'Validation failed',
+ code: 'VALIDATION_ERROR'
+ }));
+ });
+});
+
+describe('shellStartSchema', () => {
+ it('accepts undefined, null, empty and string fields', () => {
+ expect(shellStartSchema.safeParse(undefined).success).toBe(true);
+ expect(shellStartSchema.safeParse(null).success).toBe(true);
+ expect(shellStartSchema.safeParse({ cwd: '/tmp', initialCommand: 'ls', providerId: 'p' }).success).toBe(true);
+ });
+
+ it('rejects non-string cwd or initialCommand', () => {
+ expect(shellStartSchema.safeParse({ cwd: { a: 1 } }).success).toBe(false);
+ expect(shellStartSchema.safeParse({ initialCommand: 5 }).success).toBe(false);
+ });
});
diff --git a/server/sockets/shell.js b/server/sockets/shell.js
index b33faaeb12..038651a634 100644
--- a/server/sockets/shell.js
+++ b/server/sockets/shell.js
@@ -6,6 +6,7 @@ import {
shellCdSchema,
shellInputSchema,
shellResizeSchema,
+ shellStartSchema,
shellStopSchema,
validateSocketData
} from '../lib/socketValidation.js';
@@ -16,7 +17,9 @@ export const registerShellHandlers = (socket, _io) => {
// `providerId` is the AI Providers page's "Launch in Shell" path. The client
// sends only the ID and the server resolves the command and secret-bearing
// environment, preventing both backend drift and client-selected commands.
- socket.on('shell:start', async (options) => {
+ socket.on('shell:start', async (rawOptions) => {
+ const options = validateSocketData(shellStartSchema, rawOptions, socket, 'shell:start');
+ if (options === null) return;
try {
const cwd = options?.cwd || undefined;
const providerId = typeof options?.providerId === 'string' ? options.providerId : null;
diff --git a/server/sockets/shell.test.js b/server/sockets/shell.test.js
new file mode 100644
index 0000000000..1ecc81fbf7
--- /dev/null
+++ b/server/sockets/shell.test.js
@@ -0,0 +1,37 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const createShellSession = vi.fn(() => 'sess-1');
+vi.mock('../services/shell.js', () => ({
+ createShellSession,
+ submitToSession: vi.fn(),
+ attachSession: vi.fn(),
+ detachSocketSessions: vi.fn()
+}));
+vi.mock('../services/providers.js', () => ({ getProviderById: vi.fn() }));
+
+const { registerShellHandlers } = await import('./shell.js');
+
+const setup = () => {
+ const handlers = {};
+ const socket = { on: (event, fn) => { handlers[event] = fn; }, emit: vi.fn() };
+ registerShellHandlers(socket, {});
+ return { handlers, socket };
+};
+
+describe('shell:start payload validation', () => {
+ beforeEach(() => createShellSession.mockClear());
+
+ it('rejects a non-string cwd on shell:error without creating a session', async () => {
+ const { handlers, socket } = setup();
+ await handlers['shell:start']({ cwd: { not: 'a string' } });
+ expect(createShellSession).not.toHaveBeenCalled();
+ expect(socket.emit).toHaveBeenCalledWith('shell:error', expect.objectContaining({ code: 'VALIDATION_ERROR' }));
+ });
+
+ it('still starts a session for an absent payload', async () => {
+ const { handlers, socket } = setup();
+ await handlers['shell:start'](undefined);
+ expect(createShellSession).toHaveBeenCalledTimes(1);
+ expect(socket.emit).toHaveBeenCalledWith('shell:started', { sessionId: 'sess-1' });
+ });
+});