@nitrostack/cli 1.0.0

package/dist/commands/install.d.ts

@@ -0,0 +1,10 @@
+interface InstallOptions {
+    skipWidgets?: boolean;
+    production?: boolean;
+}
+/**
+ * Main install command handler
+ */
+export declare function installCommand(options: InstallOptions): Promise<void>;
+export {};
+//# sourceMappingURL=install.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/commands/install.ts"],"names":[],"mappings":"AAcA,UAAU,cAAc;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAoBD;;GAEG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA+D3E"}

package/dist/commands/install.js

@@ -0,0 +1,80 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs-extra';
+import { createHeader, createSuccessBox, createErrorBox, NitroSpinner, log, spacer, nextSteps } from '../ui/branding.js';
+/**
+ * Run npm install silently
+ */
+function runNpmInstall(directory, production) {
+    const args = production ? ['install', '--production'] : ['install'];
+    execSync(`npm ${args.join(' ')}`, {
+        cwd: directory,
+        stdio: 'pipe',
+    });
+}
+/**
+ * Check if a directory has a package.json
+ */
+function hasPackageJson(directory) {
+    return fs.existsSync(path.join(directory, 'package.json'));
+}
+/**
+ * Main install command handler
+ */
+export async function installCommand(options) {
+    console.log(createHeader('Install', 'Install project dependencies'));
+    const projectRoot = process.cwd();
+    const rootPackageJsonPath = path.join(projectRoot, 'package.json');
+    const widgetsPath = path.join(projectRoot, 'src', 'widgets');
+    // Validate project
+    if (!fs.existsSync(rootPackageJsonPath)) {
+        console.log(createErrorBox('Not a Valid Project', 'package.json not found'));
+        process.exit(1);
+    }
+    const production = options.production ?? false;
+    const skipWidgets = options.skipWidgets ?? false;
+    if (production) {
+        log('Production mode - dev dependencies will be skipped', 'info');
+        spacer();
+    }
+    const installed = [];
+    // Install root dependencies
+    const rootSpinner = new NitroSpinner('Installing root dependencies...').start();
+    try {
+        runNpmInstall(projectRoot, production);
+        rootSpinner.succeed('Root dependencies installed');
+        installed.push('Root project');
+    }
+    catch (error) {
+        rootSpinner.fail('Failed to install root dependencies');
+        console.log(createErrorBox('Installation Failed', error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+    // Install widget dependencies if they exist
+    if (!skipWidgets && hasPackageJson(widgetsPath)) {
+        const widgetsSpinner = new NitroSpinner('Installing widget dependencies...').start();
+        try {
+            runNpmInstall(widgetsPath, production);
+            widgetsSpinner.succeed('Widget dependencies installed');
+            installed.push('Widgets (src/widgets)');
+        }
+        catch (error) {
+            widgetsSpinner.fail('Failed to install widget dependencies');
+            log(error instanceof Error ? error.message : String(error), 'dim');
+        }
+    }
+    else if (!skipWidgets) {
+        log('No widgets directory found', 'dim');
+    }
+    else {
+        log('Widgets skipped (--skip-widgets)', 'dim');
+    }
+    // Summary
+    spacer();
+    console.log(createSuccessBox('Installation Complete', installed));
+    nextSteps([
+        'npm run dev     - Start development server',
+        'npm run build   - Build for production',
+        'npm run upgrade - Upgrade nitrostack',
+    ]);
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,6 @@
+interface StartOptions {
+    port?: string;
+}
+export declare function startCommand(options: StartOptions): Promise<void>;
+export {};
+//# sourceMappingURL=start.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/commands/start.ts"],"names":[],"mappings":"AAaA,UAAU,YAAY;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,iBA4EvD"}

package/dist/commands/start.js

@@ -0,0 +1,70 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { createHeader, createInfoBox, createErrorBox, log, spacer, brand } from '../ui/branding.js';
+export async function startCommand(options) {
+    console.log(createHeader('Start', 'Production mode'));
+    const port = options.port || '3000';
+    // Check if dist/index.js exists
+    const distIndexPath = path.join(process.cwd(), 'dist', 'index.js');
+    if (!fs.existsSync(distIndexPath)) {
+        console.log(createErrorBox('Build Required', 'Run npm run build first'));
+        spacer();
+        log('npm run build', 'dim');
+        process.exit(1);
+    }
+    // Auto-detect widgets
+    const widgetsOutPath = path.join(process.cwd(), 'src', 'widgets', 'out');
+    const hasBuiltWidgets = fs.existsSync(widgetsOutPath);
+    if (!hasBuiltWidgets) {
+        const widgetsPackageJsonPath = path.join(process.cwd(), 'src', 'widgets', 'package.json');
+        if (fs.existsSync(widgetsPackageJsonPath)) {
+            log('Widgets not built - run npm run build to include widgets', 'warning');
+            spacer();
+        }
+    }
+    // Show server info
+    console.log(createInfoBox([
+        { label: 'Server', value: `http://localhost:${port}` },
+        { label: 'Mode', value: 'Production' },
+        { label: 'Transport', value: 'HTTP + STDIO (dual)' },
+        ...(hasBuiltWidgets ? [{ label: 'Widgets', value: 'Bundled' }] : []),
+    ]));
+    log('Starting server...', 'info');
+    spacer();
+    // Start the MCP server
+    const serverProcess = spawn('node', [distIndexPath], {
+        cwd: process.cwd(),
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            NODE_ENV: 'production',
+            PORT: port,
+        },
+    });
+    // Handle process exit
+    serverProcess.on('exit', (code) => {
+        if (code !== 0) {
+            console.log(createErrorBox('Server Crashed', `Exit code: ${code}`));
+            process.exit(code || 1);
+        }
+    });
+    // Handle graceful shutdown
+    const shutdown = () => {
+        spacer();
+        console.log(brand.accentBold('┌──────────────────────────────────────────────────────────────────┐'));
+        console.log(brand.accentBold('│') + chalk.yellow.bold('                       Shutting down...                          ') + brand.accentBold('│'));
+        console.log(brand.accentBold('└──────────────────────────────────────────────────────────────────┘'));
+        serverProcess.kill('SIGTERM');
+        setTimeout(() => {
+            serverProcess.kill('SIGKILL');
+            console.log(chalk.dim('\nGoodbye! 👋\n'));
+            process.exit(0);
+        }, 5000);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    // Keep process alive
+    await new Promise(() => { });
+}

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,10 @@
+interface UpgradeOptions {
+    latest?: boolean;
+    dryRun?: boolean;
+}
+/**
+ * Main upgrade command handler
+ */
+export declare function upgradeCommand(options: UpgradeOptions): Promise<void>;
+export {};
+//# sourceMappingURL=upgrade.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../src/commands/upgrade.ts"],"names":[],"mappings":"AAsBA,UAAU,cAAc;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AA2GD;;GAEG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA8I3E"}

package/dist/commands/upgrade.js

@@ -0,0 +1,214 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs-extra';
+import { createHeader, createSuccessBox, createErrorBox, NitroSpinner, log, spacer, nextSteps, brand } from '../ui/branding.js';
+/**
+ * Get the latest version of nitrostack from npm registry
+ */
+function getLatestVersion() {
+    try {
+        const result = execSync('npm view nitrostack version', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return result;
+    }
+    catch {
+        throw new Error('Failed to fetch latest version from npm');
+    }
+}
+/**
+ * Get the current installed version of nitrostack from package.json
+ */
+function getCurrentVersion(packageJsonPath) {
+    if (!fs.existsSync(packageJsonPath)) {
+        return null;
+    }
+    const packageJson = fs.readJSONSync(packageJsonPath);
+    const version = packageJson.dependencies?.nitrostack ||
+        packageJson.devDependencies?.nitrostack;
+    return version || null;
+}
+/**
+ * Parse version string to extract the actual version number
+ */
+function parseVersion(versionString) {
+    return versionString.replace(/^[\^~>=<]+/, '');
+}
+/**
+ * Compare two version strings
+ */
+function compareVersions(v1, v2) {
+    const parts1 = parseVersion(v1).split('.').map(Number);
+    const parts2 = parseVersion(v2).split('.').map(Number);
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const p1 = parts1[i] || 0;
+        const p2 = parts2[i] || 0;
+        if (p1 > p2)
+            return 1;
+        if (p1 < p2)
+            return -1;
+    }
+    return 0;
+}
+/**
+ * Update nitrostack version in package.json
+ */
+function updatePackageJson(packageJsonPath, newVersion, dryRun) {
+    if (!fs.existsSync(packageJsonPath)) {
+        return false;
+    }
+    const packageJson = fs.readJSONSync(packageJsonPath);
+    let updated = false;
+    if (packageJson.dependencies?.nitrostack) {
+        packageJson.dependencies.nitrostack = `^${newVersion}`;
+        updated = true;
+    }
+    if (packageJson.devDependencies?.nitrostack) {
+        packageJson.devDependencies.nitrostack = `^${newVersion}`;
+        updated = true;
+    }
+    if (updated && !dryRun) {
+        fs.writeJSONSync(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    return updated;
+}
+/**
+ * Run npm install silently
+ */
+function runNpmInstall(directory) {
+    execSync('npm install', {
+        cwd: directory,
+        stdio: 'pipe',
+    });
+}
+/**
+ * Main upgrade command handler
+ */
+export async function upgradeCommand(options) {
+    console.log(createHeader('Upgrade', 'Update nitrostack to the latest version'));
+    const projectRoot = process.cwd();
+    const rootPackageJsonPath = path.join(projectRoot, 'package.json');
+    const widgetsPath = path.join(projectRoot, 'src', 'widgets');
+    const widgetsPackageJsonPath = path.join(widgetsPath, 'package.json');
+    // Validate project
+    if (!fs.existsSync(rootPackageJsonPath)) {
+        console.log(createErrorBox('Not a NitroStack Project', 'package.json not found'));
+        process.exit(1);
+    }
+    const rootCurrentVersion = getCurrentVersion(rootPackageJsonPath);
+    if (!rootCurrentVersion) {
+        console.log(createErrorBox('Not a NitroStack Project', 'nitrostack is not a dependency'));
+        process.exit(1);
+    }
+    // Fetch latest version
+    const spinner = new NitroSpinner('Checking for updates...').start();
+    let latestVersion;
+    try {
+        latestVersion = getLatestVersion();
+        spinner.succeed(`Latest version: ${chalk.cyan(latestVersion)}`);
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch latest version');
+        process.exit(1);
+    }
+    // Check if already on latest
+    const rootParsedVersion = parseVersion(rootCurrentVersion);
+    if (compareVersions(rootParsedVersion, latestVersion) >= 0) {
+        spacer();
+        console.log(createSuccessBox('Already Up to Date', [
+            `Current version: ${rootParsedVersion}`,
+            `Latest version:  ${latestVersion}`,
+        ]));
+        return;
+    }
+    const results = [];
+    const dryRun = options.dryRun ?? false;
+    if (dryRun) {
+        spacer();
+        log('Dry run mode - no changes will be made', 'warning');
+    }
+    spacer();
+    log('Upgrading dependencies...', 'info');
+    spacer();
+    // Upgrade root
+    const rootSpinner = new NitroSpinner('Updating root package.json...').start();
+    try {
+        const rootUpdated = updatePackageJson(rootPackageJsonPath, latestVersion, dryRun);
+        if (rootUpdated) {
+            results.push({
+                location: 'root',
+                previousVersion: rootCurrentVersion,
+                newVersion: `^${latestVersion}`,
+                upgraded: true,
+            });
+            rootSpinner.succeed(`Root: ${chalk.dim(rootCurrentVersion)} → ${chalk.cyan(`^${latestVersion}`)}`);
+            if (!dryRun) {
+                const installSpinner = new NitroSpinner('Installing dependencies...').start();
+                runNpmInstall(projectRoot);
+                installSpinner.succeed('Root dependencies installed');
+            }
+        }
+        else {
+            rootSpinner.info('Root: No changes needed');
+        }
+    }
+    catch (error) {
+        rootSpinner.fail('Failed to upgrade root');
+        process.exit(1);
+    }
+    // Upgrade widgets if they exist
+    if (fs.existsSync(widgetsPackageJsonPath)) {
+        const widgetsCurrentVersion = getCurrentVersion(widgetsPackageJsonPath);
+        if (widgetsCurrentVersion) {
+            const widgetsSpinner = new NitroSpinner('Updating widgets package.json...').start();
+            try {
+                const widgetsUpdated = updatePackageJson(widgetsPackageJsonPath, latestVersion, dryRun);
+                if (widgetsUpdated) {
+                    results.push({
+                        location: 'src/widgets',
+                        previousVersion: widgetsCurrentVersion,
+                        newVersion: `^${latestVersion}`,
+                        upgraded: true,
+                    });
+                    widgetsSpinner.succeed(`Widgets: ${chalk.dim(widgetsCurrentVersion)} → ${chalk.cyan(`^${latestVersion}`)}`);
+                    if (!dryRun) {
+                        const installSpinner = new NitroSpinner('Installing widget dependencies...').start();
+                        runNpmInstall(widgetsPath);
+                        installSpinner.succeed('Widget dependencies installed');
+                    }
+                }
+                else {
+                    widgetsSpinner.info('Widgets: No changes needed');
+                }
+            }
+            catch (error) {
+                widgetsSpinner.fail('Failed to upgrade widgets');
+            }
+        }
+    }
+    else {
+        log('No widgets directory found', 'dim');
+    }
+    // Summary
+    spacer();
+    if (results.length === 0) {
+        log('No packages were upgraded', 'warning');
+    }
+    else {
+        const summaryItems = results.map(r => `${r.location}: ${parseVersion(r.previousVersion)} → ${parseVersion(r.newVersion)}`);
+        if (dryRun) {
+            console.log(brand.accentBold('\n  Dry run complete - no changes made\n'));
+            log('Run without --dry-run to apply upgrade', 'dim');
+        }
+        else {
+            console.log(createSuccessBox('Upgrade Complete', summaryItems));
+            nextSteps([
+                'Review the changes',
+                'Test your application',
+                'Check the changelog for breaking changes',
+            ]);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+export declare function createProgram(): Command;
+export { initCommand } from './commands/init.js';
+export { devCommand } from './commands/dev.js';
+export { buildCommand } from './commands/build.js';
+export { startCommand } from './commands/start.js';
+export { generate } from './commands/generate.js';
+export { upgradeCommand } from './commands/upgrade.js';
+export { installCommand } from './commands/install.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,aAAa,YA8D5B;AAGD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { initCommand } from './commands/init.js';
+import { devCommand } from './commands/dev.js';
+import { buildCommand } from './commands/build.js';
+import { startCommand } from './commands/start.js';
+import { generate } from './commands/generate.js';
+import { upgradeCommand } from './commands/upgrade.js';
+import { installCommand } from './commands/install.js';
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json');
+export function createProgram() {
+    const program = new Command();
+    program
+        .name('nitrostack')
+        .description('NitroStack - Build MCP servers with ease')
+        .version(packageJson.version);
+    program
+        .command('init')
+        .description('Initialize a new NitroStack project')
+        .argument('[project-name]', 'Name of the project')
+        .option('--template <template>', 'Template to use (typescript, typescript-auth)', 'typescript')
+        .option('--skip-install', 'Skip installing dependencies')
+        .action(initCommand);
+    program
+        .command('dev')
+        .description('Start development server (MCP server + widgets) with hot reload')
+        .option('--port <port>', 'Port for widget dev server', '3001')
+        .action(devCommand);
+    program
+        .command('build')
+        .description('Build the project for production')
+        .option('--output <path>', 'Output directory', 'dist')
+        .action(buildCommand);
+    program
+        .command('start')
+        .description('Start the production server')
+        .option('--port <port>', 'Port for server', '3000')
+        .action(startCommand);
+    program
+        .command('generate')
+        .alias('g')
+        .description('Generate boilerplate code or types')
+        .argument('<type>', 'Type of component (middleware, interceptor, pipe, filter, service, guard, health, module, tools, resources, prompts, types)')
+        .argument('[name]', 'Name of the component (optional for "types")')
+        .option('--module <module>', 'Module name (for module-specific generation)')
+        .option('--output <path>', 'Output path (for types generation)')
+        .option('--force', 'Overwrite existing files')
+        .option('--skip-related', 'Skip generating related files (for modules)')
+        .action(generate);
+    program
+        .command('upgrade')
+        .description('Upgrade nitrostack to the latest version in the project')
+        .option('--dry-run', 'Show what would be upgraded without making changes')
+        .option('--latest', 'Force upgrade to the latest version even if already up to date')
+        .action(upgradeCommand);
+    program
+        .command('install')
+        .alias('i')
+        .description('Install dependencies in root and src/widgets directories')
+        .option('--skip-widgets', 'Skip installing widget dependencies')
+        .option('--production', 'Install production dependencies only')
+        .action(installCommand);
+    return program;
+}
+// Re-export commands for programmatic use
+export { initCommand } from './commands/init.js';
+export { devCommand } from './commands/dev.js';
+export { buildCommand } from './commands/build.js';
+export { startCommand } from './commands/start.js';
+export { generate } from './commands/generate.js';
+export { upgradeCommand } from './commands/upgrade.js';
+export { installCommand } from './commands/install.js';
+// Run the CLI when this module is the entry point
+import { fileURLToPath } from 'url';
+import { realpathSync } from 'fs';
+const currentFilePath = fileURLToPath(import.meta.url);
+// Resolve symlinks to compare actual file paths
+function isMainModule() {
+    try {
+        const argvPath = realpathSync(process.argv[1]);
+        const modulePath = realpathSync(currentFilePath);
+        return argvPath === modulePath;
+    }
+    catch {
+        // If we can't resolve paths, check if the filename matches
+        return process.argv[1]?.includes('index.js') ||
+            process.argv[1]?.endsWith('nitrostack-cli');
+    }
+}
+if (isMainModule()) {
+    createProgram().parse();
+}

package/dist/mcp-dev-wrapper.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * MCP Server Hot Reload Wrapper
+ *
+ * This wrapper:
+ * 1. Starts the MCP server as a child process
+ * 2. Watches for changes in the dist/ directory
+ * 3. Restarts the server when changes are detected
+ * 4. Maintains stdio connection for Studio
+ * 5. Captures stderr from the MCP server and streams it over an SSE endpoint
+ *
+ * IMPORTANT: All logs go to stderr to avoid corrupting MCP JSON-RPC on stdout
+ */
+export declare function run(): Promise<void>;
+//# sourceMappingURL=mcp-dev-wrapper.d.ts.map

package/dist/mcp-dev-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-dev-wrapper.d.ts","sourceRoot":"","sources":["../src/mcp-dev-wrapper.ts"],"names":[],"mappings":";AAUA;;;;;;;;;;;GAWG;AAEH,wBAAsB,GAAG,kBAgLxB"}