@tothalex/nulljs 0.0.53 → 0.0.54

package/src/ui.tsx

@@ -1,363 +0,0 @@
-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

@@ -1,30 +0,0 @@
-{
-  "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
-  }
-}