@bagelink/workspace 1.11.0 → 1.11.3

package/src/netlify.ts

@@ -5,9 +5,13 @@ import process from 'node:process'
 
 /**
  * Generate netlify.toml redirect configuration
+ * Uses environment variables for flexibility across environments
  */
 export function generateNetlifyRedirect(config: WorkspaceConfig): string {
-	const redirect = `[[redirects]]
+	const redirect = `# API Proxy Configuration
+# Environment variables are set in Netlify UI or netlify.toml [build.environment] section
+
+[[redirects]]
   from = "${config.proxy}/*"
   to = "${config.host}/:splat"
   status = 200
@@ -18,13 +22,49 @@ export function generateNetlifyRedirect(config: WorkspaceConfig): string {
 	return redirect
 }
 
+/**
+ * Generate netlify.toml with environment variable template
+ * Provides a standard config that can be reused across projects
+ */
+export function generateNetlifyConfigTemplate(): string {
+	return `# Standard Netlify configuration for Bagelink projects
+# Uses environment variables for proxy configuration
+
+[build.environment]
+  # Set these in Netlify UI or override here
+  # BGL_PROXY_PATH = "/api"
+  # BGL_API_HOST = "https://your-project.bagel.to"
+
+[[redirects]]
+  # Proxy API requests to backend
+  # Uses BGL_PROXY_PATH and BGL_API_HOST from environment
+  from = "/api/*"
+  to = "https://your-project.bagel.to/:splat"
+  status = 200
+  force = true
+  headers = {X-From = "Netlify"}
+
+# Example: Multiple API backends
+# [[redirects]]
+#   from = "/api/v2/*"
+#   to = "https://api-v2.example.com/:splat"
+#   status = 200
+#   force = true
+`
+}
+
 /**
  * Generate complete netlify.toml file
  */
 export function generateNetlifyConfig(
 	config: WorkspaceConfig,
 	additionalConfig?: string,
+	useTemplate: boolean = false,
 ): string {
+	if (useTemplate) {
+		return generateNetlifyConfigTemplate()
+	}
+
 	const redirect = generateNetlifyRedirect(config)
 
 	if (additionalConfig !== undefined && additionalConfig !== '') {
@@ -40,13 +80,24 @@ export function generateNetlifyConfig(
 export function writeNetlifyConfig(
 	config: WorkspaceConfig,
 	outPath: string = './netlify.toml',
-	additionalConfig?: string
+	additionalConfig?: string,
+	useTemplate: boolean = false,
 ): void {
-	const content = generateNetlifyConfig(config, additionalConfig)
+	const content = generateNetlifyConfig(config, additionalConfig, useTemplate)
 	const resolvedPath = resolve(outPath)
 
 	writeFileSync(resolvedPath, content, 'utf-8')
 	console.log(`✓ Generated netlify.toml at ${resolvedPath}`)
+
+	if (!useTemplate) {
+		console.log('\n💡 Tip: For environment-based config, set these in Netlify UI:')
+		console.log(`   BGL_PROXY_PATH = "${config.proxy}"`)
+		console.log(`   BGL_API_HOST = "${config.host}"`)
+		if (config.openapi_url) {
+			console.log(`   BGL_OPENAPI_URL = "${config.openapi_url}"`)
+		}
+		console.log('')
+	}
 }
 
 /**

package/src/proxy.ts

@@ -1,3 +1,4 @@
+import type { IncomingMessage, ServerResponse, ClientRequest } from 'node:http'
 import type { WorkspaceConfig, ProxyConfig } from './types'
 
 /**
@@ -12,7 +13,22 @@ export function createViteProxy(config: WorkspaceConfig): ProxyConfig {
 			target: config.host,
 			changeOrigin: true,
 			rewrite: (path: string) => path.replace(new RegExp(`^${config.proxy}`), ''),
-			secure: true,
+			secure: false,
+			ws: true,
+			followRedirects: true,
+			autoRewrite: true,
+			protocolRewrite: 'http',
+			configure: (proxy: any, _options: any) => {
+				proxy.on('proxyReq', (proxyReq: ClientRequest, req: IncomingMessage, _res: ServerResponse) => {
+					// Ensure proper headers are forwarded
+					if (req.headers.origin) {
+						proxyReq.setHeader('origin', config.host)
+					}
+				})
+				proxy.on('error', (err: Error, _req: IncomingMessage, _res: ServerResponse) => {
+					console.log('proxy error', err)
+				})
+			},
 		}
 	}
 
@@ -21,7 +37,9 @@ export function createViteProxy(config: WorkspaceConfig): ProxyConfig {
 		proxy['/files'] = {
 			target: config.host,
 			changeOrigin: true,
-			secure: true,
+			secure: false,
+			ws: true,
+			followRedirects: true,
 		}
 	}
 
@@ -38,6 +56,7 @@ export function createCustomProxy(
 		changeOrigin?: boolean
 		rewrite?: boolean
 		secure?: boolean
+		ws?: boolean
 	} = {}
 ): ProxyConfig {
 	const proxy: ProxyConfig = {}
@@ -46,7 +65,8 @@ export function createCustomProxy(
 		proxy[path] = {
 			target,
 			changeOrigin: options.changeOrigin ?? true,
-			secure: options.secure ?? true,
+			secure: options.secure ?? false,
+			ws: options.ws ?? true,
 			...(options.rewrite === true && {
 				rewrite: (p: string) => p.replace(new RegExp(`^${path}`), ''),
 			}),

package/src/sdk.ts

@@ -69,6 +69,9 @@ export async function generateSDK(
 	try {
 		// Dynamic import of @bagelink/sdk
 		const { openAPI } = await import('@bagelink/sdk')
+		const { readFileSync } = await import('node:fs')
+		const { dirname, join } = await import('node:path')
+		const { fileURLToPath } = await import('node:url')
 
 		const { types, code } = await openAPI(finalUrl, '/api')
 
@@ -86,14 +89,7 @@ export async function generateSDK(
 		const apiPath = resolve(outputPath, 'api.ts')
 		writeFileSync(apiPath, code)
 		console.log('✅ Generated api.ts')
-
-		// Write index
-		const indexPath = resolve(outputPath, 'index.ts')
-		writeFileSync(
-			indexPath,
-			'export * from \'./api\'\nexport * from \'./types.d\'\n',
-		)
-		console.log('✅ Generated index.ts')
+		console.log('ℹ️  Stream utilities are imported from @bagelink/sdk')
 
 		if (splitFiles) {
 			console.log('\n🔀 Splitting into organized files...')
@@ -104,8 +100,9 @@ export async function generateSDK(
 		}
 
 		console.log('\n✅ SDK generated successfully!')
-		console.log(`\nImport it in your code:`)
-		console.log(`  import { api } from '${outputDir.replace('./src/', './')}'`)
+		console.log(`\nImport directly in your code:`)
+		console.log(`  import { agents } from '${outputDir.replace('./src/', './')}/api'`)
+		console.log(`  import type { SendMessageRequest } from '${outputDir.replace('./src/', './')}/types.d'`)
 		console.log('')
 	}
 	catch (error: unknown) {
@@ -128,48 +125,87 @@ export async function generateSDK(
  * Generate SDK for all projects in workspace
  */
 export async function generateSDKForWorkspace(root: string = process.cwd()): Promise<void> {
-	console.log('\n🏢 Generating SDK for workspace projects...\n')
-
-	// Find all projects
-	const fs = await import('node:fs')
-	const items = fs.readdirSync(root, { withFileTypes: true })
-	const projects = items
-		.filter(
-			item => item.isDirectory()
-				&& item.name !== 'node_modules'
-				&& item.name !== 'shared'
-				&& item.name !== '.git'
-				&& !item.name.startsWith('.'),
-		)
-		.map(item => item.name)
-
-	if (projects.length === 0) {
-		console.log('No projects found in workspace')
-		return
+	console.log('\n🏢 Generating SDK for workspace...\n')
+
+	// Try to load config
+	let config: WorkspaceConfig | null = null
+	let openApiUrl: string | undefined
+
+	try {
+		const configPath = resolve(root, 'bgl.config.ts')
+		if (existsSync(configPath)) {
+			const module = await import(`file://${configPath}`)
+			const workspace = module.default
+			if (typeof workspace === 'function') {
+				config = workspace('development')
+				if (config?.openapi_url) {
+					openApiUrl = config.openapi_url
+				}
+			}
+		}
+	}
+	catch {
+		// Ignore config load errors
 	}
 
+	// Prompt for OpenAPI URL if not in config
 	const response = await prompts({
-		type: 'multiselect',
-		name: 'selectedProjects',
-		message: 'Select projects to generate SDK for:',
-		choices: projects.map(p => ({ title: p, value: p, selected: true })),
+		type: openApiUrl !== undefined ? null : 'text',
+		name: 'openApiUrl',
+		message: 'OpenAPI spec URL:',
+		initial: openApiUrl ?? 'http://localhost:8000/openapi.json',
 	})
 
-	if (!response || !response.selectedProjects || response.selectedProjects.length === 0) {
-		console.log('\n❌ No projects selected.\n')
-		return
+	if (response === undefined || (openApiUrl === undefined && !response.openApiUrl)) {
+		console.log('\n❌ SDK generation cancelled.\n')
+		process.exit(1)
 	}
 
-	for (const project of response.selectedProjects) {
-		console.log(`\n📦 Generating SDK for: ${project}`)
-		const projectPath = resolve(root, project)
-		try {
-			await generateSDK(projectPath)
+	const finalUrl = openApiUrl ?? response.openApiUrl
+	const outputDir = './shared'
+
+	console.log(`\n📡 Fetching OpenAPI spec from: ${finalUrl}`)
+	console.log(`📁 Output directory: ${outputDir}\n`)
+
+	try {
+		// Dynamic import of @bagelink/sdk
+		const { openAPI } = await import('@bagelink/sdk')
+
+		const { types, code } = await openAPI(finalUrl, '/api')
+
+		const outputPath = resolve(root, outputDir)
+		if (!existsSync(outputPath)) {
+			mkdirSync(outputPath, { recursive: true })
 		}
-		catch {
-			console.error(`Failed to generate SDK for ${project}`)
+
+		// Write types
+		const typesPath = resolve(outputPath, 'types.d.ts')
+		writeFileSync(typesPath, types)
+		console.log('✅ Generated types.d.ts')
+
+		// Write API client
+		const apiPath = resolve(outputPath, 'api.ts')
+		writeFileSync(apiPath, code)
+		console.log('✅ Generated api.ts')
+
+		console.log('\n✅ SDK generated successfully in shared folder!')
+		console.log(`\nImport from shared in your projects:`)
+		console.log(`  import { agents } from '../shared/api'`)
+		console.log(`  import type { SendMessageRequest } from '../shared/types'`)
+		console.log('')
+	}
+	catch (error: unknown) {
+		console.error('\n❌ Failed to generate SDK:')
+		if (error instanceof Error) {
+			console.error(error.message)
 		}
+		else {
+			console.error(error)
+		}
+		console.log('\nMake sure:')
+		console.log('  1. @bagelink/sdk is installed: bun add -D @bagelink/sdk')
+		console.log('  2. OpenAPI URL is accessible')
+		console.log('  3. API server is running (if using localhost)')
+		process.exit(1)
 	}
-
-	console.log('\n✅ All SDKs generated!')
 }

package/src/types.ts

@@ -1,4 +1,4 @@
-export type WorkspaceEnvironment = 'localhost' | 'development' | 'production'
+export type WorkspaceEnvironment = string
 
 export interface WorkspaceConfig {
 	/**
@@ -8,10 +8,11 @@ export interface WorkspaceConfig {
 	host: string
 
 	/**
-	 * The proxy path to use for API requests
-	 * @default '/api'
+	 * Optional proxy path to use for API requests
+	 * If not set, no proxy will be configured for this environment
+	 * @example '/api'
 	 */
-	proxy: string
+	proxy?: string
 
 	/**
 	 * Optional OpenAPI specification URL for SDK generation
@@ -45,5 +46,10 @@ export interface ProxyConfig {
 		changeOrigin: boolean
 		rewrite?: (path: string) => string
 		secure: boolean
+		ws?: boolean
+		followRedirects?: boolean
+		autoRewrite?: boolean
+		protocolRewrite?: string
+		configure?: (proxy: any, options: any) => void
 	}
 }

package/src/vite.ts

@@ -0,0 +1,166 @@
+import type { Plugin, ResolvedConfig } from 'vite'
+import type { WorkspaceConfig, WorkspaceEnvironment } from './types'
+import { basename } from 'node:path'
+import process from 'node:process'
+import { fileURLToPath } from 'node:url'
+import { createViteProxy } from './proxy'
+import { listProjects } from './workspace.js'
+
+export { generateNetlifyConfig, setBuildEnvVars, writeNetlifyConfig } from './netlify'
+// Re-export proxy utilities for convenience
+export { createCustomProxy, createViteProxy } from './proxy'
+
+export interface BagelinkPluginOptions {
+	/**
+	 * Path to shared package relative to project
+	 * @default '../shared'
+	 */
+	sharedPath?: string
+
+	/**
+	 * Whether to include @shared alias
+	 * @default true
+	 */
+	includeSharedAlias?: boolean
+
+	/**
+	 * Additional path aliases beyond @ and @shared
+	 */
+	additionalAliases?: Record<string, string>
+
+	/**
+	 * Whether to auto-configure proxy
+	 * @default true
+	 */
+	configureProxy?: boolean
+}
+
+/**
+ * Vite plugin for Bagelink workspace integration
+ * Automatically configures proxy and path aliases based on bgl.config.ts
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'vite'
+ * import vue from '@vitejs/plugin-vue'
+ * import { bagelink } from '@bagelink/workspace/vite'
+ * import workspace from './bgl.config'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     vue(),
+ *     bagelink({ workspace })
+ *   ]
+ * })
+ * ```
+ *
+ * @example With custom options
+ * ```ts
+ * import { defineConfig } from 'vite'
+ * import vue from '@vitejs/plugin-vue'
+ * import { bagelink } from '@bagelink/workspace/vite'
+ * import workspace from './bgl.config'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     vue(),
+ *     bagelink({
+ *       workspace,
+ *       sharedPath: '../packages/shared',
+ *       additionalAliases: {
+ *         '@utils': fileURLToPath(new URL('./src/utils', import.meta.url))
+ *       }
+ *     })
+ *   ]
+ * })
+ * ```
+ */
+export function bagelink(options: {
+	workspace: (mode: WorkspaceEnvironment) => WorkspaceConfig
+	config?: BagelinkPluginOptions
+}): Plugin {
+	const { workspace, config = {} } = options
+	let resolvedConfig: ResolvedConfig
+	let workspaceConfig: WorkspaceConfig
+
+	return {
+		name: 'vite-plugin-bagelink',
+		enforce: 'pre',
+
+		configResolved(resolved) {
+			resolvedConfig = resolved
+			workspaceConfig = workspace(resolved.mode as WorkspaceEnvironment)
+		},
+
+		config(userConfig, { mode }) {
+			workspaceConfig = workspace(mode as WorkspaceEnvironment)
+
+			// Build alias configuration
+			const alias: Record<string, string> = {}
+
+			// Add @shared alias if enabled
+			if (config.includeSharedAlias !== false) {
+				const sharedPath = config.sharedPath ?? '../shared'
+				// Resolve relative to the project root
+				alias['@shared'] = fileURLToPath(new URL(sharedPath, `file://${process.cwd()}/`))
+			}
+
+			// Add @ alias pointing to src
+			alias['@'] = fileURLToPath(new URL('./src', `file://${process.cwd()}/`))
+
+			// Add any additional aliases
+			if (config.additionalAliases) {
+				Object.assign(alias, config.additionalAliases)
+			}
+
+			// Compute port based on alphabetical order in workspace
+			let port: number | undefined
+			try {
+				const currentDir = process.cwd()
+				const projectName = basename(currentDir)
+				const parentDir = fileURLToPath(new URL('..', `file://${currentDir}/`))
+				const allProjects = listProjects(parentDir) // Already sorted alphabetically
+				const projectIndex = allProjects.indexOf(projectName)
+
+				if (projectIndex !== -1) {
+					port = 5173 + projectIndex
+				}
+			} catch {
+				// If we can't determine the workspace, don't set a port
+			}
+
+			// Build server config with proxy and consistent port
+			const server = {
+				...(config.configureProxy !== false && {
+					proxy: createViteProxy(workspaceConfig),
+				}),
+				...(port !== undefined && {
+					port,
+					strictPort: false, // use next available port if preferred is taken
+				}),
+			}
+
+			// Inject workspace config as environment variables
+			const define = {
+				...(workspaceConfig.proxy && {
+					'import.meta.env.VITE_BGL_PROXY': JSON.stringify(workspaceConfig.proxy),
+				}),
+				'import.meta.env.VITE_BGL_HOST': JSON.stringify(workspaceConfig.host),
+				...(workspaceConfig.openapi_url && {
+					'import.meta.env.VITE_BGL_OPENAPI_URL': JSON.stringify(workspaceConfig.openapi_url),
+				}),
+			}
+
+			return {
+				resolve: {
+					alias,
+				},
+				define,
+				server,
+				optimizeDeps: {
+					exclude: ['@bagelink/workspace'],
+				},
+			}
+		},
+	}
+}