@tothalex/nulljs 0.0.48 → 0.0.53

package/package.json

@@ -1,46 +1,36 @@
 {
   "name": "@tothalex/nulljs",
-  "module": "index.ts",
-  "version": "0.0.48",
+  "module": "src/index.tsx",
+  "version": "0.0.53",
   "type": "module",
   "bin": {
-    "nulljs": "./src/index.ts"
+    "nulljs": "./src/cli.ts"
   },
   "scripts": {
-    "postinstall": "bun scripts/install-server.js"
+    "dev": "bun run src/cli.ts dev"
   },
-  "files": [
-    "src",
-    "scripts"
-  ],
   "devDependencies": {
-    "@eslint/js": "^9.20.0",
-    "@types/bun": "1.2.16",
-    "@types/degit": "^2.8.6",
-    "@types/mime-types": "^2.1.4",
-    "@types/yargs": "^17.0.33",
-    "eslint": "^9.20.1",
-    "rollup": "^4.30.1",
-    "typescript-eslint": "^8.24.0"
+    "@types/bun": "latest",
+    "@types/react": "^19.2.3"
   },
   "peerDependencies": {
-    "typescript": "~5.7.2"
+    "typescript": "^5"
+  },
+  "optionalDependencies": {
+    "@tothalex/nulljs-darwin-arm64": "^0.0.79",
+    "@tothalex/nulljs-linux-arm64": "^0.0.79",
+    "@tothalex/nulljs-linux-x64": "^0.0.79"
   },
   "dependencies": {
-    "@tailwindcss/vite": "^4.1.11",
-    "@types/react": "^19.1.11",
-    "@vitejs/plugin-react": "^4.3.4",
-    "@vitejs/plugin-react-swc": "^3.8.0",
-    "chalk": "^5.4.1",
-    "chokidar": "^4.0.3",
-    "degit": "^2.8.4",
-    "execa": "^9.6.0",
-    "glob": "^11.0.3",
-    "ink": "^6.5.1",
-    "mime-types": "^2.1.35",
-    "react": "^19.1.1",
-    "tar": "^7.5.2",
-    "vite": "^7.0.0",
-    "yargs": "^17.7.2"
+    "@clack/prompts": "^0.11.0",
+    "@nulljs/api": "workspace:*",
+    "@opentui/core": "^0.1.62",
+    "@opentui/react": "^0.1.62",
+    "@tailwindcss/vite": "^4.1.18",
+    "@vitejs/plugin-react": "^5.1.2",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "react": "^19.2.3",
+    "vite": "^7.3.0"
   }
 }

package/src/cli.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+import { Command } from 'commander'
+
+import {
+  registerDevCommand,
+  registerDeployCommand,
+  registerConfigCommand,
+  registerStatusCommand,
+  registerSecretCommand,
+  registerHostCommand
+} from './commands'
+
+const program = new Command()
+
+program.name('nulljs').description('NullJS CLI').version('0.0.49')
+
+registerDevCommand(program)
+registerDeployCommand(program)
+registerConfigCommand(program)
+registerStatusCommand(program)
+registerSecretCommand(program)
+registerHostCommand(program)
+
+program.parse()

package/src/commands/config.ts

@@ -0,0 +1,130 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import * as p from '@clack/prompts'
+
+import { createConfig, listConfigs, useConfig } from '../config'
+
+export const registerConfigCommand = (program: Command) => {
+  program
+    .command('config')
+    .description('Configuration management')
+    .addCommand(
+      new Command('new')
+        .description('Create a new configuration')
+        .argument('[name]', 'Configuration name (e.g., prod, staging)')
+        .argument('[api]', 'API endpoint (e.g., https://api.example.com)')
+        .action(async (name?: string, api?: string) => {
+          let configName = name
+          let configApi = api
+
+          // Interactive mode if no arguments provided
+          if (!configName || !configApi) {
+            p.intro(chalk.cyan('Create new configuration'))
+
+            if (!configName) {
+              const nameInput = await p.text({
+                message: 'Configuration name',
+                placeholder: 'e.g., prod, staging',
+                validate: (value) => {
+                  if (!value.trim()) return 'Name is required'
+                  if (!/^[a-zA-Z0-9-_]+$/.test(value)) {
+                    return 'Name can only contain letters, numbers, hyphens and underscores'
+                  }
+                }
+              })
+
+              if (p.isCancel(nameInput)) {
+                p.cancel('Configuration cancelled')
+                process.exit(0)
+              }
+
+              configName = nameInput as string
+            }
+
+            if (!configApi) {
+              const apiInput = await p.text({
+                message: 'API endpoint',
+                placeholder: 'e.g., https://api.example.com',
+                validate: (value) => {
+                  if (!value.trim()) return 'API endpoint is required'
+                  try {
+                    new URL(value)
+                  } catch {
+                    return 'Please enter a valid URL'
+                  }
+                }
+              })
+
+              if (p.isCancel(apiInput)) {
+                p.cancel('Configuration cancelled')
+                process.exit(0)
+              }
+
+              configApi = apiInput as string
+            }
+          }
+
+          await createConfig(configName, configApi)
+        })
+    )
+    .addCommand(
+      new Command('list').description('List all configurations').action(() => {
+        const result = listConfigs()
+
+        if (!result || result.configs.length === 0) {
+          console.log(chalk.yellow('No configurations found.'))
+          console.log(chalk.gray('  Run "nulljs dev" to create a dev config, or'))
+          console.log(chalk.gray('  Run "nulljs config new <name> <api>" to create a new config'))
+          return
+        }
+
+        console.log(chalk.bold('Configurations:'))
+        result.configs.forEach((config) => {
+          const isActive = config.name === result.current
+          const marker = isActive ? chalk.green('●') : chalk.gray('○')
+          const name = isActive ? chalk.green(config.name) : config.name
+          const suffix = isActive ? chalk.green(' (active)') : ''
+          console.log(`  ${marker} ${name}${suffix}`)
+          console.log(chalk.gray(`    API: ${config.api}`))
+        })
+      })
+    )
+    .addCommand(
+      new Command('use')
+        .description('Switch to a configuration')
+        .argument('[name]', 'Configuration name')
+        .action(async (name?: string) => {
+          let configName = name
+
+          if (!configName) {
+            const configList = listConfigs()
+
+            if (!configList || configList.configs.length === 0) {
+              console.log(chalk.yellow('No configurations found.'))
+              console.log(chalk.gray('  Run "nulljs dev" to create a dev config, or'))
+              console.log(chalk.gray('  Run "nulljs config new" to create a new config'))
+              return
+            }
+
+            const selected = await p.select({
+              message: 'Select config to use',
+              options: configList.configs.map((c) => ({
+                value: c.name,
+                label: c.name,
+                hint: c.name === configList.current ? 'current' : c.api
+              })),
+              initialValue: configList.current
+            })
+
+            if (p.isCancel(selected)) {
+              p.cancel('Cancelled')
+              process.exit(0)
+            }
+
+            configName = selected as string
+          }
+
+          useConfig(configName)
+        })
+    )
+}

package/src/commands/deploy.ts

@@ -1,160 +1,219 @@
-import { resolve } from 'path'
-import { readdir, exists, stat } from 'node:fs/promises'
+import type { Command } from 'commander'
 import chalk from 'chalk'
-import chokidar from 'chokidar'
+import { basename, resolve, join } from 'path'
+import { existsSync } from 'fs'
+import { readdir } from 'fs/promises'
+import * as p from '@clack/prompts'
 
-import { deployFunction, deployPage, isReact, isTypescript } from '../lib/deployment'
-import { requireProfileConfiguration } from '../lib/config'
+import { loadPrivateKey, readLocalConfig, getConfig, listConfigs, type Config } from '../config'
+import { isReact } from '../lib/bundle'
+import { deployFunction, deployReact, clearDeployCache } from '../lib/deploy'
 
-const deployFunctionsRecursively = async (functionsPath: string, force: boolean = true) => {
-  if (!(await exists(functionsPath))) {
-    return
+const FUNCTION_DIRS = ['api', 'cron', 'event']
+
+const selectConfig = async (): Promise<Config | null> => {
+  const configList = listConfigs()
+
+  if (!configList || configList.configs.length === 0) {
+    return null
   }
 
-  const functionsStat = await stat(functionsPath)
-  if (!functionsStat.isDirectory()) {
-    return
+  // If only one config, use it directly
+  if (configList.configs.length === 1) {
+    return configList.configs[0] ?? null
   }
 
-  const items = await readdir(functionsPath)
-  for (const item of items) {
-    const fullPath = `${functionsPath}/${item}`
-    const itemStat = await stat(fullPath)
-
-    if (itemStat.isDirectory()) {
-      // Recursively process subdirectories
-      await deployFunctionsRecursively(fullPath, force)
-    } else if (isTypescript(item)) {
-      const result = await deployFunction(fullPath, console, force)
-
-      if (result.error) {
-        console.log(chalk.red(`${item} deployment failed: ${result.error.message}`))
-      } else if (result.cached) {
-        console.log(chalk.gray(`${item} skipped (no changes)`))
-      } else if (result.deployed) {
-        console.log(chalk.green(`${item} deployed successfully`))
-      }
-    }
+  const selected = await p.select({
+    message: 'Select config to deploy to',
+    options: configList.configs.map((c) => ({
+      value: c.name,
+      label: c.name,
+      hint: c.name === configList.current ? 'current' : c.api
+    })),
+    initialValue: configList.current
+  })
+
+  if (p.isCancel(selected)) {
+    p.cancel('Deployment cancelled')
+    process.exit(0)
   }
+
+  return getConfig(selected as string)
 }
 
-const deploy = async (path?: string, force: boolean = true) => {
-  // Ensure a profile is selected and properly configured for deployment
-  const { profileName, config } = requireProfileConfiguration(['api', 'key'])
-  console.log(chalk.gray(`Using profile: ${profileName}`))
-  console.log(config.api ? chalk.gray(`API: ${config.api}`) : '')
-  console.log(config.key?.public ? chalk.gray(`Key: ${config.key.public}`) : '')
-
-  let deployPath = path
-
-  // If no path provided, look for index.tsx
-  if (!deployPath) {
-    const indexPath = resolve('src/index.tsx')
-    if (await exists(indexPath)) {
-      deployPath = indexPath
-    } else {
-      deployPath = resolve('.')
+const findAllDeployables = async (srcPath: string) => {
+  const functions: string[] = []
+
+  // Find functions in src/function/{api,cron,event}/
+  const functionsPath = join(srcPath, 'function')
+  for (const dir of FUNCTION_DIRS) {
+    const dirPath = join(functionsPath, dir)
+    try {
+      const items = await readdir(dirPath, { withFileTypes: true })
+      for (const item of items) {
+        if (item.isFile() && (item.name.endsWith('.ts') || item.name.endsWith('.tsx'))) {
+          functions.push(join(dirPath, item.name))
+        }
+      }
+    } catch {
+      // Directory doesn't exist
     }
   }
 
-  if (!(await exists(deployPath))) {
-    console.log(chalk.red("Path doesn't exists: ") + chalk.bgRed(deployPath))
-    process.exit(0)
-  }
+  // React entrypoint is always src/index.tsx
+  const reactEntry = join(srcPath, 'index.tsx')
+  const hasReact = existsSync(reactEntry)
 
-  const pathStat = await stat(deployPath)
+  return { functions, reactEntry: hasReact ? reactEntry : null }
+}
 
-  if (pathStat.isFile()) {
-    const file = resolve(deployPath)
+const deployAll = async (config: Config, options: { force?: boolean }) => {
+  const srcPath = join(process.cwd(), 'src')
 
-    if (isReact(file)) {
-      console.log(`${chalk.gray('Deploying page: ')} ${chalk.green(file)}`)
-      await deployPage(file)
-    }
+  if (!existsSync(srcPath)) {
+    console.error(chalk.red('✗ No src directory found'))
+    process.exit(1)
+  }
 
-    // Also deploy functions directory recursively
-    const functionsPath = resolve('src/function')
-    await deployFunctionsRecursively(functionsPath, force)
+  const { functions, reactEntry } = await findAllDeployables(srcPath)
+  const total = functions.length + (reactEntry ? 1 : 0)
 
+  if (total === 0) {
+    console.log(chalk.yellow('No functions or React app found to deploy'))
     return
   }
 
-  const dir = await readdir(deployPath)
-  const p = resolve(deployPath)
-  for (const file of dir) {
-    if (isTypescript(file)) {
-      const result = await deployFunction(`${p}/${file}`, console, force)
-
-      if (result.error) {
-        console.log(chalk.red(`${file} deployment failed: ${result.error.message}`))
-      } else if (result.cached) {
-        console.log(chalk.gray(`${file} skipped (no changes)`))
-      } else if (result.deployed) {
-        console.log(chalk.green(`${file} deployed successfully`))
-      }
-    }
+  if (options.force) {
+    clearDeployCache()
+  }
 
-    if (isReact(file)) {
-      await deployPage(`${p}/${file}`)
+  const privateKey = await loadPrivateKey(config)
+  let successful = 0
+  let failed = 0
+  let skipped = 0
+
+  console.log(chalk.cyan(`Deploying ${total} file(s) to ${config.name}...\n`))
+
+  // Deploy functions
+  for (const filePath of functions) {
+    const fileName = basename(filePath)
+    try {
+      console.log(chalk.yellow('Bundling ') + chalk.bold(fileName))
+      const result = await deployFunction(filePath, privateKey, config.api)
+      if (result.skipped) {
+        console.log(chalk.gray('– Skipped ') + chalk.bold(fileName) + chalk.gray(' (unchanged)'))
+        skipped++
+      } else {
+        console.log(chalk.green('✓ Deployed ') + chalk.bold(fileName))
+        successful++
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Failed ') + chalk.bold(fileName) + chalk.red(`: ${error instanceof Error ? error.message : error}`))
+      failed++
     }
   }
 
-  // Also deploy functions directory recursively
-  const functionsPath = resolve('src/function')
-  await deployFunctionsRecursively(functionsPath, force)
-}
-
-const onFileChange = async (file: string) => {
-  const absolutePath = resolve(file)
-  console.log(`File changed: ${absolutePath}`)
-
-  try {
-    const indexPage = resolve('src/index.tsx')
-    if (await exists(indexPage)) {
-      if (isReact(indexPage)) {
-        await deployPage(indexPage)
+  // Deploy React app (src/index.tsx)
+  if (reactEntry) {
+    const fileName = basename(reactEntry)
+    try {
+      console.log(chalk.yellow('Bundling React SPA ') + chalk.bold(fileName))
+      const result = await deployReact(reactEntry, privateKey, config.api)
+      if (result.skipped) {
+        console.log(chalk.gray('– Skipped ') + chalk.bold(fileName) + chalk.gray(' (unchanged)'))
+        skipped++
+      } else {
+        console.log(chalk.green('✓ Deployed ') + chalk.bold(fileName))
+        successful++
       }
+    } catch (error) {
+      console.error(chalk.red('✗ Failed ') + chalk.bold(fileName) + chalk.red(`: ${error instanceof Error ? error.message : error}`))
+      failed++
     }
+  }
 
-    // Deploy all files in src/functions/ directory recursively
-    const functionsPath = resolve('src/function')
-    await deployFunctionsRecursively(functionsPath)
-  } catch (error) {
-    console.error(chalk.red('Deployment failed:'), error)
+  console.log('')
+  if (failed > 0) {
+    console.log(chalk.red(`Deployment completed with errors: ${successful} deployed, ${skipped} skipped, ${failed} failed`))
+    process.exit(1)
+  } else {
+    console.log(chalk.green(`Deployment completed: ${successful} deployed, ${skipped} skipped`))
   }
 }
 
-const watch = async (path: string) => {
-  // Ensure a profile is selected and properly configured for deployment
-  const { profileName } = requireProfileConfiguration(['api', 'key'])
-  console.log(chalk.gray(`Using profile: ${profileName}`))
+export const registerDeployCommand = (program: Command) => {
+  program
+    .command('deploy')
+    .description('Bundle and deploy functions and React SPAs')
+    .argument('[file]', 'Path to a specific file (deploys all if omitted)')
+    .option('-e, --env <name>', 'Use a specific config environment')
+    .option('-f, --force', 'Force deploy even if unchanged')
+    .action(async (file: string | undefined, options: { env?: string; force?: boolean }) => {
+      let config: Config | null
+
+      if (options.env) {
+        // Use specified config
+        config = getConfig(options.env)
+        if (!config) {
+          console.error(chalk.red(`✗ Config "${options.env}" not found.`))
+          console.error(chalk.gray('  Run "nulljs config list" to see available configs'))
+          process.exit(1)
+        }
+      } else {
+        // Interactive picker
+        config = await selectConfig()
+        if (!config) {
+          console.error(chalk.red('✗ No configurations found.'))
+          console.error(chalk.gray('  Run "nulljs dev" first to initialize the project'))
+          process.exit(1)
+        }
+      }
 
-  if (!exists(path)) {
-    console.log(chalk.red("Path doesn't exists: ") + chalk.bgRed(path))
-    process.exit(0)
-  }
+      // If no file specified, deploy all
+      if (!file) {
+        await deployAll(config, options)
+        return
+      }
 
-  const watcher = chokidar.watch(`${path}`, {
-    ignored: (path) => ['node_modules', '.git'].some((s) => path.includes(s)),
-    persistent: true,
-    ignoreInitial: true,
-    cwd: process.cwd()
-  })
+      // Single file deployment
+      const filePath = resolve(file)
 
-  watcher
-    .on('add', (filePath) => onFileChange(filePath))
-    .on('change', (filePath) => onFileChange(filePath))
-    .on('ready', () => {
-      console.log('Initial scan complete. Ready for changes')
-    })
+      if (!existsSync(filePath)) {
+        console.error(chalk.red(`✗ File not found: ${filePath}`))
+        process.exit(1)
+      }
 
-  process.on('SIGINT', () => {
-    console.log('\nShutting down file watcher...')
-    watcher.close().then(() => {
-      console.log('File watcher stopped')
-      process.exit(0)
+      if (options.force) {
+        clearDeployCache()
+      }
+
+      const fileName = basename(filePath)
+      const privateKey = await loadPrivateKey(config)
+
+      try {
+        if (isReact(filePath)) {
+          console.log(chalk.yellow('Bundling React SPA ') + chalk.bold(fileName))
+          const result = await deployReact(filePath, privateKey, config.api)
+          if (result.skipped) {
+            console.log(chalk.gray('– Skipped ') + chalk.bold(fileName) + chalk.gray(' (unchanged)'))
+          } else {
+            console.log(chalk.green('✓ Deployed ') + chalk.bold(fileName) + chalk.gray(` to ${config.name}`))
+          }
+        } else {
+          console.log(chalk.yellow('Bundling ') + chalk.bold(fileName))
+          const result = await deployFunction(filePath, privateKey, config.api)
+          if (result.skipped) {
+            console.log(chalk.gray('– Skipped ') + chalk.bold(fileName) + chalk.gray(' (unchanged)'))
+          } else {
+            console.log(chalk.green('✓ Deployed ') + chalk.bold(fileName) + chalk.gray(` to ${config.name}`))
+          }
+        }
+      } catch (error) {
+        console.error(
+          chalk.red('✗ Deployment failed:'),
+          error instanceof Error ? error.message : error
+        )
+        process.exit(1)
+      }
     })
-  })
 }
-
-export { deploy, watch }

package/src/commands/dev.ts

@@ -0,0 +1,10 @@
+import type { Command } from 'commander'
+
+export const registerDevCommand = (program: Command) => {
+  program
+    .command('dev')
+    .description('Launch the development renderer')
+    .action(async () => {
+      await import('../ui.tsx')
+    })
+}