@tothalex/nulljs 0.0.40

package/src/commands/dev/ui/logging-context.tsx

@@ -0,0 +1,76 @@
+import React, { createContext, useContext, useState, useCallback, type ReactNode } from 'react'
+
+export type LogEntry = {
+  id: string
+  timestamp: Date
+  service: 'server' | 'functions' | 'vite'
+  level: 'info' | 'warn' | 'error'
+  message: string
+}
+
+type LoggingContextType = {
+  logs: Record<string, LogEntry[]>
+  addLog: (service: LogEntry['service'], level: LogEntry['level'], message: string) => void
+  clearLogs: (service?: LogEntry['service']) => void
+}
+
+const LoggingContext = createContext<LoggingContextType | undefined>(undefined)
+
+export const useLogging = () => {
+  const context = useContext(LoggingContext)
+  if (!context) {
+    throw new Error('useLogging must be used within a LoggingProvider')
+  }
+  return context
+}
+
+type LoggingProviderProps = {
+  children: ReactNode
+}
+
+export const LoggingProvider: React.FC<LoggingProviderProps> = ({ children }) => {
+  const [logs, setLogs] = useState<Record<string, LogEntry[]>>({
+    server: [],
+    functions: [],
+    vite: []
+  })
+
+  const addLog = useCallback(
+    (service: LogEntry['service'], level: LogEntry['level'], message: string) => {
+      const newLog: LogEntry = {
+        id: `${service}-${Date.now()}-${Math.random()}`,
+        timestamp: new Date(),
+        service,
+        level,
+        message
+      }
+
+      setLogs((prev) => ({
+        ...prev,
+        [service]: [...prev[service], newLog]
+      }))
+    },
+    []
+  )
+
+  const clearLogs = useCallback((service?: LogEntry['service']) => {
+    if (service) {
+      setLogs((prev) => ({
+        ...prev,
+        [service]: []
+      }))
+    } else {
+      setLogs({
+        server: [],
+        functions: [],
+        vite: []
+      })
+    }
+  }, [])
+
+  return (
+    <LoggingContext.Provider value={{ logs, addLog, clearLogs }}>
+      {children}
+    </LoggingContext.Provider>
+  )
+}

package/src/commands/dev/ui/tabs/functions-tab.tsx

@@ -0,0 +1,35 @@
+import React from 'react'
+import { Box, Text, useStdout } from 'ink'
+import { ScrollArea } from '../components/scroll-area'
+import { LoggingManager } from '../../logging-manager'
+import { useLogging } from '../use-logging'
+
+type FunctionsTabProps = {
+  loggingManager: LoggingManager
+}
+
+export const FunctionsTab: React.FC<FunctionsTabProps> = ({ loggingManager }) => {
+  const { stdout } = useStdout()
+  const { logs } = useLogging(loggingManager, 'functions')
+
+  return (
+    <ScrollArea height={stdout.rows - 5} autoScroll={true}>
+      <Box flexDirection="column" padding={1}>
+        <Text color="green">Functions</Text>
+        {logs.length === 0 ? (
+          <Text dimColor>No function logs yet...</Text>
+        ) : (
+          <Box flexDirection="column">
+            {logs.map((log) => (
+              <Text
+                key={`function-tab-${log.id}`}
+                color={log.level === 'error' ? 'red' : log.level === 'warn' ? 'yellow' : 'white'}>
+                [{log.timestamp.toLocaleTimeString()}] {log.message}
+              </Text>
+            ))}
+          </Box>
+        )}
+      </Box>
+    </ScrollArea>
+  )
+}

package/src/commands/dev/ui/tabs/server-tab.tsx

@@ -0,0 +1,36 @@
+import React from 'react'
+import { Box, Text, useStdout } from 'ink'
+
+import { ScrollArea } from '../components/scroll-area'
+import { LoggingManager } from '../../logging-manager'
+import { useLogging } from '../use-logging'
+
+type ServerTabProps = {
+  loggingManager: LoggingManager
+}
+
+export const ServerTab: React.FC<ServerTabProps> = ({ loggingManager }) => {
+  const { stdout } = useStdout()
+  const { logs } = useLogging(loggingManager, 'server')
+
+  return (
+    <ScrollArea height={stdout.rows - 5} autoScroll={true}>
+      <Box flexDirection="column" padding={1}>
+        <Text color="cyan">Server</Text>
+        {logs.length === 0 ? (
+          <Text dimColor>No server logs yet...</Text>
+        ) : (
+          <Box flexDirection="column">
+            {logs.map((log) => (
+              <Text
+                key={log.id}
+                color={log.level === 'error' ? 'red' : log.level === 'warn' ? 'yellow' : 'white'}>
+                [{log.timestamp.toLocaleTimeString()}] {log.message}
+              </Text>
+            ))}
+          </Box>
+        )}
+      </Box>
+    </ScrollArea>
+  )
+}

package/src/commands/dev/ui/tabs/vite-tab.tsx

@@ -0,0 +1,35 @@
+import React from 'react'
+import { Box, Text, useStdout } from 'ink'
+import { ScrollArea } from '../components/scroll-area'
+import { LoggingManager } from '../../logging-manager'
+import { useLogging } from '../use-logging'
+
+type ViteTabProps = {
+  loggingManager: LoggingManager
+}
+
+export const ViteTab: React.FC<ViteTabProps> = ({ loggingManager }) => {
+  const { stdout } = useStdout()
+  const { logs } = useLogging(loggingManager, 'vite')
+
+  return (
+    <ScrollArea height={stdout.rows - 5} autoScroll={true}>
+      <Box flexDirection="column" padding={1}>
+        <Text color="yellow">Vite</Text>
+        {logs.length === 0 ? (
+          <Text dimColor>No Vite logs yet...</Text>
+        ) : (
+          <Box flexDirection="column">
+            {logs.map((log) => (
+              <Text
+                key={log.id}
+                color={log.level === 'error' ? 'red' : log.level === 'warn' ? 'yellow' : 'white'}>
+                [{log.timestamp.toLocaleTimeString()}] {log.message}
+              </Text>
+            ))}
+          </Box>
+        )}
+      </Box>
+    </ScrollArea>
+  )
+}

package/src/commands/dev/ui/use-logging.tsx

@@ -0,0 +1,34 @@
+import { useState, useEffect } from 'react'
+import { LoggingManager, type LogEntry } from '../logging-manager'
+
+export const useLogging = (loggingManager: LoggingManager, service?: LogEntry['service']) => {
+  const [logs, setLogs] = useState<LogEntry[]>(() => {
+    return service ? loggingManager.getLogs(service) : loggingManager.getLogs()
+  })
+
+  const [allLogs, setAllLogs] = useState<Record<string, LogEntry[]>>(() => {
+    return loggingManager.getAllLogs()
+  })
+
+  useEffect(() => {
+    const unsubscribe = loggingManager.subscribe(() => {
+      if (service) {
+        setLogs(loggingManager.getLogs(service))
+      } else {
+        setLogs(loggingManager.getLogs())
+      }
+      setAllLogs(loggingManager.getAllLogs())
+    })
+
+    return () => {
+      unsubscribe()
+    }
+  }, [loggingManager, service])
+
+  return {
+    logs,
+    allLogs,
+    addLog: loggingManager.addLog.bind(loggingManager),
+    clearLogs: loggingManager.clearLogs.bind(loggingManager)
+  }
+}

package/src/commands/dev/vite/index.ts

@@ -0,0 +1,54 @@
+import { createServer, type LogOptions } from 'vite'
+import { dirname, resolve } from 'path'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import { writeFile } from 'node:fs/promises'
+
+import { createTempIndexHtml, createViteLogger } from './utils'
+import { getDevConfig } from '../../../lib/config'
+
+const PORT = 5173
+
+export const createVite = async (props: {
+  srcDir: string
+  indexTsxPath: string
+  log: (msg: string, level?: string, options?: LogOptions) => void
+}) => {
+  const devConfig = getDevConfig()
+  const projectDir = dirname(props.srcDir)
+  const tempIndexPath = resolve(projectDir, 'index.html')
+
+  try {
+    const indexHtml = createTempIndexHtml(props.indexTsxPath, projectDir)
+    await writeFile(tempIndexPath, indexHtml)
+
+    const server = await createServer({
+      root: projectDir,
+      plugins: [react(), tailwindcss()],
+      customLogger: createViteLogger(props.log),
+      server: {
+        port: PORT,
+        host: true,
+        proxy: {
+          '/api': {
+            target: `http://localhost:${devConfig.gatewayPort}`,
+            changeOrigin: true,
+            secure: false
+          },
+          '/assets': {
+            target: `http://localhost:${devConfig.gatewayPort}`,
+            changeOrigin: true,
+            secure: false
+          }
+        }
+      }
+    })
+
+    await server.listen()
+    props.log(`Vite server started on http://localhost:${PORT}`)
+
+    return server
+  } catch (error) {
+    console.error('Error setting up Vite:', error)
+  }
+}

package/src/commands/dev/vite/utils.ts

@@ -0,0 +1,71 @@
+import { resolve, basename } from 'path'
+import type { Logger, LogOptions } from 'vite'
+
+export const createViteLogger = (
+  log: (msg: string, level?: string, options?: LogOptions) => void
+): Logger => {
+  return {
+    info: (msg: string, options) => {
+      log(msg, 'info', options)
+    },
+    warn: (msg: string, options) => {
+      log(msg, 'warn', options)
+    },
+    warnOnce: (msg: string, options) => {
+      log(msg, 'warn', options)
+    },
+    error: (msg: string, options) => {
+      log(msg, 'error', options)
+    },
+    clearScreen: () => {
+      // Not implemented - we don't want to clear screens in our UI
+    },
+    hasErrorLogged: () => {
+      return false // Simple implementation
+    },
+    hasWarned: false
+  }
+}
+
+export const createTempIndexHtml = (componentPath: string, projectRoot: string): string => {
+  const relativePath = resolve(componentPath).replace(projectRoot + '/', '')
+  const componentName = basename(componentPath, '.tsx')
+
+  return `<!DOCTYPE html>
+    <html lang="en">
+      <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>${componentName} - Dev Mode</title>
+        <style>
+          * {
+            box-sizing: border-box;
+          }
+          body {
+            margin: 0;
+            padding: 0;
+            font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+          }
+          #root {
+            min-height: 100vh;
+          }
+        </style>
+      </head>
+      <body>
+        <div id="root"></div>
+        <script type="module">
+          import React from 'react'
+          import ReactDOM from 'react-dom/client'
+          import { Page } from '/${relativePath}'
+
+          const root = ReactDOM.createRoot(document.getElementById('root'))
+
+          root.render(
+            React.createElement(React.StrictMode, null,
+              React.createElement(Page)
+            )
+          )
+        </script>
+      </body>
+    </html>`
+}

package/src/commands/host.ts

@@ -0,0 +1,339 @@
+import { existsSync, writeFileSync, mkdirSync, readFileSync } from 'node:fs'
+import { join, resolve, dirname } from 'node:path'
+import { execSync } from 'node:child_process'
+import { homedir } from 'node:os'
+import { fileURLToPath } from 'node:url'
+import chalk from 'chalk'
+import { updateServer } from '../lib/update-server'
+
+const getServerBinPath = (): string => {
+  // Try to find the server binary relative to this module
+  // This works both in development and when installed globally
+  const currentFile = fileURLToPath(import.meta.url)
+  const moduleRoot = resolve(dirname(currentFile), '../..')
+  return join(moduleRoot, 'bin', 'server')
+}
+
+type ProductionConfig = {
+  key: {
+    private: string
+    public: string
+  }
+}
+
+const generateProductionKeys = async (): Promise<{ privateKey: string; publicKey: string }> => {
+  console.log(chalk.blue('🔑 Generating production keys...'))
+
+  const keyPair = await crypto.subtle.generateKey(
+    {
+      name: 'Ed25519',
+      namedCurve: 'Ed25519'
+    },
+    true,
+    ['sign', 'verify']
+  )
+
+  const privateKeyBuffer = await crypto.subtle.exportKey('pkcs8', keyPair.privateKey)
+  const publicKeyBuffer = await crypto.subtle.exportKey('spki', keyPair.publicKey)
+
+  const privateKey = btoa(String.fromCharCode(...new Uint8Array(privateKeyBuffer)))
+  const publicKey = btoa(String.fromCharCode(...new Uint8Array(publicKeyBuffer)))
+
+  return { privateKey, publicKey }
+}
+
+const saveProductionConfig = (cloudPath: string, privateKey: string, publicKey: string): void => {
+  const configPath = join(cloudPath, 'config.json')
+  const config: ProductionConfig = {
+    key: {
+      private: privateKey,
+      public: publicKey
+    }
+  }
+
+  console.log(chalk.blue('💾 Saving production configuration...'))
+  writeFileSync(configPath, JSON.stringify(config, null, 2))
+
+  // Set proper permissions on the config file (readable only by owner)
+  execSync(`chmod 600 ${configPath}`, { stdio: 'inherit' })
+
+  console.log(chalk.green('✅ Production configuration saved'))
+}
+
+const createSystemdService = (cloudPath: string, publicKey: string, serverBinPath: string, userName: string) => {
+  const serviceContent = `
+  [Unit]
+  Description=NullJS Server
+  After=network.target
+  StartLimitIntervalSec=0
+
+  [Service]
+  Type=simple
+  Restart=always
+  RestartSec=1
+  User=${userName}
+  ExecStart=${serverBinPath}
+  Environment=CLOUD_PATH=${cloudPath}
+  Environment=PUBLIC_KEY=${publicKey}
+  WorkingDirectory=${cloudPath}
+
+  [Install]
+  WantedBy=multi-user.target
+`
+
+  return serviceContent
+}
+
+
+const ensureCloudDirectory = (cloudPath: string) => {
+  if (!existsSync(cloudPath)) {
+    console.log(chalk.blue('🔧 Creating cloud directory...'))
+    try {
+      mkdirSync(cloudPath, { recursive: true })
+      console.log(chalk.green(`✅ Cloud directory created: ${cloudPath}`))
+    } catch (error) {
+      console.log(chalk.red('❌ Failed to create cloud directory:'), error.message)
+      throw error
+    }
+  } else {
+    console.log(chalk.gray(`ℹ️  Cloud directory already exists: ${cloudPath}`))
+  }
+}
+
+
+const installSystemdService = (serviceContent: string) => {
+  const servicePath = '/etc/systemd/system/nulljs.service'
+
+  console.log(chalk.blue('🔧 Installing systemd service...'))
+
+  // Write service file
+  writeFileSync('/tmp/nulljs.service', serviceContent)
+  execSync(`sudo mv /tmp/nulljs.service ${servicePath}`, { stdio: 'inherit' })
+
+  // Reload systemd and enable service
+  execSync('sudo systemctl daemon-reload', { stdio: 'inherit' })
+  execSync('sudo systemctl enable nulljs.service', { stdio: 'inherit' })
+
+  console.log(chalk.green('✅ Systemd service installed and enabled'))
+}
+
+const validateLinux = () => {
+  if (process.platform !== 'linux') {
+    console.log(chalk.red('❌ This command only works on Linux'))
+    process.exit(1)
+  }
+}
+
+const validateServerBinary = (serverBinPath: string) => {
+  if (!existsSync(serverBinPath)) {
+    console.log(chalk.red('❌ Server binary not found at:'), serverBinPath)
+    console.log(chalk.yellow('   Make sure you have built the server first'))
+    process.exit(1)
+  }
+}
+
+const checkExistingProductionConfig = (cloudPath: string): ProductionConfig | null => {
+  const configPath = join(cloudPath, 'config.json')
+
+  if (!existsSync(configPath)) {
+    return null
+  }
+
+  try {
+    const configContent = JSON.parse(readFileSync(configPath, 'utf8'))
+    if (configContent.key?.private && configContent.key?.public) {
+      return configContent as ProductionConfig
+    }
+  } catch {
+    console.log(chalk.yellow('⚠️  Existing production config is invalid, will regenerate'))
+  }
+
+  return null
+}
+
+const unhost = async (options: { keepData?: boolean } = {}) => {
+  validateLinux()
+
+  console.log(chalk.blue('🧹 Removing NullJS production hosting...'))
+
+  try {
+    // Stop and disable the systemd service
+    console.log(chalk.blue('🛑 Stopping NullJS service...'))
+    try {
+      execSync('sudo systemctl stop nulljs', { stdio: 'inherit' })
+      console.log(chalk.green('✅ Service stopped'))
+    } catch {
+      console.log(chalk.yellow('⚠️  Service was not running'))
+    }
+
+    try {
+      execSync('sudo systemctl disable nulljs', { stdio: 'inherit' })
+      console.log(chalk.green('✅ Service disabled'))
+    } catch {
+      console.log(chalk.yellow('⚠️  Service was not enabled'))
+    }
+
+    // Remove the systemd service file
+    const servicePath = '/etc/systemd/system/nulljs.service'
+    if (existsSync(servicePath)) {
+      console.log(chalk.blue('🗑️  Removing systemd service file...'))
+      execSync(`sudo rm ${servicePath}`, { stdio: 'inherit' })
+      execSync('sudo systemctl daemon-reload', { stdio: 'inherit' })
+      console.log(chalk.green('✅ Systemd service file removed'))
+    }
+
+    // Remove cloud directory (optional)
+    if (!options.keepData) {
+      const defaultCloudPath = join(homedir(), '.nulljs')
+      if (existsSync(defaultCloudPath)) {
+        console.log(chalk.blue('🗂️  Removing cloud directory...'))
+        execSync(`rm -rf ${defaultCloudPath}`, { stdio: 'inherit' })
+        console.log(chalk.green('✅ Cloud directory removed'))
+      } else {
+        console.log(chalk.gray('ℹ️  Cloud directory does not exist'))
+      }
+    } else {
+      console.log(chalk.gray('ℹ️  Keeping cloud data (--keep-data specified)'))
+    }
+
+    console.log(chalk.green('🎉 NullJS hosting cleanup complete!'))
+    console.log('')
+    console.log(chalk.blue('📋 Summary:'))
+    console.log(chalk.gray('   • Systemd service stopped and removed'))
+    if (!options.keepData) {
+      console.log(chalk.gray('   • Cloud directory removed'))
+    }
+  } catch (error) {
+    console.log(chalk.red('❌ Failed to remove hosting setup:'), error.message)
+    process.exit(1)
+  }
+}
+
+const hostUpdate = async () => {
+  validateLinux()
+
+  console.log(chalk.blue('🔄 Updating NullJS server...'))
+
+  // Check if service exists
+  const serviceExists = existsSync('/etc/systemd/system/nulljs.service')
+  if (!serviceExists) {
+    console.log(chalk.red('❌ NullJS service is not installed. Run `nulljs host` first.'))
+    process.exit(1)
+  }
+
+  let wasRunning = false
+
+  try {
+    // Check if service is running
+    execSync('sudo systemctl is-active nulljs >/dev/null 2>&1')
+    wasRunning = true
+    console.log(chalk.blue('🛑 Stopping NullJS service...'))
+    execSync('sudo systemctl stop nulljs', { stdio: 'inherit' })
+    console.log(chalk.green('✅ Service stopped'))
+  } catch {
+    // Service wasn't running, that's fine
+    console.log(chalk.gray('ℹ️  Service was not running'))
+  }
+
+  try {
+    // Update the binary
+    await updateServer()
+
+    // Restart service if it was running before
+    if (wasRunning) {
+      console.log(chalk.blue('🚀 Starting NullJS service...'))
+      execSync('sudo systemctl start nulljs', { stdio: 'inherit' })
+      console.log(chalk.green('✅ Service restarted'))
+    }
+
+    console.log(chalk.green('🎉 NullJS server update complete!'))
+    console.log('')
+    console.log(chalk.blue('📋 Service management commands:'))
+    console.log(chalk.gray('   Start:   '), chalk.white('sudo systemctl start nulljs'))
+    console.log(chalk.gray('   Stop:    '), chalk.white('sudo systemctl stop nulljs'))
+    console.log(chalk.gray('   Status:  '), chalk.white('sudo systemctl status nulljs'))
+    console.log(chalk.gray('   Logs:    '), chalk.white('sudo journalctl -u nulljs -f'))
+  } catch (error) {
+    console.log(chalk.red('❌ Failed to update server:'), error.message)
+
+    // Try to restart the service even if update failed
+    if (wasRunning) {
+      try {
+        console.log(chalk.yellow('⚠️  Attempting to restart service with previous binary...'))
+        execSync('sudo systemctl start nulljs', { stdio: 'inherit' })
+        console.log(chalk.green('✅ Service restarted with previous binary'))
+      } catch (restartError) {
+        console.log(chalk.red('❌ Failed to restart service:'), restartError.message)
+      }
+    }
+
+    process.exit(1)
+  }
+}
+
+const host = async (cloudPath?: string, options: { update?: boolean } = {}) => {
+  // Handle update flag
+  if (options.update) {
+    return hostUpdate()
+  }
+
+  validateLinux()
+
+  // Use provided cloud path or default to ~/.nulljs
+  const resolvedCloudPath = cloudPath
+    ? cloudPath.startsWith('/')
+      ? cloudPath
+      : join(process.cwd(), cloudPath)
+    : join(homedir(), '.nulljs')
+
+  console.log(chalk.blue('🚀 Setting up NullJS production hosting...'))
+  console.log(chalk.gray(`   Cloud path: ${resolvedCloudPath}`))
+
+  const serverBinPath = getServerBinPath()
+  validateServerBinary(serverBinPath)
+
+  // Get current user
+  const currentUser = process.env.USER || process.env.USERNAME || 'root'
+  console.log(chalk.blue(`🔧 Setting up service to run as user: ${currentUser}`))
+
+  // Ensure cloud directory exists
+  ensureCloudDirectory(resolvedCloudPath)
+
+  // Check for existing production config or generate new keys
+  let productionConfig = checkExistingProductionConfig(resolvedCloudPath)
+
+  if (!productionConfig) {
+    const { privateKey, publicKey } = await generateProductionKeys()
+    saveProductionConfig(resolvedCloudPath, privateKey, publicKey)
+    productionConfig = { key: { private: privateKey, public: publicKey } }
+
+    console.log(chalk.green('🔑 Production keys generated'))
+    console.log(chalk.blue('📋 Production Public Key:'))
+    console.log(chalk.gray(publicKey))
+  } else {
+    console.log(chalk.green('🔑 Using existing production keys'))
+    console.log(chalk.blue('📋 Production Public Key:'))
+    console.log(chalk.gray(productionConfig.key.public))
+  }
+
+  // Create and install systemd service
+  const serviceContent = createSystemdService(
+    resolvedCloudPath,
+    productionConfig.key.public,
+    serverBinPath,
+    currentUser
+  )
+  installSystemdService(serviceContent)
+
+  console.log(chalk.green('🎉 NullJS hosting setup complete!'))
+  console.log('')
+  console.log(chalk.blue('📋 Service management commands:'))
+  console.log(chalk.gray('   Start:   '), chalk.white('sudo systemctl start nulljs'))
+  console.log(chalk.gray('   Stop:    '), chalk.white('sudo systemctl stop nulljs'))
+  console.log(chalk.gray('   Status:  '), chalk.white('sudo systemctl status nulljs'))
+  console.log(chalk.gray('   Logs:    '), chalk.white('sudo journalctl -u nulljs -f'))
+  console.log('')
+  console.log(chalk.yellow('⚠️  Remember to start the service: sudo systemctl start nulljs'))
+}
+
+export { host, unhost }

package/src/commands/index.ts

@@ -0,0 +1,8 @@
+export * from './deploy'
+export * from './auth'
+export * from './secret'
+export * from './api'
+export * from './create'
+export * from './dev'
+export * from './host'
+export * from './profile'