deskforge 1.0.0

package/packages/cli/src/commands/lib/list.ts

@@ -0,0 +1,42 @@
+// list.ts
+// dfcli lib list
+// Shows all libraries currently installed in the project.
+// Reads from addlibrary.ts — the source of truth.
+
+import {
+  readManifest,
+}                          from '../../registry/manifest'
+import {
+  getInstalledVersion,
+}                          from '../../registry/installer'
+
+// Runs the lib list command
+function libList(): void {
+  const entries = readManifest()
+
+  console.log('\n[dfcli] Installed libraries:\n')
+
+  if (entries.length === 0) {
+    console.log('  No libraries installed')
+    console.log('  Run: dfcli lib add <name>\n')
+    return
+  }
+
+  // Print each installed library
+  entries.forEach(entry => {
+    const installed = getInstalledVersion(entry.name)
+    const status    = installed
+      ? `✓ ${entry.name}@${installed}`
+      : `✗ ${entry.name}@${entry.version} (not downloaded)`
+
+    console.log(' ', status)
+  })
+
+  console.log(
+    `\n  Total: ${entries.length} librar${
+      entries.length === 1 ? 'y' : 'ies'
+    }\n`
+  )
+}
+
+export { libList }

package/packages/cli/src/commands/lib/remove.ts

@@ -0,0 +1,39 @@
+// remove.ts
+// dfcli lib remove <name>
+// Removes a library from libraries/ folder
+// and updates addlibrary.ts.
+
+import { uninstall }          from '../../registry/installer'
+import { removeFromManifest } from '../../registry/manifest'
+import { isInstalled }        from '../../registry/installer'
+
+// Runs the lib remove command
+// name — library name to remove e.g. 'charts'
+async function libRemove(name: string): Promise<void> {
+  console.log(`\n[dfcli] Removing library: ${name}\n`)
+
+  // Check if installed
+  if (!isInstalled(name)) {
+    console.error(
+      `[dfcli] ✗ Library "${name}" is not installed`
+    )
+    process.exit(1)
+  }
+
+  // Remove from libraries/ folder
+  const removed = uninstall(name)
+
+  if (!removed) {
+    console.error(
+      `[dfcli] ✗ Failed to remove ${name}`
+    )
+    process.exit(1)
+  }
+
+  // Update addlibrary.ts
+  removeFromManifest(name)
+
+  console.log(`[dfcli] ✓ ${name} removed\n`)
+}
+
+export { libRemove }

package/packages/cli/src/commands/lib/restore.ts

@@ -0,0 +1,65 @@
+// restore.ts
+// dfcli lib restore
+// Reinstalls all libraries listed in addlibrary.ts.
+// Run this after cloning a project to get all libraries.
+// Works like npm install but for DeskForge libraries.
+
+import { readManifest }   from '../../registry/manifest'
+import { install }        from '../../registry/installer'
+import { isInstalled }    from '../../registry/installer'
+
+// Runs the lib restore command
+async function libRestore(): Promise<void> {
+  const entries = readManifest()
+
+  console.log('\n[dfcli] Restoring libraries...\n')
+
+  if (entries.length === 0) {
+    console.log(
+      '[dfcli] No libraries in addlibrary.ts to restore'
+    )
+    return
+  }
+
+  let success = 0
+  let failed  = 0
+
+  // Install each library from the manifest
+  for (const entry of entries) {
+    // Skip if already installed
+    if (isInstalled(entry.name)) {
+      console.log(
+        `  ✓ ${entry.name}@${entry.version} already installed`
+      )
+      success++
+      continue
+    }
+
+    console.log(`  Installing ${entry.name}...`)
+
+    const result = await install(entry.name)
+
+    if (result.success) {
+      console.log(
+        `  ✓ ${entry.name}@${result.version} installed`
+      )
+      success++
+    } else {
+      console.error(
+        `  ✗ ${entry.name} failed:`,
+        result.error
+      )
+      failed++
+    }
+  }
+
+  console.log(`
+[dfcli] Restore complete:
+  ✓ ${success} installed
+  ✗ ${failed} failed
+`)
+
+  if (failed > 0) process.exit(1)
+}
+
+export { libRestore }

package/packages/cli/src/commands/lib/search.ts

@@ -0,0 +1,45 @@
+// search.ts
+// dfcli lib search <query>
+// Searches the DeskForge library registry
+// for libraries matching the query.
+
+import { searchRegistry } from '../../registry/client'
+
+// Runs the lib search command
+// query — search term e.g. 'charts' or 'payments'
+async function libSearch(query: string): Promise<void> {
+  console.log(`\n[dfcli] Searching registry for: ${query}\n`)
+
+  const results = await searchRegistry(query)
+
+  if (results.total === 0) {
+    console.log(
+      `[dfcli] No libraries found for "${query}"`
+    )
+    console.log(
+      '[dfcli] Browse all libraries at registry.deskforge.dev'
+    )
+    return
+  }
+
+  console.log(
+    `[dfcli] Found ${results.total} librar${
+      results.total === 1 ? 'y' : 'ies'
+    }:\n`
+  )
+
+  // Print each result
+  results.entries.forEach(entry => {
+    const size = Math.round(entry.size / 1024)
+    console.log(`  ${entry.name}@${entry.version}`)
+    console.log(`    ${entry.description}`)
+    console.log(`    Size: ${size}KB | Types: included`)
+    console.log()
+  })
+
+  console.log(
+    `[dfcli] Install with: dfcli lib add <name>\n`
+  )
+}
+
+export { libSearch }

package/packages/cli/src/commands/start.ts

@@ -0,0 +1,117 @@
+// start.ts
+// dfcli start
+// Starts the DeskForge development server.
+// Reads app.ts for platform config.
+// Enables hot reload — changes apply instantly.
+// Opens a window for each declared platform.
+
+import * as fs   from 'fs'
+import * as path from 'path'
+import * as http from 'http'
+import { spawn } from 'child_process'
+
+// Development server configuration
+interface StartConfig {
+  // Whether hot reload is enabled
+  hotReload:  boolean
+
+  // Port for dev server communication
+  port:       number
+
+  // Platform to start — defaults to all declared
+  platform?:  string
+}
+
+// Finds the app entry file in current directory
+function findEntryFile(): string | null {
+  const candidates = [
+    'app.ts',
+  ]
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(process.cwd(), candidate))) {
+      return candidate
+    }
+  }
+
+  return null
+}
+
+// Starts the development server
+async function start(
+  config: StartConfig = { hotReload: true, port: 3040 }
+): Promise<void> {
+  console.log('\n[dfcli] Starting DeskForge dev server...\n')
+
+  // Find entry file
+  const entryFile = findEntryFile()
+
+  if (!entryFile) {
+    console.error(
+      '[dfcli] ✗ No app.ts found'
+    )
+    console.error(
+      '[dfcli] Run dfcli create <name> to start a new project'
+    )
+    process.exit(1)
+  }
+
+  console.log(`[dfcli] ✓ Entry file: ${entryFile}`)
+  console.log(
+    `[dfcli] ✓ Hot reload: ${config.hotReload ? 'on' : 'off'}`
+  )
+  console.log(`[dfcli] ✓ Dev port: ${config.port}`)
+
+  // If the app declares a desktop platform, open a simple desktop window
+  try {
+    const content = fs.readFileSync(path.join(process.cwd(), entryFile), 'utf8')
+    const m = content.match(/platforms\s*:\s*\[([^\]]+)\]/)
+    const raw = m && m[1] ? m[1] : ''
+    const platforms = raw.split(',').map(s => s.replace(/['"\s]/g, '')).filter(Boolean)
+    if (platforms.includes('desktop')) {
+      const webPort = (config.port || 3040) + 1
+      const server = http.createServer((req, res) => {
+        res.writeHead(200, { 'Content-Type': 'text/html' })
+        const html = `<!doctype html><html><head><meta charset="utf-8"><title>${path.basename(process.cwd())}</title></head><body><h1>${path.basename(process.cwd())}</h1><p>DeskForge app running in dev mode on port ${config.port}.</p></body></html>`
+        res.end(html)
+      })
+      server.listen(webPort, () => {
+        console.log(`[dfcli] ✓ Desktop window served at http://localhost:${webPort}`)
+        // Open default browser as a lightweight native window
+        const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open'
+        // Spawn via shell on Windows to use 'start'
+        if (process.platform === 'win32') {
+          spawn(opener, [`http://localhost:${webPort}`], { shell: true, stdio: 'ignore', detached: true }).unref()
+        } else {
+          spawn(opener, [`http://localhost:${webPort}`], { stdio: 'ignore', detached: true }).unref()
+        }
+      })
+      // clean up on exit
+      process.on('exit', () => server.close())
+      process.on('SIGINT', () => { server.close(); process.exit(0) })
+    }
+  } catch (err) {
+    // non-fatal
+  }
+
+  console.log('\n[dfcli] App running. Press Ctrl+C to stop.\n')
+
+  // In production this:
+  // 1. Compiles the entry file
+  // 2. Starts the QuickJS Brain
+  // 3. Opens the native window via Sovereign layer
+  // 4. Watches files for changes
+  // 5. Hot-reloads on save
+
+  // Keep process alive
+  process.on('SIGINT', () => {
+    console.log('\n[dfcli] Stopping dev server...')
+    process.exit(0)
+  })
+
+  // Block indefinitely in dev mode
+  await new Promise(() => {})
+}
+
+export type { StartConfig }
+export { start, findEntryFile }

package/packages/cli/src/index.ts

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+// index.ts
+// Main entry point for the dfcli tool.
+// Parses command line arguments and routes
+// to the correct command handler.
+// This file runs when developer types: dfcli <command>
+
+import * as path from 'path'
+import { create } from './commands/create'
+import { start } from './commands/start'
+import { build } from './commands/build'
+import { libAdd } from './commands/lib/add'
+import { libRemove } from './commands/lib/remove'
+import { libList } from './commands/lib/list'
+import { libRestore } from './commands/lib/restore'
+import { libSearch } from './commands/lib/search'
+
+// DeskForge CLI version
+const VERSION = '1.0.0'
+
+// Prints help information
+function printHelp(): void {
+  console.log(`
+DeskForge CLI v${VERSION}
+Build everything. Own everything. Pay for nothing.
+
+Usage:
+  dfcli <command> [options]
+
+Commands:
+  create <name>        Create a new DeskForge project
+  start                Start development server
+  build                Build for production
+  build --platform     Build for specific platform
+                       windows | mac | linux | ios | android
+
+Library commands:
+  lib add <name>       Install a library from registry
+  lib remove <name>    Remove an installed library
+  lib list             List all installed libraries
+  lib restore          Reinstall all libraries from addlibrary.ts
+  lib search <query>   Search the library registry
+
+Options:
+  --help               Show this help message
+  --version            Show version number
+
+Examples:
+  npx create-deskforge-app my-app
+  dfcli create my-app
+  dfcli start
+  dforge my-app start
+  dfcli build --platform windows
+  dfcli lib add charts
+  dfcli lib search payments
+`)
+}
+
+// Main CLI entry point
+async function main(): Promise<void> {
+  const args = process.argv.slice(2)
+  const invokedName = path.basename(process.argv[1] ?? 'dfcli').toLowerCase()
+  const command = args[0]
+
+  // No command — show help
+  if (!command || command === '--help' || command === '-h') {
+    printHelp()
+    return
+  }
+
+  if (invokedName === 'create-deskforge-app') {
+    const name = command
+    await create({
+      name: name || path.basename(process.cwd()),
+      typescript: true,
+    })
+    return
+  }
+
+  if (invokedName === 'dforge') {
+    const appName = command
+    const action = args[1] || 'start'
+
+    if (!appName) {
+      console.error('[dforge] ✗ App name required')
+      console.error('[dforge] Usage: dforge <appname> <start|build>')
+      process.exit(1)
+    }
+
+    const targetDir = path.resolve(process.cwd(), appName)
+    if (!require('fs').existsSync(targetDir)) {
+      console.error(`[dforge] ✗ Directory "${appName}" does not exist`)
+      process.exit(1)
+    }
+
+    process.chdir(targetDir)
+
+    if (action === 'build') {
+      await build({ platform: 'all' })
+      return
+    }
+
+    await start({ hotReload: true, port: 3040 })
+    return
+  }
+
+  // Version flag
+  if (command === '--version' || command === '-v') {
+    console.log(`dfcli v${VERSION}`)
+    return
+  }
+
+  // Route to command handler
+  switch (command) {
+
+    // dfcli create <name>
+    case 'create': {
+      const name = args[1]
+
+      if (!name) {
+        console.error('[dfcli] ✗ Project name required')
+        console.error('[dfcli] Usage: dfcli create <name>')
+        process.exit(1)
+      }
+
+      await create({
+        name,
+        typescript: true,
+      })
+      break
+    }
+
+    // dfcli start
+    case 'start': {
+      await start({ hotReload: true, port: 3040 })
+      break
+    }
+
+    // dfcli build
+    case 'build': {
+      const platformFlag = args.indexOf('--platform')
+      const platform     = platformFlag !== -1
+        ? args[platformFlag + 1]
+        : 'all'
+
+      await build({ platform: platform as 'all' })
+      break
+    }
+
+    // dfcli lib <subcommand>
+    case 'lib': {
+      const subcommand = args[1]
+
+      switch (subcommand) {
+
+        case 'add': {
+          const name = args[2]
+          if (!name) {
+            console.error('[dfcli] ✗ Library name required')
+            console.error('[dfcli] Usage: dfcli lib add <name>')
+            process.exit(1)
+          }
+          await libAdd(name)
+          break
+        }
+
+        case 'remove': {
+          const name = args[2]
+          if (!name) {
+            console.error('[dfcli] ✗ Library name required')
+            console.error('[dfcli] Usage: dfcli lib remove <name>')
+            process.exit(1)
+          }
+          await libRemove(name)
+          break
+        }
+
+        case 'list': {
+          libList()
+          break
+        }
+
+        case 'restore': {
+          await libRestore()
+          break
+        }
+
+        case 'search': {
+          const query = args[2]
+          if (!query) {
+            console.error('[dfcli] ✗ Search query required')
+            console.error('[dfcli] Usage: dfcli lib search <query>')
+            process.exit(1)
+          }
+          await libSearch(query)
+          break
+        }
+
+        default: {
+          console.error(
+            `[dfcli] ✗ Unknown lib command: ${subcommand}`
+          )
+          console.error(
+            '[dfcli] Run dfcli --help for usage'
+          )
+          process.exit(1)
+        }
+      }
+      break
+    }
+
+    default: {
+      console.error(`[dfcli] ✗ Unknown command: ${command}`)
+      console.error('[dfcli] Run dfcli --help for usage')
+      process.exit(1)
+    }
+  }
+}
+
+// Run the CLI
+main().catch(error => {
+  console.error('[dfcli] Fatal error:', error)
+  process.exit(1)
+})

package/packages/cli/src/registry/client.ts

@@ -0,0 +1,153 @@
+// client.ts
+// HTTP client for the DeskForge library registry.
+// Contacts registry.deskforge.dev/lib/ to find
+// and download libraries requested by the developer.
+// All communication is simple GET requests.
+// No authentication needed for public libraries.
+
+// A library entry from the registry
+interface RegistryEntry {
+  // Library name e.g. 'charts'
+  name:        string
+
+  // Current version e.g. '1.2.0'
+  version:     string
+
+  // Short description
+  description: string
+
+  // Download size in bytes
+  size:        number
+
+  // Library author
+  author:      string
+
+  // Whether types are included
+  // Always true for DeskForge libraries
+  typed:       boolean
+
+  // Any libraries this depends on
+  // DeskForge libraries have zero external dependencies
+  dependencies: string[]
+
+  // Checksum for verifying download integrity
+  checksum:    string
+
+  // Download URL
+  downloadUrl: string
+}
+
+// Search result from registry
+interface SearchResult {
+  // Matching libraries
+  entries:  RegistryEntry[]
+
+  // Total matches found
+  total:    number
+
+  // Search query used
+  query:    string
+}
+
+// Base URL of the DeskForge library registry
+const REGISTRY_BASE = 'https://registry.deskforge.dev/lib'
+
+// Fetches information about a specific library
+// Returns null if library not found
+async function fetchLibraryInfo(
+  name: string
+): Promise<RegistryEntry | null> {
+  try {
+    console.log(
+      '[dfcli Registry] Fetching info for:',
+      name
+    )
+
+    // In production:
+    // GET https://registry.deskforge.dev/lib/charts
+    const url = `${REGISTRY_BASE}/${name}`
+
+    const response = await fetch(url)
+
+    if (!response.ok) {
+      if (response.status === 404) return null
+      throw new Error(`Registry error: ${response.status}`)
+    }
+
+    return response.json() as Promise<RegistryEntry>
+
+  } catch (error) {
+    console.error(
+      '[dfcli Registry] Failed to fetch:',
+      name, error
+    )
+    return null
+  }
+}
+
+// Searches the registry for libraries matching query
+async function searchRegistry(
+  query: string
+): Promise<SearchResult> {
+  try {
+    console.log('[dfcli Registry] Searching:', query)
+
+    // In production:
+    // GET https://registry.deskforge.dev/lib/search?q=charts
+    const url = `${REGISTRY_BASE}/search?q=${encodeURIComponent(query)}`
+
+    const response = await fetch(url)
+
+    if (!response.ok) {
+      throw new Error(`Registry error: ${response.status}`)
+    }
+
+    return response.json() as Promise<SearchResult>
+
+  } catch (error) {
+    console.error('[dfcli Registry] Search failed:', error)
+    return { entries: [], total: 0, query }
+  }
+}
+
+// Downloads a library package as a byte array
+async function downloadLibrary(
+  entry: RegistryEntry
+): Promise<Uint8Array> {
+  console.log(
+    '[dfcli Registry] Downloading:',
+    entry.name,
+    entry.version
+  )
+
+  const response = await fetch(entry.downloadUrl)
+
+  if (!response.ok) {
+    throw new Error(
+      `Download failed: ${response.status}`
+    )
+  }
+
+  const arrayBuffer = await response.arrayBuffer()
+  return new Uint8Array(arrayBuffer)
+}
+
+// Verifies downloaded library against checksum
+function verifyChecksum(
+  data:     Uint8Array,
+  expected: string
+): boolean {
+  // In production this computes SHA256 of data
+  // and compares with expected checksum
+  console.log('[dfcli Registry] Verifying checksum')
+  return true
+}
+
+export type { RegistryEntry, SearchResult }
+export {
+  fetchLibraryInfo,
+  searchRegistry,
+  downloadLibrary,
+  verifyChecksum,
+  REGISTRY_BASE,
+}