@objectstack/cli 1.0.11 → 1.0.12

package/dist/index.js

@@ -1,7 +1,1940 @@
-#!/usr/bin/env node
-import {
-  compileCommand
-} from "./chunk-2YXVEYO7.js";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/commands/compile.ts
+import { Command } from "commander";
+import path2 from "path";
+import fs2 from "fs";
+import chalk3 from "chalk";
+import { ObjectStackDefinitionSchema } from "@objectstack/spec";
+
+// src/utils/config.ts
+import path from "path";
+import fs from "fs";
+import chalk2 from "chalk";
+import { bundleRequire } from "bundle-require";
+
+// src/utils/format.ts
+import chalk from "chalk";
+function printHeader(title) {
+  console.log(chalk.bold(`
+\u25C6 ${title}`));
+  console.log(chalk.dim("\u2500".repeat(40)));
+}
+function printKV(key, value, icon) {
+  const prefix = icon ? `${icon} ` : "  ";
+  console.log(`${prefix}${chalk.dim(key + ":")} ${chalk.white(String(value))}`);
+}
+function printSuccess(msg) {
+  console.log(chalk.green(`  \u2713 ${msg}`));
+}
+function printWarning(msg) {
+  console.log(chalk.yellow(`  \u26A0 ${msg}`));
+}
+function printError(msg) {
+  console.log(chalk.red(`  \u2717 ${msg}`));
+}
+function printInfo(msg) {
+  console.log(chalk.blue(`  \u2139 ${msg}`));
+}
+function printStep(msg) {
+  console.log(chalk.yellow(`  \u2192 ${msg}`));
+}
+function createTimer() {
+  const start = Date.now();
+  return {
+    elapsed: () => Date.now() - start,
+    display: () => `${Date.now() - start}ms`
+  };
+}
+function formatZodErrors(error) {
+  const issues = error.issues || error.errors || [];
+  if (issues.length === 0) {
+    console.log(chalk.red("  Unknown validation error"));
+    return;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const topPath = issue.path?.[0] || "_root";
+    if (!grouped.has(String(topPath))) {
+      grouped.set(String(topPath), []);
+    }
+    grouped.get(String(topPath)).push(issue);
+  }
+  for (const [section, sectionIssues] of grouped) {
+    console.log(chalk.bold.red(`
+  ${section}:`));
+    for (const issue of sectionIssues) {
+      const path11 = issue.path?.join(".") || "";
+      const code = issue.code || "";
+      const msg = issue.message || "";
+      console.log(chalk.red(`    \u2717 ${path11}`));
+      console.log(chalk.dim(`      ${code}: ${msg}`));
+      if (issue.expected) {
+        console.log(chalk.dim(`      expected: ${chalk.green(issue.expected)}`));
+      }
+      if (issue.received) {
+        console.log(chalk.dim(`      received: ${chalk.red(issue.received)}`));
+      }
+    }
+  }
+  console.log("");
+  console.log(chalk.dim(`  ${issues.length} validation error(s) total`));
+}
+function collectMetadataStats(config) {
+  const count = (arr) => Array.isArray(arr) ? arr.length : 0;
+  let fields = 0;
+  if (Array.isArray(config.objects)) {
+    for (const obj of config.objects) {
+      if (obj.fields && typeof obj.fields === "object") {
+        fields += Object.keys(obj.fields).length;
+      }
+    }
+  }
+  return {
+    objects: count(config.objects),
+    objectExtensions: count(config.objectExtensions),
+    fields,
+    views: count(config.views),
+    pages: count(config.pages),
+    apps: count(config.apps),
+    dashboards: count(config.dashboards),
+    reports: count(config.reports),
+    actions: count(config.actions),
+    flows: count(config.flows),
+    workflows: count(config.workflows),
+    approvals: count(config.approvals),
+    agents: count(config.agents),
+    apis: count(config.apis),
+    roles: count(config.roles),
+    permissions: count(config.permissions),
+    themes: count(config.themes),
+    datasources: count(config.datasources),
+    translations: count(config.translations),
+    plugins: count(config.plugins),
+    devPlugins: count(config.devPlugins)
+  };
+}
+function printServerReady(opts) {
+  const base = `http://localhost:${opts.port}`;
+  console.log("");
+  console.log(chalk.bold.green("  \u2713 Server is ready"));
+  console.log("");
+  console.log(chalk.cyan("  \u279C") + chalk.bold("  API:     ") + chalk.cyan(base + "/"));
+  if (opts.uiEnabled && opts.studioPath) {
+    console.log(chalk.cyan("  \u279C") + chalk.bold("  Console: ") + chalk.cyan(base + opts.studioPath + "/"));
+  }
+  console.log("");
+  console.log(chalk.dim(`  Config:  ${opts.configFile}`));
+  console.log(chalk.dim(`  Mode:    ${opts.isDev ? "development" : "production"}`));
+  console.log(chalk.dim(`  Plugins: ${opts.pluginCount} loaded`));
+  if (opts.pluginNames && opts.pluginNames.length > 0) {
+    console.log(chalk.dim(`           ${opts.pluginNames.join(", ")}`));
+  }
+  console.log("");
+  console.log(chalk.dim("  Press Ctrl+C to stop"));
+  console.log("");
+}
+function printMetadataStats(stats) {
+  const sections = [
+    {
+      label: "Data",
+      items: [
+        ["Objects", stats.objects],
+        ["Fields", stats.fields],
+        ["Extensions", stats.objectExtensions],
+        ["Datasources", stats.datasources]
+      ]
+    },
+    {
+      label: "UI",
+      items: [
+        ["Apps", stats.apps],
+        ["Views", stats.views],
+        ["Pages", stats.pages],
+        ["Dashboards", stats.dashboards],
+        ["Reports", stats.reports],
+        ["Actions", stats.actions],
+        ["Themes", stats.themes]
+      ]
+    },
+    {
+      label: "Logic",
+      items: [
+        ["Flows", stats.flows],
+        ["Workflows", stats.workflows],
+        ["Approvals", stats.approvals],
+        ["Agents", stats.agents],
+        ["APIs", stats.apis]
+      ]
+    },
+    {
+      label: "Security",
+      items: [
+        ["Roles", stats.roles],
+        ["Permissions", stats.permissions]
+      ]
+    }
+  ];
+  for (const section of sections) {
+    const nonZero = section.items.filter(([, v]) => v > 0);
+    if (nonZero.length === 0) continue;
+    const line = nonZero.map(([k, v]) => `${chalk.white(v)} ${chalk.dim(k)}`).join("  ");
+    console.log(`  ${chalk.bold(section.label + ":")} ${line}`);
+  }
+  if (stats.plugins > 0 || stats.devPlugins > 0) {
+    const parts = [];
+    if (stats.plugins > 0) parts.push(`${stats.plugins} plugins`);
+    if (stats.devPlugins > 0) parts.push(`${stats.devPlugins} devPlugins`);
+    console.log(`  ${chalk.bold("Runtime:")} ${chalk.dim(parts.join(", "))}`);
+  }
+}
+
+// src/utils/config.ts
+function resolveConfigPath(source) {
+  if (source) {
+    const abs = path.resolve(process.cwd(), source);
+    if (!fs.existsSync(abs)) {
+      printError(`Config file not found: ${chalk2.white(abs)}`);
+      console.log("");
+      console.log(chalk2.dim("  Hint: Run this command from a directory with objectstack.config.ts"));
+      console.log(chalk2.dim("  Or specify the path: objectstack <command> path/to/config.ts"));
+      process.exit(1);
+    }
+    return abs;
+  }
+  const candidates = [
+    "objectstack.config.ts",
+    "objectstack.config.js",
+    "objectstack.config.mjs"
+  ];
+  for (const candidate of candidates) {
+    const abs = path.resolve(process.cwd(), candidate);
+    if (fs.existsSync(abs)) return abs;
+  }
+  printError("No objectstack.config.{ts,js,mjs} found in current directory");
+  console.log("");
+  console.log(chalk2.dim("  Hint: Run `objectstack init` to create a new project"));
+  process.exit(1);
+}
+async function loadConfig(source) {
+  const absolutePath = resolveConfigPath(source);
+  const start = Date.now();
+  const { mod } = await bundleRequire({
+    filepath: absolutePath
+  });
+  const config = mod.default || mod;
+  if (!config) {
+    throw new Error(`No default export found in ${path.basename(absolutePath)}`);
+  }
+  return {
+    config,
+    absolutePath,
+    duration: Date.now() - start
+  };
+}
+
+// src/commands/compile.ts
+var compileCommand = new Command("compile").description("Compile ObjectStack configuration to JSON artifact").argument("[config]", "Source configuration file").option("-o, --output <path>", "Output JSON file", "dist/objectstack.json").option("--json", "Output compile result as JSON (for CI)").action(async (configPath, options) => {
+  const timer = createTimer();
+  if (!options.json) {
+    printHeader("Compile");
+  }
+  try {
+    if (!options.json) printStep("Loading configuration...");
+    const { config, absolutePath, duration } = await loadConfig(configPath);
+    if (!options.json) {
+      printKV("Config", path2.relative(process.cwd(), absolutePath));
+      printKV("Load time", `${duration}ms`);
+    }
+    if (!options.json) printStep("Validating protocol compliance...");
+    const result = ObjectStackDefinitionSchema.safeParse(config);
+    if (!result.success) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, errors: result.error.issues }));
+        process.exit(1);
+      }
+      console.log("");
+      printError("Validation failed");
+      formatZodErrors(result.error);
+      process.exit(1);
+    }
+    if (!options.json) printStep("Writing artifact...");
+    const output = options.output;
+    const artifactPath = path2.resolve(process.cwd(), output);
+    const artifactDir = path2.dirname(artifactPath);
+    if (!fs2.existsSync(artifactDir)) {
+      fs2.mkdirSync(artifactDir, { recursive: true });
+    }
+    const jsonContent = JSON.stringify(result.data, null, 2);
+    fs2.writeFileSync(artifactPath, jsonContent);
+    const sizeKB = (jsonContent.length / 1024).toFixed(1);
+    const stats = collectMetadataStats(config);
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: true,
+        output: artifactPath,
+        size: jsonContent.length,
+        stats,
+        duration: timer.elapsed()
+      }));
+      return;
+    }
+    console.log("");
+    printSuccess(`Build complete ${chalk3.dim(`(${timer.display()})`)}`);
+    console.log("");
+    printMetadataStats(stats);
+    console.log("");
+    printKV("Artifact", `${output} ${chalk3.dim(`(${sizeKB} KB`)})`);
+    console.log("");
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: error.message }));
+      process.exit(1);
+    }
+    console.log("");
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/validate.ts
+import { Command as Command2 } from "commander";
+import chalk4 from "chalk";
+import { ObjectStackDefinitionSchema as ObjectStackDefinitionSchema2 } from "@objectstack/spec";
+var validateCommand = new Command2("validate").description("Validate ObjectStack configuration against the protocol schema").argument("[config]", "Configuration file path").option("--strict", "Treat warnings as errors").option("--json", "Output results as JSON").action(async (configPath, options) => {
+  const timer = createTimer();
+  if (!options.json) {
+    printHeader("Validate");
+  }
+  try {
+    if (!options.json) printStep("Loading configuration...");
+    const { config, absolutePath, duration } = await loadConfig(configPath);
+    if (!options.json) {
+      printKV("Config", absolutePath);
+      printKV("Load time", `${duration}ms`);
+    }
+    if (!options.json) printStep("Validating against ObjectStack Protocol...");
+    const result = ObjectStackDefinitionSchema2.safeParse(config);
+    if (!result.success) {
+      if (options.json) {
+        console.log(JSON.stringify({
+          valid: false,
+          errors: result.error.issues,
+          duration: timer.elapsed()
+        }, null, 2));
+        process.exit(1);
+      }
+      console.log("");
+      printError("Validation failed");
+      formatZodErrors(result.error);
+      process.exit(1);
+    }
+    const stats = collectMetadataStats(config);
+    if (options.json) {
+      console.log(JSON.stringify({
+        valid: true,
+        manifest: config.manifest,
+        stats,
+        duration: timer.elapsed()
+      }, null, 2));
+      return;
+    }
+    const warnings = [];
+    if (stats.objects === 0) {
+      warnings.push("No objects defined \u2014 this stack has no data model");
+    }
+    if (stats.apps === 0 && stats.plugins === 0) {
+      warnings.push("No apps or plugins defined \u2014 this stack may not do much");
+    }
+    if (!config.manifest?.id) {
+      warnings.push("Missing manifest.id \u2014 required for deployment");
+    }
+    if (!config.manifest?.namespace) {
+      warnings.push("Missing manifest.namespace \u2014 required for multi-app hosting");
+    }
+    console.log("");
+    printSuccess(`Validation passed ${chalk4.dim(`(${timer.display()})`)}`);
+    console.log("");
+    if (config.manifest) {
+      console.log(`  ${chalk4.bold(config.manifest.name || config.manifest.id || "Unnamed")} ${chalk4.dim(`v${config.manifest.version || "0.0.0"}`)}`);
+      if (config.manifest.description) {
+        console.log(chalk4.dim(`  ${config.manifest.description}`));
+      }
+      console.log("");
+    }
+    printMetadataStats(stats);
+    if (warnings.length > 0) {
+      console.log("");
+      for (const w of warnings) {
+        console.log(chalk4.yellow(`  \u26A0 ${w}`));
+      }
+      if (options.strict) {
+        console.log("");
+        printError("Strict mode: warnings treated as errors");
+        process.exit(1);
+      }
+    }
+    console.log("");
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        valid: false,
+        error: error.message,
+        duration: timer.elapsed()
+      }, null, 2));
+      process.exit(1);
+    }
+    console.log("");
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/info.ts
+import { Command as Command3 } from "commander";
+import chalk5 from "chalk";
+var infoCommand = new Command3("info").description("Display metadata summary of an ObjectStack configuration").argument("[config]", "Configuration file path").option("--json", "Output as JSON").action(async (configPath, options) => {
+  const timer = createTimer();
+  if (!options.json) {
+    printHeader("Info");
+  }
+  try {
+    const { config, absolutePath, duration } = await loadConfig(configPath);
+    const stats = collectMetadataStats(config);
+    if (options.json) {
+      console.log(JSON.stringify({
+        config: absolutePath,
+        manifest: config.manifest || null,
+        stats,
+        objects: (config.objects || []).map((o) => ({
+          name: o.name,
+          label: o.label,
+          fields: o.fields ? Object.keys(o.fields).length : 0
+        })),
+        loadTime: duration
+      }, null, 2));
+      return;
+    }
+    if (config.manifest) {
+      const m = config.manifest;
+      console.log("");
+      console.log(`  ${chalk5.bold(m.name || m.id || "Unnamed")} ${chalk5.dim(`v${m.version || "0.0.0"}`)}`);
+      if (m.id) console.log(chalk5.dim(`  ${m.id}`));
+      if (m.description) console.log(chalk5.dim(`  ${m.description}`));
+      if (m.namespace) printKV("  Namespace", m.namespace);
+      if (m.type) printKV("  Type", m.type);
+    }
+    console.log("");
+    printMetadataStats(stats);
+    if (config.objects && config.objects.length > 0) {
+      console.log("");
+      console.log(chalk5.bold("  Objects:"));
+      for (const obj of config.objects) {
+        const fieldCount = obj.fields ? Object.keys(obj.fields).length : 0;
+        const ownership = obj.ownership || "own";
+        console.log(
+          `    ${chalk5.cyan(obj.name || "?")}` + chalk5.dim(` (${fieldCount} fields, ${ownership})`) + (obj.label ? chalk5.dim(` \u2014 ${obj.label}`) : "")
+        );
+      }
+    }
+    if (config.agents && config.agents.length > 0) {
+      console.log("");
+      console.log(chalk5.bold("  Agents:"));
+      for (const agent of config.agents) {
+        console.log(
+          `    ${chalk5.magenta(agent.name || "?")}` + (agent.role ? chalk5.dim(` \u2014 ${agent.role}`) : "")
+        );
+      }
+    }
+    if (config.apps && config.apps.length > 0) {
+      console.log("");
+      console.log(chalk5.bold("  Apps:"));
+      for (const app of config.apps) {
+        console.log(
+          `    ${chalk5.green(app.name || "?")}` + (app.label ? chalk5.dim(` \u2014 ${app.label}`) : "")
+        );
+      }
+    }
+    console.log("");
+    console.log(chalk5.dim(`  Loaded in ${duration}ms`));
+    console.log("");
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error.message }));
+      process.exit(1);
+    }
+    console.log("");
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command4 } from "commander";
+import chalk6 from "chalk";
+import fs3 from "fs";
+import path3 from "path";
+var TEMPLATES = {
+  app: {
+    description: "Full application with objects, views, and actions",
+    dependencies: {
+      "@objectstack/spec": "workspace:*",
+      "@objectstack/runtime": "workspace:^",
+      "@objectstack/objectql": "workspace:^",
+      "@objectstack/driver-memory": "workspace:^"
+    },
+    devDependencies: {
+      "@objectstack/cli": "workspace:*",
+      "typescript": "^5.3.0"
+    },
+    scripts: {
+      dev: "objectstack dev",
+      start: "objectstack serve",
+      build: "objectstack compile",
+      validate: "objectstack validate",
+      typecheck: "tsc --noEmit"
+    },
+    configContent: (name) => `import { defineStack } from '@objectstack/spec';
+import * as objects from './src/objects';
+
+export default defineStack({
+  manifest: {
+    id: 'com.example.${name}',
+    namespace: '${name}',
+    version: '0.1.0',
+    type: 'app',
+    name: '${toTitleCase(name)}',
+    description: '${toTitleCase(name)} application built with ObjectStack',
+  },
+
+  objects: Object.values(objects),
+});
+`,
+    srcFiles: {
+      "src/objects/index.ts": (name) => `export { default as ${toCamelCase(name)} } from './${name}';
+`,
+      "src/objects/__name__.ts": (name) => `import { Data } from '@objectstack/spec';
+
+const ${toCamelCase(name)}: Data.Object = {
+  name: '${name}',
+  label: '${toTitleCase(name)}',
+  ownership: 'own',
+  fields: {
+    name: {
+      type: 'text',
+      label: 'Name',
+      required: true,
+    },
+    description: {
+      type: 'textarea',
+      label: 'Description',
+    },
+    status: {
+      type: 'select',
+      label: 'Status',
+      options: [
+        { label: 'Draft', value: 'draft' },
+        { label: 'Active', value: 'active' },
+        { label: 'Archived', value: 'archived' },
+      ],
+      defaultValue: 'draft',
+    },
+  },
+};
+
+export default ${toCamelCase(name)};
+`
+    }
+  },
+  plugin: {
+    description: "Reusable plugin with objects and extensions",
+    dependencies: {
+      "@objectstack/spec": "workspace:*"
+    },
+    devDependencies: {
+      "typescript": "^5.3.0",
+      "vitest": "^4.0.18"
+    },
+    scripts: {
+      build: "objectstack compile",
+      validate: "objectstack validate",
+      test: "vitest run",
+      typecheck: "tsc --noEmit"
+    },
+    configContent: (name) => `import { defineStack } from '@objectstack/spec';
+import * as objects from './src/objects';
+
+export default defineStack({
+  manifest: {
+    id: 'com.objectstack.plugin-${name}',
+    namespace: 'plugin_${name}',
+    version: '0.1.0',
+    type: 'plugin',
+    name: '${toTitleCase(name)} Plugin',
+    description: 'ObjectStack Plugin: ${toTitleCase(name)}',
+  },
+
+  objects: Object.values(objects),
+});
+`,
+    srcFiles: {
+      "src/objects/index.ts": (name) => `export { default as ${toCamelCase(name)} } from './${name}';
+`,
+      "src/objects/__name__.ts": (name) => `import { Data } from '@objectstack/spec';
+
+const ${toCamelCase(name)}: Data.Object = {
+  name: '${name}',
+  label: '${toTitleCase(name)}',
+  ownership: 'own',
+  fields: {
+    name: {
+      type: 'text',
+      label: 'Name',
+      required: true,
+    },
+  },
+};
+
+export default ${toCamelCase(name)};
+`
+    }
+  },
+  empty: {
+    description: "Minimal project with just a config file",
+    dependencies: {
+      "@objectstack/spec": "workspace:*"
+    },
+    devDependencies: {
+      "@objectstack/cli": "workspace:*",
+      "typescript": "^5.3.0"
+    },
+    scripts: {
+      build: "objectstack compile",
+      validate: "objectstack validate",
+      typecheck: "tsc --noEmit"
+    },
+    configContent: (name) => `import { defineStack } from '@objectstack/spec';
+
+export default defineStack({
+  manifest: {
+    id: 'com.example.${name}',
+    namespace: '${name}',
+    version: '0.1.0',
+    type: 'app',
+    name: '${toTitleCase(name)}',
+    description: '',
+  },
+});
+`,
+    srcFiles: {}
+  }
+};
+function toCamelCase(str) {
+  return str.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toTitleCase(str) {
+  return str.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+var initCommand = new Command4("init").description("Initialize a new ObjectStack project in the current directory").argument("[name]", "Project name (defaults to directory name)").option("-t, --template <template>", "Template: app, plugin, empty", "app").option("--no-install", "Skip dependency installation").action(async (name, options) => {
+  printHeader("Init");
+  const cwd = process.cwd();
+  const projectName = name || path3.basename(cwd);
+  const template = TEMPLATES[options.template];
+  if (!template) {
+    printError(`Unknown template: ${options.template}`);
+    console.log(chalk6.dim(`  Available: ${Object.keys(TEMPLATES).join(", ")}`));
+    process.exit(1);
+  }
+  if (fs3.existsSync(path3.join(cwd, "objectstack.config.ts"))) {
+    printError("objectstack.config.ts already exists in this directory");
+    console.log(chalk6.dim("  Use `objectstack generate` to add metadata to an existing project"));
+    process.exit(1);
+  }
+  printKV("Project", projectName);
+  printKV("Template", `${options.template} \u2014 ${template.description}`);
+  printKV("Directory", cwd);
+  console.log("");
+  const createdFiles = [];
+  try {
+    const pkgPath = path3.join(cwd, "package.json");
+    if (!fs3.existsSync(pkgPath)) {
+      const pkg = {
+        name: projectName,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        scripts: template.scripts,
+        dependencies: template.dependencies,
+        devDependencies: template.devDependencies
+      };
+      fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+      createdFiles.push("package.json");
+    } else {
+      printInfo("package.json already exists, skipping");
+    }
+    const configContent = template.configContent(projectName);
+    fs3.writeFileSync(path3.join(cwd, "objectstack.config.ts"), configContent);
+    createdFiles.push("objectstack.config.ts");
+    const tsconfigPath = path3.join(cwd, "tsconfig.json");
+    if (!fs3.existsSync(tsconfigPath)) {
+      const tsconfig = {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          outDir: "dist",
+          rootDir: ".",
+          declaration: true
+        },
+        include: ["*.ts", "src/**/*"],
+        exclude: ["dist", "node_modules"]
+      };
+      fs3.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+      createdFiles.push("tsconfig.json");
+    }
+    for (const [filePath, contentFn] of Object.entries(template.srcFiles)) {
+      const resolvedPath = filePath.replace("__name__", projectName);
+      const fullPath = path3.join(cwd, resolvedPath);
+      const dir = path3.dirname(fullPath);
+      if (!fs3.existsSync(dir)) {
+        fs3.mkdirSync(dir, { recursive: true });
+      }
+      fs3.writeFileSync(fullPath, contentFn(projectName));
+      createdFiles.push(resolvedPath);
+    }
+    const gitignorePath = path3.join(cwd, ".gitignore");
+    if (!fs3.existsSync(gitignorePath)) {
+      fs3.writeFileSync(gitignorePath, `node_modules/
+dist/
+*.tsbuildinfo
+`);
+      createdFiles.push(".gitignore");
+    }
+    console.log(chalk6.bold("  Created files:"));
+    for (const f of createdFiles) {
+      console.log(chalk6.green(`    + ${f}`));
+    }
+    console.log("");
+    if (options.install !== false) {
+      printStep("Installing dependencies...");
+      const { execSync: execSync3 } = await import("child_process");
+      try {
+        execSync3("pnpm install", { stdio: "inherit", cwd });
+      } catch {
+        printWarning2("Dependency installation failed. Run `pnpm install` manually.");
+      }
+    }
+    printSuccess("Project initialized!");
+    console.log("");
+    console.log(chalk6.bold("  Next steps:"));
+    console.log(chalk6.dim("    objectstack validate   # Check configuration"));
+    console.log(chalk6.dim("    objectstack dev        # Start development server"));
+    console.log(chalk6.dim("    objectstack generate   # Add objects, views, etc."));
+    console.log("");
+  } catch (error) {
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+function printWarning2(msg) {
+  console.log(chalk6.yellow(`  \u26A0 ${msg}`));
+}
+
+// src/commands/generate.ts
+import { Command as Command5 } from "commander";
+import chalk7 from "chalk";
+import fs4 from "fs";
+import path4 from "path";
+var GENERATORS = {
+  object: {
+    description: "Business data object",
+    defaultDir: "src/objects",
+    generate: (name) => `import { Data } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Object
+ */
+const ${toCamelCase2(name)}: Data.Object = {
+  name: '${toSnakeCase(name)}',
+  label: '${toTitleCase2(name)}',
+  pluralLabel: '${toTitleCase2(name)}s',
+  ownership: 'own',
+  fields: {
+    name: {
+      type: 'text',
+      label: 'Name',
+      required: true,
+      maxLength: 255,
+    },
+    description: {
+      type: 'textarea',
+      label: 'Description',
+    },
+  },
+};
+
+export default ${toCamelCase2(name)};
+`
+  },
+  view: {
+    description: "List or form view",
+    defaultDir: "src/views",
+    generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} List View
+ */
+const ${toCamelCase2(name)}ListView: UI.View = {
+  name: '${toSnakeCase(name)}_list',
+  label: '${toTitleCase2(name)} List',
+  type: 'list',
+  objectName: '${toSnakeCase(name)}',
+  list: {
+    type: 'grid',
+    columns: [
+      { field: 'name', width: 200 },
+    ],
+    defaultSort: { field: 'name', direction: 'asc' },
+    pageSize: 25,
+  },
+};
+
+export default ${toCamelCase2(name)}ListView;
+`
+  },
+  action: {
+    description: "Button or batch action",
+    defaultDir: "src/actions",
+    generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Action
+ */
+const ${toCamelCase2(name)}Action: UI.Action = {
+  name: '${toSnakeCase(name)}',
+  label: '${toTitleCase2(name)}',
+  type: 'custom',
+  objectName: '${toSnakeCase(name)}',
+  handler: {
+    type: 'flow',
+    target: '${toSnakeCase(name)}_flow',
+  },
+};
+
+export default ${toCamelCase2(name)}Action;
+`
+  },
+  flow: {
+    description: "Automation flow",
+    defaultDir: "src/flows",
+    generate: (name) => `import { Automation } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Flow
+ */
+const ${toCamelCase2(name)}Flow: Automation.Flow = {
+  name: '${toSnakeCase(name)}_flow',
+  label: '${toTitleCase2(name)} Flow',
+  type: 'autolaunched',
+  status: 'draft',
+  trigger: {
+    type: 'record_change',
+    object: '${toSnakeCase(name)}',
+    events: ['after_insert', 'after_update'],
+  },
+  nodes: [
+    {
+      id: 'start',
+      type: 'start',
+      name: 'Start',
+      next: 'end',
+    },
+  ],
+};
+
+export default ${toCamelCase2(name)}Flow;
+`
+  },
+  agent: {
+    description: "AI agent",
+    defaultDir: "src/agents",
+    generate: (name) => `import { AI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Agent
+ */
+const ${toCamelCase2(name)}Agent: AI.Agent = {
+  name: '${toSnakeCase(name)}_agent',
+  label: '${toTitleCase2(name)} Agent',
+  role: '${toTitleCase2(name)} assistant',
+  instructions: 'You are a helpful ${toTitleCase2(name).toLowerCase()} assistant.',
+  model: {
+    provider: 'openai',
+    model: 'gpt-4o',
+  },
+  tools: [],
+};
+
+export default ${toCamelCase2(name)}Agent;
+`
+  },
+  dashboard: {
+    description: "Analytics dashboard",
+    defaultDir: "src/dashboards",
+    generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Dashboard
+ */
+const ${toCamelCase2(name)}Dashboard: UI.Dashboard = {
+  name: '${toSnakeCase(name)}_dashboard',
+  label: '${toTitleCase2(name)} Dashboard',
+  widgets: [],
+};
+
+export default ${toCamelCase2(name)}Dashboard;
+`
+  },
+  app: {
+    description: "Application navigation",
+    defaultDir: "src/apps",
+    generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} App
+ */
+const ${toCamelCase2(name)}App: UI.App = {
+  name: '${toSnakeCase(name)}_app',
+  label: '${toTitleCase2(name)}',
+  navigation: {
+    type: 'sidebar',
+    items: [],
+  },
+};
+
+export default ${toCamelCase2(name)}App;
+`
+  }
+};
+function toCamelCase2(str) {
+  return str.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toTitleCase2(str) {
+  return str.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function toSnakeCase(str) {
+  return str.replace(/[-]/g, "_").replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`).replace(/^_/, "");
+}
+var generateCommand = new Command5("generate").alias("g").description("Generate metadata files (object, view, action, flow, agent, dashboard, app)").argument("<type>", "Metadata type to generate").argument("<name>", "Name for the metadata (use kebab-case)").option("-d, --dir <directory>", "Target directory (overrides default)").option("--dry-run", "Show what would be created without writing files").action(async (type, name, options) => {
+  printHeader("Generate");
+  const generator = GENERATORS[type];
+  if (!generator) {
+    printError(`Unknown type: ${type}`);
+    console.log("");
+    console.log(chalk7.bold("  Available types:"));
+    for (const [key, gen] of Object.entries(GENERATORS)) {
+      console.log(`    ${chalk7.cyan(key.padEnd(12))} ${chalk7.dim(gen.description)}`);
+    }
+    console.log("");
+    console.log(chalk7.dim("  Usage: objectstack generate <type> <name>"));
+    console.log(chalk7.dim("  Example: objectstack generate object project"));
+    console.log(chalk7.dim("  Alias: os g object project"));
+    process.exit(1);
+  }
+  const dir = options.dir || generator.defaultDir;
+  const fileName = `${toSnakeCase(name)}.ts`;
+  const filePath = path4.join(process.cwd(), dir, fileName);
+  console.log(`  ${chalk7.dim("Type:")}  ${chalk7.cyan(type)} \u2014 ${generator.description}`);
+  console.log(`  ${chalk7.dim("Name:")}  ${chalk7.white(name)}`);
+  console.log(`  ${chalk7.dim("File:")}  ${chalk7.white(path4.join(dir, fileName))}`);
+  console.log("");
+  if (options.dryRun) {
+    printInfo("Dry run \u2014 no files written");
+    console.log("");
+    console.log(chalk7.dim("  Content:"));
+    console.log(chalk7.dim("  " + "-".repeat(38)));
+    const content = generator.generate(name);
+    for (const line of content.split("\n")) {
+      console.log(chalk7.dim(`  ${line}`));
+    }
+    console.log("");
+    return;
+  }
+  if (fs4.existsSync(filePath)) {
+    printError(`File already exists: ${filePath}`);
+    process.exit(1);
+  }
+  try {
+    const fullDir = path4.dirname(filePath);
+    if (!fs4.existsSync(fullDir)) {
+      fs4.mkdirSync(fullDir, { recursive: true });
+    }
+    const content = generator.generate(name);
+    fs4.writeFileSync(filePath, content);
+    printSuccess(`Created ${path4.join(dir, fileName)}`);
+    const indexPath = path4.join(process.cwd(), dir, "index.ts");
+    if (fs4.existsSync(indexPath)) {
+      const indexContent = fs4.readFileSync(indexPath, "utf-8");
+      const exportLine = `export { default as ${toCamelCase2(name)} } from './${toSnakeCase(name)}';`;
+      if (!indexContent.includes(toCamelCase2(name))) {
+        fs4.appendFileSync(indexPath, exportLine + "\n");
+        printSuccess(`Updated ${dir}/index.ts with export`);
+      }
+    } else {
+      const exportLine = `export { default as ${toCamelCase2(name)} } from './${toSnakeCase(name)}';
+`;
+      fs4.writeFileSync(indexPath, exportLine);
+      printSuccess(`Created ${dir}/index.ts`);
+    }
+    console.log("");
+    console.log(chalk7.dim(`  Tip: Run \`objectstack validate\` to check your config`));
+    console.log("");
+  } catch (error) {
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/create.ts
+import { Command as Command6 } from "commander";
+import chalk8 from "chalk";
+import fs5 from "fs";
+import path5 from "path";
+var templates = {
+  plugin: {
+    description: "Create a new ObjectStack plugin",
+    files: {
+      "package.json": (name) => ({
+        name: `@objectstack/plugin-${name}`,
+        version: "0.1.0",
+        description: `ObjectStack Plugin: ${name}`,
+        main: "dist/index.js",
+        types: "dist/index.d.ts",
+        scripts: {
+          build: "tsc",
+          dev: "tsc --watch",
+          test: "vitest"
+        },
+        keywords: ["objectstack", "plugin", name],
+        author: "",
+        license: "MIT",
+        dependencies: {
+          "@objectstack/spec": "workspace:*",
+          zod: "^4.3.6"
+        },
+        devDependencies: {
+          "@types/node": "^22.0.0",
+          typescript: "^5.8.0",
+          vitest: "^4.0.0"
+        }
+      }),
+      "tsconfig.json": () => ({
+        extends: "../../tsconfig.json",
+        compilerOptions: {
+          outDir: "dist",
+          rootDir: "src"
+        },
+        include: ["src/**/*"]
+      }),
+      "src/index.ts": (name) => `import type { Plugin } from '@objectstack/spec';
+
+/**
+ * ${name} Plugin for ObjectStack
+ */
+export const ${toCamelCase3(name)}Plugin: Plugin = {
+  name: '${name}',
+  version: '0.1.0',
+  
+  async initialize(context) {
+    console.log('Initializing ${name} plugin...');
+    // Plugin initialization logic
+  },
+  
+  async destroy() {
+    console.log('Destroying ${name} plugin...');
+    // Plugin cleanup logic
+  },
+};
+
+export default ${toCamelCase3(name)}Plugin;
+`,
+      "README.md": (name) => `# @objectstack/plugin-${name}
+
+ObjectStack Plugin: ${name}
+
+## Installation
+
+\`\`\`bash
+pnpm add @objectstack/plugin-${name}
+\`\`\`
+
+## Usage
+
+\`\`\`typescript
+import { ${toCamelCase3(name)}Plugin } from '@objectstack/plugin-${name}';
+
+// Use the plugin in your ObjectStack configuration
+export default {
+  plugins: [
+    ${toCamelCase3(name)}Plugin,
+  ],
+};
+\`\`\`
+
+## License
+
+MIT
+`
+    }
+  },
+  example: {
+    description: "Create a new ObjectStack example application",
+    files: {
+      "package.json": (name) => ({
+        name: `@example/${name}`,
+        version: "0.1.0",
+        private: true,
+        description: `ObjectStack Example: ${name}`,
+        scripts: {
+          build: "objectstack compile",
+          dev: "objectstack dev",
+          test: "vitest"
+        },
+        dependencies: {
+          "@objectstack/spec": "workspace:*",
+          "@objectstack/cli": "workspace:*",
+          zod: "^4.3.6"
+        },
+        devDependencies: {
+          "@types/node": "^22.0.0",
+          tsx: "^4.21.0",
+          typescript: "^5.8.0",
+          vitest: "^4.0.0"
+        }
+      }),
+      "objectstack.config.ts": (name) => `import { defineStack } from '@objectstack/spec';
+
+// Barrel imports \u2014 add more as you create new type folders
+// import * as objects from './src/objects';
+// import * as actions from './src/actions';
+// import * as apps from './src/apps';
+
+export default defineStack({
+  manifest: {
+    name: '${name}',
+    version: '0.1.0',
+    description: '${name} example application',
+  },
+  
+  objects: [
+    // Object.values(objects),  // Uncomment after creating src/objects/index.ts
+  ],
+  
+  apps: [
+    // Object.values(apps),     // Uncomment after creating src/apps/index.ts
+  ],
+});
+`,
+      "README.md": (name) => `# ${name} Example
+
+ObjectStack example application: ${name}
+
+## Quick Start
+
+\`\`\`bash
+# Build the configuration
+pnpm build
+
+# Run in development mode
+pnpm dev
+\`\`\`
+
+## Structure
+
+- \`objectstack.config.ts\` - Main configuration file
+- \`dist/objectstack.json\` - Compiled artifact
+
+## Learn More
+
+- [ObjectStack Documentation](../../content/docs)
+- [Examples](../)
+`,
+      "tsconfig.json": () => ({
+        extends: "../../tsconfig.json",
+        compilerOptions: {
+          outDir: "dist",
+          rootDir: "."
+        },
+        include: ["*.ts", "src/**/*"]
+      })
+    }
+  }
+};
+function toCamelCase3(str) {
+  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+var createCommand = new Command6("create").description("Create a new package, plugin, or example from template").argument("<type>", "Type of project to create (plugin, example)").argument("[name]", "Name of the project").option("-d, --dir <directory>", "Target directory").action(async (type, name, options) => {
+  console.log(chalk8.bold(`
+\u{1F4E6} ObjectStack Project Creator`));
+  console.log(chalk8.dim(`-------------------------------`));
+  if (!templates[type]) {
+    console.error(chalk8.red(`
+\u274C Unknown type: ${type}`));
+    console.log(chalk8.dim("Available types: plugin, example"));
+    process.exit(1);
+  }
+  if (!name) {
+    console.error(chalk8.red("\n\u274C Project name is required"));
+    console.log(chalk8.dim(`Usage: objectstack create ${type} <name>`));
+    process.exit(1);
+  }
+  const template = templates[type];
+  const cwd = process.cwd();
+  let targetDir;
+  if (options?.dir) {
+    targetDir = path5.resolve(cwd, options.dir);
+  } else {
+    const baseDir = type === "plugin" ? "packages/plugins" : "examples";
+    const projectName = type === "plugin" ? `plugin-${name}` : name;
+    targetDir = path5.join(cwd, baseDir, projectName);
+  }
+  if (fs5.existsSync(targetDir)) {
+    console.error(chalk8.red(`
+\u274C Directory already exists: ${targetDir}`));
+    process.exit(1);
+  }
+  console.log(`\u{1F4C1} Creating ${type}: ${chalk8.blue(name)}`);
+  console.log(`\u{1F4C2} Location: ${chalk8.dim(targetDir)}`);
+  console.log("");
+  try {
+    fs5.mkdirSync(targetDir, { recursive: true });
+    for (const [filePath, contentFn] of Object.entries(template.files)) {
+      const fullPath = path5.join(targetDir, filePath);
+      const dir = path5.dirname(fullPath);
+      if (!fs5.existsSync(dir)) {
+        fs5.mkdirSync(dir, { recursive: true });
+      }
+      const content = contentFn(name);
+      const fileContent = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+      fs5.writeFileSync(fullPath, fileContent);
+      console.log(chalk8.green(`\u2713 Created ${filePath}`));
+    }
+    console.log("");
+    console.log(chalk8.green("\u2705 Project created successfully!"));
+    console.log("");
+    console.log(chalk8.bold("Next steps:"));
+    console.log(chalk8.dim(`  cd ${path5.relative(cwd, targetDir)}`));
+    console.log(chalk8.dim("  pnpm install"));
+    console.log(chalk8.dim("  pnpm build"));
+    console.log("");
+  } catch (error) {
+    console.error(chalk8.red("\n\u274C Failed to create project:"));
+    console.error(error.message || error);
+    if (fs5.existsSync(targetDir)) {
+      fs5.rmSync(targetDir, { recursive: true });
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/dev.ts
+import { Command as Command7 } from "commander";
+import chalk9 from "chalk";
+import { execSync, spawn } from "child_process";
+import fs6 from "fs";
+import path6 from "path";
+var devCommand = new Command7("dev").description("Start development mode with hot-reload").argument("[package]", "Package name or filter pattern", "all").option("-w, --watch", "Enable watch mode (default)", true).option("--ui", "Enable Console UI at /_studio/").option("-v, --verbose", "Verbose output").action(async (packageName, options) => {
+  printHeader("Development Mode");
+  const configPath = path6.resolve(process.cwd(), "objectstack.config.ts");
+  if (packageName === "all" && fs6.existsSync(configPath)) {
+    printKV("Config", configPath, "\u{1F4C2}");
+    printStep("Starting dev server...");
+    const binPath = process.argv[1];
+    const child = spawn(process.execPath, [binPath, "serve", "--dev", ...options.ui ? ["--ui"] : [], ...options.verbose ? ["--verbose"] : []], {
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: "development" }
+    });
+    return;
+  }
+  try {
+    const cwd = process.cwd();
+    const workspaceConfigPath = path6.resolve(cwd, "pnpm-workspace.yaml");
+    const isWorkspaceRoot = fs6.existsSync(workspaceConfigPath);
+    if (packageName === "all" && !isWorkspaceRoot) {
+      printError(`Config file not found in ${cwd}`);
+      console.error(chalk9.yellow("  Run in a directory with objectstack.config.ts, or from the monorepo root."));
+      process.exit(1);
+    }
+    const filter = packageName === "all" ? "" : `--filter ${packageName}`;
+    printKV("Package", packageName === "all" ? "All packages" : packageName, "\u{1F4E6}");
+    printKV("Watch", "enabled", "\u{1F504}");
+    const command = `pnpm ${filter} dev`.trim();
+    console.log(chalk9.dim(`$ ${command}`));
+    console.log("");
+    execSync(command, {
+      stdio: "inherit",
+      cwd
+    });
+  } catch (error) {
+    printError(`Development mode failed: ${error.message || error}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/serve.ts
+import { Command as Command8 } from "commander";
+import path8 from "path";
+import fs8 from "fs";
+import net2 from "net";
+import chalk10 from "chalk";
+import { bundleRequire as bundleRequire2 } from "bundle-require";
+
+// src/utils/console.ts
+import path7 from "path";
+import fs7 from "fs";
+import net from "net";
+import { spawn as spawn2 } from "child_process";
+var STUDIO_PATH = "/_studio";
+var VITE_PORT_START = 24678;
+function resolveConsolePath() {
+  const cwd = process.cwd();
+  const candidates = [
+    path7.resolve(cwd, "apps/console"),
+    path7.resolve(cwd, "../../apps/console"),
+    path7.resolve(cwd, "../apps/console")
+  ];
+  for (const candidate of candidates) {
+    const pkgPath = path7.join(candidate, "package.json");
+    if (fs7.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@objectstack/console") return candidate;
+      } catch {
+      }
+    }
+  }
+  try {
+    const { createRequire } = __require("module");
+    const req = createRequire(import.meta.url);
+    const resolved = req.resolve("@objectstack/console/package.json");
+    return path7.dirname(resolved);
+  } catch {
+    return null;
+  }
+}
+function hasConsoleDist(consolePath) {
+  return fs7.existsSync(path7.join(consolePath, "dist", "index.html"));
+}
+function findAvailablePort(start = VITE_PORT_START) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once("error", () => {
+      findAvailablePort(start + 1).then(resolve, reject);
+    });
+    server.once("listening", () => {
+      server.close(() => resolve(start));
+    });
+    server.listen(start);
+  });
+}
+async function spawnViteDevServer(consolePath, options = {}) {
+  const vitePort = await findAvailablePort(VITE_PORT_START);
+  const viteBinCandidates = [
+    path7.join(consolePath, "node_modules", ".bin", "vite"),
+    path7.join(consolePath, "..", "..", "node_modules", ".bin", "vite")
+  ];
+  let viteBin = null;
+  for (const candidate of viteBinCandidates) {
+    if (fs7.existsSync(candidate)) {
+      viteBin = candidate;
+      break;
+    }
+  }
+  const command = viteBin || "npx";
+  const args = viteBin ? ["--port", String(vitePort), "--strictPort"] : ["vite", "--port", String(vitePort), "--strictPort"];
+  const child = spawn2(command, args, {
+    cwd: consolePath,
+    env: {
+      ...process.env,
+      VITE_BASE: `${STUDIO_PATH}/`,
+      VITE_PORT: String(vitePort),
+      VITE_HMR_PORT: String(vitePort),
+      VITE_RUNTIME_MODE: "server",
+      VITE_SERVER_URL: "",
+      // Same-origin API
+      NODE_ENV: "development"
+    },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stderr = "";
+  child.stderr?.on("data", (data) => {
+    stderr += data.toString();
+  });
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      child.kill();
+      reject(new Error(`Vite dev server timed out after 30 s.
+${stderr}`));
+    }, 3e4);
+    child.stdout?.on("data", (data) => {
+      const output = data.toString();
+      if (output.includes("Local:") || output.includes("ready in")) {
+        clearTimeout(timeout);
+        resolve();
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+    child.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        clearTimeout(timeout);
+        reject(new Error(`Vite exited with code ${code}.
+${stderr}`));
+      }
+    });
+  });
+  return { port: vitePort, process: child };
+}
+function createConsoleProxyPlugin(vitePort) {
+  return {
+    name: "com.objectstack.console-proxy",
+    init: async () => {
+    },
+    start: async (ctx) => {
+      const httpServer = ctx.getService?.("http.server");
+      if (!httpServer?.getRawApp) {
+        ctx.logger?.warn?.("Console proxy: http.server service not found \u2014 skipping");
+        return;
+      }
+      const app = httpServer.getRawApp();
+      app.get(STUDIO_PATH, (c) => c.redirect(`${STUDIO_PATH}/`));
+      app.all(`${STUDIO_PATH}/*`, async (c) => {
+        const targetUrl = `http://localhost:${vitePort}${c.req.path}`;
+        try {
+          const headers = new Headers(c.req.raw.headers);
+          headers.delete("host");
+          const isBodyAllowed = !["GET", "HEAD"].includes(c.req.method);
+          const resp = await fetch(targetUrl, {
+            method: c.req.method,
+            headers,
+            body: isBodyAllowed ? c.req.raw.body : void 0,
+            // @ts-expect-error — duplex required for streaming request body
+            duplex: isBodyAllowed ? "half" : void 0
+          });
+          return new Response(resp.body, {
+            status: resp.status,
+            headers: resp.headers
+          });
+        } catch {
+          return c.text("Console dev server is starting\u2026", 502);
+        }
+      });
+    }
+  };
+}
+function createConsoleStaticPlugin(distPath) {
+  return {
+    name: "com.objectstack.console-static",
+    init: async () => {
+    },
+    start: async (ctx) => {
+      const httpServer = ctx.getService?.("http.server");
+      if (!httpServer?.getRawApp) {
+        ctx.logger?.warn?.("Console static: http.server service not found \u2014 skipping");
+        return;
+      }
+      const app = httpServer.getRawApp();
+      const absoluteDist = path7.resolve(distPath);
+      const indexPath = path7.join(absoluteDist, "index.html");
+      if (!fs7.existsSync(indexPath)) {
+        ctx.logger?.warn?.(`Console static: dist not found at ${absoluteDist}`);
+        return;
+      }
+      app.get(STUDIO_PATH, (c) => c.redirect(`${STUDIO_PATH}/`));
+      app.get(`${STUDIO_PATH}/*`, async (c) => {
+        const reqPath = c.req.path.substring(STUDIO_PATH.length) || "/";
+        const filePath = path7.join(absoluteDist, reqPath);
+        if (!filePath.startsWith(absoluteDist)) {
+          return c.text("Forbidden", 403);
+        }
+        if (fs7.existsSync(filePath) && fs7.statSync(filePath).isFile()) {
+          const content = fs7.readFileSync(filePath);
+          return new Response(content, {
+            headers: { "content-type": mimeType(filePath) }
+          });
+        }
+        const html = fs7.readFileSync(indexPath);
+        return new Response(html, {
+          headers: { "content-type": "text/html; charset=utf-8" }
+        });
+      });
+    }
+  };
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json"
+};
+function mimeType(filePath) {
+  const ext = path7.extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+
+// src/commands/serve.ts
+var getAvailablePort = async (startPort) => {
+  const isPortAvailable = (port2) => {
+    return new Promise((resolve) => {
+      const server = net2.createServer();
+      server.once("error", (err) => {
+        resolve(false);
+      });
+      server.once("listening", () => {
+        server.close(() => resolve(true));
+      });
+      server.listen(port2);
+    });
+  };
+  let port = startPort;
+  while (!await isPortAvailable(port)) {
+    port++;
+    if (port > startPort + 100) {
+      throw new Error(`Could not find an available port starting from ${startPort}`);
+    }
+  }
+  return port;
+};
+var serveCommand = new Command8("serve").description("Start ObjectStack server with plugins from configuration").argument("[config]", "Configuration file path", "objectstack.config.ts").option("-p, --port <port>", "Server port", "3000").option("--dev", "Run in development mode (load devPlugins)").option("--ui", "Enable Console UI at /_studio/").option("--no-server", "Skip starting HTTP server plugin").action(async (configPath, options) => {
+  let port = parseInt(options.port);
+  try {
+    const availablePort = await getAvailablePort(port);
+    if (availablePort !== port) {
+      port = availablePort;
+    }
+  } catch (e) {
+  }
+  const isDev = options.dev || process.env.NODE_ENV === "development";
+  const absolutePath = path8.resolve(process.cwd(), configPath);
+  const relativeConfig = path8.relative(process.cwd(), absolutePath);
+  if (!fs8.existsSync(absolutePath)) {
+    printError(`Configuration file not found: ${absolutePath}`);
+    console.log(chalk10.dim("  Hint: Run `objectstack init` to create a new project"));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(chalk10.dim(`  Loading ${relativeConfig}...`));
+  const loadedPlugins = [];
+  const shortPluginName = (raw) => {
+    if (raw.includes("objectql")) return "ObjectQL";
+    if (raw.includes("driver") && raw.includes("memory")) return "MemoryDriver";
+    if (raw.startsWith("plugin.app.")) return raw.replace("plugin.app.", "").split(".").pop() || raw;
+    if (raw.includes("hono")) return "HonoServer";
+    return raw;
+  };
+  const trackPlugin = (name) => {
+    loadedPlugins.push(shortPluginName(name));
+  };
+  const originalConsoleLog = console.log;
+  const originalConsoleDebug = console.debug;
+  const origStdoutWrite = process.stdout.write.bind(process.stdout);
+  let bootQuiet = false;
+  const restoreOutput = () => {
+    bootQuiet = false;
+    process.stdout.write = origStdoutWrite;
+    console.log = originalConsoleLog;
+    console.debug = originalConsoleDebug;
+  };
+  const portShifted = parseInt(options.port) !== port;
+  try {
+    bootQuiet = true;
+    process.stdout.write = (chunk, ...rest) => {
+      if (bootQuiet) return true;
+      return origStdoutWrite(chunk, ...rest);
+    };
+    console.log = (...args) => {
+      if (!bootQuiet) originalConsoleLog(...args);
+    };
+    console.debug = (...args) => {
+      if (!bootQuiet) originalConsoleDebug(...args);
+    };
+    const { mod } = await bundleRequire2({
+      filepath: absolutePath
+    });
+    const config = mod.default || mod;
+    if (!config) {
+      throw new Error(`No default export found in ${configPath}`);
+    }
+    const { Runtime } = await import("@objectstack/runtime");
+    const loggerConfig = { level: "silent" };
+    const runtime = new Runtime({
+      kernel: {
+        logger: loggerConfig
+      }
+    });
+    const kernel = runtime.getKernel();
+    let plugins = config.plugins || [];
+    if (options.dev && config.devPlugins) {
+      plugins = [...plugins, ...config.devPlugins];
+    }
+    const hasObjectQL = plugins.some((p) => p.name?.includes("objectql") || p.constructor?.name?.includes("ObjectQL"));
+    if (config.objects && !hasObjectQL) {
+      try {
+        const { ObjectQLPlugin } = await import("@objectstack/objectql");
+        await kernel.use(new ObjectQLPlugin());
+        trackPlugin("ObjectQL");
+      } catch (e) {
+      }
+    }
+    const hasDriver = plugins.some((p) => p.name?.includes("driver") || p.constructor?.name?.includes("Driver"));
+    if (isDev && !hasDriver && config.objects) {
+      try {
+        const { DriverPlugin } = await import("@objectstack/runtime");
+        const { InMemoryDriver } = await import("@objectstack/driver-memory");
+        await kernel.use(new DriverPlugin(new InMemoryDriver()));
+        trackPlugin("MemoryDriver");
+      } catch (e) {
+      }
+    }
+    if (config.objects || config.manifest || config.apps) {
+      try {
+        const { AppPlugin } = await import("@objectstack/runtime");
+        await kernel.use(new AppPlugin(config));
+        trackPlugin("App");
+      } catch (e) {
+      }
+    }
+    if (plugins.length > 0) {
+      for (const plugin of plugins) {
+        try {
+          let pluginToLoad = plugin;
+          if (typeof plugin === "string") {
+            try {
+              const imported = await import(plugin);
+              pluginToLoad = imported.default || imported;
+            } catch (importError) {
+              throw new Error(`Failed to import plugin '${plugin}': ${importError.message}`);
+            }
+          }
+          await kernel.use(pluginToLoad);
+          const pluginName = plugin.name || plugin.constructor?.name || "unnamed";
+          trackPlugin(pluginName);
+        } catch (e) {
+          console.error(chalk10.red(`  \u2717 Failed to load plugin: ${e.message}`));
+        }
+      }
+    }
+    if (options.server !== false) {
+      try {
+        const { HonoServerPlugin } = await import("@objectstack/plugin-hono-server");
+        const serverPlugin = new HonoServerPlugin({ port });
+        await kernel.use(serverPlugin);
+        trackPlugin("HonoServer");
+      } catch (e) {
+        console.warn(chalk10.yellow(`  \u26A0 HTTP server plugin not available: ${e.message}`));
+      }
+    }
+    let viteProcess = null;
+    if (options.ui) {
+      const consolePath = resolveConsolePath();
+      if (!consolePath) {
+        console.warn(chalk10.yellow(`  \u26A0 @objectstack/console not found \u2014 skipping UI`));
+      } else if (isDev) {
+        try {
+          const result = await spawnViteDevServer(consolePath, { serverPort: port });
+          viteProcess = result.process;
+          await kernel.use(createConsoleProxyPlugin(result.port));
+          trackPlugin("ConsoleUI");
+        } catch (e) {
+          console.warn(chalk10.yellow(`  \u26A0 Console UI failed to start: ${e.message}`));
+        }
+      } else {
+        const distPath = path8.join(consolePath, "dist");
+        if (hasConsoleDist(consolePath)) {
+          await kernel.use(createConsoleStaticPlugin(distPath));
+          trackPlugin("ConsoleUI");
+        } else {
+          console.warn(chalk10.yellow(`  \u26A0 Console dist not found \u2014 run "pnpm --filter @objectstack/console build" first`));
+        }
+      }
+    }
+    await runtime.start();
+    await new Promise((r) => setTimeout(r, 100));
+    restoreOutput();
+    printServerReady({
+      port,
+      configFile: relativeConfig,
+      isDev,
+      pluginCount: loadedPlugins.length,
+      pluginNames: loadedPlugins,
+      uiEnabled: !!options.ui,
+      studioPath: STUDIO_PATH
+    });
+    process.on("SIGINT", async () => {
+      console.warn(chalk10.yellow(`
+
+\u23F9  Stopping server...`));
+      if (viteProcess) {
+        viteProcess.kill();
+        viteProcess = null;
+      }
+      await runtime.getKernel().shutdown();
+      console.log(chalk10.green(`\u2705 Server stopped`));
+      process.exit(0);
+    });
+  } catch (error) {
+    restoreOutput();
+    console.log("");
+    printError(error.message || String(error));
+    if (process.env.DEBUG) console.error(chalk10.dim(error.stack));
+    process.exit(1);
+  }
+});
+
+// src/commands/test.ts
+import { Command as Command9 } from "commander";
+import chalk11 from "chalk";
+import path9 from "path";
+import fs9 from "fs";
+import { QA as CoreQA } from "@objectstack/core";
+var testCommand = new Command9("test").description("Run Quality Protocol test scenarios against a running server").argument("[files]", 'Glob pattern for test files (e.g. "qa/*.test.json")', "qa/*.test.json").option("--url <url>", "Target base URL", "http://localhost:3000").option("--token <token>", "Authentication token").action(async (filesPattern, options) => {
+  console.log(chalk11.bold(`
+\u{1F9EA} ObjectStack Quality Protocol Runner`));
+  console.log(chalk11.dim(`-------------------------------------`));
+  console.log(`Target: ${chalk11.blue(options.url)}`);
+  const adapter = new CoreQA.HttpTestAdapter(options.url, options.token);
+  const runner = new CoreQA.TestRunner(adapter);
+  const cwd = process.cwd();
+  const testFiles = [];
+  if (fs9.existsSync(filesPattern)) {
+    testFiles.push(filesPattern);
+  } else {
+    const dir = path9.dirname(filesPattern);
+    const ext = path9.extname(filesPattern);
+    if (fs9.existsSync(dir)) {
+      const files = fs9.readdirSync(dir).filter((f) => f.endsWith(ext) || f.endsWith(".json"));
+      files.forEach((f) => testFiles.push(path9.join(dir, f)));
+    }
+  }
+  if (testFiles.length === 0) {
+    console.warn(chalk11.yellow(`No test files found matching: ${filesPattern}`));
+    return;
+  }
+  console.log(`Found ${testFiles.length} test suites.`);
+  let totalPassed = 0;
+  let totalFailed = 0;
+  for (const file of testFiles) {
+    console.log(`
+\u{1F4C4} Running suite: ${chalk11.bold(path9.basename(file))}`);
+    try {
+      const content = fs9.readFileSync(file, "utf-8");
+      const suite = JSON.parse(content);
+      const results = await runner.runSuite(suite);
+      for (const result of results) {
+        const icon = result.passed ? "\u2705" : "\u274C";
+        console.log(`  ${icon} Scenario: ${result.scenarioId} (${result.duration}ms)`);
+        if (!result.passed) {
+          console.error(chalk11.red(`     Error: ${result.error}`));
+          result.steps.forEach((step) => {
+            if (!step.passed) {
+              console.error(chalk11.red(`     Step Failed: ${step.stepName}`));
+              if (step.output) console.error(`     Output:`, step.output);
+              if (step.error) console.error(`     Error:`, step.error);
+            }
+          });
+          totalFailed++;
+        } else {
+          totalPassed++;
+        }
+      }
+    } catch (e) {
+      console.error(chalk11.red(`Failed to load or run suite ${file}: ${e}`));
+      totalFailed++;
+    }
+  }
+  console.log(chalk11.dim(`
+-------------------------------------`));
+  if (totalFailed > 0) {
+    console.log(chalk11.red(`FAILED: ${totalFailed} scenarios failed. ${totalPassed} passed.`));
+    process.exit(1);
+  } else {
+    console.log(chalk11.green(`SUCCESS: All ${totalPassed} scenarios passed.`));
+    process.exit(0);
+  }
+});
+
+// src/commands/doctor.ts
+import { Command as Command10 } from "commander";
+import chalk12 from "chalk";
+import { execSync as execSync2 } from "child_process";
+import fs10 from "fs";
+import path10 from "path";
+var doctorCommand = new Command10("doctor").description("Check development environment health").option("-v, --verbose", "Show detailed information").action(async (options) => {
+  printHeader("Environment Health Check");
+  const results = [];
+  try {
+    const nodeVersion = process.version;
+    const majorVersion = parseInt(nodeVersion.slice(1).split(".")[0]);
+    if (majorVersion >= 18) {
+      results.push({
+        name: "Node.js",
+        status: "ok",
+        message: `Version ${nodeVersion}`
+      });
+    } else {
+      results.push({
+        name: "Node.js",
+        status: "error",
+        message: `Version ${nodeVersion} (requires >= 18.0.0)`,
+        fix: "Upgrade Node.js: https://nodejs.org"
+      });
+    }
+  } catch (error) {
+    results.push({
+      name: "Node.js",
+      status: "error",
+      message: "Not found",
+      fix: "Install Node.js: https://nodejs.org"
+    });
+  }
+  try {
+    const pnpmVersion = execSync2("pnpm -v", { encoding: "utf-8" }).trim();
+    results.push({
+      name: "pnpm",
+      status: "ok",
+      message: `Version ${pnpmVersion}`
+    });
+  } catch (error) {
+    results.push({
+      name: "pnpm",
+      status: "error",
+      message: "Not found",
+      fix: "Install pnpm: npm install -g pnpm@10.28.1"
+    });
+  }
+  try {
+    const tscVersion = execSync2("tsc -v", { encoding: "utf-8" }).trim();
+    results.push({
+      name: "TypeScript",
+      status: "ok",
+      message: tscVersion
+    });
+  } catch (error) {
+    results.push({
+      name: "TypeScript",
+      status: "warning",
+      message: "Not found in PATH",
+      fix: "Installed locally via pnpm"
+    });
+  }
+  const cwd = process.cwd();
+  const nodeModulesPath = path10.join(cwd, "node_modules");
+  if (fs10.existsSync(nodeModulesPath)) {
+    results.push({
+      name: "Dependencies",
+      status: "ok",
+      message: "Installed"
+    });
+  } else {
+    results.push({
+      name: "Dependencies",
+      status: "error",
+      message: "Not installed",
+      fix: "Run: pnpm install"
+    });
+  }
+  const specDistPath = path10.join(cwd, "packages/spec/dist");
+  if (fs10.existsSync(specDistPath)) {
+    results.push({
+      name: "@objectstack/spec",
+      status: "ok",
+      message: "Built"
+    });
+  } else {
+    results.push({
+      name: "@objectstack/spec",
+      status: "warning",
+      message: "Not built",
+      fix: "Run: pnpm --filter @objectstack/spec build"
+    });
+  }
+  try {
+    const gitVersion = execSync2("git --version", { encoding: "utf-8" }).trim();
+    results.push({
+      name: "Git",
+      status: "ok",
+      message: gitVersion
+    });
+  } catch (error) {
+    results.push({
+      name: "Git",
+      status: "warning",
+      message: "Not found",
+      fix: "Install Git for version control"
+    });
+  }
+  let hasErrors = false;
+  let hasWarnings = false;
+  console.log("");
+  results.forEach((result) => {
+    const padded = result.name.padEnd(20);
+    if (result.status === "ok") {
+      printSuccess(`${padded} ${result.message}`);
+    } else if (result.status === "warning") {
+      printWarning(`${padded} ${result.message}`);
+    } else {
+      printError(`${padded} ${result.message}`);
+    }
+    if (result.fix && (options.verbose || result.status === "error")) {
+      console.log(chalk12.dim(`      \u2192 ${result.fix}`));
+    }
+    if (result.status === "error") hasErrors = true;
+    if (result.status === "warning") hasWarnings = true;
+  });
+  console.log("");
+  if (hasErrors) {
+    console.log(chalk12.red("\u274C Some critical issues found. Please fix them before continuing."));
+    results.filter((r) => r.status === "error" && r.fix).forEach((r) => console.log(chalk12.dim(`   ${r.fix}`)));
+    process.exit(1);
+  } else if (hasWarnings) {
+    console.log(chalk12.yellow("\u26A0\uFE0F  Environment is functional but has some warnings."));
+    console.log(chalk12.dim("   Run with --verbose to see fix suggestions."));
+  } else {
+    console.log(chalk12.green("\u2705 Environment is healthy and ready for development!"));
+  }
+  console.log("");
+});
 export {
-  compileCommand
+  compileCommand,
+  createCommand,
+  devCommand,
+  doctorCommand,
+  generateCommand,
+  infoCommand,
+  initCommand,
+  serveCommand,
+  templates,
+  testCommand,
+  validateCommand
 };