@bagelink/workspace 1.7.3 → 1.7.8

package/dist/shared/workspace.BMTTo3s8.cjs

@@ -0,0 +1,993 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const node_path = require('node:path');
+const process = require('node:process');
+const prompts = require('prompts');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+const prompts__default = /*#__PURE__*/_interopDefaultCompat(prompts);
+
+function generateNetlifyRedirect(config) {
+  const redirect = `[[redirects]]
+  from = "${config.proxy}/*"
+  to = "${config.host}/:splat"
+  status = 200
+  force = true
+  headers = {X-From = "Netlify"}
+`;
+  return redirect;
+}
+function generateNetlifyConfig(config, additionalConfig) {
+  const redirect = generateNetlifyRedirect(config);
+  if (additionalConfig !== void 0 && additionalConfig !== "") {
+    return `${redirect}
+${additionalConfig}`;
+  }
+  return redirect;
+}
+function writeNetlifyConfig(config, outPath = "./netlify.toml", additionalConfig) {
+  const content = generateNetlifyConfig(config, additionalConfig);
+  const resolvedPath = node_path.resolve(outPath);
+  node_fs.writeFileSync(resolvedPath, content, "utf-8");
+  console.log(`\u2713 Generated netlify.toml at ${resolvedPath}`);
+}
+function setBuildEnvVars(config) {
+  process__default.env.BGL_PROXY_PATH = config.proxy;
+  process__default.env.BGL_API_HOST = config.host;
+  if (config.openapi_url !== void 0 && config.openapi_url !== "") {
+    process__default.env.BGL_OPENAPI_URL = config.openapi_url;
+  }
+}
+
+async function generateWorkspaceConfig(root = process__default.cwd(), configFile = "bgl.config.ts") {
+  console.log("\n\u{1F527} No bgl.config.ts found. Let's create one!\n");
+  const response = await prompts__default([
+    {
+      type: "text",
+      name: "projectId",
+      message: "What is your Bagel project ID?",
+      initial: "my-project",
+      validate: (value) => value.length > 0 ? true : "Project ID is required"
+    },
+    {
+      type: "confirm",
+      name: "useCustomHost",
+      message: "Use custom production host?",
+      initial: false
+    },
+    {
+      type: (prev) => prev ? "text" : null,
+      name: "customHost",
+      message: "Enter production host URL:",
+      initial: "https://api.example.com"
+    }
+  ]);
+  if (!response || !response.projectId) {
+    console.log("\n\u274C Config generation cancelled.\n");
+    process__default.exit(1);
+  }
+  const productionHost = response.useCustomHost === true ? response.customHost : `https://${response.projectId}.bagel.to`;
+  const configContent = `import { defineWorkspace } from '@bagelink/workspace'
+import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
+
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+	production: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+}
+
+export default defineWorkspace(configs)
+`;
+  const configPath = node_path.resolve(root, configFile);
+  node_fs.writeFileSync(configPath, configContent, "utf-8");
+  console.log(`
+\u2705 Created ${configFile}`);
+  console.log(`   Production host: ${productionHost}`);
+  console.log(`   Local dev host: http://localhost:8000
+`);
+  const setupResponse = await prompts__default([
+    {
+      type: "confirm",
+      name: "updatePackageJson",
+      message: "Add/update dev scripts in package.json?",
+      initial: true
+    },
+    {
+      type: "confirm",
+      name: "updateViteConfig",
+      message: "Create/update vite.config.ts?",
+      initial: true
+    },
+    {
+      type: "confirm",
+      name: "generateNetlify",
+      message: "Generate netlify.toml for deployment?",
+      initial: true
+    }
+  ]);
+  if (setupResponse.updatePackageJson) {
+    updatePackageJsonScripts(root);
+  }
+  if (setupResponse.updateViteConfig) {
+    updateViteConfig(root);
+  }
+  if (setupResponse.generateNetlify) {
+    const prodConfig = {
+      host: productionHost,
+      proxy: "/api"
+    };
+    writeNetlifyConfig(prodConfig, node_path.resolve(root, "netlify.toml"));
+  }
+  console.log("\n\u{1F4A1} You can edit these files to customize your configuration.\n");
+}
+function generateWorkspaceConfigSync(projectId, root = process__default.cwd(), configFile = "bgl.config.ts", customHost) {
+  const productionHost = customHost ?? `https://${projectId}.bagel.to`;
+  const configContent = `import { defineWorkspace } from '@bagelink/workspace'
+import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
+
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+	production: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+}
+
+export default defineWorkspace(configs)
+`;
+  const configPath = node_path.resolve(root, configFile);
+  node_fs.writeFileSync(configPath, configContent, "utf-8");
+  console.log(`\u2705 Created ${configPath}`);
+}
+function updatePackageJsonScripts(root) {
+  const packageJsonPath = node_path.resolve(root, "package.json");
+  if (!node_fs.existsSync(packageJsonPath)) {
+    console.log("\u26A0\uFE0F  No package.json found, skipping script update");
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    const scriptsToAdd = {
+      "dev": "vite",
+      "dev:local": "vite --mode localhost",
+      "build": "vite build",
+      "preview": "vite preview"
+    };
+    let modified = false;
+    for (const [key, value] of Object.entries(scriptsToAdd)) {
+      if (key === "dev" || key === "dev:local") {
+        if (packageJson.scripts[key] !== value) {
+          packageJson.scripts[key] = value;
+          modified = true;
+        }
+      } else {
+        if (!packageJson.scripts[key]) {
+          packageJson.scripts[key] = value;
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      node_fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf-8");
+      console.log("\u2705 Updated package.json with dev scripts");
+    } else {
+      console.log("\u2139\uFE0F  Scripts already up to date in package.json");
+    }
+  } catch (error) {
+    console.error("\u274C Failed to update package.json:", error);
+  }
+}
+function updateViteConfig(root) {
+  const viteConfigPath = node_path.resolve(root, "vite.config.ts");
+  const viteConfigExists = node_fs.existsSync(viteConfigPath);
+  if (viteConfigExists) {
+    const existingConfig = node_fs.readFileSync(viteConfigPath, "utf-8");
+    if (existingConfig.includes("@bagelink/workspace")) {
+      console.log("\u2139\uFE0F  vite.config.ts already configured");
+      return;
+    }
+    console.log("\u26A0\uFE0F  vite.config.ts exists. Please manually add the workspace configuration.");
+    console.log("    See: https://github.com/bageldb/bagelink/tree/master/packages/workspace#readme");
+    return;
+  }
+  const viteConfigContent = `import { defineConfig } from 'vite'
+import { createViteProxy } from '@bagelink/workspace'
+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),
+		},
+	}
+})
+`;
+  node_fs.writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
+  console.log("\u2705 Created vite.config.ts");
+}
+
+async function setupLint(root = process__default.cwd(), isWorkspace = false) {
+  console.log("\n\u{1F50D} Setting up linting...\n");
+  const response = await prompts__default([
+    {
+      type: "multiselect",
+      name: "configs",
+      message: "Select configurations to set up:",
+      choices: [
+        { title: "ESLint", value: "eslint", selected: true },
+        { title: "Prettier", value: "prettier", selected: true },
+        { title: "EditorConfig", value: "editorconfig", selected: true },
+        { title: "Git Hooks", value: "githooks", selected: false }
+      ]
+    },
+    {
+      type: "confirm",
+      name: "installDeps",
+      message: "Install dependencies?",
+      initial: true
+    }
+  ]);
+  if (!response || !response.configs) {
+    console.log("\n\u274C Setup cancelled.\n");
+    process__default.exit(1);
+  }
+  const { configs, installDeps } = response;
+  if (configs.includes("eslint")) {
+    createEslintConfig(root, isWorkspace);
+  }
+  if (configs.includes("prettier")) {
+    createPrettierConfig(root);
+  }
+  if (configs.includes("editorconfig")) {
+    createEditorConfig(root);
+  }
+  if (configs.includes("githooks")) {
+    createGitHooks(root);
+  }
+  updatePackageJsonLint(root, configs);
+  if (installDeps) {
+    console.log("\n\u{1F4E6} Installing dependencies...");
+    console.log("Run: bun add -D @bagelink/lint-config eslint prettier typescript");
+  }
+  console.log("\n\u2705 Linting setup complete!");
+  console.log("\nAvailable commands:");
+  console.log("  bun run lint       - Run linter");
+  console.log("  bun run lint:fix   - Fix linting issues");
+  console.log("  bun run format     - Format code with Prettier");
+  console.log("");
+}
+function createEslintConfig(root, isWorkspace) {
+  const configPath = node_path.resolve(root, "eslint.config.js");
+  const config = isWorkspace ? `import { defineConfig } from '@bagelink/lint-config/eslint'
+
+export default defineConfig({
+	// Workspace-level ESLint config
+	ignores: ['**/dist/**', '**/node_modules/**', '**/.bun-cache/**'],
+})
+` : `import vue3Config from '@bagelink/lint-config/eslint/vue3'
+
+export default vue3Config
+`;
+  node_fs.writeFileSync(configPath, config);
+  console.log("\u2705 Created eslint.config.js");
+}
+function createPrettierConfig(root) {
+  const configPath = node_path.resolve(root, ".prettierrc");
+  const config = {
+    semi: false,
+    singleQuote: true,
+    tabWidth: 2,
+    useTabs: true,
+    trailingComma: "all",
+    printWidth: 100,
+    arrowParens: "avoid"
+  };
+  node_fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  console.log("\u2705 Created .prettierrc");
+  const ignorePath = node_path.resolve(root, ".prettierignore");
+  const ignore = `dist
+node_modules
+.bun-cache
+*.min.js
+*.min.css
+`;
+  node_fs.writeFileSync(ignorePath, ignore);
+  console.log("\u2705 Created .prettierignore");
+}
+function createEditorConfig(root) {
+  const configPath = node_path.resolve(root, ".editorconfig");
+  const config = `root = true
+
+[*]
+charset = utf-8
+indent_style = tab
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{json,yml,yaml}]
+indent_style = space
+indent_size = 2
+`;
+  node_fs.writeFileSync(configPath, config);
+  console.log("\u2705 Created .editorconfig");
+}
+function createGitHooks(root) {
+  const packageJsonPath = node_path.resolve(root, "package.json");
+  if (!node_fs.existsSync(packageJsonPath)) {
+    console.warn("\u26A0\uFE0F  No package.json found, skipping git hooks");
+    return;
+  }
+  const lintStagedConfig = {
+    "*.{js,jsx,ts,tsx,vue}": ["eslint --fix"],
+    "*.{json,md,yml,yaml}": ["prettier --write"]
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(root, ".lintstagedrc"),
+    `${JSON.stringify(lintStagedConfig, null, 2)}
+`
+  );
+  console.log("\u2705 Created .lintstagedrc");
+  console.log("\u2139\uFE0F  Add simple-git-hooks and lint-staged to devDependencies");
+  console.log("   Then run: npx simple-git-hooks");
+}
+function updatePackageJsonLint(root, configs) {
+  const packageJsonPath = node_path.resolve(root, "package.json");
+  if (!node_fs.existsSync(packageJsonPath)) {
+    console.warn("\u26A0\uFE0F  No package.json found");
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(
+      node_fs.readFileSync(packageJsonPath, "utf-8")
+    );
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    if (configs.includes("eslint")) {
+      if (!packageJson.scripts.lint) {
+        packageJson.scripts.lint = "eslint .";
+      }
+      if (!packageJson.scripts["lint:fix"]) {
+        packageJson.scripts["lint:fix"] = "eslint . --fix";
+      }
+    }
+    if (configs.includes("prettier")) {
+      if (!packageJson.scripts.format) {
+        packageJson.scripts.format = "prettier --write .";
+      }
+      if (!packageJson.scripts["format:check"]) {
+        packageJson.scripts["format:check"] = "prettier --check .";
+      }
+    }
+    node_fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}
+`
+    );
+    console.log("\u2705 Updated package.json with lint scripts");
+  } catch (error) {
+    console.error("\u274C Failed to update package.json:", error);
+  }
+}
+
+async function generateSDK(root = process__default.cwd()) {
+  console.log("\n\u{1F527} Generating SDK from OpenAPI...\n");
+  let config = null;
+  let openApiUrl;
+  try {
+    const configPath = node_path.resolve(root, "bgl.config.ts");
+    if (node_fs.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 {
+  }
+  const response = await prompts__default([
+    {
+      type: openApiUrl !== void 0 ? null : "text",
+      name: "openApiUrl",
+      message: "OpenAPI spec URL:",
+      initial: openApiUrl ?? "http://localhost:8000/openapi.json"
+    },
+    {
+      type: "text",
+      name: "outputDir",
+      message: "Output directory:",
+      initial: "./src/api"
+    },
+    {
+      type: "confirm",
+      name: "splitFiles",
+      message: "Split into organized files?",
+      initial: true
+    }
+  ]);
+  if (!response) {
+    console.log("\n\u274C SDK generation cancelled.\n");
+    process__default.exit(1);
+  }
+  const finalUrl = openApiUrl ?? response.openApiUrl;
+  const { outputDir, splitFiles } = response;
+  console.log(`
+\u{1F4E1} Fetching OpenAPI spec from: ${finalUrl}`);
+  console.log(`\u{1F4C1} Output directory: ${outputDir}
+`);
+  try {
+    const { openAPI } = await import('@bagelink/sdk');
+    const { types, code } = await openAPI(finalUrl, "/api");
+    const outputPath = node_path.resolve(root, outputDir);
+    if (!node_fs.existsSync(outputPath)) {
+      node_fs.mkdirSync(outputPath, { recursive: true });
+    }
+    const typesPath = node_path.resolve(outputPath, "types.d.ts");
+    node_fs.writeFileSync(typesPath, types);
+    console.log("\u2705 Generated types.d.ts");
+    const apiPath = node_path.resolve(outputPath, "api.ts");
+    node_fs.writeFileSync(apiPath, code);
+    console.log("\u2705 Generated api.ts");
+    const indexPath = node_path.resolve(outputPath, "index.ts");
+    node_fs.writeFileSync(
+      indexPath,
+      "export * from './api'\nexport * from './types.d'\n"
+    );
+    console.log("\u2705 Generated index.ts");
+    if (splitFiles) {
+      console.log("\n\u{1F500} Splitting into organized files...");
+      console.log("\u2139\uFE0F  File splitting requires @bagelink/sdk bin scripts");
+      console.log("    Keeping monolithic structure for now");
+    }
+    console.log("\n\u2705 SDK generated successfully!");
+    console.log(`
+Import it in your code:`);
+    console.log(`  import { api } from '${outputDir.replace("./src/", "./")}'`);
+    console.log("");
+  } catch (error) {
+    console.error("\n\u274C 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__default.exit(1);
+  }
+}
+async function generateSDKForWorkspace(root = process__default.cwd()) {
+  console.log("\n\u{1F3E2} Generating SDK for workspace projects...\n");
+  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;
+  }
+  const response = await prompts__default({
+    type: "multiselect",
+    name: "selectedProjects",
+    message: "Select projects to generate SDK for:",
+    choices: projects.map((p) => ({ title: p, value: p, selected: true }))
+  });
+  if (!response || !response.selectedProjects || response.selectedProjects.length === 0) {
+    console.log("\n\u274C No projects selected.\n");
+    return;
+  }
+  for (const project of response.selectedProjects) {
+    console.log(`
+\u{1F4E6} Generating SDK for: ${project}`);
+    const projectPath = node_path.resolve(root, project);
+    try {
+      await generateSDK(projectPath);
+    } catch {
+      console.error(`Failed to generate SDK for ${project}`);
+    }
+  }
+  console.log("\n\u2705 All SDKs generated!");
+}
+
+async function initWorkspace(root = process__default.cwd()) {
+  console.log("\n\u{1F680} Creating Bagel workspace...\n");
+  const response = await prompts__default([
+    {
+      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__default.exit(1);
+  }
+  const { workspaceName, projectId, createFirstProject, firstProjectName } = response;
+  const workspaceDir = node_path.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 = node_path.resolve(root, name);
+  if (node_fs.existsSync(workspaceDir)) {
+    console.error(`\u274C Directory ${name} already exists`);
+    process__default.exit(1);
+  }
+  node_fs.mkdirSync(workspaceDir, { recursive: true });
+  const packageJson = {
+    name,
+    private: true,
+    workspaces: ["*", "!node_modules"],
+    scripts: {
+      dev: "bun scripts/dev.ts",
+      "dev:verbose": "bun run --filter './[!shared]*' dev",
+      build: "bun run --filter './[!shared]*' build",
+      typecheck: "tsc --noEmit"
+    },
+    devDependencies: {
+      "@bagelink/workspace": "latest",
+      "typescript": "^5.0.0",
+      "vite": "latest"
+    }
+  };
+  node_fs.writeFileSync(
+    node_path.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',
+	},
+})
+`;
+  node_fs.writeFileSync(node_path.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/*"]
+      }
+    }
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(workspaceDir, "tsconfig.json"),
+    `${JSON.stringify(tsConfig, null, 2)}
+`
+  );
+  const gitignore = `node_modules
+dist
+.DS_Store
+*.local
+.env.local
+.vite
+`;
+  node_fs.writeFileSync(node_path.resolve(workspaceDir, ".gitignore"), gitignore);
+  const scriptsDir = node_path.resolve(workspaceDir, "scripts");
+  node_fs.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()
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(scriptsDir, "dev.ts"), devRunnerContent);
+  console.log(`\u2705 Created workspace: ${name}`);
+}
+function createSharedPackage(root) {
+  const sharedDir = node_path.resolve(root, "shared");
+  node_fs.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"
+    }
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "index.ts"),
+    "// Shared utilities and exports\nexport * from './utils'\n"
+  );
+  node_fs.mkdirSync(node_path.resolve(sharedDir, "utils"), { recursive: true });
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "utils", "index.ts"),
+    "// Shared utility functions\nexport function formatDate(date: Date): string {\n  return date.toISOString()\n}\n"
+  );
+  node_fs.mkdirSync(node_path.resolve(sharedDir, "types"), { recursive: true });
+  node_fs.writeFileSync(
+    node_path.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__default.cwd()) {
+  const projectDir = node_path.resolve(root, name);
+  if (node_fs.existsSync(projectDir)) {
+    console.error(`\u274C Project ${name} already exists`);
+    process__default.exit(1);
+  }
+  console.log(`
+\u{1F4E6} Creating project: ${name}
+`);
+  node_fs.mkdirSync(projectDir, { recursive: true });
+  const isWorkspace = node_fs.existsSync(node_path.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:*";
+  }
+  node_fs.writeFileSync(
+    node_path.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',
+	},
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(projectDir, "bgl.config.ts"), bglConfigContent);
+  const viteConfig = `import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { createViteProxy } from '@bagelink/workspace'
+import workspace from './bgl.config'
+
+export default defineConfig(({ mode }) => {
+	const config = workspace(mode as 'localhost' | 'development' | 'production')
+
+	return {
+		plugins: [vue()],
+		server: {
+			proxy: createViteProxy(config),
+		},
+	}
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(projectDir, "vite.config.ts"), viteConfig);
+  const srcDir = node_path.resolve(projectDir, "src");
+  node_fs.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>
+`;
+  node_fs.writeFileSync(node_path.resolve(projectDir, "index.html"), indexHtml);
+  const mainTs = `import { createApp } from 'vue'
+import App from './App.vue'
+
+createApp(App).mount('#app')
+`;
+  node_fs.writeFileSync(node_path.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>
+`;
+  node_fs.writeFileSync(node_path.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 = node_path.resolve(root, "package.json");
+  if (!node_fs.existsSync(packageJsonPath)) return;
+  try {
+    const packageJson = JSON.parse(
+      node_fs.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`;
+    node_fs.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__default.cwd()) {
+  try {
+    const items = node_fs.readdirSync(root, { withFileTypes: true });
+    return items.filter(
+      (item) => item.isDirectory() && item.name !== "node_modules" && item.name !== "shared" && item.name !== ".git" && !item.name.startsWith(".")
+    ).map((item) => item.name);
+  } catch {
+    return [];
+  }
+}
+
+function isWorkspace(root = process__default.cwd()) {
+  const packageJsonPath = node_path.resolve(root, "package.json");
+  if (node_fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, "utf-8"));
+      if (packageJson.workspaces !== void 0) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  try {
+    const items = node_fs.readdirSync(root, { withFileTypes: true });
+    const projectDirs = items.filter(
+      (item) => item.isDirectory() && item.name !== "node_modules" && item.name !== "shared" && item.name !== ".git" && !item.name.startsWith(".") && node_fs.existsSync(node_path.resolve(root, item.name, "package.json"))
+    );
+    return projectDirs.length >= 2;
+  } catch {
+    return false;
+  }
+}
+function getWorkspaceInfo(root = process__default.cwd()) {
+  const workspace = isWorkspace(root);
+  if (!workspace) {
+    return {
+      isWorkspace: false,
+      projects: [],
+      hasShared: false
+    };
+  }
+  try {
+    const items = node_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(".") && node_fs.existsSync(node_path.resolve(root, item.name, "package.json"))
+    ).map((item) => item.name);
+    const hasShared = node_fs.existsSync(node_path.resolve(root, "shared"));
+    return {
+      isWorkspace: true,
+      projects,
+      hasShared
+    };
+  } catch {
+    return {
+      isWorkspace: false,
+      projects: [],
+      hasShared: false
+    };
+  }
+}
+
+exports.addProject = addProject;
+exports.generateNetlifyConfig = generateNetlifyConfig;
+exports.generateNetlifyRedirect = generateNetlifyRedirect;
+exports.generateSDK = generateSDK;
+exports.generateSDKForWorkspace = generateSDKForWorkspace;
+exports.generateWorkspaceConfig = generateWorkspaceConfig;
+exports.generateWorkspaceConfigSync = generateWorkspaceConfigSync;
+exports.getWorkspaceInfo = getWorkspaceInfo;
+exports.initWorkspace = initWorkspace;
+exports.isWorkspace = isWorkspace;
+exports.listProjects = listProjects;
+exports.setBuildEnvVars = setBuildEnvVars;
+exports.setupLint = setupLint;
+exports.writeNetlifyConfig = writeNetlifyConfig;