@bagelink/workspace 1.10.7 → 1.10.11

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'],
+				},
+			}
+		},
+	}
+}

package/src/workspace.ts

@@ -87,12 +87,27 @@ function createWorkspaceRoot(root: string, name: string, projectId: string): voi
 		private: true,
 		workspaces: ['*', '!node_modules'],
 		scripts: {
-			dev: 'bun run --filter \'./[!shared]*\' dev',
-			build: 'bun run --filter \'./[!shared]*\' build',
-			typecheck: 'tsc --noEmit',
+			'dev': 'bgl dev',
+			'dev:local': 'bgl dev --mode localhost',
+			'dev:verbose': 'bun run --filter \'./!shared*\' dev',
+			'build': 'bgl build',
+			'typecheck': 'tsc --noEmit',
+			'lint': 'eslint . --cache',
+			'lint:fix': 'eslint . --cache --fix',
+		},
+		dependencies: {
+			'@bagelink/auth': 'latest',
+			'@bagelink/sdk': 'latest',
+			'@bagelink/vue': 'latest',
+			'pinia': 'latest',
+			'vue': 'latest',
+			'vue-router': 'latest',
 		},
 		devDependencies: {
+			'@bagelink/lint-config': 'latest',
 			'@bagelink/workspace': 'latest',
+			'@vitejs/plugin-vue': 'latest',
+			'eslint': 'latest',
 			'typescript': '^5.0.0',
 			'vite': 'latest',
 		},
@@ -106,10 +121,15 @@ function createWorkspaceRoot(root: string, name: string, projectId: string): voi
 	// bgl.config.ts (shared)
 	const bglConfig = `import { defineWorkspace } from '@bagelink/workspace'
 
+/**
+ * Define your workspace environments
+ * You can add as many custom environments as needed (e.g., 'staging', 'preview')
+ * Use --mode flag to switch: bgl dev --mode <env_name>
+ */
 export default defineWorkspace({
 	localhost: {
 		host: 'http://localhost:8000',
-		proxy: '/api',
+		proxy: '/api', // Optional: remove to skip proxy setup
 		openapi_url: 'http://localhost:8000/openapi.json',
 	},
 	development: {
@@ -168,6 +188,77 @@ dist
 
 	writeFileSync(resolve(workspaceDir, '.gitignore'), gitignore)
 
+	// Create scripts directory
+	const scriptsDir = resolve(workspaceDir, 'scripts')
+	mkdirSync(scriptsDir, { recursive: true })
+
+	// Copy dev runner script
+	const devRunnerContent = `#!/usr/bin/env bun
+import { spawn } from 'bun'
+import { readdir } from 'fs/promises'
+import { resolve } from 'path'
+
+const projectsRoot = process.cwd()
+const projects = (await readdir(projectsRoot, { withFileTypes: true }))
+	.filter(
+		item =>
+			item.isDirectory()
+			&& item.name !== 'node_modules'
+			&& item.name !== 'shared'
+			&& item.name !== 'scripts'
+			&& item.name !== '.git'
+			&& !item.name.startsWith('.'),
+	)
+	.map(item => item.name)
+
+console.log(\`\\n🚀 Starting \${projects.length} project\${projects.length > 1 ? 's' : ''}...\\n\`)
+
+const urlPattern = /Local:\\s+(http:\\/\\/localhost:\\d+)/
+
+projects.forEach((project) => {
+	const proc = spawn({
+		cmd: ['bun', 'run', 'dev'],
+		cwd: resolve(projectsRoot, project),
+		stdout: 'pipe',
+		stderr: 'pipe',
+	})
+
+	const decoder = new TextDecoder()
+
+	proc.stdout.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				const match = text.match(urlPattern)
+				if (match) {
+					console.log(\`  ✓ \${project.padEnd(15)} → \${match[1]}\`)
+				}
+			},
+		}),
+	)
+
+	proc.stderr.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				if (text.includes('error') || text.includes('Error')) {
+					console.error(\`  ✗ \${project}: \${text.trim()}\`)
+				}
+			},
+		}),
+	)
+})
+
+console.log('\\n💡 Press Ctrl+C to stop all servers\\n')
+
+process.on('SIGINT', () => {
+	console.log('\\n\\n👋 Stopping all servers...\\n')
+	process.exit()
+})
+`
+
+	writeFileSync(resolve(scriptsDir, 'dev.ts'), devRunnerContent)
+
 	console.log(`✅ Created workspace: ${name}`)
 }
 
@@ -300,18 +391,14 @@ export default defineWorkspace({
 	// vite.config.ts
 	const viteConfig = `import { defineConfig } from 'vite'
 import vue from '@vitejs/plugin-vue'
-import { createViteProxy } from '@bagelink/workspace'
+import { bagelink } from '@bagelink/workspace/vite'
 import workspace from './bgl.config'
 
-export default defineConfig(({ mode }) => {
-	const config = workspace(mode as 'localhost' | 'development' | 'production')
-
-	return {
-		plugins: [vue()],
-		server: {
-			proxy: createViteProxy(config),
-		},
-	}
+export default defineConfig({
+	plugins: [
+		vue(),
+		bagelink({ workspace }),
+	],
 })
 `
 
@@ -340,9 +427,12 @@ export default defineConfig(({ mode }) => {
 
 	// main.ts
 	const mainTs = `import { createApp } from 'vue'
+import { BagelVue } from '@bagelink/vue'
 import App from './App.vue'
 
-createApp(App).mount('#app')
+createApp(App)
+	.use(BagelVue)
+	.mount('#app')
 `
 
 	writeFileSync(resolve(srcDir, 'main.ts'), mainTs)
@@ -412,7 +502,7 @@ function updateWorkspaceScripts(root: string, projectName: string): void {
 }
 
 /**
- * List all projects in workspace
+ * List all projects in workspace (sorted alphabetically for consistent ordering)
  */
 export function listProjects(root: string = process.cwd()): string[] {
 	try {
@@ -422,10 +512,25 @@ export function listProjects(root: string = process.cwd()): string[] {
 				item => item.isDirectory()
 					&& item.name !== 'node_modules'
 					&& item.name !== 'shared'
+					&& item.name !== 'scripts'
 					&& item.name !== '.git'
 					&& !item.name.startsWith('.'),
 			)
+			.filter((item) => {
+				// Only include directories with package.json that has a dev script
+				const packageJsonPath = resolve(root, item.name, 'package.json')
+				if (!existsSync(packageJsonPath)) return false
+
+				try {
+					const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+					return packageJson.scripts?.dev !== undefined
+				}
+				catch {
+					return false
+				}
+			})
 			.map(item => item.name)
+			.sort() // Sort alphabetically for consistent port assignment
 	}
 	catch {
 		return []

package/templates/dev-runner.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+import { spawn } from 'bun'
+import { readdir } from 'fs/promises'
+import { resolve } from 'path'
+
+const projectsRoot = process.cwd()
+const projects = (await readdir(projectsRoot, { withFileTypes: true }))
+	.filter(
+		item =>
+			item.isDirectory()
+			&& item.name !== 'node_modules'
+			&& item.name !== 'shared'
+			&& item.name !== '.git'
+			&& !item.name.startsWith('.'),
+	)
+	.map(item => item.name)
+
+console.log(`\n🚀 Starting ${projects.length} project${projects.length > 1 ? 's' : ''}...\n`)
+
+const urlPattern = /Local:\s+(http:\/\/localhost:\d+)/
+
+projects.forEach((project) => {
+	const proc = spawn({
+		cmd: ['bun', 'run', 'dev'],
+		cwd: resolve(projectsRoot, project),
+		stdout: 'pipe',
+		stderr: 'pipe',
+	})
+
+	const decoder = new TextDecoder()
+
+	proc.stdout.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				const match = text.match(urlPattern)
+				if (match) {
+					console.log(`  ✓ ${project.padEnd(15)} → ${match[1]}`)
+				}
+			},
+		}),
+	)
+
+	proc.stderr.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				if (text.includes('error') || text.includes('Error')) {
+					console.error(`  ✗ ${project}: ${text.trim()}`)
+				}
+			},
+		}),
+	)
+})
+
+console.log('\n💡 Press Ctrl+C to stop all servers\n')
+
+process.on('SIGINT', () => {
+	console.log('\n\n👋 Stopping all servers...\n')
+	process.exit()
+})

package/templates/tsconfig.app.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ],
+      "@shared/*": [
+        "../shared/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*",
+    "src/**/*.vue"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}