@objectstack/cli 1.0.11 → 1.1.0

package/src/commands/init.ts

@@ -0,0 +1,313 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { printHeader, printSuccess, printError, printStep, printKV, printInfo } from '../utils/format.js';
+
+const TEMPLATES: Record<string, {
+  description: string;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+  scripts: Record<string, string>;
+  configContent: (name: string) => string;
+  srcFiles: Record<string, (name: string) => string>;
+}> = {
+  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: string) => `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: string) => `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: string) => `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: string): string {
+  return str.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+function toTitleCase(str: string): string {
+  return str.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+}
+
+export const initCommand = new Command('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 || path.basename(cwd);
+    const template = TEMPLATES[options.template];
+
+    if (!template) {
+      printError(`Unknown template: ${options.template}`);
+      console.log(chalk.dim(`  Available: ${Object.keys(TEMPLATES).join(', ')}`));
+      process.exit(1);
+    }
+
+    // Check for existing config
+    if (fs.existsSync(path.join(cwd, 'objectstack.config.ts'))) {
+      printError('objectstack.config.ts already exists in this directory');
+      console.log(chalk.dim('  Use `objectstack generate` to add metadata to an existing project'));
+      process.exit(1);
+    }
+
+    printKV('Project', projectName);
+    printKV('Template', `${options.template} — ${template.description}`);
+    printKV('Directory', cwd);
+    console.log('');
+
+    const createdFiles: string[] = [];
+
+    try {
+      // 1. Create package.json if missing
+      const pkgPath = path.join(cwd, 'package.json');
+      if (!fs.existsSync(pkgPath)) {
+        const pkg = {
+          name: projectName,
+          version: '0.1.0',
+          private: true,
+          type: 'module',
+          scripts: template.scripts,
+          dependencies: template.dependencies,
+          devDependencies: template.devDependencies,
+        };
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+        createdFiles.push('package.json');
+      } else {
+        printInfo('package.json already exists, skipping');
+      }
+
+      // 2. Create objectstack.config.ts
+      const configContent = template.configContent(projectName);
+      fs.writeFileSync(path.join(cwd, 'objectstack.config.ts'), configContent);
+      createdFiles.push('objectstack.config.ts');
+
+      // 3. Create tsconfig.json if missing
+      const tsconfigPath = path.join(cwd, 'tsconfig.json');
+      if (!fs.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'],
+        };
+        fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + '\n');
+        createdFiles.push('tsconfig.json');
+      }
+
+      // 4. Create src files
+      for (const [filePath, contentFn] of Object.entries(template.srcFiles)) {
+        const resolvedPath = filePath.replace('__name__', projectName);
+        const fullPath = path.join(cwd, resolvedPath);
+        const dir = path.dirname(fullPath);
+
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+
+        fs.writeFileSync(fullPath, contentFn(projectName));
+        createdFiles.push(resolvedPath);
+      }
+
+      // 5. Create .gitignore if missing
+      const gitignorePath = path.join(cwd, '.gitignore');
+      if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, `node_modules/\ndist/\n*.tsbuildinfo\n`);
+        createdFiles.push('.gitignore');
+      }
+
+      // Summary
+      console.log(chalk.bold('  Created files:'));
+      for (const f of createdFiles) {
+        console.log(chalk.green(`    + ${f}`));
+      }
+      console.log('');
+
+      // Install dependencies
+      if (options.install !== false) {
+        printStep('Installing dependencies...');
+        const { execSync } = await import('child_process');
+        try {
+          execSync('pnpm install', { stdio: 'inherit', cwd });
+        } catch {
+          printWarning('Dependency installation failed. Run `pnpm install` manually.');
+        }
+      }
+
+      printSuccess('Project initialized!');
+      console.log('');
+      console.log(chalk.bold('  Next steps:'));
+      console.log(chalk.dim('    objectstack validate   # Check configuration'));
+      console.log(chalk.dim('    objectstack dev        # Start development server'));
+      console.log(chalk.dim('    objectstack generate   # Add objects, views, etc.'));
+      console.log('');
+
+    } catch (error: any) {
+      printError(error.message || String(error));
+      process.exit(1);
+    }
+  });
+
+function printWarning(msg: string) {
+  console.log(chalk.yellow(`  ⚠ ${msg}`));
+}

package/src/commands/serve.ts

@@ -4,6 +4,24 @@ import fs from 'fs';
 import net from 'net';
 import chalk from 'chalk';
 import { bundleRequire } from 'bundle-require';
+import { loadConfig } from '../utils/config.js';
+import {
+  printHeader,
+  printKV,
+  printSuccess,
+  printError,
+  printStep,
+  printInfo,
+  printServerReady,
+} from '../utils/format.js';
+import {
+  STUDIO_PATH,
+  resolveConsolePath,
+  hasConsoleDist,
+  spawnViteDevServer,
+  createConsoleProxyPlugin,
+  createConsoleStaticPlugin,
+} from '../utils/console.js';
 
 // Helper to find available port
 const getAvailablePort = async (startPort: number): Promise<number> => {
@@ -35,6 +53,7 @@ export const serveCommand = new Command('serve')
   .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);
@@ -44,30 +63,67 @@ export const serveCommand = new Command('serve')
         port = availablePort;
       }
     } catch (e) {
-      // Ignore error and try with original port, or let it fail later
+      // Ignore error and try with original port
     }
 
-    console.log(chalk.bold(`\n🚀 ObjectStack Server`));
-    console.log(chalk.dim(`------------------------`));
-    console.log(`📂 Config: ${chalk.blue(configPath)}`);
-    if (parseInt(options.port) !== port) {
-      console.log(`🌐 Port: ${chalk.blue(port)} ${chalk.yellow(`(requested: ${options.port} in use)`)}`);
-    } else {
-      console.log(`🌐 Port: ${chalk.blue(port)}`);
-    }
-    console.log('');
-
+    const isDev = options.dev || process.env.NODE_ENV === 'development';
 
     const absolutePath = path.resolve(process.cwd(), configPath);
+    const relativeConfig = path.relative(process.cwd(), absolutePath);
     
     if (!fs.existsSync(absolutePath)) {
-      console.error(chalk.red(`\n❌ Configuration file not found: ${absolutePath}`));
+      printError(`Configuration file not found: ${absolutePath}`);
+      console.log(chalk.dim('  Hint: Run `objectstack init` to create a new project'));
       process.exit(1);
     }
 
+    // Quiet loading — only show a single spinner line
+    console.log('');
+    console.log(chalk.dim(`  Loading ${relativeConfig}...`));
+
+    // Track loaded plugins for summary
+    const loadedPlugins: string[] = [];
+    const shortPluginName = (raw: string) => {
+      // Map verbose internal IDs to short display names
+      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: string) => { loadedPlugins.push(shortPluginName(name)); };
+
+    // Save original console/stdout methods — we'll suppress noise during boot
+    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 {
+      // ── Suppress ALL runtime noise during boot ────────────────────
+      // Multiple sources write to stdout during startup:
+      //   • Pino-pretty (direct process.stdout.write)
+      //   • ObjectLogger browser fallback (console.log)
+      //   • SchemaRegistry (console.log)
+      // We capture stdout entirely, then restore after runtime.start().
+      bootQuiet = true;
+      process.stdout.write = (chunk: any, ...rest: any[]) => {
+        if (bootQuiet) return true;  // swallow
+        return (origStdoutWrite as any)(chunk, ...rest);
+      };
+      console.log = (...args: any[]) => { if (!bootQuiet) originalConsoleLog(...args); };
+      console.debug = (...args: any[]) => { if (!bootQuiet) originalConsoleDebug(...args); };
+
       // Load configuration
-      console.log(chalk.yellow(`📦 Loading configuration...`));
       const { mod } = await bundleRequire({
         filepath: absolutePath,
       });
@@ -75,20 +131,14 @@ export const serveCommand = new Command('serve')
       const config = mod.default || mod;
 
       if (!config) {
-        throw new Error(`Default export not found in ${configPath}`);
+        throw new Error(`No default export found in ${configPath}`);
       }
 
-      console.log(chalk.green(`✓ Configuration loaded`));
-
       // Import ObjectStack runtime
       const { Runtime } = await import('@objectstack/runtime');
-      
-      // Create runtime instance
-      console.log(chalk.yellow(`🔧 Initializing ObjectStack runtime...`));
-      
-      // Auto-configure pretty logging in development mode
-      const isDev = options.dev || process.env.NODE_ENV === 'development';
-      const loggerConfig = isDev ? { format: 'pretty' } : undefined;
+
+      // Set kernel logger to 'silent' — the CLI manages its own output
+      const loggerConfig = { level: 'silent' as const };
 
       const runtime = new Runtime({
         kernel: {
@@ -102,7 +152,6 @@ export const serveCommand = new Command('serve')
 
       // Merge devPlugins if in dev mode
       if (options.dev && config.devPlugins) {
-        console.log(chalk.blue(`📦 Loading development plugins...`));
         plugins = [...plugins, ...config.devPlugins];
       }
 
@@ -110,12 +159,11 @@ export const serveCommand = new Command('serve')
       const hasObjectQL = plugins.some((p: any) => p.name?.includes('objectql') || p.constructor?.name?.includes('ObjectQL'));
       if (config.objects && !hasObjectQL) {
          try {
-           console.log(chalk.dim(`  Auto-injecting ObjectQL Engine...`));
            const { ObjectQLPlugin } = await import('@objectstack/objectql');
            await kernel.use(new ObjectQLPlugin());
-           console.log(chalk.green(`  ✓ Registered ObjectQL Plugin (auto-detected)`));
+           trackPlugin('ObjectQL');
          } catch (e: any) {
-           console.warn(chalk.yellow(`  ⚠ Could not auto-load ObjectQL: ${e.message}`));
+           // silent
          }
       }
 
@@ -123,14 +171,12 @@ export const serveCommand = new Command('serve')
       const hasDriver = plugins.some((p: any) => p.name?.includes('driver') || p.constructor?.name?.includes('Driver'));
       if (isDev && !hasDriver && config.objects) {
          try {
-           console.log(chalk.dim(`  Auto-injecting Memory Driver (Dev Mode)...`));
            const { DriverPlugin } = await import('@objectstack/runtime');
            const { InMemoryDriver } = await import('@objectstack/driver-memory');
            await kernel.use(new DriverPlugin(new InMemoryDriver()));
-           console.log(chalk.green(`  ✓ Registered Memory Driver (auto-detected)`));
+           trackPlugin('MemoryDriver');
          } catch (e: any) {
-           // Silent fail - maybe they don't want a driver or don't have the package
-           console.log(chalk.dim(`  ℹ No default driver loaded: ${e.message}`));
+           // silent
          }
       }
 
@@ -139,38 +185,33 @@ export const serveCommand = new Command('serve')
         try {
            const { AppPlugin } = await import('@objectstack/runtime');
            await kernel.use(new AppPlugin(config));
-           console.log(chalk.green(`  ✓ Registered App Plugin (auto-detected)`));
+           trackPlugin('App');
         } catch (e: any) {
-           console.warn(chalk.yellow(`  ⚠ Could not auto-load AppPlugin: ${e.message}`));
+           // silent
         }
       }
 
       
       if (plugins.length > 0) {
-        console.log(chalk.yellow(`📦 Loading ${plugins.length} plugin(s)...`));
-        
         for (const plugin of plugins) {
           try {
             let pluginToLoad = plugin;
 
             // Resolve string references (package names)
             if (typeof plugin === 'string') {
-              console.log(chalk.dim(`  Trying to resolve plugin: ${plugin}`));
               try {
-                // Try dynamic import for packages
                  const imported = await import(plugin);
                  pluginToLoad = imported.default || imported;
               } catch (importError: any) {
-                 // Fallback: try bundleRequire for local paths if needed, otherwise throw
                  throw new Error(`Failed to import plugin '${plugin}': ${importError.message}`);
               }
             }
 
             await kernel.use(pluginToLoad);
             const pluginName = plugin.name || plugin.constructor?.name || 'unnamed';
-            console.log(chalk.green(`  ✓ Registered plugin: ${pluginName}`));
+            trackPlugin(pluginName);
           } catch (e: any) {
-            console.error(chalk.red(`  ✗ Failed to register plugin: ${e.message}`));
+            console.error(chalk.red(`  ✗ Failed to load plugin: ${e.message}`));
           }
         }
       }
@@ -181,31 +222,76 @@ export const serveCommand = new Command('serve')
           const { HonoServerPlugin } = await import('@objectstack/plugin-hono-server');
           const serverPlugin = new HonoServerPlugin({ port });
           await kernel.use(serverPlugin);
-          console.log(chalk.green(`  ✓ Registered HTTP server plugin (port: ${port})`));
+          trackPlugin('HonoServer');
         } catch (e: any) {
           console.warn(chalk.yellow(`  ⚠ HTTP server plugin not available: ${e.message}`));
         }
       }
 
+      // ── Console UI (--ui) ───────────────────────────────────────────
+      let viteProcess: import('child_process').ChildProcess | null = null;
+
+      if (options.ui) {
+        const consolePath = resolveConsolePath();
+        if (!consolePath) {
+          console.warn(chalk.yellow(`  ⚠ @objectstack/console not found — skipping UI`));
+        } else if (isDev) {
+          // Dev mode → spawn Vite dev server & proxy through Hono
+          try {
+            const result = await spawnViteDevServer(consolePath, { serverPort: port });
+            viteProcess = result.process;
+            await kernel.use(createConsoleProxyPlugin(result.port));
+            trackPlugin('ConsoleUI');
+          } catch (e: any) {
+            console.warn(chalk.yellow(`  ⚠ Console UI failed to start: ${e.message}`));
+          }
+        } else {
+          // Production mode → serve pre-built static files
+          const distPath = path.join(consolePath, 'dist');
+          if (hasConsoleDist(consolePath)) {
+            await kernel.use(createConsoleStaticPlugin(distPath));
+            trackPlugin('ConsoleUI');
+          } else {
+            console.warn(chalk.yellow(`  ⚠ Console dist not found — run "pnpm --filter @objectstack/console build" first`));
+          }
+        }
+      }
+
       // Boot the runtime
-      console.log(chalk.yellow(`\n🚀 Starting ObjectStack...`));
       await runtime.start();
 
-      console.log(chalk.green(`\n✅ ObjectStack server is running!`));
-      console.log(chalk.dim(`   Press Ctrl+C to stop\n`));
+      // Wait briefly for pino worker thread buffers to flush, then restore
+      await new Promise(r => setTimeout(r, 100));
+      restoreOutput();
+
+      // ── Clean startup summary ──────────────────────────────────────
+      printServerReady({
+        port,
+        configFile: relativeConfig,
+        isDev,
+        pluginCount: loadedPlugins.length,
+        pluginNames: loadedPlugins,
+        uiEnabled: !!options.ui,
+        studioPath: STUDIO_PATH,
+      });
 
       // Keep process alive
       process.on('SIGINT', async () => {
-        console.log(chalk.yellow(`\n\n⏹  Stopping server...`));
+        console.warn(chalk.yellow(`\n\n⏹  Stopping server...`));
+        if (viteProcess) {
+          viteProcess.kill();
+          viteProcess = null;
+        }
         await runtime.getKernel().shutdown();
         console.log(chalk.green(`✅ Server stopped`));
         process.exit(0);
       });
 
     } catch (error: any) {
-      console.error(chalk.red(`\n❌ Server Error:`));
-      console.error(error.message || error);
-      console.error(error.stack);
+      restoreOutput();
+      console.log('');
+      printError(error.message || String(error));
+      if (process.env.DEBUG) console.error(chalk.dim(error.stack));
       process.exit(1);
     }
   });

package/src/commands/studio.ts

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { printHeader, printKV, printStep } from '../utils/format.js';
+
+/**
+ * `objectstack studio` — Launch the ObjectStack Console UI.
+ *
+ * Alias for `objectstack serve --dev --ui`.
+ * Starts the ObjectStack server in development mode with the Console
+ * UI available at http://localhost:<port>/_studio/
+ */
+export const studioCommand = new Command('studio')
+  .description('Launch Console UI with development server')
+  .argument('[config]', 'Configuration file path', 'objectstack.config.ts')
+  .option('-p, --port <port>', 'Server port', '3000')
+  .action(async (configPath, options) => {
+    printHeader('Studio');
+    printKV('Mode', 'dev + ui', '🎨');
+    printStep('Delegating to serve --dev --ui …');
+    console.log('');
+
+    // Delegate to the serve command with --dev --ui flags
+    const binPath = process.argv[1];
+    const args = [
+      binPath,
+      'serve',
+      configPath,
+      '--dev',
+      '--ui',
+      '--port', options.port,
+    ];
+
+    const child = spawn(process.execPath, args, {
+      stdio: 'inherit',
+      env: { ...process.env, NODE_ENV: 'development' },
+    });
+
+    child.on('exit', (code) => process.exit(code ?? 0));
+  });

package/src/commands/test.ts

@@ -5,8 +5,8 @@ import fs from 'fs';
 import { QA as CoreQA } from '@objectstack/core';
 import { QA } from '@objectstack/spec';
 
-export const testCommand = new Command('test:run')
-  .description('Run Quality Protocol test scenarios')
+export const testCommand = new Command('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')