@nitrostack/cli 1.0.0

package/templates/typescript-starter/src/health/system.health.ts

@@ -0,0 +1,55 @@
+import { HealthCheck, HealthCheckInterface, HealthCheckResult } from 'nitrostack';
+
+/**
+ * System Health Check
+ * 
+ * Monitors system resources and uptime
+ */
+@HealthCheck({ 
+  name: 'system', 
+  description: 'System resource and uptime check',
+  interval: 30 // Check every 30 seconds
+})
+export class SystemHealthCheck implements HealthCheckInterface {
+  private startTime: number;
+
+  constructor() {
+    this.startTime = Date.now();
+  }
+
+  async check(): Promise<HealthCheckResult> {
+    try {
+      const memoryUsage = process.memoryUsage();
+      const uptime = Date.now() - this.startTime;
+      const uptimeSeconds = Math.floor(uptime / 1000);
+      
+      // Convert memory to MB
+      const memoryUsedMB = Math.round(memoryUsage.heapUsed / 1024 / 1024);
+      const memoryTotalMB = Math.round(memoryUsage.heapTotal / 1024 / 1024);
+      
+      // Consider unhealthy if memory usage is > 90%
+      const memoryPercent = (memoryUsage.heapUsed / memoryUsage.heapTotal) * 100;
+      const isHealthy = memoryPercent < 90;
+      
+      return {
+        status: isHealthy ? 'up' : 'degraded',
+        message: isHealthy 
+          ? 'System is healthy' 
+          : 'High memory usage detected',
+        details: {
+          uptime: `${uptimeSeconds}s`,
+          memory: `${memoryUsedMB}MB / ${memoryTotalMB}MB (${Math.round(memoryPercent)}%)`,
+          pid: process.pid,
+          nodeVersion: process.version,
+        },
+      };
+    } catch (error: any) {
+      return {
+        status: 'down',
+        message: 'System health check failed',
+        details: error.message,
+      };
+    }
+  }
+}
+

package/templates/typescript-starter/src/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Calculator MCP Server
+ * 
+ * Main entry point for the MCP server.
+ * Uses the @McpApp decorator pattern for clean, NestJS-style architecture.
+ * 
+ * Transport Configuration:
+ * - Development (NODE_ENV=development): STDIO only
+ * - Production (NODE_ENV=production): Dual transport (STDIO + HTTP SSE)
+ */
+
+import 'dotenv/config';
+import { McpApplicationFactory } from 'nitrostack';
+import { AppModule } from './app.module.js';
+
+/**
+ * Bootstrap the application
+ */
+async function bootstrap() {
+  // Create and start the MCP server
+  const server = await McpApplicationFactory.create(AppModule);
+  await server.start();
+}
+
+// Start the application
+bootstrap().catch((error) => {
+  console.error('❌ Failed to start server:', error);
+  process.exit(1);
+});

package/templates/typescript-starter/src/modules/calculator/calculator.module.ts

@@ -0,0 +1,12 @@
+import { Module } from 'nitrostack';
+import { CalculatorTools } from './calculator.tools.js';
+import { CalculatorResources } from './calculator.resources.js';
+import { CalculatorPrompts } from './calculator.prompts.js';
+
+@Module({
+  name: 'calculator',
+  description: 'Basic arithmetic calculator',
+  controllers: [CalculatorTools, CalculatorResources, CalculatorPrompts]
+})
+export class CalculatorModule {}
+

package/templates/typescript-starter/src/modules/calculator/calculator.prompts.ts

@@ -0,0 +1,73 @@
+import { PromptDecorator as Prompt, ExecutionContext } from 'nitrostack';
+
+export class CalculatorPrompts {
+  @Prompt({
+    name: 'calculator_help',
+    description: 'Get help with calculator operations',
+    arguments: [
+      {
+        name: 'operation',
+        description: 'The operation to get help with (optional)',
+        required: false
+      }
+    ]
+  })
+  async getHelp(args: any, ctx: ExecutionContext) {
+    ctx.logger.info('Generating calculator help prompt');
+
+    const operation = args.operation;
+
+    if (operation) {
+      // Help for specific operation
+      const helpText = this.getOperationHelp(operation);
+      return [
+        {
+          role: 'user' as const,
+          content: `How do I use the ${operation} operation in the calculator?`
+        },
+        {
+          role: 'assistant' as const,
+          content: helpText
+        }
+      ];
+    }
+
+    // General help
+    return [
+      {
+        role: 'user' as const,
+        content: 'How do I use the calculator?'
+      },
+      {
+        role: 'assistant' as const,
+        content: `The calculator supports four basic operations:
+
+1. **Addition** - Add two numbers together
+   Example: calculate(operation="add", a=5, b=3) = 8
+
+2. **Subtraction** - Subtract one number from another
+   Example: calculate(operation="subtract", a=10, b=4) = 6
+
+3. **Multiplication** - Multiply two numbers
+   Example: calculate(operation="multiply", a=6, b=7) = 42
+
+4. **Division** - Divide one number by another
+   Example: calculate(operation="divide", a=20, b=5) = 4
+
+Just call the 'calculate' tool with the operation and two numbers!`
+      }
+    ];
+  }
+
+  private getOperationHelp(operation: string): string {
+    const helps: Record<string, string> = {
+      add: 'Use addition to sum two numbers. Call calculate(operation="add", a=5, b=3) to get 8.',
+      subtract: 'Use subtraction to find the difference. Call calculate(operation="subtract", a=10, b=4) to get 6.',
+      multiply: 'Use multiplication to find the product. Call calculate(operation="multiply", a=6, b=7) to get 42.',
+      divide: 'Use division to find the quotient. Call calculate(operation="divide", a=20, b=5) to get 4. Note: Cannot divide by zero!'
+    };
+
+    return helps[operation] || 'Unknown operation. Available operations: add, subtract, multiply, divide.';
+  }
+}
+

package/templates/typescript-starter/src/modules/calculator/calculator.resources.ts

@@ -0,0 +1,59 @@
+import { ResourceDecorator as Resource, Widget, ExecutionContext } from 'nitrostack';
+
+export class CalculatorResources {
+  @Resource({
+    uri: 'calculator://operations',
+    name: 'Calculator Operations',
+    description: 'List of available calculator operations',
+    mimeType: 'application/json',
+    examples: {
+      response: {
+        operations: [
+          { name: 'add', symbol: '+', description: 'Addition' },
+          { name: 'subtract', symbol: '-', description: 'Subtraction' },
+          { name: 'multiply', symbol: '×', description: 'Multiplication' },
+          { name: 'divide', symbol: '÷', description: 'Division' }
+        ]
+      }
+    }
+  })
+  async getOperations(uri: string, ctx: ExecutionContext) {
+    ctx.logger.info('Fetching calculator operations');
+
+    const operations = [
+      {
+        name: 'add',
+        symbol: '+',
+        description: 'Addition',
+        example: '5 + 3 = 8'
+      },
+      {
+        name: 'subtract',
+        symbol: '-',
+        description: 'Subtraction',
+        example: '10 - 4 = 6'
+      },
+      {
+        name: 'multiply',
+        symbol: '×',
+        description: 'Multiplication',
+        example: '6 × 7 = 42'
+      },
+      {
+        name: 'divide',
+        symbol: '÷',
+        description: 'Division',
+        example: '20 ÷ 5 = 4'
+      }
+    ];
+
+    return {
+      contents: [{
+        uri,
+        mimeType: 'application/json',
+        text: JSON.stringify({ operations }, null, 2)
+      }]
+    };
+  }
+}
+

package/templates/typescript-starter/src/modules/calculator/calculator.tools.ts

@@ -0,0 +1,166 @@
+import { ToolDecorator as Tool, Widget, ExecutionContext, z } from 'nitrostack';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export class CalculatorTools {
+  @Tool({
+    name: 'calculate',
+    description: 'Perform basic arithmetic calculations',
+    inputSchema: z.object({
+      operation: z.enum(['add', 'subtract', 'multiply', 'divide']).describe('The operation to perform'),
+      a: z.number().describe('First number'),
+      b: z.number().describe('Second number')
+    }),
+    examples: {
+      request: {
+        operation: 'add',
+        a: 5,
+        b: 3
+      },
+      response: {
+        operation: 'add',
+        a: 5,
+        b: 3,
+        result: 8,
+        expression: '5 + 3 = 8'
+      }
+    }
+  })
+  @Widget('calculator-result')
+  async calculate(input: any, ctx: ExecutionContext) {
+    ctx.logger.info('Performing calculation', {
+      operation: input.operation,
+      a: input.a,
+      b: input.b
+    });
+
+    let result: number;
+    let symbol: string;
+
+    switch (input.operation) {
+      case 'add':
+        result = input.a + input.b;
+        symbol = '+';
+        break;
+      case 'subtract':
+        result = input.a - input.b;
+        symbol = '-';
+        break;
+      case 'multiply':
+        result = input.a * input.b;
+        symbol = '×';
+        break;
+      case 'divide':
+        if (input.b === 0) {
+          throw new Error('Cannot divide by zero');
+        }
+        result = input.a / input.b;
+        symbol = '÷';
+        break;
+      default:
+        throw new Error('Invalid operation');
+    }
+
+    return {
+      operation: input.operation,
+      a: input.a,
+      b: input.b,
+      result,
+      expression: `${input.a} ${symbol} ${input.b} = ${result}`
+    };
+  }
+
+  @Tool({
+    name: 'convert_temperature',
+    description: 'Convert temperature units based on file content or direct input. Supports Celsius (C) and Fahrenheit (F).',
+    inputSchema: z.object({
+      file_name: z.string().describe('Name of the uploaded file'),
+      file_type: z.string().describe('MIME type of the uploaded file'),
+      file_content: z.string().describe('Base64 encoded file content. Will be injected by system.'),
+      value: z.number().optional().describe('Temperature value to convert'),
+      from_unit: z.enum(['C', 'F']).optional().describe('Unit to convert from (C or F)'),
+      to_unit: z.enum(['C', 'F']).optional().describe('Unit to convert to (C or F)')
+    })
+  })
+  async convertTemperature(input: any, ctx: ExecutionContext) {
+    ctx.logger.info('Processing temperature file', {
+      name: input.file_name,
+      type: input.file_type,
+      value: input.value,
+      from: input.from_unit,
+      to: input.to_unit
+    });
+
+    // Save file to uploads directory
+    const uploadsDir = path.join(process.cwd(), 'uploads');
+    if (!fs.existsSync(uploadsDir)) {
+      fs.mkdirSync(uploadsDir, { recursive: true });
+    }
+
+    const filePath = path.join(uploadsDir, input.file_name);
+
+    // Decode base64
+    if (input.file_content) {
+      try {
+        const matches = input.file_content.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/);
+        let buffer;
+
+        if (matches && matches.length === 3) {
+          buffer = Buffer.from(matches[2], 'base64');
+        } else {
+          buffer = Buffer.from(input.file_content, 'base64');
+        }
+
+        fs.writeFileSync(filePath, buffer);
+        ctx.logger.info(`Saved file to ${filePath}`);
+      } catch (e) {
+        ctx.logger.error('Failed to save file', { error: e instanceof Error ? e.message : String(e) });
+      }
+    }
+
+    const fileStats = {
+      name: input.file_name,
+      type: input.file_type,
+      saved_path: filePath,
+      status: 'saved'
+    };
+
+    let result: number | null = null;
+    let message = `Successfully processed and saved file ${input.file_name}`;
+
+    // Perform conversion logic
+    if (input.value !== undefined && input.from_unit && input.to_unit) {
+      try {
+        message += `. Converting ${input.value}°${input.from_unit} to ${input.to_unit}`;
+
+        if (input.from_unit === input.to_unit) {
+          result = input.value;
+        } else if (input.from_unit === 'C' && input.to_unit === 'F') {
+          result = (input.value * 9 / 5) + 32;
+        } else if (input.from_unit === 'F' && input.to_unit === 'C') {
+          result = (input.value - 32) * 5 / 9;
+        } else {
+          throw new Error('Unsupported unit conversion');
+        }
+
+        // Round to 2 decimal places
+        if (result !== null) {
+          result = Math.round(result * 100) / 100;
+          message += `. Result: ${result}°${input.to_unit}`;
+        }
+      } catch (e: any) {
+        message += `. Conversion failed: ${e.message}`;
+      }
+    } else {
+      message += `. No valid conversion parameters detected from manual input or file extraction.`;
+    }
+
+    return {
+      status: 'success',
+      message,
+      file_info: fileStats,
+      conversion_result: result !== null ? { value: result, unit: input.to_unit } : null,
+      original_value: input.value !== undefined ? { value: input.value, unit: input.from_unit } : null
+    };
+  }
+}

package/templates/typescript-starter/src/widgets/app/calculator-result/page.tsx

@@ -0,0 +1,180 @@
+'use client';
+
+import { useTheme, useWidgetState, useWidgetSDK } from '@nitrostack/widgets';
+
+/**
+ * Example widget demonstrating NitroStack Widget SDK
+ * This widget is fully compatible with OpenAI ChatGPT
+ */
+
+interface CalculatorData {
+  operation: string;
+  a: number;
+  b: number;
+  result: number;
+  expression: string;
+}
+
+export default function CalculatorResult() {
+  // Use Widget SDK hooks
+  const theme = useTheme();
+  const { getToolOutput } = useWidgetSDK();
+  const [state, setState] = useWidgetState<{ viewMode: 'compact' | 'detailed' }>(() => ({
+    viewMode: 'detailed'
+  }));
+
+  // Access tool output from Widget SDK
+  const data = getToolOutput<CalculatorData>();
+
+  if (!data) {
+    return (
+      <div style={{
+        padding: '24px',
+        textAlign: 'center',
+        color: theme === 'dark' ? '#fff' : '#000',
+      }}>
+        Loading...
+      </div>
+    );
+  }
+
+  const getOperationColor = (op: string) => {
+    const colors: Record<string, string> = {
+      add: '#10b981',
+      subtract: '#f59e0b',
+      multiply: '#3b82f6',
+      divide: '#8b5cf6'
+    };
+    return colors[op] || '#6b7280';
+  };
+
+  const getOperationIcon = (op: string) => {
+    const icons: Record<string, string> = {
+      add: '➕',
+      subtract: '➖',
+      multiply: '✖️',
+      divide: '➗'
+    };
+    return icons[op] || '🔢';
+  };
+
+  const isDark = theme === 'dark';
+  const bgColor = isDark ? '#1a1a1a' : '#ffffff';
+  const textColor = isDark ? '#ffffff' : '#000000';
+  const mutedColor = isDark ? 'rgba(255,255,255,0.6)' : 'rgba(0,0,0,0.6)';
+
+  return (
+    <div style={{
+      padding: '24px',
+      background: isDark
+        ? 'linear-gradient(135deg, #2d3748 0%, #1a202c 100%)'
+        : 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
+      borderRadius: '16px',
+      color: 'white',
+      maxWidth: '400px',
+      boxShadow: '0 10px 30px rgba(0,0,0,0.2)',
+      transition: 'all 0.3s ease',
+    }}>
+      <div style={{
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        marginBottom: '20px'
+      }}>
+        <div style={{ display: 'flex', alignItems: 'center', gap: '12px' }}>
+          <span style={{ fontSize: '32px' }}>
+            {getOperationIcon(data.operation)}
+          </span>
+          <div>
+            <h3 style={{ margin: 0, fontSize: '18px', opacity: 0.9 }}>
+              Calculator Result
+            </h3>
+            <p style={{ margin: '4px 0 0 0', fontSize: '14px', opacity: 0.7 }}>
+              {data.operation.charAt(0).toUpperCase() + data.operation.slice(1)}
+            </p>
+          </div>
+        </div>
+
+        {/* View mode toggle */}
+        <button
+          onClick={() => setState({
+            viewMode: state?.viewMode === 'compact' ? 'detailed' : 'compact'
+          })}
+          style={{
+            padding: '6px 12px',
+            borderRadius: '8px',
+            border: '1px solid rgba(255,255,255,0.3)',
+            background: 'rgba(255,255,255,0.1)',
+            color: 'white',
+            cursor: 'pointer',
+            fontSize: '12px',
+            transition: 'all 0.2s',
+          }}
+        >
+          {state?.viewMode === 'compact' ? '📊 Detailed' : '📋 Compact'}
+        </button>
+      </div>
+
+      <div style={{
+        background: 'rgba(255, 255, 255, 0.15)',
+        borderRadius: '12px',
+        padding: '20px',
+        backdropFilter: 'blur(10px)',
+        marginBottom: '16px'
+      }}>
+        <div style={{
+          fontSize: '28px',
+          fontWeight: 'bold',
+          textAlign: 'center',
+          marginBottom: '12px',
+          fontFamily: 'monospace'
+        }}>
+          {data.expression}
+        </div>
+
+        {state?.viewMode === 'detailed' && (
+          <div style={{
+            display: 'flex',
+            justifyContent: 'space-around',
+            fontSize: '14px',
+            opacity: 0.9,
+            marginTop: '16px'
+          }}>
+            <div style={{ textAlign: 'center' }}>
+              <div style={{ fontSize: '12px', opacity: 0.7 }}>First</div>
+              <div style={{ fontWeight: 'bold', fontSize: '20px' }}>{data.a}</div>
+            </div>
+            <div style={{ textAlign: 'center' }}>
+              <div style={{ fontSize: '12px', opacity: 0.7 }}>Second</div>
+              <div style={{ fontWeight: 'bold', fontSize: '20px' }}>{data.b}</div>
+            </div>
+            <div style={{ textAlign: 'center' }}>
+              <div style={{ fontSize: '12px', opacity: 0.7 }}>Result</div>
+              <div style={{
+                fontWeight: 'bold',
+                fontSize: '24px',
+                color: '#fbbf24'
+              }}>
+                {data.result}
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+
+      <div style={{
+        fontSize: '12px',
+        textAlign: 'center',
+        opacity: 0.7,
+        display: 'flex',
+        justifyContent: 'space-between',
+        alignItems: 'center',
+      }}>
+        <span>✨ NitroStack Calculator</span>
+        <span style={{ fontSize: '10px' }}>
+          Theme: {theme || 'light'} | Mode: {state?.viewMode || 'detailed'}
+        </span>
+      </div>
+    </div>
+  );
+}

package/templates/typescript-starter/src/widgets/app/layout.tsx

@@ -0,0 +1,18 @@
+'use client';
+
+import { WidgetLayout } from '@nitrostack/widgets';
+
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en">
+      <body style={{ margin: 0, padding: 0, fontFamily: 'system-ui, sans-serif' }}>
+        <WidgetLayout>{children}</WidgetLayout>
+      </body>
+    </html>
+  );
+}

package/templates/typescript-starter/src/widgets/next.config.js

@@ -0,0 +1,45 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+  transpilePackages: ['nitrostack'],
+  
+  // Static export for production builds
+  ...(process.env.NODE_ENV === 'production' && {
+    output: 'export',
+    distDir: 'out',
+    images: {
+      unoptimized: true,
+    },
+  }),
+  
+  // Development optimizations to prevent cache corruption
+  ...(process.env.NODE_ENV === 'development' && {
+    // Use memory cache instead of filesystem cache in dev to avoid stale chunks
+    webpack: (config, { isServer }) => {
+      // Disable persistent caching in development to prevent chunk reference errors
+      if (config.cache && config.cache.type === 'filesystem') {
+        config.cache = {
+          type: 'memory',
+        };
+      }
+      
+      // Improve cache busting for new files
+      if (!isServer) {
+        config.cache = false; // Disable cache completely on client in dev
+      }
+      
+      return config;
+    },
+    
+    // Disable build activity indicator which can cause issues
+    devIndicators: {
+      buildActivity: false,
+      buildActivityPosition: 'bottom-right',
+    },
+    
+    // Faster dev server
+    compress: false,
+  }),
+};
+
+export default nextConfig;

package/templates/typescript-starter/src/widgets/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "calculator-widgets",
+  "version": "1.0.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "next dev -p 3001 --port 3001",
+    "build": "next build",
+    "start": "next start -p 3001"
+  },
+  "dependencies": {
+    "next": "^14.2.5",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "@nitrostack/widgets": "^1"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@types/react": "^18",
+    "@types/react-dom": "^18",
+    "typescript": "^5"
+  }
+}
+

package/templates/typescript-starter/src/widgets/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}
+