@tothalex/nulljs 0.0.47 → 0.0.53

package/src/ui.tsx

@@ -0,0 +1,363 @@
+import { useEffect, useState } from 'react'
+import { createCliRenderer } from '@opentui/core'
+import { createRoot } from '@opentui/react'
+import {
+  getSystemLogs,
+  searchDeploymentLogs,
+  type LogEntry,
+  type SystemLogEntry
+} from '@nulljs/api'
+
+import { startServer, type BinarySource } from './lib/server'
+import { startWatcher, forceDeployAll } from './lib/watcher'
+import { startViteServer, stopViteServer } from './lib/vite'
+import { getOrCreateLocalDevConfig, type Config } from './config'
+import { DeploymentLogsPane } from './components/DeploymentLogsPane'
+import { SystemLogsPane } from './components/SystemLogsPane'
+import { DeployAnimation, type DeployedFunction } from './components/DeployAnimation'
+import { Header } from './components/Header'
+import { HelpModal } from './components/HelpModal'
+
+type WatcherEvent = {
+  type: 'deploy' | 'change'
+  deployed?: DeployedFunction[]
+  filePath?: string
+  success?: boolean
+  skipped?: boolean
+  error?: string
+  affectedCount?: number
+  timestamp: Date
+}
+
+const App = (props: {
+  config: Config
+  binarySource: BinarySource
+  functionCount: number
+  viteRunning: boolean
+  onWatcherEvent: (handler: (event: WatcherEvent) => void) => void
+  onForceDeploy: () => Promise<void>
+}) => {
+  const [error, setError] = useState<string | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [deploymentLogs, setDeploymentLogs] = useState<LogEntry[]>([])
+  const [systemLogs, setSystemLogs] = useState<SystemLogEntry[]>([])
+  const [activeTab, setActiveTab] = useState<'deployment' | 'system'>('system')
+  const [autoScroll, setAutoScroll] = useState(true)
+  const [jumpTrigger, setJumpTrigger] = useState(0)
+  const [watcherStatus, setWatcherStatus] = useState<WatcherEvent | null>(null)
+  const [showKeyBindings, setShowKeyBindings] = useState(false)
+  const [isDeploying, setIsDeploying] = useState(false)
+
+  useEffect(() => {
+    props.onWatcherEvent((event) => {
+      console.error('DEBUG: received watcher event:', event.type, event.deployed?.length)
+      setWatcherStatus(event)
+    })
+  }, [props.onWatcherEvent])
+
+  useEffect(() => {
+    const fn = async () => {
+      try {
+        setLoading(true)
+        setError(null)
+
+        const [deploymentLogsData, systemLogsData] = await Promise.all([
+          searchDeploymentLogs(props.config.key.public, { limit: 100 }, props.config.api),
+          getSystemLogs(props.config.key.public, { limit: 100 }, props.config.api)
+        ])
+
+        setDeploymentLogs(deploymentLogsData)
+        setSystemLogs(systemLogsData)
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err))
+        console.error('Failed to fetch logs:', err)
+      } finally {
+        setLoading(false)
+      }
+    }
+
+    fn()
+  }, [props.config.key.public, props.config.api])
+
+  // Poll for new logs every 2 seconds
+  useEffect(() => {
+    const interval = setInterval(async () => {
+      if (loading) return
+
+      try {
+        const [newDeploymentLogs, newSystemLogs] = await Promise.all([
+          searchDeploymentLogs(props.config.key.public, { limit: 100 }, props.config.api),
+          getSystemLogs(props.config.key.public, { limit: 100 }, props.config.api)
+        ])
+
+        // Only update if we have new logs
+        if (newDeploymentLogs.length > 0) {
+          setDeploymentLogs(newDeploymentLogs)
+        }
+        if (newSystemLogs.length > 0) {
+          setSystemLogs(newSystemLogs)
+        }
+      } catch (err) {
+        console.error('Failed to poll for new logs:', err)
+      }
+    }, 2000)
+
+    return () => clearInterval(interval)
+  }, [loading, props.config.key.public, props.config.api])
+
+  useEffect(() => {
+    const handleKeyPress = (data: Buffer) => {
+      const key = data.toString()
+
+      // Number keys to jump to specific panel
+      if (key === '1') {
+        setActiveTab('system')
+        return
+      }
+      if (key === '2') {
+        setActiveTab('deployment')
+        return
+      }
+
+      // Tab key cycles between panels
+      if (key === '\t') {
+        setActiveTab((prev) => (prev === 'system' ? 'deployment' : 'system'))
+        return
+      }
+
+      // h/l for vim-style navigation
+      if (key === 'h') {
+        setActiveTab('system')
+        return
+      }
+      if (key === 'l') {
+        setActiveTab('deployment')
+        return
+      }
+
+      // g - jump to top and disable auto-scroll
+      if (key === 'g') {
+        setAutoScroll(false)
+        setJumpTrigger((prev) => prev + 1)
+        return
+      }
+
+      // Shift+G - jump to bottom and enable auto-scroll
+      if (key === 'G') {
+        setAutoScroll(true)
+        setJumpTrigger((prev) => prev + 1)
+        return
+      }
+
+      // ? - toggle key bindings modal
+      if (key === '?') {
+        setShowKeyBindings((prev) => !prev)
+        return
+      }
+
+      // ESC - close key bindings modal
+      if (key === '\x1b') {
+        setShowKeyBindings(false)
+        return
+      }
+
+      // d - force deploy all
+      if (key === 'd' && !isDeploying) {
+        setIsDeploying(true)
+        props.onForceDeploy().finally(() => {
+          setIsDeploying(false)
+        })
+        return
+      }
+    }
+
+    process.stdin.setRawMode(true)
+    process.stdin.on('data', handleKeyPress)
+
+    return () => {
+      process.stdin.setRawMode(false)
+      process.stdin.off('data', handleKeyPress)
+    }
+  }, [isDeploying, props.onForceDeploy])
+
+  if (error) {
+    return (
+      <box flexGrow={1} flexDirection="column" padding={1}>
+        <text>
+          <span fg="red">Error: {error}</span>
+        </text>
+      </box>
+    )
+  }
+
+  return (
+    <box flexDirection="column">
+      <Header
+        activeTab={activeTab}
+        functionCount={props.functionCount}
+        viteRunning={props.viteRunning}
+        isDeploying={isDeploying}
+        binarySource={props.binarySource}
+      />
+
+      <box paddingTop={1} flexDirection="column">
+        {activeTab === 'system' ? (
+          <SystemLogsPane
+            logs={systemLogs}
+            loading={loading}
+            autoScroll={autoScroll}
+            jumpTrigger={jumpTrigger}
+          />
+        ) : (
+          <DeploymentLogsPane
+            logs={deploymentLogs}
+            loading={loading}
+            autoScroll={autoScroll}
+            jumpTrigger={jumpTrigger}
+          />
+        )}
+        {watcherStatus?.type === 'deploy' &&
+          watcherStatus.deployed &&
+          watcherStatus.deployed.length > 0 && (
+            <DeployAnimation
+              deployed={watcherStatus.deployed}
+              onComplete={() => {
+                console.error('DEBUG: animation complete')
+                setWatcherStatus(null)
+              }}
+            />
+          )}
+      </box>
+
+      <HelpModal visible={showKeyBindings} />
+    </box>
+  )
+}
+
+const main = async () => {
+  let serverInfo: Awaited<ReturnType<typeof startServer>> | null = null
+  let viteInfo: Awaited<ReturnType<typeof startViteServer>> | null = null
+  let stopWatcher: (() => void) | null = null
+  let isCleaningUp = false
+
+  const cleanup = async (exitAfter = true) => {
+    if (isCleaningUp) return
+    isCleaningUp = true
+
+    if (stopWatcher) {
+      stopWatcher()
+      stopWatcher = null
+    }
+    if (viteInfo) {
+      await stopViteServer(viteInfo)
+      viteInfo = null
+    }
+    if (serverInfo) {
+      const pid = serverInfo.process.pid
+      serverInfo = null
+      try {
+        // Kill the server process and its children
+        process.kill(pid, 'SIGTERM')
+      } catch {
+        // Process might already be dead
+      }
+    }
+    if (exitAfter) {
+      process.exit(0)
+    }
+  }
+
+  process.on('SIGINT', () => cleanup(true))
+  process.on('SIGTERM', () => cleanup(true))
+  process.on('exit', () => cleanup(false))
+
+  try {
+    serverInfo = await startServer()
+
+    const devConfig = await getOrCreateLocalDevConfig()
+
+    const srcPath = process.cwd() + '/src'
+
+    viteInfo = await startViteServer({
+      srcDir: srcPath,
+      onLog: (_msg, _level) => {}
+    })
+
+    let watcherEventHandler: ((event: WatcherEvent) => void) | null = null
+    let pendingEvents: WatcherEvent[] = []
+    let functionCount = 0
+
+    const sendEvent = (event: WatcherEvent) => {
+      if (watcherEventHandler) {
+        watcherEventHandler(event)
+      } else {
+        pendingEvents.push(event)
+      }
+    }
+
+    const renderer = await createCliRenderer()
+    const root = createRoot(renderer)
+
+    const handleForceDeploy = async () => {
+      const deployResults: DeployedFunction[] = []
+
+      await forceDeployAll(srcPath, {
+        onDeploy: (filePath, success, error) => {
+          deployResults.push({ name: filePath, success, error })
+        }
+      })
+
+      if (deployResults.length > 0) {
+        sendEvent({
+          type: 'deploy',
+          deployed: deployResults,
+          timestamp: new Date()
+        })
+      }
+    }
+
+    // Start watcher after renderer is ready
+    stopWatcher = await startWatcher(srcPath, {
+      silent: true,
+      onReady: (count) => {
+        functionCount = count
+      },
+      onDeployBatch: (results) => {
+        sendEvent({
+          type: 'deploy',
+          deployed: results.map((r) => ({
+            name: r.name,
+            success: r.success,
+            error: r.error
+          })),
+          timestamp: new Date()
+        })
+      }
+    })
+
+    root.render(
+      <App
+        config={devConfig}
+        binarySource={serverInfo.binarySource}
+        functionCount={functionCount}
+        viteRunning={viteInfo !== null}
+        onWatcherEvent={(handler) => {
+          watcherEventHandler = handler
+          // Flush any pending events
+          if (pendingEvents.length > 0) {
+            for (const event of pendingEvents) {
+              handler(event)
+            }
+            pendingEvents = []
+          }
+        }}
+        onForceDeploy={handleForceDeploy}
+      />
+    )
+  } catch (error) {
+    console.error('Failed to start server:', error)
+    cleanup()
+  }
+}
+
+main()

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/scripts/install-server.js

@@ -1,199 +0,0 @@
-#!/usr/bin/env bun
-
-const https = require('https')
-const fs = require('fs')
-const path = require('path')
-const { createWriteStream } = require('fs')
-const tar = require('tar')
-
-// --- Configuration ---
-const S3_BASE_URL = 'https://nulljs.s3.eu-north-1.amazonaws.com'
-const S3_PREFIX = 'releases/'
-const DOWNLOAD_BASE_URL = `${S3_BASE_URL}/${S3_PREFIX}`
-// ---------------------
-
-function getPlatformInfo() {
-  const platform = process.platform
-  const arch = process.arch
-
-  const platformMap = {
-    linux: {
-      x64: 'x86_64-unknown-linux-gnu',
-      arm64: 'aarch64-unknown-linux-gnu'
-    },
-    darwin: {
-      x64: 'x86_64-apple-darwin',
-      arm64: 'aarch64-apple-darwin'
-    }
-  }
-
-  const target = platformMap[platform]?.[arch]
-  if (!target) {
-    throw new Error(`Unsupported platform: ${platform}-${arch}`)
-  }
-
-  const extension = '.tar.gz'
-  const binaryName = 'server'
-
-  return { target, extension, binaryName }
-}
-
-// Helper to fetch XML and return response data
-async function fetchXml(url) {
-  return new Promise((resolve, reject) => {
-    https
-      .get(url, (res) => {
-        if (res.statusCode !== 200) {
-          reject(
-            new Error(`S3 Request Failed: ${res.statusCode}. Check if public listing is enabled.`)
-          )
-          return
-        }
-        let data = ''
-        res.on('data', (chunk) => (data += chunk))
-        res.on('end', () => resolve(data))
-      })
-      .on('error', reject)
-  })
-}
-
-/**
- * Lists the S3 prefix, parses the XML, and determines the latest version tag.
- */
-async function getLatestVersionFromS3() {
-  // Query S3 for folders using delimiter and prefix
-  const listUrl = `${S3_BASE_URL}/?delimiter=/&prefix=${S3_PREFIX}`
-  const xmlData = await fetchXml(listUrl)
-
-  // Regex to find all CommonPrefixes entries (the version folders)
-  const prefixRegex = /<Prefix>(releases\/v[^<]+)\/<\/Prefix>/g
-  const versionFolders = []
-  let match
-
-  while ((match = prefixRegex.exec(xmlData)) !== null) {
-    // Extract version part: "releases/v1.0.0/" -> "v1.0.0"
-    const fullPrefix = match[1]
-    const version = fullPrefix.substring(S3_PREFIX.length)
-    versionFolders.push(version)
-  }
-
-  if (versionFolders.length === 0) {
-    throw new Error('No version folders found in S3 bucket.')
-  }
-
-  // Sort versions to find the latest (using semantic versioning logic)
-  const sortedVersions = versionFolders.sort((a, b) => {
-    // Strips 'v', splits by '.', and converts to number arrays for comparison
-    const aParts = a.replace('v', '').split('.').map(Number)
-    const bParts = b.replace('v', '').split('.').map(Number)
-
-    // Compare major, minor, and patch numbers
-    for (let i = 0; i < 3; i++) {
-      if (aParts[i] > bParts[i]) return 1
-      if (aParts[i] < bParts[i]) return -1
-    }
-    return 0
-  })
-
-  // The latest version is the last one after sorting
-  return sortedVersions[sortedVersions.length - 1]
-}
-
-async function downloadFile(url, destination) {
-  return new Promise((resolve, reject) => {
-    const file = createWriteStream(destination)
-
-    https
-      .get(url, (response) => {
-        if (response.statusCode === 302 || response.statusCode === 301) {
-          // Handle redirect
-          return downloadFile(response.headers.location, destination).then(resolve).catch(reject)
-        }
-
-        if (response.statusCode !== 200) {
-          reject(new Error(`Failed to download: ${response.statusCode}`))
-          return
-        }
-
-        response.pipe(file)
-
-        file.on('finish', () => {
-          file.close()
-          resolve()
-        })
-
-        file.on('error', reject)
-      })
-      .on('error', reject)
-  })
-}
-
-async function extractArchive(archivePath, extractPath, binaryName) {
-  // Extract tar.gz
-  await tar.x({
-    file: archivePath,
-    cwd: extractPath
-  })
-
-  // Make binary executable
-  const binaryPath = path.join(extractPath, binaryName)
-  if (fs.existsSync(binaryPath)) {
-    fs.chmodSync(binaryPath, '755')
-  }
-}
-
-async function installServer() {
-  try {
-    console.log('📦 Installing nulljs server binary...')
-
-    const { target, extension, binaryName } = getPlatformInfo()
-    const binDir = path.join(__dirname, '..', 'bin')
-    const archivePath = path.join(binDir, `server${extension}`)
-    const binaryPath = path.join(binDir, 'server')
-
-    // Create bin directory
-    if (!fs.existsSync(binDir)) {
-      fs.mkdirSync(binDir, { recursive: true })
-    }
-
-    // Check if binary already exists (optional optimization)
-    if (fs.existsSync(binaryPath)) {
-      console.log('✅ Server binary already installed')
-      return
-    }
-
-    // 1. Determine Version from S3
-    console.log('🔍 Checking for latest version on S3...')
-    const version = await getLatestVersionFromS3()
-    console.log(`   Found version: ${version}`)
-
-    // 2. Construct URL
-    // URL format: https://.../releases/VERSION/nulljs-server-TARGET.tar.gz
-    const downloadUrl = `${DOWNLOAD_BASE_URL}${version}/nulljs-server-${target}${extension}`
-    console.log(`   Downloading from: ${downloadUrl}`)
-
-    // 3. Download
-    await downloadFile(downloadUrl, archivePath)
-    console.log('✅ Download completed')
-
-    // 4. Extract
-    console.log('📂 Extracting binary...')
-    await extractArchive(archivePath, binDir, binaryName)
-
-    // 5. Clean up archive
-    fs.unlinkSync(archivePath)
-
-    console.log('✅ nulljs server installed successfully')
-  } catch (error) {
-    console.error('❌ Failed to install server binary:', error.message)
-    console.error('⚠️  You may need to build the server manually')
-    process.exit(0)
-  }
-}
-
-// Only run if called directly
-if (require.main === module) {
-  installServer()
-}
-
-module.exports = { installServer }

package/src/commands/api.ts

@@ -1,16 +0,0 @@
-import chalk from 'chalk'
-
-import { saveApiUrl } from '../lib/config'
-
-const setApiUrl = (url: string, profileName?: string) => {
-  try {
-    saveApiUrl(url, profileName)
-    const profileText = profileName ? ` to profile '${profileName}'` : ''
-    console.log(chalk.green('✓'), `API URL saved${profileText}: ${chalk.blue(url)}`)
-  } catch (error) {
-    console.error(chalk.red('✗'), 'Failed to save API URL:', error)
-    process.exit(1)
-  }
-}
-
-export { setApiUrl }

package/src/commands/auth.ts

@@ -1,54 +0,0 @@
-import chalk from 'chalk'
-import readline from 'node:readline'
-
-import { loadConfigWithProfile, saveKeys } from '../lib/config'
-
-const askQuestion = (query: string): Promise<string> => {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  })
-
-  return new Promise((resolve) =>
-    rl.question(query, (answer) => {
-      rl.close()
-      resolve(answer.trim())
-    })
-  )
-}
-
-const auth = async (profileName?: string) => {
-  const config = loadConfigWithProfile()
-
-  if (config.key) {
-    const answer = await askQuestion(
-      'Keys already exist. Are you sure you want to regenerate them? (Y/n): '
-    )
-
-    if (answer.toLowerCase() === 'n') {
-      console.log(chalk.green('Public Key:'), chalk.blue(config.key.public))
-      return
-    }
-  }
-
-  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)))
-
-  saveKeys(privateKey, publicKey, profileName)
-
-  console.log(chalk.green('Public Key:'), chalk.blue(publicKey))
-}
-
-export { auth }

package/src/commands/create.ts

@@ -1,43 +0,0 @@
-import chalk from 'chalk'
-import { existsSync } from 'node:fs'
-import degit from 'degit'
-import path from 'node:path'
-
-const repo = 'tothalex/nulljs-template'
-
-const modifyName = async (newName: string, packagePath: string) => {
-  const file = Bun.file(packagePath)
-  const packageContent = await file.text()
-  const packageJson = JSON.parse(packageContent)
-
-  packageJson.name = newName
-
-  await Bun.write(packagePath, JSON.stringify(packageJson, null, 2) + '\n')
-}
-
-const create = async (name: string) => {
-  if (existsSync(name)) {
-    console.log(chalk.red('Folder already exists: ') + chalk.bgRed(name))
-    process.exit(0)
-  }
-
-  const targetDir = path.join(process.cwd(), name)
-
-  try {
-    const emitter = degit(repo, {
-      cache: false,
-      force: true,
-      verbose: true
-    })
-
-    await emitter.clone(targetDir)
-
-    await modifyName(name, targetDir + '/package.json')
-    console.log(chalk.green('Project setup completed successfully!'))
-  } catch (error) {
-    console.error(chalk.red('An error occurred during project creation:'))
-    console.error(error)
-  }
-}
-
-export { create }