@bagelink/workspace 1.8.26 → 1.8.30

package/dist/shared/workspace.ThBu2HJO.mjs

@@ -0,0 +1,483 @@
+import { existsSync, mkdirSync, writeFileSync, readdirSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import process from 'node:process';
+import prompts from 'prompts';
+
+async function initWorkspace(root = process.cwd()) {
+  console.log("\n\u{1F680} Creating Bagel workspace...\n");
+  const response = await prompts([
+    {
+      type: "text",
+      name: "workspaceName",
+      message: "Workspace name:",
+      initial: "my-workspace"
+    },
+    {
+      type: "text",
+      name: "projectId",
+      message: "Bagel project ID:",
+      initial: "my-project"
+    },
+    {
+      type: "confirm",
+      name: "createFirstProject",
+      message: "Create first project?",
+      initial: true
+    },
+    {
+      type: (prev) => prev ? "text" : null,
+      name: "firstProjectName",
+      message: "First project name:",
+      initial: "web"
+    }
+  ]);
+  if (!response || !response.workspaceName) {
+    console.log("\n\u274C Workspace creation cancelled.\n");
+    process.exit(1);
+  }
+  const { workspaceName, projectId, createFirstProject, firstProjectName } = response;
+  const workspaceDir = resolve(root, workspaceName);
+  createWorkspaceRoot(root, workspaceName, projectId);
+  createSharedPackage(workspaceDir);
+  if (createFirstProject && firstProjectName) {
+    await addProject(firstProjectName, workspaceDir);
+  }
+  console.log("\n\u2705 Workspace created successfully!");
+  console.log("\nNext steps:");
+  console.log(`  cd ${workspaceName}`);
+  console.log("  bun install");
+  if (createFirstProject) {
+    console.log(`  bun run dev:${firstProjectName}`);
+  } else {
+    console.log("  bgl add <project-name>  # Add a project");
+  }
+  console.log("");
+}
+function createWorkspaceRoot(root, name, projectId) {
+  const workspaceDir = resolve(root, name);
+  if (existsSync(workspaceDir)) {
+    console.error(`\u274C Directory ${name} already exists`);
+    process.exit(1);
+  }
+  mkdirSync(workspaceDir, { recursive: true });
+  const packageJson = {
+    name,
+    private: true,
+    workspaces: ["*", "!node_modules"],
+    scripts: {
+      "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"
+    }
+  };
+  writeFileSync(
+    resolve(workspaceDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  const bglConfig = `import { defineWorkspace } from '@bagelink/workspace'
+
+export default defineWorkspace({
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: 'https://${projectId}.bagel.to',
+		proxy: '/api',
+		openapi_url: 'https://${projectId}.bagel.to/openapi.json',
+	},
+	production: {
+		host: 'https://${projectId}.bagel.to',
+		proxy: '/api',
+		openapi_url: 'https://${projectId}.bagel.to/openapi.json',
+	},
+})
+`;
+  writeFileSync(resolve(workspaceDir, "bgl.config.ts"), bglConfig);
+  const tsConfig = {
+    compilerOptions: {
+      target: "ES2020",
+      useDefineForClassFields: true,
+      module: "ESNext",
+      lib: ["ES2020", "DOM", "DOM.Iterable"],
+      skipLibCheck: true,
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      resolveJsonModule: true,
+      isolatedModules: true,
+      noEmit: true,
+      jsx: "preserve",
+      strict: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      noFallthroughCasesInSwitch: true,
+      baseUrl: ".",
+      paths: {
+        "shared/*": ["./shared/*"]
+      }
+    }
+  };
+  writeFileSync(
+    resolve(workspaceDir, "tsconfig.json"),
+    `${JSON.stringify(tsConfig, null, 2)}
+`
+  );
+  const gitignore = `node_modules
+dist
+.DS_Store
+*.local
+.env.local
+.vite
+`;
+  writeFileSync(resolve(workspaceDir, ".gitignore"), gitignore);
+  const scriptsDir = resolve(workspaceDir, "scripts");
+  mkdirSync(scriptsDir, { recursive: true });
+  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\u{1F680} 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(\`  \u2713 \${project.padEnd(15)} \u2192 \${match[1]}\`)
+				}
+			},
+		}),
+	)
+
+	proc.stderr.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				if (text.includes('error') || text.includes('Error')) {
+					console.error(\`  \u2717 \${project}: \${text.trim()}\`)
+				}
+			},
+		}),
+	)
+})
+
+console.log('\\n\u{1F4A1} Press Ctrl+C to stop all servers\\n')
+
+process.on('SIGINT', () => {
+	console.log('\\n\\n\u{1F44B} Stopping all servers...\\n')
+	process.exit()
+})
+`;
+  writeFileSync(resolve(scriptsDir, "dev.ts"), devRunnerContent);
+  console.log(`\u2705 Created workspace: ${name}`);
+}
+function createSharedPackage(root) {
+  const sharedDir = resolve(root, "shared");
+  mkdirSync(sharedDir, { recursive: true });
+  const packageJson = {
+    name: "shared",
+    version: "1.0.0",
+    type: "module",
+    exports: {
+      ".": "./index.ts",
+      "./utils": "./utils/index.ts",
+      "./types": "./types/index.ts"
+    }
+  };
+  writeFileSync(
+    resolve(sharedDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  writeFileSync(
+    resolve(sharedDir, "index.ts"),
+    "// Shared utilities and exports\nexport * from './utils'\n"
+  );
+  mkdirSync(resolve(sharedDir, "utils"), { recursive: true });
+  writeFileSync(
+    resolve(sharedDir, "utils", "index.ts"),
+    "// Shared utility functions\nexport function formatDate(date: Date): string {\n  return date.toISOString()\n}\n"
+  );
+  mkdirSync(resolve(sharedDir, "types"), { recursive: true });
+  writeFileSync(
+    resolve(sharedDir, "types", "index.ts"),
+    "// Shared types\nexport interface User {\n  id: string\n  name: string\n}\n"
+  );
+  console.log("\u2705 Created shared package");
+}
+async function addProject(name, root = process.cwd()) {
+  const projectDir = resolve(root, name);
+  if (existsSync(projectDir)) {
+    console.error(`\u274C Project ${name} already exists`);
+    process.exit(1);
+  }
+  console.log(`
+\u{1F4E6} Creating project: ${name}
+`);
+  mkdirSync(projectDir, { recursive: true });
+  const isWorkspace = existsSync(resolve(root, "bgl.config.ts"));
+  const packageJson = {
+    name,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview"
+    },
+    dependencies: {},
+    devDependencies: {
+      "@vitejs/plugin-vue": "latest",
+      "vite": "latest",
+      "vue": "latest"
+    }
+  };
+  if (isWorkspace) {
+    packageJson.dependencies.shared = "workspace:*";
+  }
+  writeFileSync(
+    resolve(projectDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  const bglConfigContent = isWorkspace ? `import { defineWorkspace } from '@bagelink/workspace'
+import rootWorkspace from '../bgl.config'
+
+export default defineWorkspace({
+	localhost: rootWorkspace('localhost'),
+	development: rootWorkspace('development'),
+	production: rootWorkspace('production'),
+})
+` : `import { defineWorkspace } from '@bagelink/workspace'
+
+export default defineWorkspace({
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+	},
+	development: {
+		host: 'https://my-project.bagel.to',
+		proxy: '/api',
+	},
+	production: {
+		host: 'https://my-project.bagel.to',
+		proxy: '/api',
+	},
+})
+`;
+  writeFileSync(resolve(projectDir, "bgl.config.ts"), bglConfigContent);
+  const viteConfig = `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 }),
+	],
+})
+`;
+  writeFileSync(resolve(projectDir, "vite.config.ts"), viteConfig);
+  const srcDir = resolve(projectDir, "src");
+  mkdirSync(srcDir, { recursive: true });
+  const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>${name}</title>
+</head>
+<body>
+	<div id="app"></div>
+	<script type="module" src="/src/main.ts"><\/script>
+</body>
+</html>
+`;
+  writeFileSync(resolve(projectDir, "index.html"), indexHtml);
+  const mainTs = `import { createApp } from 'vue'
+import App from './App.vue'
+
+createApp(App).mount('#app')
+`;
+  writeFileSync(resolve(srcDir, "main.ts"), mainTs);
+  const appVue = `<script setup lang="ts">
+import { ref } from 'vue'
+${isWorkspace ? "import { formatDate } from 'shared/utils'\n" : ""}
+const count = ref(0)
+<\/script>
+
+<template>
+	<div>
+		<h1>${name}</h1>
+		<button @click="count++">Count: {{ count }}</button>
+		${isWorkspace ? "<p>{{ formatDate(new Date()) }}</p>" : ""}
+	</div>
+</template>
+`;
+  writeFileSync(resolve(srcDir, "App.vue"), appVue);
+  console.log(`\u2705 Created project: ${name}`);
+  if (isWorkspace) {
+    updateWorkspaceScripts(root, name);
+  }
+  console.log("\nNext steps:");
+  console.log(`  cd ${name}`);
+  console.log("  bun install");
+  console.log("  bun run dev");
+  console.log("");
+}
+function updateWorkspaceScripts(root, projectName) {
+  const packageJsonPath = resolve(root, "package.json");
+  if (!existsSync(packageJsonPath)) return;
+  try {
+    const packageJson = JSON.parse(
+      readFileSync(packageJsonPath, "utf-8")
+    );
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    packageJson.scripts[`dev:${projectName}`] = `bun --filter ${projectName} dev`;
+    packageJson.scripts[`build:${projectName}`] = `bun --filter ${projectName} build`;
+    writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}
+`
+    );
+    console.log(`\u2705 Added scripts: dev:${projectName}, build:${projectName}`);
+  } catch (error) {
+    console.warn("\u26A0\uFE0F  Could not update workspace scripts");
+  }
+}
+function listProjects(root = process.cwd()) {
+  try {
+    const items = readdirSync(root, { withFileTypes: true });
+    return items.filter(
+      (item) => item.isDirectory() && item.name !== "node_modules" && item.name !== "shared" && item.name !== "scripts" && item.name !== ".git" && !item.name.startsWith(".")
+    ).map((item) => item.name).sort();
+  } catch {
+    return [];
+  }
+}
+
+function generateNetlifyRedirect(config) {
+  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
+  force = true
+  headers = {X-From = "Netlify"}
+`;
+  return redirect;
+}
+function generateNetlifyConfigTemplate() {
+  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
+`;
+}
+function generateNetlifyConfig(config, additionalConfig, useTemplate = false) {
+  if (useTemplate) {
+    return generateNetlifyConfigTemplate();
+  }
+  const redirect = generateNetlifyRedirect(config);
+  if (additionalConfig !== void 0 && additionalConfig !== "") {
+    return `${redirect}
+${additionalConfig}`;
+  }
+  return redirect;
+}
+function writeNetlifyConfig(config, outPath = "./netlify.toml", additionalConfig, useTemplate = false) {
+  const content = generateNetlifyConfig(config, additionalConfig, useTemplate);
+  const resolvedPath = resolve(outPath);
+  writeFileSync(resolvedPath, content, "utf-8");
+  console.log(`\u2713 Generated netlify.toml at ${resolvedPath}`);
+  if (!useTemplate) {
+    console.log("\n\u{1F4A1} 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("");
+  }
+}
+function setBuildEnvVars(config) {
+  process.env.BGL_PROXY_PATH = config.proxy;
+  process.env.BGL_API_HOST = config.host;
+  if (config.openapi_url !== void 0 && config.openapi_url !== "") {
+    process.env.BGL_OPENAPI_URL = config.openapi_url;
+  }
+}
+
+export { addProject as a, generateNetlifyConfig as g, initWorkspace as i, listProjects as l, setBuildEnvVars as s, writeNetlifyConfig as w };

package/dist/vite.cjs

@@ -1,10 +1,11 @@
 'use strict';
 
+const node_path = require('node:path');
 const process = require('node:process');
 const node_url = require('node:url');
-const netlify = require('./shared/workspace.Dx9_TIij.cjs');
+const netlify = require('./shared/workspace.CuE882NE.cjs');
 require('node:fs');
-require('node:path');
+require('prompts');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -81,9 +82,27 @@ function bagelink(options) {
       if (config.additionalAliases) {
         Object.assign(alias, config.additionalAliases);
       }
-      const server = config.configureProxy !== false ? {
-        proxy: createViteProxy(workspaceConfig)
-      } : void 0;
+      let port;
+      try {
+        const currentDir = process__default.cwd();
+        const projectName = node_path.basename(currentDir);
+        const parentDir = node_url.fileURLToPath(new URL("..", `file://${currentDir}/`));
+        const allProjects = netlify.listProjects(parentDir);
+        const projectIndex = allProjects.indexOf(projectName);
+        if (projectIndex !== -1) {
+          port = 5173 + projectIndex;
+        }
+      } catch {
+      }
+      const server = {
+        ...config.configureProxy !== false && {
+          proxy: createViteProxy(workspaceConfig)
+        },
+        ...port !== void 0 && {
+          port,
+          strictPort: true
+        }
+      };
       const define = {
         "import.meta.env.VITE_BGL_PROXY": JSON.stringify(workspaceConfig.proxy),
         "import.meta.env.VITE_BGL_HOST": JSON.stringify(workspaceConfig.host),
@@ -96,7 +115,7 @@ function bagelink(options) {
           alias
         },
         define,
-        ...server && { server }
+        server
       };
     }
   };

package/dist/vite.mjs

@@ -1,8 +1,10 @@
+import { basename } from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
-export { g as generateNetlifyConfig, s as setBuildEnvVars, w as writeNetlifyConfig } from './shared/workspace.Twuo1PFw.mjs';
+import { l as listProjects } from './shared/workspace.ThBu2HJO.mjs';
+export { g as generateNetlifyConfig, s as setBuildEnvVars, w as writeNetlifyConfig } from './shared/workspace.ThBu2HJO.mjs';
 import 'node:fs';
-import 'node:path';
+import 'prompts';
 
 function createViteProxy(config) {
   const proxy = {};
@@ -75,9 +77,27 @@ function bagelink(options) {
       if (config.additionalAliases) {
         Object.assign(alias, config.additionalAliases);
       }
-      const server = config.configureProxy !== false ? {
-        proxy: createViteProxy(workspaceConfig)
-      } : void 0;
+      let port;
+      try {
+        const currentDir = process.cwd();
+        const projectName = basename(currentDir);
+        const parentDir = fileURLToPath(new URL("..", `file://${currentDir}/`));
+        const allProjects = listProjects(parentDir);
+        const projectIndex = allProjects.indexOf(projectName);
+        if (projectIndex !== -1) {
+          port = 5173 + projectIndex;
+        }
+      } catch {
+      }
+      const server = {
+        ...config.configureProxy !== false && {
+          proxy: createViteProxy(workspaceConfig)
+        },
+        ...port !== void 0 && {
+          port,
+          strictPort: true
+        }
+      };
       const define = {
         "import.meta.env.VITE_BGL_PROXY": JSON.stringify(workspaceConfig.proxy),
         "import.meta.env.VITE_BGL_HOST": JSON.stringify(workspaceConfig.host),
@@ -90,7 +110,7 @@ function bagelink(options) {
           alias
         },
         define,
-        ...server && { server }
+        server
       };
     }
   };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/workspace",
   "type": "module",
-  "version": "1.8.26",
+  "version": "1.8.30",
   "description": "Monorepo workspace tooling for Bagel projects with proxy and config management",
   "author": {
     "name": "Bagel Studio",

package/src/dev.ts

@@ -4,12 +4,16 @@ import { listProjects } from './workspace.js'
 
 interface ServerInfo {
 	name: string
-	port?: number
+	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 = {
@@ -29,13 +33,16 @@ function clearAndPrintServers() {
 
 	console.log(`${colors.cyan}🚀 Development Servers${colors.reset}\n`)
 
-	for (const [name, info] of servers.entries()) {
-		if (info.status === 'ready' && info.port) {
-			const url = `http://localhost:${info.port}`
+	// 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.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}`)
+			console.log(`${colors.yellow}○${colors.reset} ${colors.dim}${name} (starting...)${colors.reset} ${colors.dim}${url}${colors.reset}`)
 		}
 	}
 
@@ -50,9 +57,23 @@ export async function runDev(
 	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 projectNames = resolvedFilters.map(f => f.replace('./', '')).join(', ')
-	console.log(`${colors.dim}Starting dev servers: ${projectNames}${argsStr}${colors.reset}\n`)
+	const projectNamesDisplay = projectNames.join(', ')
 
 	const command = `bun run ${filterArgs} dev${argsStr}`
 	const proc = spawn(command, {
@@ -71,17 +92,6 @@ export async function runDev(
 		if (seenLines.has(line)) return
 		seenLines.add(line)
 
-		// Extract project name from "project dev: ..."
-		const projectMatch = line.match(/^(\w+)\s+dev:/)
-		if (projectMatch) {
-			const name = projectMatch[1]
-			if (!servers.has(name)) {
-				console.log(`${colors.dim}[DEBUG] Detected project: ${name}${colors.reset}`)
-				servers.set(name, { name, status: 'starting' })
-				clearAndPrintServers()
-			}
-		}
-
 		// Extract port from "project dev:   ➜  Local:   http://localhost:5173/"
 		const portMatch = line.match(/Local:\s+http:\/\/localhost:(\d+)/)
 		if (portMatch) {
@@ -92,9 +102,8 @@ export async function runDev(
 			if (projectInLine) {
 				const name = projectInLine[1]
 				const info = servers.get(name)
-				console.log(`${colors.dim}[DEBUG] Port ${port} for project: ${name}, exists: ${!!info}, hasPort: ${info?.port}${colors.reset}`)
-				if (info && !info.port) {
-					info.port = port
+				if (info && info.assignedPort === port && !info.actualPort) {
+					info.actualPort = port
 					info.status = 'ready'
 					clearAndPrintServers()
 				}