@agentuity/cli 0.0.63 → 0.0.65

package/dist/utils/workbench-notify.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Utility to send notifications directly to workbench clients via WebSocket
+ */
+export interface WorkbenchNotifyOptions {
+    port?: number;
+    message: 'restarting' | 'alive';
+}
+/**
+ * Send a notification directly to workbench clients via WebSocket
+ *
+ * @param options - Configuration for the notification
+ * @returns Promise that resolves when notification is sent
+ *
+ * @example
+ * ```typescript
+ * // Notify clients that server is restarting
+ * await notifyWorkbenchClients({
+ *   baseUrl: 'ws://localhost:3500',
+ *   message: 'restarting'
+ * });
+ *
+ * // Notify clients that server is alive
+ * await notifyWorkbenchClients({
+ *   message: 'alive'
+ * });
+ * ```
+ */
+export declare function notifyWorkbenchClients(options: WorkbenchNotifyOptions): Promise<void>;
+//# sourceMappingURL=workbench-notify.d.ts.map

package/dist/utils/workbench-notify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbench-notify.d.ts","sourceRoot":"","sources":["../../src/utils/workbench-notify.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,sBAAsB;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqC3F"}

package/dist/utils/workbench-notify.js

@@ -0,0 +1,56 @@
+/**
+ * Utility to send notifications directly to workbench clients via WebSocket
+ */
+/**
+ * Send a notification directly to workbench clients via WebSocket
+ *
+ * @param options - Configuration for the notification
+ * @returns Promise that resolves when notification is sent
+ *
+ * @example
+ * ```typescript
+ * // Notify clients that server is restarting
+ * await notifyWorkbenchClients({
+ *   baseUrl: 'ws://localhost:3500',
+ *   message: 'restarting'
+ * });
+ *
+ * // Notify clients that server is alive
+ * await notifyWorkbenchClients({
+ *   message: 'alive'
+ * });
+ * ```
+ */
+export async function notifyWorkbenchClients(options) {
+    const { port = 3500, message } = options;
+    const wsUrl = new URL(`ws://localhost:${port}`);
+    return new Promise((resolve) => {
+        try {
+            wsUrl.pathname = '/_agentuity/workbench/ws';
+            const ws = new WebSocket(wsUrl.toString());
+            // Set a timeout to avoid hanging
+            const timeout = setTimeout(() => {
+                ws.close();
+                resolve();
+            }, 2000);
+            ws.onopen = () => {
+                ws.send(message);
+                ws.close();
+            };
+            ws.onclose = () => {
+                clearTimeout(timeout);
+                resolve();
+            };
+            ws.onerror = () => {
+                clearTimeout(timeout);
+                ws.close();
+                resolve();
+            };
+        }
+        catch (_error) {
+            // Silently fail - this ensures the CLI doesn't fail if the app server isn't running
+            resolve();
+        }
+    });
+}
+//# sourceMappingURL=workbench-notify.js.map

package/dist/utils/workbench-notify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbench-notify.js","sourceRoot":"","sources":["../../src/utils/workbench-notify.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,OAA+B;IAC3E,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IAEzC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC;IAEhD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC9B,IAAI,CAAC;YACJ,KAAK,CAAC,QAAQ,GAAG,0BAA0B,CAAC;YAE5C,MAAM,EAAE,GAAG,IAAI,SAAS,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;YAE3C,iCAAiC;YACjC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC/B,EAAE,CAAC,KAAK,EAAE,CAAC;gBACX,OAAO,EAAE,CAAC;YACX,CAAC,EAAE,IAAI,CAAC,CAAC;YAET,EAAE,CAAC,MAAM,GAAG,GAAG,EAAE;gBAChB,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACjB,EAAE,CAAC,KAAK,EAAE,CAAC;YACZ,CAAC,CAAC;YAEF,EAAE,CAAC,OAAO,GAAG,GAAG,EAAE;gBACjB,YAAY,CAAC,OAAO,CAAC,CAAC;gBACtB,OAAO,EAAE,CAAC;YACX,CAAC,CAAC;YAEF,EAAE,CAAC,OAAO,GAAG,GAAG,EAAE;gBACjB,YAAY,CAAC,OAAO,CAAC,CAAC;gBACtB,EAAE,CAAC,KAAK,EAAE,CAAC;gBACX,OAAO,EAAE,CAAC;YACX,CAAC,CAAC;QACH,CAAC;QAAC,OAAO,MAAM,EAAE,CAAC;YACjB,oFAAoF;YACpF,OAAO,EAAE,CAAC;QACX,CAAC;IACF,CAAC,CAAC,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/cli",
-	"version": "0.0.63",
+	"version": "0.0.65",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"type": "module",
@@ -35,8 +35,8 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/core": "0.0.63",
-		"@agentuity/server": "0.0.63",
+		"@agentuity/core": "0.0.65",
+		"@agentuity/server": "0.0.65",
 		"@datasert/cronjs-parser": "^1.4.0",
 		"@terascope/fetch-github-release": "^2.2.1",
 		"acorn-loose": "^8.5.2",

package/src/cmd/build/ast.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'bun:test';
-import { parseRoute } from './ast';
+import { parseRoute, parseAgentMetadata } from './ast';
 import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 
@@ -171,3 +171,248 @@ export default router;
 		cleanup();
 	});
 });
+
+describe('parseAgentMetadata - Schema Code Extraction', () => {
+	const setup = () => {
+		rmSync(TEST_DIR, { recursive: true, force: true });
+		mkdirSync(TEST_DIR, { recursive: true });
+	};
+
+	const cleanup = () => {
+		rmSync(TEST_DIR, { recursive: true, force: true });
+	};
+
+	test('should extract input and output schema code', async () => {
+		setup();
+		const agentFile = join(TEST_DIR, 'agent.ts');
+		const code = `
+import { createAgent } from '@agentuity/runtime';
+import { z } from 'zod';
+
+const agent = createAgent({
+	metadata: {
+		name: 'test-agent',
+		description: 'Test agent',
+	},
+	schema: {
+		input: z.object({
+			name: z.string(),
+			age: z.number(),
+		}),
+		output: z.object({
+			result: z.string(),
+		}),
+	},
+	handler: async (ctx, input) => {
+		return { result: 'success' };
+	},
+});
+
+export default agent;
+		`;
+		writeFileSync(agentFile, code);
+
+		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+		const contents = transpiler.transformSync(code);
+		const [, metadata] = await parseAgentMetadata(
+			TEST_DIR,
+			agentFile,
+			contents,
+			'proj_1',
+			'dep_1'
+		);
+
+		expect(metadata.has('inputSchemaCode')).toBe(true);
+		expect(metadata.has('outputSchemaCode')).toBe(true);
+
+		const inputSchemaCode = metadata.get('inputSchemaCode');
+		const outputSchemaCode = metadata.get('outputSchemaCode');
+
+		expect(inputSchemaCode).toContain('z.object');
+		expect(inputSchemaCode).toContain('name');
+		expect(inputSchemaCode).toContain('age');
+
+		expect(outputSchemaCode).toContain('z.object');
+		expect(outputSchemaCode).toContain('result');
+
+		cleanup();
+	});
+
+	test('should extract only input schema code when output is missing', async () => {
+		setup();
+		const agentFile = join(TEST_DIR, 'agent.ts');
+		const code = `
+import { createAgent } from '@agentuity/runtime';
+import { z } from 'zod';
+
+const agent = createAgent({
+	metadata: {
+		name: 'test-agent',
+	},
+	schema: {
+		input: z.string(),
+	},
+	handler: async (ctx, input) => {
+		return 'success';
+	},
+});
+
+export default agent;
+		`;
+		writeFileSync(agentFile, code);
+
+		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+		const contents = transpiler.transformSync(code);
+		const [, metadata] = await parseAgentMetadata(
+			TEST_DIR,
+			agentFile,
+			contents,
+			'proj_1',
+			'dep_1'
+		);
+
+		expect(metadata.has('inputSchemaCode')).toBe(true);
+		expect(metadata.has('outputSchemaCode')).toBe(false);
+
+		const inputSchemaCode = metadata.get('inputSchemaCode');
+		expect(inputSchemaCode).toContain('z.string');
+
+		cleanup();
+	});
+
+	test('should extract only output schema code when input is missing', async () => {
+		setup();
+		const agentFile = join(TEST_DIR, 'agent.ts');
+		const code = `
+import { createAgent } from '@agentuity/runtime';
+import { z } from 'zod';
+
+const agent = createAgent({
+	metadata: {
+		name: 'test-agent',
+	},
+	schema: {
+		output: z.array(z.string()),
+	},
+	handler: async (ctx) => {
+		return ['item1', 'item2'];
+	},
+});
+
+export default agent;
+		`;
+		writeFileSync(agentFile, code);
+
+		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+		const contents = transpiler.transformSync(code);
+		const [, metadata] = await parseAgentMetadata(
+			TEST_DIR,
+			agentFile,
+			contents,
+			'proj_1',
+			'dep_1'
+		);
+
+		expect(metadata.has('inputSchemaCode')).toBe(false);
+		expect(metadata.has('outputSchemaCode')).toBe(true);
+
+		const outputSchemaCode = metadata.get('outputSchemaCode');
+		expect(outputSchemaCode).toContain('z.array');
+		expect(outputSchemaCode).toContain('z.string');
+
+		cleanup();
+	});
+
+	test('should handle complex nested schemas', async () => {
+		setup();
+		const agentFile = join(TEST_DIR, 'agent.ts');
+		const code = `
+import { createAgent } from '@agentuity/runtime';
+import { z } from 'zod';
+
+const agent = createAgent({
+	metadata: {
+		name: 'test-agent',
+	},
+	schema: {
+		input: z.object({
+			user: z.object({
+				name: z.string(),
+				email: z.string().email(),
+			}),
+			tags: z.array(z.string()),
+		}),
+		output: z.union([
+			z.object({ success: z.boolean() }),
+			z.object({ error: z.string() }),
+		]),
+	},
+	handler: async (ctx, input) => {
+		return { success: true };
+	},
+});
+
+export default agent;
+		`;
+		writeFileSync(agentFile, code);
+
+		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+		const contents = transpiler.transformSync(code);
+		const [, metadata] = await parseAgentMetadata(
+			TEST_DIR,
+			agentFile,
+			contents,
+			'proj_1',
+			'dep_1'
+		);
+
+		expect(metadata.has('inputSchemaCode')).toBe(true);
+		expect(metadata.has('outputSchemaCode')).toBe(true);
+
+		const inputSchemaCode = metadata.get('inputSchemaCode');
+		const outputSchemaCode = metadata.get('outputSchemaCode');
+
+		expect(inputSchemaCode).toContain('z.object');
+		expect(inputSchemaCode).toContain('user');
+		expect(inputSchemaCode).toContain('tags');
+
+		expect(outputSchemaCode).toContain('z.union');
+
+		cleanup();
+	});
+
+	test('should handle agent without schema property', async () => {
+		setup();
+		const agentFile = join(TEST_DIR, 'agent.ts');
+		const code = `
+import { createAgent } from '@agentuity/runtime';
+
+const agent = createAgent({
+	metadata: {
+		name: 'test-agent',
+	},
+	handler: async (ctx) => {
+		return 'success';
+	},
+});
+
+export default agent;
+		`;
+		writeFileSync(agentFile, code);
+
+		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+		const contents = transpiler.transformSync(code);
+		const [, metadata] = await parseAgentMetadata(
+			TEST_DIR,
+			agentFile,
+			contents,
+			'proj_1',
+			'dep_1'
+		);
+
+		expect(metadata.has('inputSchemaCode')).toBe(false);
+		expect(metadata.has('outputSchemaCode')).toBe(false);
+
+		cleanup();
+	});
+});

package/src/cmd/build/ast.ts

@@ -174,6 +174,49 @@ function generateStableEvalId(projectId: string, agentId: string, name: string):
 	return `evalid_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
 }
 
+/**
+ * Extract schema code from createAgent call arguments
+ * Returns input and output schema code as strings
+ */
+function extractSchemaCode(callargexp: ASTObjectExpression): {
+	inputSchemaCode?: string;
+	outputSchemaCode?: string;
+} {
+	let schemaObj: ASTObjectExpression | undefined;
+
+	// Find the schema property
+	for (const prop of callargexp.properties) {
+		if (prop.key.type === 'Identifier' && prop.key.name === 'schema') {
+			if (prop.value.type === 'ObjectExpression') {
+				schemaObj = prop.value as ASTObjectExpression;
+				break;
+			}
+		}
+	}
+
+	if (!schemaObj) {
+		return {};
+	}
+
+	let inputSchemaCode: string | undefined;
+	let outputSchemaCode: string | undefined;
+
+	// Extract input and output schema code
+	for (const prop of schemaObj.properties) {
+		if (prop.key.type === 'Identifier') {
+			if (prop.key.name === 'input' && prop.value) {
+				// Generate source code from AST node
+				inputSchemaCode = generate(prop.value);
+			} else if (prop.key.name === 'output' && prop.value) {
+				// Generate source code from AST node
+				outputSchemaCode = generate(prop.value);
+			}
+		}
+	}
+
+	return { inputSchemaCode, outputSchemaCode };
+}
+
 type AcornParseResultType = ReturnType<typeof acornLoose.parse>;
 
 const MetadataError = StructuredError('MetatadataNameMissingError')<{
@@ -189,7 +232,9 @@ function augmentAgentMetadataNode(
 	version: string,
 	ast: AcornParseResultType,
 	propvalue: ASTObjectExpression,
-	filename: string
+	filename: string,
+	inputSchemaCode?: string,
+	outputSchemaCode?: string
 ): [string, Map<string, string>] {
 	const metadata = parseObjectExpressionToMap(propvalue);
 	if (!metadata.has('name')) {
@@ -218,6 +263,12 @@ function augmentAgentMetadataNode(
 	metadata.set('id', id);
 	metadata.set('agentId', agentId);
 	metadata.set('description', description);
+	if (inputSchemaCode) {
+		metadata.set('inputSchemaCode', inputSchemaCode);
+	}
+	if (outputSchemaCode) {
+		metadata.set('outputSchemaCode', outputSchemaCode);
+	}
 	propvalue.properties.push(
 		createObjectPropertyNode('id', id),
 		createObjectPropertyNode('agentId', agentId),
@@ -226,6 +277,12 @@ function augmentAgentMetadataNode(
 		createObjectPropertyNode('filename', rel),
 		createObjectPropertyNode('description', description)
 	);
+	if (inputSchemaCode) {
+		propvalue.properties.push(createObjectPropertyNode('inputSchemaCode', inputSchemaCode));
+	}
+	if (outputSchemaCode) {
+		propvalue.properties.push(createObjectPropertyNode('outputSchemaCode', outputSchemaCode));
+	}
 
 	const newsource = generate(ast);
 
@@ -626,6 +683,7 @@ export async function parseAgentMetadata(
 	const id = getAgentId(projectId, deploymentId, rel, version);
 
 	let result: [string, Map<string, string>] | undefined;
+	let schemaCodeExtracted = false;
 
 	for (const body of ast.body) {
 		if (body.type === 'ExportDefaultDeclaration') {
@@ -634,6 +692,17 @@ export async function parseAgentMetadata(
 				if (call.callee.name === 'createAgent') {
 					for (const callarg of call.arguments) {
 						const callargexp = callarg as ASTObjectExpression;
+
+						// Extract schema code before processing metadata
+						let inputSchemaCode: string | undefined;
+						let outputSchemaCode: string | undefined;
+						if (!schemaCodeExtracted) {
+							const schemaCode = extractSchemaCode(callargexp);
+							inputSchemaCode = schemaCode.inputSchemaCode;
+							outputSchemaCode = schemaCode.outputSchemaCode;
+							schemaCodeExtracted = true;
+						}
+
 						for (const prop of callargexp.properties) {
 							if (prop.key.type === 'Identifier' && prop.key.name === 'metadata') {
 								result = augmentAgentMetadataNode(
@@ -644,7 +713,9 @@ export async function parseAgentMetadata(
 									version,
 									ast,
 									prop.value as ASTObjectExpression,
-									filename
+									filename,
+									inputSchemaCode,
+									outputSchemaCode
 								);
 								break;
 							}
@@ -689,6 +760,17 @@ export async function parseAgentMetadata(
 								if (call.callee.name === 'createAgent') {
 									for (const callarg of call.arguments) {
 										const callargexp = callarg as ASTObjectExpression;
+
+										// Extract schema code before processing metadata
+										let inputSchemaCode: string | undefined;
+										let outputSchemaCode: string | undefined;
+										if (!schemaCodeExtracted) {
+											const schemaCode = extractSchemaCode(callargexp);
+											inputSchemaCode = schemaCode.inputSchemaCode;
+											outputSchemaCode = schemaCode.outputSchemaCode;
+											schemaCodeExtracted = true;
+										}
+
 										for (const prop of callargexp.properties) {
 											if (
 												prop.key.type === 'Identifier' &&
@@ -702,7 +784,9 @@ export async function parseAgentMetadata(
 													version,
 													ast,
 													prop.value as ASTObjectExpression,
-													filename
+													filename,
+													inputSchemaCode,
+													outputSchemaCode
 												);
 												break;
 											}
@@ -1572,7 +1656,7 @@ export function analyzeWorkbench(content: string): WorkbenchAnalysis {
 
 		// Set default config if workbench is used but no config was parsed
 		if (hasImport && hasUsage && !config) {
-			config = { route: '/workbench' };
+			config = { route: '/workbench', headers: {}, port: 3500 };
 		}
 
 		return {

package/src/cmd/build/bundler.ts

@@ -1,5 +1,4 @@
 import { $ } from 'bun';
-import { z } from 'zod';
 import { join, relative, resolve, dirname, basename } from 'node:path';
 import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
@@ -12,34 +11,11 @@ import { createLogger } from '@agentuity/server';
 import type { LogLevel } from '../../types';
 import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench-templates';
 import { analyzeWorkbench } from './ast';
-import { encodeWorkbenchConfig, StructuredError } from '@agentuity/core';
-
-export const DeployOptionsSchema = z.object({
-	tag: z
-		.array(z.string())
-		.default(['latest'])
-		.optional()
-		.describe('One or more tags to add to the deployment'),
-	logsUrl: z.url().optional().describe('The url to the CI build logs'),
-	trigger: z
-		.enum(['cli', 'workflow', 'webhook'])
-		.default('cli')
-		.optional()
-		.describe('The trigger that caused the build'),
-	commitUrl: z.url().optional().describe('The url to the CI commit'),
-	message: z.string().optional().describe('The message to associate with this deployment'),
-	provider: z.string().optional().describe('The CI provider name (attempts to autodetect)'),
-	event: z
-		.enum(['pull_request', 'push', 'manual', 'workflow'])
-		.default('manual')
-		.optional()
-		.describe('The event that triggered the deployment'),
-	pullRequestNumber: z.number().optional().describe('the pull request number'),
-	pullRequestCommentId: z.string().optional().describe('the pull request comment id'),
-	pullRequestURL: z.url().optional().describe('the pull request url'),
-});
-
-type DeployOptions = z.infer<typeof DeployOptionsSchema>;
+import { StructuredError } from '@agentuity/core';
+import { DeployOptionsSchema, type DeployOptions } from '../../schemas/deploy';
+
+// Re-export for backward compatibility
+export { DeployOptionsSchema };
 
 export interface BundleOptions extends DeployOptions {
 	rootDir: string;
@@ -138,6 +114,15 @@ export async function bundle({
 	mkdirSync(join(outDir, 'chunk'), { recursive: true });
 	mkdirSync(join(outDir, 'asset'), { recursive: true });
 
+	// Pre-create all nested source directories in output
+	// This is needed because Bun.build with naming.entry preserves structure
+	// but doesn't create nested directories automatically
+	for (const entrypoint of appEntrypoints) {
+		const relPath = relative(rootDir, dirname(entrypoint));
+		const outputSubdir = join(outDir, relPath);
+		mkdirSync(outputSubdir, { recursive: true });
+	}
+
 	const pkgFile = Bun.file(join(rootDir, 'package.json'));
 	const pkgContents = JSON.parse(await pkgFile.text());
 	const isProd = !dev;
@@ -270,10 +255,15 @@ export async function bundle({
 			);
 
 			if (webEntrypoints.length) {
+				const webOutDir = join(outDir, 'web');
+				mkdirSync(webOutDir, { recursive: true });
+				mkdirSync(join(webOutDir, 'chunk'), { recursive: true });
+				mkdirSync(join(webOutDir, 'asset'), { recursive: true });
+
 				const config: Bun.BuildConfig = {
 					entrypoints: webEntrypoints,
 					root: webDir,
-					outdir: join(outDir, 'web'),
+					outdir: webOutDir,
 					define,
 					sourcemap: dev ? 'inline' : 'linked',
 					env: 'AGENTUITY_PUBLIC_*',
@@ -330,15 +320,9 @@ export async function bundle({
 		const analysis = analyzeWorkbench(appContent);
 
 		if (analysis.hasWorkbench) {
-			// Encode workbench config for environment variable
-			const config = analysis.config || { route: '/workbench', headers: {} };
-			// Add port to config (defaults to 3500 if not provided)
-			const configWithPort = { ...config, port: port || 3500 };
-			const encodedConfig = encodeWorkbenchConfig(configWithPort);
-			const workbenchDefine = {
-				...define,
-				AGENTUITY_WORKBENCH_CONFIG_INLINE: JSON.stringify(encodedConfig),
-			};
+			// Create workbench config with proper defaults
+			const defaultConfig = { route: '/workbench', headers: {}, port: port || 3500 };
+			const config = { ...defaultConfig, ...analysis.config };
 			const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL as LogLevel) || 'info');
 			try {
 				// Generate workbench files on the fly instead of using files from package
@@ -356,14 +340,13 @@ export async function bundle({
 				const workbenchBuildConfig: Bun.BuildConfig = {
 					entrypoints: [workbenchIndexFile],
 					outdir: join(outDir, 'workbench'),
-					define: workbenchDefine,
 					sourcemap: dev ? 'inline' : 'linked',
-					plugins: [AgentuityBundler],
+					plugins: [AgentuityBundler], // i dont think we need this plugin here
 					target: 'browser',
 					format: 'esm',
 					banner: `// Generated file. DO NOT EDIT`,
-					minify: true,
-					splitting: true,
+					minify: !dev, // Disable minification in dev to avoid module resolution issues
+					splitting: !dev, // Disable code splitting in dev to avoid relative import resolution issues
 					packages: 'bundle',
 					naming: {
 						entry: '[dir]/[name].[ext]',
@@ -390,7 +373,7 @@ export async function bundle({
 					}
 					// Clean up temp directory even on failure
 					rmSync(tempWorkbenchDir, { recursive: true, force: true });
-					process.exit(1);
+					logger.fatal('Workbench bundling failed');
 				}
 			} catch (error) {
 				logger.error('Failed to bundle workbench:', error);