@bagelink/workspace 1.11.0 → 1.11.3

package/src/build.ts

@@ -0,0 +1,45 @@
+import { spawn } from 'node:child_process'
+import process from 'node:process'
+import { listProjects } from './workspace.js'
+
+export async function runBuild(
+	filter?: string,
+	additionalArgs: string[] = [],
+) {
+	const argsStr = additionalArgs.length > 0 ? ` -- ${additionalArgs.join(' ')}` : ''
+	const resolvedFilters = resolveFilters(filter)
+	if (!resolvedFilters || resolvedFilters.length === 0) return 1
+
+	const filterArgs = resolvedFilters.map(f => `--filter '${f}'`).join(' ')
+	const command = `bun run ${filterArgs} build${argsStr}`
+
+	const proc = spawn(command, {
+		cwd: process.cwd(),
+		stdio: 'inherit',
+		shell: true,
+	})
+
+	proc.on('error', (error) => {
+		console.error('Failed to start build:', error.message)
+	})
+
+	return new Promise<number>((resolve, reject) => {
+		proc.on('exit', (code) => {
+			resolve(code || 0)
+		})
+		proc.on('error', reject)
+	})
+}
+
+function resolveFilters(filter?: string): string[] | null {
+	if (filter) return [filter]
+
+	const projects = listProjects()
+	if (projects.length === 0) {
+		console.error('No projects found')
+		return null
+	}
+
+	// Return all projects as individual filters
+	return projects.map(p => `./${p}`)
+}

package/src/composable.ts

@@ -0,0 +1,70 @@
+/// <reference types="vite/client" />
+
+/**
+ * Runtime workspace configuration
+ * Provides access to workspace config injected at build time
+ */
+export interface RuntimeWorkspaceConfig {
+	/** API proxy path (e.g., '/api') */
+	proxy?: string
+	/** API host URL (e.g., 'https://project.bagel.to') */
+	host: string
+	/** Base URL for API requests (proxy if available, otherwise host) */
+	baseURL: string
+	/** OpenAPI specification URL (if configured) */
+	openapiUrl?: string
+	/** Current environment mode */
+	mode: string
+}
+
+/**
+ * Get workspace configuration at runtime
+ * Config is injected as environment variables during build
+ *
+ * @example
+ * ```ts
+ * import { useWorkspace } from '@bagelink/workspace'
+ *
+ * const { proxy, host } = useWorkspace()
+ * const auth = createAuth({ baseURL: proxy })
+ * ```
+ *
+ * @example In Vue component
+ * ```vue
+ * <script setup>
+ * import { useWorkspace } from '@bagelink/workspace'
+ *
+ * const { proxy, host, mode } = useWorkspace()
+ * </script>
+ * ```
+ */
+export function useWorkspace(): RuntimeWorkspaceConfig {
+	// Access env variables injected by the Vite plugin
+	const proxy = import.meta.env.VITE_BGL_PROXY || undefined
+	const host = import.meta.env.VITE_BGL_HOST || ''
+	const openapiUrl = import.meta.env.VITE_BGL_OPENAPI_URL
+	const mode = (import.meta.env.MODE as string) || 'development'
+
+	return {
+		proxy,
+		host,
+		baseURL: proxy ?? host,
+		openapiUrl,
+		mode,
+	}
+}
+
+/**
+ * Get the full API URL by combining host and proxy
+ *
+ * @example
+ * ```ts
+ * import { getApiUrl } from '@bagelink/workspace'
+ *
+ * const apiUrl = getApiUrl() // 'https://project.bagel.to/api'
+ * ```
+ */
+export function getApiUrl(): string {
+	const { host, proxy } = useWorkspace()
+	return `${host}${proxy}`
+}

package/src/dev.ts

@@ -0,0 +1,171 @@
+import { spawn } from 'node:child_process'
+import process from 'node:process'
+import { listProjects } from './workspace.js'
+
+interface ServerInfo {
+	name: string
+	assignedPort: number
+	actualPort?: number
+	status: 'starting' | 'ready'
+	order: number
+}
+
+const servers = new Map<string, ServerInfo>()
+const projectToPort = new Map<string, number>()
+const seenLines = new Set<string>()
+const START_PORT = 5173
+
+// ANSI colors
+const colors = {
+	reset: '\x1B[0m',
+	cyan: '\x1B[36m',
+	green: '\x1B[32m',
+	yellow: '\x1B[33m',
+	dim: '\x1B[2m',
+	red: '\x1B[31m',
+}
+
+function clearAndPrintServers() {
+	// Clear previous output
+	if (servers.size > 0) {
+		process.stdout.write('\x1B[2J\x1B[H') // Clear screen and move to top
+	}
+
+	console.log(`${colors.cyan}🚀 Development Servers${colors.reset}\n`)
+
+	// Sort by order to maintain consistent display
+	const sortedServers = Array.from(servers.entries()).sort((a, b) => a[1].order - b[1].order)
+
+	for (const [name, info] of sortedServers) {
+		const url = `http://localhost:${info.actualPort ?? info.assignedPort}`
+		if (info.status === 'ready') {
+			console.log(`${colors.green}●${colors.reset} ${colors.cyan}${name}${colors.reset} ${colors.dim}→${colors.reset} ${url}`)
+		}
+		else {
+			console.log(`${colors.yellow}○${colors.reset} ${colors.dim}${name} (starting...)${colors.reset} ${colors.dim}${url}${colors.reset}`)
+		}
+	}
+
+	console.log('')
+}
+
+export async function runDev(
+	filter?: string,
+	additionalArgs: string[] = [],
+) {
+	const argsStr = additionalArgs.length > 0 ? ` -- ${additionalArgs.join(' ')}` : ''
+	const resolvedFilters = resolveFilters(filter)
+	if (!resolvedFilters || resolvedFilters.length === 0) return 1
+
+	// Pre-assign ports based on alphabetical order
+	const projectNames = resolvedFilters.map(f => f.replace('./', '')).sort()
+	projectNames.forEach((name, index) => {
+		const assignedPort = START_PORT + index
+		servers.set(name, {
+			name,
+			assignedPort,
+			status: 'starting',
+			order: index,
+		})
+		projectToPort.set(name, assignedPort)
+	})
+
+	clearAndPrintServers()
+
+	const filterArgs = resolvedFilters.map(f => `--filter '${f}'`).join(' ')
+	const projectNamesDisplay = projectNames.join(', ')
+
+	const command = `bun run ${filterArgs} dev${argsStr}`
+	const proc = spawn(command, {
+		cwd: process.cwd(),
+		stdio: ['inherit', 'pipe', 'pipe'],
+		shell: true,
+	})
+
+	let stdoutBuffer = ''
+	let stderrBuffer = ''
+
+	function processLine(line: string) {
+		if (!line.trim()) return
+
+		// Skip duplicate lines
+		if (seenLines.has(line)) return
+		seenLines.add(line)
+
+		// Extract port from "project dev:   ➜  Local:   http://localhost:5173/"
+		const portMatch = line.match(/Local:\s+http:\/\/localhost:(\d+)/)
+		if (portMatch) {
+			const port = Number.parseInt(portMatch[1], 10)
+
+			// Extract project name from this line
+			const projectInLine = line.match(/^([\w-]+)\s+dev:/)
+			if (projectInLine) {
+				const name = projectInLine[1]
+				const info = servers.get(name)
+				if (info && !info.actualPort) {
+					info.actualPort = port
+					info.status = 'ready'
+					clearAndPrintServers()
+				}
+			}
+		}
+	}
+
+	proc.stdout?.setEncoding('utf8')
+	proc.stderr?.setEncoding('utf8')
+
+	proc.stdout?.on('data', (data: string) => {
+		// Debug: show we're receiving data
+		if (servers.size === 0) {
+			console.log(`${colors.dim}Receiving output...${colors.reset}`)
+		}
+
+		stdoutBuffer += data
+		const lines = stdoutBuffer.split('\n')
+		stdoutBuffer = lines.pop() || ''
+
+		for (const line of lines) {
+			processLine(line)
+		}
+	})
+
+	proc.stderr?.on('data', (data: string) => {
+		stderrBuffer += data
+		const lines = stderrBuffer.split('\n')
+		stderrBuffer = lines.pop() || ''
+
+		for (const line of lines) {
+			processLine(line)
+		}
+	})
+
+	proc.on('error', (error) => {
+		console.error(`${colors.red}Failed to start dev servers:${colors.reset}`, error.message)
+	})
+
+	// Handle Ctrl+C gracefully
+	process.on('SIGINT', () => {
+		proc.kill('SIGINT')
+		process.exit(0)
+	})
+
+	return new Promise<number>((resolve, reject) => {
+		proc.on('exit', (code) => {
+			resolve(code || 0)
+		})
+		proc.on('error', reject)
+	})
+}
+
+function resolveFilters(filter?: string): string[] | null {
+	if (filter) return [filter]
+
+	const projects = listProjects()
+	if (projects.length === 0) {
+		console.error('No projects found')
+		return null
+	}
+
+	// Return all projects as individual filters
+	return projects.map(p => `./${p}`)
+}

package/src/index.ts

@@ -4,16 +4,8 @@ import type {
 	WorkspaceOptions,
 	ProxyConfig,
 } from './types'
-import { resolveConfig, mergeConfigs } from './config'
-import { generateWorkspaceConfig, generateWorkspaceConfigSync } from './init'
-import {
-	generateNetlifyConfig,
-	generateNetlifyRedirect,
-	writeNetlifyConfig,
-	setBuildEnvVars,
-} from './netlify'
-import { createViteProxy, createCustomProxy } from './proxy'
 
+// Export types (no runtime code)
 export type {
 	ProxyConfig,
 	WorkspaceConfig,
@@ -21,23 +13,9 @@ export type {
 	WorkspaceOptions,
 }
 
-export {
-	createCustomProxy,
-	createViteProxy,
-	generateNetlifyConfig,
-	generateNetlifyRedirect,
-	generateWorkspaceConfig,
-	generateWorkspaceConfigSync,
-	mergeConfigs,
-	resolveConfig,
-	setBuildEnvVars,
-	writeNetlifyConfig,
-}
-
-export { setupLint } from './lint'
-export { generateSDK, generateSDKForWorkspace } from './sdk'
-export { addProject, initWorkspace, listProjects } from './workspace'
-export { getWorkspaceInfo, isWorkspace } from './detect'
+// Runtime composables (browser-safe, no Node.js dependencies)
+export { getApiUrl, useWorkspace } from './composable'
+export type { RuntimeWorkspaceConfig } from './composable'
 
 /**
  * Define workspace configuration
@@ -50,55 +28,3 @@ export function defineWorkspace(
 		return configs[mode] || configs.development
 	}
 }
-
-/**
- * Create a workspace instance for managing project configuration
- * Supports both single project and monorepo setups
- */
-export function createWorkspace(options: WorkspaceOptions = {}) {
-	let cachedConfig: WorkspaceConfig | null = null
-
-	return {
-		/**
-		 * Get resolved config for the specified environment
-		 */
-		async getConfig(mode: WorkspaceEnvironment = 'development'): Promise<WorkspaceConfig> {
-			if (!cachedConfig) {
-				cachedConfig = await resolveConfig(mode, options)
-			}
-			return cachedConfig
-		},
-
-		/**
-		 * Create Vite proxy configuration
-		 */
-		createProxy(config: WorkspaceConfig): ProxyConfig {
-			return createViteProxy(config)
-		},
-
-		/**
-		 * Generate Netlify configuration file
-		 */
-		generateNetlify(
-			config: WorkspaceConfig,
-			outPath: string = './netlify.toml',
-			additionalConfig?: string
-		): void {
-			writeNetlifyConfig(config, outPath, additionalConfig)
-		},
-
-		/**
-		 * Set build environment variables
-		 */
-		setBuildEnv(config: WorkspaceConfig): void {
-			setBuildEnvVars(config)
-		},
-
-		/**
-		 * Clear cached configuration
-		 */
-		clearCache(): void {
-			cachedConfig = null
-		},
-	}
-}

package/src/init.ts

@@ -49,10 +49,15 @@ export async function generateWorkspaceConfig(
 	const configContent = `import { defineWorkspace } from '@bagelink/workspace'
 import type { WorkspaceConfig, WorkspaceEnvironment } 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>
+ */
 const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
 	localhost: {
 		host: 'http://localhost:8000',
-		proxy: '/api',
+		proxy: '/api', // Optional: remove to skip proxy setup
 		openapi_url: 'http://localhost:8000/openapi.json',
 	},
 	development: {
@@ -91,6 +96,12 @@ export default defineWorkspace(configs)
 			message: 'Create/update vite.config.ts?',
 			initial: true,
 		},
+		{
+			type: 'confirm',
+			name: 'createTsConfig',
+			message: 'Create tsconfig.app.json with path aliases?',
+			initial: true,
+		},
 		{
 			type: 'confirm',
 			name: 'generateNetlify',
@@ -107,6 +118,10 @@ export default defineWorkspace(configs)
 		updateViteConfig(root)
 	}
 
+	if (setupResponse.createTsConfig) {
+		createTsConfig(root)
+	}
+
 	if (setupResponse.generateNetlify) {
 		const prodConfig: WorkspaceConfig = {
 			host: productionHost,
@@ -132,10 +147,15 @@ export function generateWorkspaceConfigSync(
 	const configContent = `import { defineWorkspace } from '@bagelink/workspace'
 import type { WorkspaceConfig, WorkspaceEnvironment } 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>
+ */
 const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
 	localhost: {
 		host: 'http://localhost:8000',
-		proxy: '/api',
+		proxy: '/api', // Optional: remove to skip proxy setup
 		openapi_url: 'http://localhost:8000/openapi.json',
 	},
 	development: {
@@ -216,6 +236,38 @@ function updatePackageJsonScripts(root: string): void {
 	}
 }
 
+/**
+ * Create tsconfig.app.json with path aliases
+ */
+function createTsConfig(root: string): void {
+	const tsConfigPath = resolve(root, 'tsconfig.app.json')
+	const tsConfigExists = existsSync(tsConfigPath)
+
+	if (tsConfigExists) {
+		console.log('⚠️  tsconfig.app.json already exists, skipping')
+		return
+	}
+
+	const tsConfigContent = `{
+  "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"]
+}
+`
+
+	writeFileSync(tsConfigPath, tsConfigContent, 'utf-8')
+	console.log('✅ Created tsconfig.app.json')
+}
+
 /**
  * Create or update vite.config.ts
  */
@@ -233,25 +285,31 @@ function updateViteConfig(root: string): void {
 		}
 
 		// Ask to overwrite
-		console.log('⚠️  vite.config.ts exists. Please manually add the workspace configuration.')
-		console.log('    See: https://github.com/bageldb/bagelink/tree/master/packages/workspace#readme')
+		console.log('⚠️  vite.config.ts exists. Please manually add the bagelink plugin:')
+		console.log('')
+		console.log('    import { bagelink } from \'@bagelink/workspace/vite\'')
+		console.log('    import workspace from \'./bgl.config\'')
+		console.log('')
+		console.log('    plugins: [')
+		console.log('      vue(),')
+		console.log('      bagelink({ workspace }),')
+		console.log('    ]')
+		console.log('')
 		return
 	}
 
-	// Create new vite.config.ts
+	// Create new vite.config.ts with plugin
 	const viteConfigContent = `import { defineConfig } from 'vite'
-import { createViteProxy } from '@bagelink/workspace'
+import vue from '@vitejs/plugin-vue'
+import { bagelink } from '@bagelink/workspace/vite'
 import workspace from './bgl.config'
 
 // https://vitejs.dev/config/
-export default defineConfig(({ mode }) => {
-	const config = workspace(mode as 'localhost' | 'development' | 'production')
-
-	return {
-		server: {
-			proxy: createViteProxy(config),
-		},
-	}
+export default defineConfig({
+	plugins: [
+		vue(),
+		bagelink({ workspace }),
+	],
 })
 `
 

package/src/lint.ts

@@ -1,8 +1,35 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import process from 'node:process'
 import prompts from 'prompts'
 
+/**
+ * List of redundant lint config files that can be safely removed
+ * after setting up the new lint configuration
+ */
+const REDUNDANT_FILES = [
+	// Old ESLint configs
+	'.eslintrc',
+	'.eslintrc.json',
+	'.eslintrc.js',
+	'.eslintrc.cjs',
+	'.eslintrc.yaml',
+	'.eslintrc.yml',
+	// Oxlint
+	'oxlint.json',
+	// Old Prettier configs (we create .prettierrc)
+	'prettier.config.js',
+	'prettier.config.cjs',
+	'prettier.config.mjs',
+	'.prettierrc.json',
+	'.prettierrc.yaml',
+	'.prettierrc.yml',
+	'.prettierrc.js',
+	'.prettierrc.cjs',
+	'.prettierrc.mjs',
+	'.prettierrc.toml',
+]
+
 /**
  * Set up linting in a project
  */
@@ -24,6 +51,12 @@ export async function setupLint(
 				{ title: 'Git Hooks', value: 'githooks', selected: false },
 			],
 		},
+		{
+			type: 'confirm',
+			name: 'cleanRedundant',
+			message: 'Clean up redundant lint config files?',
+			initial: true,
+		},
 		{
 			type: 'confirm',
 			name: 'installDeps',
@@ -37,7 +70,12 @@ export async function setupLint(
 		process.exit(1)
 	}
 
-	const { configs, installDeps } = response
+	const { configs, cleanRedundant, installDeps } = response
+
+	// Clean up redundant files first
+	if (cleanRedundant) {
+		await cleanRedundantFiles(root)
+	}
 
 	// Create config files
 	if (configs.includes('eslint')) {
@@ -182,6 +220,56 @@ function createGitHooks(root: string): void {
 	console.log('   Then run: npx simple-git-hooks')
 }
 
+/**
+ * Clean up redundant lint configuration files
+ */
+async function cleanRedundantFiles(root: string): Promise<void> {
+	const foundFiles: string[] = []
+
+	// Check which redundant files exist
+	for (const file of REDUNDANT_FILES) {
+		const filePath = resolve(root, file)
+		if (existsSync(filePath)) {
+			foundFiles.push(file)
+		}
+	}
+
+	if (foundFiles.length === 0) {
+		console.log('✨ No redundant files found')
+		return
+	}
+
+	console.log('\n📋 Found redundant files:')
+	foundFiles.forEach((file) => { console.log(`   - ${file}`) })
+
+	const confirmResponse = await prompts({
+		type: 'confirm',
+		name: 'confirm',
+		message: `Delete ${foundFiles.length} redundant file${foundFiles.length > 1 ? 's' : ''}?`,
+		initial: true,
+	})
+
+	if (!confirmResponse.confirm) {
+		console.log('⏭️  Skipped cleaning redundant files')
+		return
+	}
+
+	// Delete confirmed files
+	let deleted = 0
+	for (const file of foundFiles) {
+		try {
+			unlinkSync(resolve(root, file))
+			console.log(`🗑️  Deleted ${file}`)
+			deleted++
+		}
+		catch (error) {
+			console.error(`❌ Failed to delete ${file}:`, error)
+		}
+	}
+
+	console.log(`✅ Cleaned up ${deleted} file${deleted > 1 ? 's' : ''}`)
+}
+
 /**
  * Update package.json with lint scripts
  */