@tothalex/nulljs 0.0.40

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@tothalex/nulljs",
+  "module": "index.ts",
+  "version": "0.0.40",
+  "type": "module",
+  "bin": {
+    "nulljs": "./src/index.ts"
+  },
+  "scripts": {
+    "postinstall": "bun scripts/install-server.js"
+  },
+  "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"
+  },
+  "peerDependencies": {
+    "typescript": "~5.7.2"
+  },
+  "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",
+    "ink": "^6.2.2",
+    "mime-types": "^2.1.35",
+    "react": "^19.1.1",
+    "tar": "^7.5.2",
+    "vite": "^7.0.0",
+    "yargs": "^17.7.2"
+  }
+}

package/scripts/install-server.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env bun
+
+const https = require('https')
+const fs = require('fs')
+const path = require('path')
+const { createWriteStream } = require('fs')
+const tar = require('tar')
+
+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 }
+}
+
+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)
+  fs.chmodSync(binaryPath, '755')
+}
+
+async function getLatestReleaseUrl(target, extension) {
+  const baseUrl = 'https://nulljs.s3.eu-north-1.amazonaws.com/releases'
+  return `${baseUrl}/nulljs-server-${target}/nulljs-server-${target}${extension}`
+}
+
+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
+    if (fs.existsSync(binaryPath)) {
+      console.log('✅ Server binary already installed')
+      return
+    }
+
+    console.log(`🔍 Downloading server for ${target}...`)
+
+    // Get download URL from latest release
+    const downloadUrl = await getLatestReleaseUrl(target, extension)
+
+    // Download the archive
+    await downloadFile(downloadUrl, archivePath)
+    console.log('✅ Download completed')
+
+    // Extract the binary
+    console.log('📂 Extracting binary...')
+    await extractArchive(archivePath, binDir, binaryName)
+
+    // 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) // Don't fail the installation
+  }
+}
+
+// Only run if called directly
+if (require.main === module) {
+  installServer()
+}
+
+module.exports = { installServer }
+

package/src/commands/api.ts

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

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

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

package/src/commands/deploy.ts

@@ -0,0 +1,160 @@
+import { resolve } from 'path'
+import { readdir, exists, stat } from 'node:fs/promises'
+import chalk from 'chalk'
+import chokidar from 'chokidar'
+
+import { deployFunction, deployPage, isReact, isTypescript } from '../lib/deployment'
+import { requireProfileConfiguration } from '../lib/config'
+
+const deployFunctionsRecursively = async (functionsPath: string, force: boolean = true) => {
+  if (!(await exists(functionsPath))) {
+    return
+  }
+
+  const functionsStat = await stat(functionsPath)
+  if (!functionsStat.isDirectory()) {
+    return
+  }
+
+  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 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('.')
+    }
+  }
+
+  if (!(await exists(deployPath))) {
+    console.log(chalk.red("Path doesn't exists: ") + chalk.bgRed(deployPath))
+    process.exit(0)
+  }
+
+  const pathStat = await stat(deployPath)
+
+  if (pathStat.isFile()) {
+    const file = resolve(deployPath)
+
+    if (isReact(file)) {
+      console.log(`${chalk.gray('Deploying page: ')} ${chalk.green(file)}`)
+      await deployPage(file)
+    }
+
+    // Also deploy functions directory recursively
+    const functionsPath = resolve('src/function')
+    await deployFunctionsRecursively(functionsPath, force)
+
+    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 (isReact(file)) {
+      await deployPage(`${p}/${file}`)
+    }
+  }
+
+  // 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 all files in src/functions/ directory recursively
+    const functionsPath = resolve('src/function')
+    await deployFunctionsRecursively(functionsPath)
+  } catch (error) {
+    console.error(chalk.red('Deployment failed:'), error)
+  }
+}
+
+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}`))
+
+  if (!exists(path)) {
+    console.log(chalk.red("Path doesn't exists: ") + chalk.bgRed(path))
+    process.exit(0)
+  }
+
+  const watcher = chokidar.watch(`${path}`, {
+    ignored: (path) => ['node_modules', '.git'].some((s) => path.includes(s)),
+    persistent: true,
+    ignoreInitial: true,
+    cwd: process.cwd()
+  })
+
+  watcher
+    .on('add', (filePath) => onFileChange(filePath))
+    .on('change', (filePath) => onFileChange(filePath))
+    .on('ready', () => {
+      console.log('Initial scan complete. Ready for changes')
+    })
+
+  process.on('SIGINT', () => {
+    console.log('\nShutting down file watcher...')
+    watcher.close().then(() => {
+      console.log('File watcher stopped')
+      process.exit(0)
+    })
+  })
+}
+
+export { deploy, watch }

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

@@ -0,0 +1,221 @@
+import { existsSync } from 'fs'
+import { resolve } from 'path'
+import chokidar from 'chokidar'
+import chalk from 'chalk'
+import ts from 'typescript'
+
+import { deployFunctionAndLog } from './utils'
+
+// Track dependencies between files
+const dependencyGraph = new Map<string, Set<string>>()
+const reverseDependencyGraph = new Map<string, Set<string>>()
+
+function analyzeDependencies(filePath: string): Set<string> {
+  const dependencies = new Set<string>()
+
+  try {
+    const fs = require('fs')
+    const path = require('path')
+
+    const sourceCode = fs.readFileSync(filePath, 'utf-8')
+    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true)
+
+    function visit(node: ts.Node) {
+      if (
+        ts.isImportDeclaration(node) &&
+        node.moduleSpecifier &&
+        ts.isStringLiteral(node.moduleSpecifier)
+      ) {
+        const importPath = node.moduleSpecifier.text
+
+        // Resolve relative imports
+        if (importPath.startsWith('./') || importPath.startsWith('../')) {
+          const resolvedPath = path.resolve(path.dirname(filePath), importPath)
+
+          // Try different extensions
+          const extensions = ['.ts', '.js', '.tsx', '.jsx']
+          for (const ext of extensions) {
+            const fullPath = resolvedPath + ext
+            if (fs.existsSync(fullPath)) {
+              dependencies.add(fullPath)
+              break
+            }
+          }
+
+          // Also try index files
+          const indexPath = path.join(resolvedPath, 'index.ts')
+          if (fs.existsSync(indexPath)) {
+            dependencies.add(indexPath)
+          }
+        }
+      }
+
+      ts.forEachChild(node, visit)
+    }
+
+    visit(sourceFile)
+  } catch {
+    // Silent fallback - dependency tracking is nice-to-have
+  }
+
+  return dependencies
+}
+
+function updateDependencyGraph(filePath: string) {
+  // Remove old dependencies
+  const oldDeps = dependencyGraph.get(filePath) || new Set()
+  oldDeps.forEach((dep) => {
+    const reverseDeps = reverseDependencyGraph.get(dep) || new Set()
+    reverseDeps.delete(filePath)
+    if (reverseDeps.size === 0) {
+      reverseDependencyGraph.delete(dep)
+    } else {
+      reverseDependencyGraph.set(dep, reverseDeps)
+    }
+  })
+
+  // Add new dependencies
+  const newDeps = analyzeDependencies(filePath)
+  dependencyGraph.set(filePath, newDeps)
+
+  newDeps.forEach((dep) => {
+    const reverseDeps = reverseDependencyGraph.get(dep) || new Set()
+    reverseDeps.add(filePath)
+    reverseDependencyGraph.set(dep, reverseDeps)
+  })
+}
+
+function getAffectedFunctions(changedFile: string, functionDir: string): Set<string> {
+  const affected = new Set<string>()
+
+  // If the changed file is already in function dir, include it
+  if (changedFile.startsWith(functionDir) && changedFile.endsWith('.ts')) {
+    affected.add(changedFile)
+  }
+
+  // Find all functions that depend on this changed file
+  function findDependents(filePath: string, visited = new Set<string>()) {
+    if (visited.has(filePath)) return
+    visited.add(filePath)
+
+    const dependents = reverseDependencyGraph.get(filePath) || new Set()
+    dependents.forEach((dependent) => {
+      if (dependent.startsWith(functionDir) && dependent.endsWith('.ts')) {
+        affected.add(dependent)
+      }
+      findDependents(dependent, visited)
+    })
+  }
+
+  findDependents(changedFile)
+  return affected
+}
+
+export const createFunctionWatcher = (props: { srcDir: string; log: (data: string) => void }) => {
+  const functionDir = resolve(props.srcDir, 'function')
+
+  if (!existsSync(functionDir)) {
+    props.log(
+      chalk.yellow(
+        `⚠️  Functions directory not found at ${functionDir}, skipping function watcher.`
+      )
+    )
+    return null
+  }
+
+  props.log(chalk.cyan(`👀 Watching functions and dependencies in ${props.srcDir}`))
+
+  // Build initial dependency graph for all TypeScript files
+  const buildInitialDependencyGraph = () => {
+    const glob = require('glob')
+    const tsFiles = glob.sync(`${props.srcDir}/**/*.ts`, {
+      ignore: ['**/node_modules/**', '**/dist/**', '**/build/**']
+    })
+
+    props.log(chalk.gray(`🔍 Analyzing ${tsFiles.length} files for dependencies...`))
+
+    tsFiles.forEach((filePath: string) => {
+      const absolutePath = resolve(filePath)
+      updateDependencyGraph(absolutePath)
+    })
+
+    props.log(chalk.gray(`✓ Ready for smart rebuilds`))
+  }
+
+  // Build initial graph
+  buildInitialDependencyGraph()
+
+  return chokidar
+    .watch(props.srcDir, {
+      ignored: (path) => {
+        // Exclude common web/React directories and file types
+        const excludePatterns = [
+          'node_modules',
+          '.git',
+          'pages',
+          'components',
+          'styles',
+          'public',
+          'assets',
+          'dist',
+          'build'
+        ]
+
+        // Exclude file extensions that aren't relevant to functions
+        const excludeExtensions = [
+          '.css',
+          '.scss',
+          '.sass',
+          '.less',
+          '.jsx',
+          '.tsx',
+          '.html',
+          '.md'
+        ]
+
+        return (
+          excludePatterns.some((pattern) => path.includes(pattern)) ||
+          excludeExtensions.some((ext) => path.endsWith(ext))
+        )
+      },
+      persistent: true,
+      ignoreInitial: true,
+      cwd: process.cwd()
+    })
+    .on('add', (filePath) => {
+      if (filePath.endsWith('.ts')) {
+        const absolutePath = resolve(filePath)
+        updateDependencyGraph(absolutePath)
+
+        // Only deploy if it's a function file
+        if (absolutePath.startsWith(functionDir)) {
+          deployFunctionAndLog(absolutePath, props.log)
+        }
+      }
+    })
+    .on('change', (filePath) => {
+      if (filePath.endsWith('.ts')) {
+        const absolutePath = resolve(filePath)
+        updateDependencyGraph(absolutePath)
+
+        // Find all affected functions and deploy them
+        const affectedFunctions = getAffectedFunctions(absolutePath, functionDir)
+
+        if (affectedFunctions.size > 0) {
+          const fileName = require('path').basename(filePath)
+          const functionNames = Array.from(affectedFunctions).map((f) =>
+            require('path').basename(f, '.ts')
+          )
+
+          props.log(chalk.blue(`${fileName} changed → checking ${functionNames.join(', ')}`))
+
+          affectedFunctions.forEach((functionPath) => {
+            deployFunctionAndLog(functionPath, props.log)
+          })
+        }
+      }
+    })
+    .on('error', (error) => {
+      props.log(chalk.red('❌ Function watcher error:' + error))
+    })
+}