@tothalex/nulljs 0.0.47 → 0.0.53

package/src/commands/secret.ts

@@ -1,79 +1,387 @@
+import { Command } from 'commander'
 import chalk from 'chalk'
-import fs from 'fs/promises'
-import path, { resolve } from 'path'
+import { resolve } from 'path'
+import { readFile, readdir } from 'fs/promises'
+import { existsSync } from 'fs'
+import * as p from '@clack/prompts'
 
-import { fetchSecretKeys, postSecret } from '../lib/api'
+import { listSecrets, createSecret } from '@nulljs/api'
+import { loadPrivateKey, listConfigs, getConfig, type Config } from '../config'
 
-export const createSecret = async (props: { key: string; value: string }) => {
-  try {
-    await postSecret(props)
-    console.log(chalk.green('Secret stored: ') + chalk.bgGreen.black(props.key))
-  } catch (error) {
-    console.log(error)
-  }
-}
+const selectConfig = async (): Promise<Config | null> => {
+  const configList = listConfigs()
 
-export const listSecretKeys = async () => {
-  const keys = await fetchSecretKeys()
+  if (!configList || configList.configs.length === 0) {
+    return null
+  }
 
-  if (keys.length === 0) {
-    console.log(chalk.yellow('No secrets found'))
-    return
+  if (configList.configs.length === 1) {
+    return configList.configs[0] ?? null
   }
 
-  console.log(chalk.bold.blue('Available secret keys:'))
-  keys.forEach((key, index) => {
-    console.log(chalk.green(`${index + 1}.`), chalk.cyan(key))
+  const selected = await p.select({
+    message: 'Select config',
+    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)
+  }
+
+  return getConfig(selected as string)
 }
 
-export const createSecretsFromFile = async (props: {
-  filePath: string
-  log?: (message: string) => void
-}) => {
-  const logger = props.log || console.log
+const selectFile = async (cwd: string): Promise<string | null> => {
+  const files: string[] = []
 
+  // Find .secret files in current directory
   try {
-    const file = resolve(props.filePath)
-    const fileContent = await fs.readFile(file, 'utf-8')
-    const lines = fileContent.split('\n')
+    const items = await readdir(cwd)
+    for (const item of items) {
+      if (item === '.secret' || item.startsWith('.secret.')) {
+        files.push(item)
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
 
-    let createdCount = 0
+  if (files.length === 0) {
+    console.log(chalk.yellow('No .secret files found in current directory'))
+    return null
+  }
 
-    for (const line of lines) {
-      const trimmedLine = line.trim()
+  const selected = await p.select({
+    message: 'Select file to import secrets from',
+    options: files.map((f) => ({
+      value: f,
+      label: f
+    }))
+  })
 
-      if (!trimmedLine || trimmedLine.startsWith('#')) {
-        continue
-      }
+  if (p.isCancel(selected)) {
+    p.cancel('Cancelled')
+    process.exit(0)
+  }
 
-      const equalIndex = trimmedLine.indexOf('=')
-      if (equalIndex === -1) {
-        logger(chalk.yellow(`Skipping invalid line: ${trimmedLine}`))
-        continue
-      }
+  return resolve(cwd, selected as string)
+}
 
-      const key = trimmedLine.substring(0, equalIndex).trim()
-      const value = trimmedLine.substring(equalIndex + 1).trim()
+const parseEnvFile = async (filePath: string): Promise<Array<{ key: string; value: string }>> => {
+  const content = await readFile(filePath, 'utf-8')
+  const lines = content.split('\n')
+  const secrets: Array<{ key: string; value: string }> = []
 
-      if (!key) {
-        logger(chalk.yellow(`Skipping line with empty key: ${trimmedLine}`))
-        continue
-      }
+  for (const line of lines) {
+    const trimmed = line.trim()
 
-      try {
-        await postSecret({ key, value })
-        logger(chalk.green(`✓ Created secret: ${key}`))
-        createdCount++
-      } catch (error) {
-        logger(chalk.red(`✗ Failed to create secret ${key}:`, error))
-      }
+    // Skip empty lines and comments
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue
     }
 
-    logger(
-      chalk.bold.blue(`\nCreated ${createdCount} secrets from ${path.basename(props.filePath)}`)
-    )
-  } catch (error) {
-    logger(chalk.red(`Error reading file ${props.filePath}:`, error))
+    const equalIndex = trimmed.indexOf('=')
+    if (equalIndex === -1) {
+      continue
+    }
+
+    const key = trimmed.substring(0, equalIndex).trim()
+    let value = trimmed.substring(equalIndex + 1).trim()
+
+    // Remove quotes if present
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1)
+    }
+
+    if (key) {
+      secrets.push({ key, value })
+    }
   }
+
+  return secrets
+}
+
+export const registerSecretCommand = (program: Command) => {
+  program
+    .command('secret')
+    .description('Secret management')
+    .addCommand(
+      new Command('list')
+        .description('List all secret keys')
+        .option('-e, --env <name>', 'Use a specific config environment')
+        .action(async (options: { env?: string }) => {
+          let config: Awaited<ReturnType<typeof selectConfig>>
+
+          try {
+            config = options.env ? getConfig(options.env) : await selectConfig()
+          } catch (err) {
+            console.error(chalk.red('✗ Failed to get config:'), err)
+            process.exit(1)
+          }
+
+          // Allow event loop to clear after p.select
+          await new Promise((resolve) => setImmediate(resolve))
+
+          if (!config) {
+            console.error(chalk.red('✗ No configuration found.'))
+            console.error(chalk.gray('  Run "nulljs dev" first to initialize the project'))
+            process.exit(1)
+          }
+
+          try {
+            console.log(chalk.gray(`Fetching secrets from ${config.api}...`))
+
+            const privateKey = await loadPrivateKey(config)
+            const keys = await listSecrets({ privateKey, url: config.api })
+
+            if (keys.length === 0) {
+              console.log(chalk.yellow('No secrets found'))
+              return
+            }
+
+            console.log(chalk.bold('\nSecret keys:'))
+            keys.forEach((key, index) => {
+              console.log(chalk.green(`  ${index + 1}.`) + ` ${chalk.cyan(key)}`)
+            })
+          } catch (error) {
+            console.error(chalk.red('✗ Failed to list secrets:'), error instanceof Error ? error.message : String(error))
+            process.exit(1)
+          }
+        })
+    )
+    .addCommand(
+      new Command('create')
+        .description('Create a new secret')
+        .argument('[key]', 'Secret key')
+        .argument('[value]', 'Secret value')
+        .option('-e, --env <name>', 'Use a specific config environment')
+        .action(async (key?: string, value?: string, options?: { env?: string }) => {
+          const config = options?.env ? getConfig(options.env) : await selectConfig()
+
+          if (!config) {
+            console.error(chalk.red('✗ No configuration found.'))
+            console.error(chalk.gray('  Run "nulljs dev" first to initialize the project'))
+            process.exit(1)
+          }
+
+          let secretKey = key
+          let secretValue = value
+
+          // Interactive mode
+          if (!secretKey || !secretValue) {
+            if (!secretKey) {
+              const keyInput = await p.text({
+                message: 'Secret key',
+                placeholder: 'e.g., API_KEY, DATABASE_URL',
+                validate: (v) => {
+                  if (!v.trim()) return 'Key is required'
+                  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(v)) {
+                    return 'Key must start with a letter or underscore and contain only letters, numbers, and underscores'
+                  }
+                }
+              })
+
+              if (p.isCancel(keyInput)) {
+                p.cancel('Cancelled')
+                process.exit(0)
+              }
+
+              secretKey = keyInput as string
+            }
+
+            if (!secretValue) {
+              const valueInput = await p.password({
+                message: 'Secret value',
+                validate: (v) => {
+                  if (!v) return 'Value is required'
+                }
+              })
+
+              if (p.isCancel(valueInput)) {
+                p.cancel('Cancelled')
+                process.exit(0)
+              }
+
+              secretValue = valueInput as string
+            }
+          }
+
+          // Allow event loop to clear after prompts
+          await new Promise((resolve) => setImmediate(resolve))
+
+          try {
+            const privateKey = await loadPrivateKey(config)
+            await createSecret(
+              { key: secretKey, value: secretValue },
+              { privateKey, url: config.api }
+            )
+            console.log(chalk.green('✓ Secret created:') + ` ${chalk.cyan(secretKey)}`)
+          } catch (error) {
+            console.error(
+              chalk.red('✗ Failed to create secret:'),
+              error instanceof Error ? error.message : error
+            )
+            process.exit(1)
+          }
+        })
+    )
+    .addCommand(
+      new Command('deploy')
+        .description('Deploy secrets from a .secret file')
+        .argument('[file]', 'Path to .secret file')
+        .option('-e, --env <name>', 'Use a specific config environment')
+        .action(async (file?: string, options?: { env?: string }) => {
+          const config = options?.env ? getConfig(options.env) : await selectConfig()
+
+          if (!config) {
+            console.error(chalk.red('✗ No configuration found.'))
+            console.error(chalk.gray('  Run "nulljs dev" first to initialize the project'))
+            process.exit(1)
+          }
+
+          let filePath = file ? resolve(file) : null
+
+          // Interactive file picker if no file provided
+          if (!filePath) {
+            filePath = await selectFile(process.cwd())
+            if (!filePath) {
+              process.exit(1)
+            }
+          }
+
+          if (!existsSync(filePath)) {
+            console.error(chalk.red(`✗ File not found: ${filePath}`))
+            process.exit(1)
+          }
+
+          // Allow event loop to clear after prompts
+          await new Promise((resolve) => setImmediate(resolve))
+
+          try {
+            const secrets = await parseEnvFile(filePath)
+
+            if (secrets.length === 0) {
+              console.log(chalk.yellow('No secrets found in file'))
+              return
+            }
+
+            const privateKey = await loadPrivateKey(config)
+            let created = 0
+            let failed = 0
+
+            console.log(chalk.cyan(`Deploying ${secrets.length} secret(s) to ${config.name}...\n`))
+
+            for (const secret of secrets) {
+              try {
+                await createSecret(secret, { privateKey, url: config.api })
+                console.log(chalk.green('✓') + ` ${secret.key}`)
+                created++
+              } catch (error) {
+                console.log(
+                  chalk.red('✗') +
+                    ` ${secret.key}: ${error instanceof Error ? error.message : error}`
+                )
+                failed++
+              }
+            }
+
+            console.log('')
+            if (failed > 0) {
+              console.log(chalk.yellow(`Deploy completed: ${created} created, ${failed} failed`))
+            } else {
+              console.log(chalk.green(`Deploy completed: ${created} secret(s) created`))
+            }
+          } catch (error) {
+            console.error(
+              chalk.red('✗ Failed to deploy secrets:'),
+              error instanceof Error ? error.message : error
+            )
+            process.exit(1)
+          }
+        })
+    )
+    .addCommand(
+      new Command('import')
+        .description('Import secrets from a file (alias for deploy)')
+        .argument('[file]', 'Path to .secret file')
+        .option('-e, --env <name>', 'Use a specific config environment')
+        .action(async (file?: string, options?: { env?: string }) => {
+          const config = options?.env ? getConfig(options.env) : await selectConfig()
+
+          if (!config) {
+            console.error(chalk.red('✗ No configuration found.'))
+            console.error(chalk.gray('  Run "nulljs dev" first to initialize the project'))
+            process.exit(1)
+          }
+
+          let filePath = file ? resolve(file) : null
+
+          // Interactive file picker if no file provided
+          if (!filePath) {
+            filePath = await selectFile(process.cwd())
+            if (!filePath) {
+              process.exit(1)
+            }
+          }
+
+          if (!existsSync(filePath)) {
+            console.error(chalk.red(`✗ File not found: ${filePath}`))
+            process.exit(1)
+          }
+
+          // Allow event loop to clear after prompts
+          await new Promise((resolve) => setImmediate(resolve))
+
+          try {
+            const secrets = await parseEnvFile(filePath)
+
+            if (secrets.length === 0) {
+              console.log(chalk.yellow('No secrets found in file'))
+              return
+            }
+
+            const privateKey = await loadPrivateKey(config)
+            let created = 0
+            let failed = 0
+
+            console.log(chalk.cyan(`Importing ${secrets.length} secret(s) to ${config.name}...\n`))
+
+            for (const secret of secrets) {
+              try {
+                await createSecret(secret, { privateKey, url: config.api })
+                console.log(chalk.green('✓') + ` ${secret.key}`)
+                created++
+              } catch (error) {
+                console.log(
+                  chalk.red('✗') +
+                    ` ${secret.key}: ${error instanceof Error ? error.message : error}`
+                )
+                failed++
+              }
+            }
+
+            console.log('')
+            if (failed > 0) {
+              console.log(chalk.yellow(`Import completed: ${created} created, ${failed} failed`))
+            } else {
+              console.log(chalk.green(`Import completed: ${created} secret(s) created`))
+            }
+          } catch (error) {
+            console.error(
+              chalk.red('✗ Failed to import secrets:'),
+              error instanceof Error ? error.message : error
+            )
+            process.exit(1)
+          }
+        })
+    )
 }

package/src/commands/status.ts

@@ -0,0 +1,41 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+
+import { listConfigs } from '../config'
+
+export const registerStatusCommand = (program: Command) => {
+  program.action(() => {
+    const result = listConfigs()
+
+    if (result && result.configs.length > 0) {
+      const currentConfig = result.configs.find((c) => c.name === result.current)
+      if (currentConfig) {
+        console.log(chalk.green('●') + ' ' + chalk.bold(`Active: ${currentConfig.name}`))
+        console.log(chalk.blue('  API:') + ` ${currentConfig.api}`)
+        console.log(chalk.blue('  Public Key:') + ` ${currentConfig.key.public.substring(0, 20)}...`)
+
+        if (result.configs.length > 1) {
+          console.log(chalk.gray(`\n  ${result.configs.length - 1} other config(s) available`))
+        }
+      }
+    } else {
+      console.log(chalk.yellow('○ No local configuration found.'))
+      console.log(chalk.gray('  Run "nulljs dev" to initialize the project'))
+    }
+
+    printAvailableCommands()
+  })
+}
+
+const printAvailableCommands = () => {
+  console.log('\n' + chalk.bold('Commands:'))
+  console.log(chalk.cyan('  nulljs dev') + chalk.gray(' - Launch development server'))
+  console.log(chalk.cyan('  nulljs deploy') + chalk.gray(' - Deploy all functions and React apps'))
+  console.log(chalk.cyan('  nulljs config list') + chalk.gray(' - List all configurations'))
+  console.log(chalk.cyan('  nulljs config new') + chalk.gray(' - Create new configuration'))
+  console.log(chalk.cyan('  nulljs config use') + chalk.gray(' - Switch active configuration'))
+  console.log(chalk.cyan('  nulljs secret list') + chalk.gray(' - List all secret keys'))
+  console.log(chalk.cyan('  nulljs secret create') + chalk.gray(' - Create a new secret'))
+  console.log(chalk.cyan('  nulljs secret deploy') + chalk.gray(' - Deploy secrets from .secret file'))
+  console.log(chalk.cyan('  nulljs host') + chalk.gray(' - Set up production hosting with systemd'))
+}

package/src/components/DeployAnimation.tsx

@@ -0,0 +1,92 @@
+import { useEffect, useState, useRef } from 'react'
+
+export type DeployedFunction = {
+  name: string
+  success: boolean
+  error?: string
+}
+
+export const DeployAnimation = (props: {
+  deployed: DeployedFunction[]
+  onComplete: () => void
+}) => {
+  const [currentIndex, setCurrentIndex] = useState(0)
+  const [progress, setProgress] = useState(0)
+  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null)
+  const completedRef = useRef(false)
+
+  const duration = 400 // ms per item
+  const frameRate = 16 // ~60fps
+
+  useEffect(() => {
+    if (props.deployed.length === 0) {
+      props.onComplete()
+      return
+    }
+
+    if (completedRef.current) {
+      return
+    }
+
+    // Reset progress for new item
+    setProgress(0)
+    const startTime = Date.now()
+
+    intervalRef.current = setInterval(() => {
+      const elapsed = Date.now() - startTime
+      const newProgress = Math.min(100, (elapsed / duration) * 100)
+      setProgress(newProgress)
+
+      if (newProgress >= 100) {
+        if (intervalRef.current) {
+          clearInterval(intervalRef.current)
+          intervalRef.current = null
+        }
+
+        // Move to next or complete
+        setTimeout(() => {
+          if (currentIndex >= props.deployed.length - 1) {
+            completedRef.current = true
+            props.onComplete()
+          } else {
+            setCurrentIndex((prev) => prev + 1)
+          }
+        }, 150)
+      }
+    }, frameRate)
+
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current)
+      }
+    }
+  }, [currentIndex, props.deployed.length, props.onComplete])
+
+  const current = props.deployed[currentIndex]
+
+  if (props.deployed.length === 0 || !current || completedRef.current) {
+    return null
+  }
+
+  const barWidth = 8
+  const filled = Math.round((progress / 100) * barWidth)
+  const empty = barWidth - filled
+  const bar = '━'.repeat(filled) + '─'.repeat(empty)
+
+  return (
+    <box backgroundColor="black" flexDirection="row" paddingLeft={1} paddingRight={1}>
+      <text>
+        <span fg={current.success ? '#22c55e' : '#ef4444'}>
+          {bar} {current.success ? '✓' : '✗'}
+        </span>
+        <span> {current.name}</span>
+        {props.deployed.length > 1 && (
+          <span fg="#666">
+            {' '}
+            ({currentIndex + 1}/{props.deployed.length})
+          </span>
+        )}
+      </text>
+    </box>
+  )
+}

package/src/components/DeploymentLogsPane.tsx

@@ -0,0 +1,79 @@
+import type { LogEntry } from '@nulljs/api'
+
+interface DeploymentLogsPaneProps {
+  logs: LogEntry[]
+  loading: boolean
+  autoScroll: boolean
+  jumpTrigger: number
+}
+
+const getLevelColor = (level: string): string => {
+  switch (level.toLowerCase()) {
+    case 'error':
+      return 'red'
+    case 'warn':
+    case 'warning':
+      return 'yellow'
+    case 'info':
+      return 'cyan'
+    case 'debug':
+      return 'gray'
+    default:
+      return 'white'
+  }
+}
+
+const sanitizeMessage = (message: string): string => {
+  return message
+    .replace(/\x1b\[[0-9;]*m/g, '')
+    .replace(/[\r\n]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+export const DeploymentLogsPane = (props: DeploymentLogsPaneProps) => {
+  if (props.loading && props.logs.length === 0) {
+    return (
+      <box flexDirection="column" padding={1}>
+        <text>Loading deployment logs...</text>
+      </box>
+    )
+  }
+
+  if (!props.loading && props.logs.length === 0) {
+    return (
+      <box flexDirection="column" padding={1}>
+        <text>No deployment logs found</text>
+      </box>
+    )
+  }
+
+  // Reverse logs so oldest are at top, newest at bottom
+  const logsInOrder = [...props.logs].reverse()
+
+  return (
+    <scrollbox
+      focused
+      stickyStart={props.autoScroll ? 'bottom' : 'top'}
+      stickyScroll={props.autoScroll}
+      key={`${props.autoScroll}-${props.jumpTrigger}`}>
+      {logsInOrder.map((log) => {
+        const time = new Date(log.time).toLocaleTimeString()
+        const timestamp = `[${time}]`
+        const level = log.level.toUpperCase()
+
+        return (
+          <box key={log.id} flexDirection="row">
+            <text>
+              <span fg="gray">{timestamp}</span>
+              <span fg={getLevelColor(log.level)}>{` ${level} `}</span>
+              <span fg="blue">{`(${log.deployment_name})`}</span>
+              <span fg="cyan">{` ${log.trigger} `}</span>
+              <span>{sanitizeMessage(log.message)}</span>
+            </text>
+          </box>
+        )
+      })}
+    </scrollbox>
+  )
+}