@nitrostack/cli 1.0.0

package/README.md

@@ -0,0 +1,131 @@
+# @nitrostack/cli
+
+Command-line interface for creating NitroStack MCP server projects.
+
+## Installation
+
+```bash
+# Use npm create (recommended)
+npm create nitrostack my-project
+
+# Or use npx
+npx create-nitrostack my-project
+
+# Or install globally
+npm install -g @nitrostack/cli
+create-nitrostack my-project
+```
+
+> **Note:** Once a project is created, use the `nitrostack` command from the main `nitrostack` package for development commands (`dev`, `build`, `start`, etc.).
+
+## Commands
+
+### `nitrostack init [project-name]`
+
+Create a new NitroStack project from a template.
+
+```bash
+nitrostack init my-mcp-server
+```
+
+**Options:**
+- `--template <template>` - Template to use (typescript-starter, typescript-pizzaz, typescript-oauth)
+- `--skip-install` - Skip installing dependencies
+
+### `nitrostack dev`
+
+Start development server with hot reload and NitroStack Studio.
+
+```bash
+nitrostack dev
+```
+
+**Options:**
+- `--port <port>` - Port for Studio (default: 3000)
+- `--no-open` - Don't open browser automatically
+
+### `nitrostack build`
+
+Build the project for production.
+
+```bash
+nitrostack build
+```
+
+**Options:**
+- `--output <path>` - Output directory (default: dist)
+
+### `nitrostack start`
+
+Start the production server.
+
+```bash
+nitrostack start
+```
+
+**Options:**
+- `--port <port>` - Port for server (default: 3000)
+
+### `nitrostack generate <type> [name]`
+
+Generate boilerplate code.
+
+```bash
+nitrostack generate module users
+nitrostack g tools payment
+```
+
+**Types:**
+- `module` - Create a new module with tools, resources, prompts
+- `tools` - Generate tool definitions
+- `resources` - Generate resource definitions
+- `prompts` - Generate prompt definitions
+- `service` - Generate a service class
+- `guard` - Generate an auth guard
+- `middleware` - Generate middleware
+- `health` - Generate health check
+
+**Options:**
+- `--module <name>` - Module name for module-specific generation
+- `--force` - Overwrite existing files
+- `--skip-related` - Skip generating related files
+
+### `nitrostack upgrade`
+
+Upgrade nitrostack to the latest version.
+
+```bash
+nitrostack upgrade
+```
+
+**Options:**
+- `--dry-run` - Show what would be upgraded without making changes
+- `--latest` - Force upgrade even if already up to date
+
+### `nitrostack install`
+
+Install dependencies in both root and widget directories.
+
+```bash
+nitrostack install
+```
+
+**Options:**
+- `--skip-widgets` - Skip installing widget dependencies
+- `--production` - Install production dependencies only
+
+## Templates
+
+### typescript-starter
+Simple calculator example for learning NitroStack basics.
+
+### typescript-pizzaz  
+Pizza shop finder with maps, widgets, and advanced features.
+
+### typescript-oauth
+Flight booking system with OAuth 2.1 authentication.
+
+## License
+
+Apache-2.0
+

package/dist/commands/build.d.ts

@@ -0,0 +1,6 @@
+interface BuildOptions {
+    output: string;
+}
+export declare function buildCommand(options: BuildOptions): Promise<void>;
+export {};
+//# sourceMappingURL=build.d.ts.map

package/dist/commands/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/commands/build.ts"],"names":[],"mappings":"AAeA,UAAU,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,iBA0MvD"}

package/dist/commands/build.js

@@ -0,0 +1,185 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import * as esbuild from 'esbuild';
+import { createHeader, createSuccessBox, createErrorBox, NitroSpinner, spacer, nextSteps } from '../ui/branding.js';
+export async function buildCommand(options) {
+    console.log(createHeader('Build', 'Production bundle'));
+    const startTime = Date.now();
+    // Validate project
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        console.log(createErrorBox('Not a NitroStack Project', 'package.json not found'));
+        process.exit(1);
+    }
+    const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+        console.log(createErrorBox('Missing Configuration', 'tsconfig.json not found'));
+        process.exit(1);
+    }
+    // Detect widgets
+    const widgetsPath = path.resolve(process.cwd(), 'src/widgets');
+    const widgetsPackageJsonPath = path.join(widgetsPath, 'package.json');
+    const hasWidgets = fs.existsSync(widgetsPackageJsonPath);
+    const buildArtifacts = [];
+    try {
+        // Build widgets first if they exist
+        if (hasWidgets) {
+            // Install dependencies if needed
+            const widgetsNodeModulesPath = path.join(widgetsPath, 'node_modules');
+            if (!fs.existsSync(widgetsNodeModulesPath)) {
+                const depsSpinner = new NitroSpinner('Installing widget dependencies...').start();
+                try {
+                    execSync('npm install', { cwd: widgetsPath, stdio: 'pipe' });
+                    depsSpinner.succeed('Widget dependencies installed');
+                }
+                catch {
+                    depsSpinner.fail('Failed to install widget dependencies');
+                    throw new Error('Widget dependency installation failed');
+                }
+            }
+            const widgetSpinner = new NitroSpinner('Bundling widgets...').start();
+            try {
+                const APP_DIR = path.join(widgetsPath, 'app');
+                const OUT_DIR = path.join(widgetsPath, 'out');
+                // Clean output directory
+                if (fs.existsSync(OUT_DIR)) {
+                    fs.rmSync(OUT_DIR, { recursive: true });
+                }
+                fs.mkdirSync(OUT_DIR, { recursive: true });
+                // Find all widget pages
+                const widgetPages = [];
+                function findWidgetPages(dir, basePath = '') {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const fullPath = path.join(dir, entry.name);
+                        const relativePath = path.join(basePath, entry.name);
+                        if (entry.isDirectory()) {
+                            findWidgetPages(fullPath, relativePath);
+                        }
+                        else if (entry.name === 'page.tsx' || entry.name === 'page.jsx') {
+                            const widgetName = basePath || 'index';
+                            widgetPages.push({
+                                name: widgetName,
+                                entryPoint: fullPath,
+                                outputName: widgetName.replace(/\//g, '-')
+                            });
+                        }
+                    }
+                }
+                if (fs.existsSync(APP_DIR)) {
+                    findWidgetPages(APP_DIR);
+                }
+                // Bundle each widget
+                for (const widget of widgetPages) {
+                    const tempEntry = path.join(OUT_DIR, `_temp_${widget.outputName}.jsx`);
+                    const jsOutput = path.join(OUT_DIR, `${widget.outputName}.js`);
+                    const htmlOutput = path.join(OUT_DIR, `${widget.outputName}.html`);
+                    const entryCode = `
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import WidgetPage from '${widget.entryPoint.replace(/\\/g, '/')}';
+
+if (document.readyState === 'loading') {
+  document.addEventListener('DOMContentLoaded', init);
+} else {
+  init();
+}
+
+function init() {
+  const data = window.openai?.toolOutput || {};
+  
+  let root = document.getElementById('widget-root');
+  if (!root) {
+    root = document.createElement('div');
+    root.id = 'widget-root';
+    document.body.appendChild(root);
+  }
+  
+  const reactRoot = createRoot(root);
+  reactRoot.render(React.createElement(WidgetPage, { data }));
+}
+`;
+                    fs.writeFileSync(tempEntry, entryCode);
+                    await esbuild.build({
+                        entryPoints: [tempEntry],
+                        bundle: true,
+                        format: 'iife',
+                        outfile: jsOutput,
+                        platform: 'browser',
+                        target: ['es2020'],
+                        minify: true,
+                        jsx: 'automatic',
+                        jsxImportSource: 'react',
+                        external: [],
+                        nodePaths: [path.join(widgetsPath, 'node_modules')],
+                        define: {
+                            'process.env.NODE_ENV': '"production"'
+                        },
+                        logLevel: 'warning'
+                    });
+                    const bundledJs = fs.readFileSync(jsOutput, 'utf-8');
+                    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    * { box-sizing: border-box; }
+    body { 
+      margin: 0; 
+      padding: 0; 
+      font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+    }
+    #widget-root {
+      width: 100%;
+      min-height: 100vh;
+    }
+  </style>
+</head>
+<body>
+  <div id="widget-root"></div>
+  <script>${bundledJs}</script>
+</body>
+</html>`;
+                    fs.writeFileSync(htmlOutput, html);
+                    fs.unlinkSync(tempEntry);
+                    fs.unlinkSync(jsOutput);
+                }
+                widgetSpinner.succeed(`Widgets bundled (${widgetPages.length} widgets)`);
+                buildArtifacts.push(`src/widgets/out/ (${widgetPages.length} widgets)`);
+            }
+            catch (error) {
+                widgetSpinner.fail('Widget bundling failed');
+                throw error;
+            }
+        }
+        // Build TypeScript
+        const tscSpinner = new NitroSpinner('Compiling TypeScript...').start();
+        try {
+            execSync('npx tsc', {
+                cwd: process.cwd(),
+                stdio: 'pipe',
+            });
+            tscSpinner.succeed('TypeScript compiled');
+            buildArtifacts.push(options.output);
+        }
+        catch (error) {
+            tscSpinner.fail('TypeScript compilation failed');
+            throw error;
+        }
+        // Summary
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        spacer();
+        console.log(createSuccessBox(`Build Complete (${elapsed}s)`, buildArtifacts));
+        nextSteps([
+            'npm start       - Start production server',
+            'nitrostack start - Alternative start command',
+        ]);
+    }
+    catch (error) {
+        spacer();
+        console.log(createErrorBox('Build Failed', error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}

package/dist/commands/dev.d.ts

@@ -0,0 +1,7 @@
+interface DevOptions {
+    port: string;
+    noOpen?: boolean;
+}
+export declare function devCommand(options: DevOptions): Promise<void>;
+export {};
+//# sourceMappingURL=dev.d.ts.map

package/dist/commands/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/commands/dev.ts"],"names":[],"mappings":"AA+LA,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,UAAU,iBAgPnD"}