ghost-dragon 4.2.1

package/src/commands/scale.ts

@@ -0,0 +1,185 @@
+/**
+ * dragon scale — DragonScale Commerce Platform management
+ * 
+ * Manages Upalis/DragonScale deployments:
+ * - Status & health checks via API
+ * - Order management
+ * - Menu management
+ * - Database operations (backup, seed)
+ * - Deployment (pull, update)
+ */
+
+import type { Command } from 'commander'
+import type { DragonConfig } from '../config.js'
+import { getProductPath } from '../config.js'
+import { exec, run, fetchJSON, label, success, error, info, warn, table } from '../utils.js'
+import chalk from 'chalk'
+import { existsSync } from 'fs'
+import { join } from 'path'
+
+export function registerScaleCommands(program: Command, config: DragonConfig) {
+  const scale = program
+    .command('scale')
+    .description('DragonScale — Commerce platform management')
+
+  // --- status ---
+  scale
+    .command('status')
+    .description('Check platform health & today\'s stats')
+    .option('-u, --url <url>', 'Base URL of the DragonScale instance')
+    .action(async (opts) => {
+      const url = opts.url || config.products.scale.url
+      if (!url) {
+        error('No URL configured. Use --url or run: dragon init')
+        process.exit(1)
+      }
+      console.log(label('DragonScale'), 'Checking status...\n')
+      try {
+        const health = await fetchJSON(`${url}/api/health.php`)
+        console.log(`  Platform:  ${health.status === 'healthy' ? chalk.green('● Online') : chalk.red('● Down')}`)
+        console.log(`  PHP:       ${chalk.dim(health.checks?.php?.version || 'unknown')}`)
+        console.log(`  Database:  ${health.checks?.database?.status === 'connected' ? chalk.green('Connected') : chalk.red('Disconnected')}`)
+        console.log(`  Disk:      ${chalk.dim(health.checks?.filesystem?.status || 'unknown')}`)
+        success('Health check passed')
+      } catch (e: any) {
+        error(`Cannot reach ${url}/api/health.php — ${e.message}`)
+      }
+    })
+
+  // --- orders ---
+  scale
+    .command('orders')
+    .description('List recent orders')
+    .option('-u, --url <url>', 'Base URL')
+    .option('-n, --limit <n>', 'Number of orders', '10')
+    .option('-s, --status <status>', 'Filter by status (pending, confirmed, preparing, ready, delivered)')
+    .action(async (opts) => {
+      const url = opts.url || config.products.scale.url
+      if (!url) { error('No URL configured.'); process.exit(1) }
+      console.log(label('DragonScale'), 'Fetching orders...\n')
+      try {
+        const params = new URLSearchParams({ action: 'list', limit: opts.limit })
+        if (opts.status) params.set('status', opts.status)
+        const data = await fetchJSON(`${url}/api/orders.php?${params}`)
+        if (data.orders?.length) {
+          table(data.orders.map((o: any) => ({
+            ID: `#${o.id}`,
+            Status: o.status,
+            Type: o.order_type || '-',
+            Total: `LKR ${o.total}`,
+            Time: o.created_at || '-',
+          })))
+        } else {
+          info('No orders found')
+        }
+      } catch (e: any) {
+        error(`Failed to fetch orders: ${e.message}`)
+      }
+    })
+
+  // --- menu ---
+  scale
+    .command('menu')
+    .description('List menu items')
+    .option('-u, --url <url>', 'Base URL')
+    .option('-c, --category <id>', 'Filter by category ID')
+    .action(async (opts) => {
+      const url = opts.url || config.products.scale.url
+      if (!url) { error('No URL configured.'); process.exit(1) }
+      console.log(label('DragonScale'), 'Fetching menu...\n')
+      try {
+        const params = new URLSearchParams({ action: 'all' })
+        if (opts.category) params.set('category_id', opts.category)
+        const data = await fetchJSON(`${url}/api/menu.php?${params}`)
+        if (data.categories?.length) {
+          for (const cat of data.categories) {
+            console.log(chalk.green.bold(`\n  ${cat.name}`))
+            if (cat.items?.length) {
+              for (const item of cat.items) {
+                const status = item.available ? chalk.green('●') : chalk.red('○')
+                console.log(`    ${status} ${item.name}  ${chalk.dim(`LKR ${item.price}`)}`)
+              }
+            }
+          }
+          console.log()
+        } else {
+          info('No menu data')
+        }
+      } catch (e: any) {
+        error(`Failed to fetch menu: ${e.message}`)
+      }
+    })
+
+  // --- deploy ---
+  scale
+    .command('deploy')
+    .description('Pull latest code & update production')
+    .action(async () => {
+      const path = getProductPath(config, 'scale')
+      const script = join(path, 'scripts/update-production.sh')
+      if (!existsSync(script)) {
+        error(`Deploy script not found: ${script}`)
+        process.exit(1)
+      }
+      console.log(label('DragonScale'), 'Deploying...\n')
+      const code = await run('bash', [script], path)
+      code === 0 ? success('Deployment complete') : error(`Deploy failed (exit ${code})`)
+    })
+
+  // --- backup ---
+  scale
+    .command('backup')
+    .description('Backup the database')
+    .option('-o, --output <dir>', 'Output directory', './backups')
+    .action(async (opts) => {
+      const path = getProductPath(config, 'scale')
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+      const outDir = join(path, opts.output)
+      console.log(label('DragonScale'), 'Backing up database...\n')
+      try {
+        exec(`mkdir -p "${outDir}"`)
+        // Try mysqldump first, fall back to sqlite
+        try {
+          exec(`mysqldump --defaults-file="${join(path, '.my.cnf')}" upalis > "${join(outDir, `backup-${timestamp}.sql`)}"`, path)
+        } catch {
+          const dbFile = join(path, 'data', 'database.sqlite')
+          if (existsSync(dbFile)) {
+            exec(`cp "${dbFile}" "${join(outDir, `backup-${timestamp}.sqlite`)}"`, path)
+          } else {
+            throw new Error('No database found to backup')
+          }
+        }
+        success(`Backup saved to ${outDir}/backup-${timestamp}.*`)
+      } catch (e: any) {
+        error(`Backup failed: ${e.message}`)
+      }
+    })
+
+  // --- seed ---
+  scale
+    .command('seed')
+    .description('Seed database with sample data')
+    .action(async () => {
+      const path = getProductPath(config, 'scale')
+      console.log(label('DragonScale'), 'Seeding database...\n')
+      const code = await run('php', ['scripts/seed-production.php'], path)
+      code === 0 ? success('Seeding complete') : error(`Seed failed (exit ${code})`)
+    })
+
+  // --- logs ---
+  scale
+    .command('logs')
+    .description('Tail application logs')
+    .option('-n, --lines <n>', 'Number of lines', '50')
+    .option('-f, --follow', 'Follow log output')
+    .action(async (opts) => {
+      const path = getProductPath(config, 'scale')
+      const logFile = join(path, 'logs/app.log')
+      if (!existsSync(logFile)) {
+        warn(`No log file at ${logFile}`)
+        return
+      }
+      const args = [opts.follow ? '-f' : `-n${opts.lines}`, logFile]
+      await run('tail', args, path)
+    })
+}

package/src/commands/serve.ts

@@ -0,0 +1,171 @@
+/**
+ * dragon serve — Start the entire stack
+ *
+ * Spawns:
+ *  - PhantomDragon Control API (Python uvicorn :4091)
+ *  - PhantomDragon Control dashboard (Next.js :4090)
+ *  - DragonNet API (Fastify :4080)
+ *  - DragonNet dashboard (Next.js :4081)
+ *
+ * PID files at ~/.dragon/pids/ so `dragon down` can stop them cleanly.
+ * Foreground mode tails stdout; --detach forks to background.
+ */
+
+import type { Command } from 'commander'
+import type { DragonConfig } from '../config.js'
+import { label, success, error, info, warn } from '../utils.js'
+import chalk from 'chalk'
+import { spawn } from 'child_process'
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+
+const PIDS_DIR = join(homedir(), '.dragon', 'pids')
+const LOGS_DIR = join(homedir(), '.dragon', 'logs')
+
+function ensureDirs() {
+  mkdirSync(PIDS_DIR, { recursive: true })
+  mkdirSync(LOGS_DIR, { recursive: true })
+}
+
+function pidAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true } catch { return false }
+}
+
+interface Service {
+  key: string
+  name: string
+  cwd: string
+  cmd: string
+  args: string[]
+  env?: Record<string, string>
+  port?: number
+}
+
+function buildServices(config: DragonConfig): Service[] {
+  const services: Service[] = []
+  const pentest = config.products.pentest.path
+  if (pentest && existsSync(join(pentest, 'phantomdragon.py'))) {
+    services.push({
+      key: 'pd-control-api',
+      name: 'PhantomDragon Control API',
+      cwd: pentest,
+      cmd: 'python3',
+      args: ['-m', 'phantom_dragon_ai.control_api'],
+      port: config.products.pentest.controlPort,
+    })
+  }
+  // The Next.js dashboard lives in a sibling dir
+  const controlDash = pentest ? join(pentest, '..', 'phantomdragon-control') : ''
+  if (controlDash && existsSync(controlDash) && existsSync(join(controlDash, 'package.json'))) {
+    services.push({
+      key: 'pd-control-ui',
+      name: 'PhantomDragon Control UI',
+      cwd: controlDash,
+      cmd: 'npm',
+      args: ['run', 'dev'],
+      port: config.products.pentest.controlUiPort,
+    })
+  }
+  const net = config.products.net.path
+  if (net && existsSync(join(net, 'pnpm-workspace.yaml'))) {
+    services.push({
+      key: 'dn-api',
+      name: 'DragonNet API',
+      cwd: net,
+      cmd: 'pnpm',
+      args: ['--filter', '@dragonnet/api', 'dev'],
+      port: config.products.net.apiPort,
+    })
+    services.push({
+      key: 'dn-ui',
+      name: 'DragonNet Dashboard',
+      cwd: net,
+      cmd: 'pnpm',
+      args: ['--filter', '@dragonnet/dashboard', 'dev'],
+      port: config.products.net.uiPort,
+    })
+  }
+  return services
+}
+
+function startService(s: Service): number {
+  const logPath = join(LOGS_DIR, `${s.key}.log`)
+  const child = spawn(s.cmd, s.args, {
+    cwd: s.cwd,
+    detached: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env, ...(s.env ?? {}) },
+  })
+  const { openSync, closeSync } = require('fs') as typeof import('fs')
+  const fd = openSync(logPath, 'a')
+  child.stdout?.on('data', (chunk: Buffer) => writeFileSync(logPath, chunk, { flag: 'a' }))
+  child.stderr?.on('data', (chunk: Buffer) => writeFileSync(logPath, chunk, { flag: 'a' }))
+  child.unref()
+  closeSync(fd)
+  writeFileSync(join(PIDS_DIR, `${s.key}.pid`), String(child.pid))
+  return child.pid ?? 0
+}
+
+export function registerServeCommands(program: Command, config: DragonConfig) {
+  program
+    .command('serve')
+    .description('Start the entire dragon stack (PhantomDragon Control + DragonNet)')
+    .option('--detach', 'Background mode (default: foreground)', false)
+    .action(async () => {
+      ensureDirs()
+      const services = buildServices(config)
+      if (services.length === 0) {
+        error('No products configured. Run: dragon init')
+        return
+      }
+      console.log(label('Dragon'), 'Starting stack...\n')
+      for (const s of services) {
+        const pidFile = join(PIDS_DIR, `${s.key}.pid`)
+        if (existsSync(pidFile)) {
+          const oldPid = Number(readFileSync(pidFile, 'utf-8'))
+          if (pidAlive(oldPid)) {
+            info(`${s.name} already running (pid ${oldPid})`)
+            continue
+          }
+        }
+        try {
+          const pid = startService(s)
+          success(`${s.name.padEnd(28)} ${chalk.dim(`pid ${pid}` + (s.port ? `  :${s.port}` : ''))}`)
+        } catch (e) {
+          error(`${s.name} → ${e}`)
+        }
+      }
+      console.log()
+      info('Logs at ~/.dragon/logs/<service>.log')
+      info('Stop with: dragon down')
+    })
+
+  program
+    .command('down')
+    .description('Stop all dragon services')
+    .action(() => {
+      ensureDirs()
+      const files = readdirSync(PIDS_DIR).filter((f) => f.endsWith('.pid'))
+      if (files.length === 0) {
+        info('Nothing to stop.')
+        return
+      }
+      for (const f of files) {
+        const pidPath = join(PIDS_DIR, f)
+        const pid = Number(readFileSync(pidPath, 'utf-8'))
+        const name = f.replace(/\.pid$/, '')
+        if (pidAlive(pid)) {
+          try {
+            process.kill(-pid, 'SIGTERM')
+          } catch {
+            try { process.kill(pid, 'SIGTERM') } catch { /* swallow */ }
+          }
+          success(`Stopped ${name} (pid ${pid})`)
+        } else {
+          warn(`${name} not running`)
+        }
+        try { unlinkSync(pidPath) } catch { /* swallow */ }
+      }
+    })
+}

package/src/commands/tui.ts

@@ -0,0 +1,126 @@
+/**
+ * dragon tui — the operator command-center. Full-screen, in the ghosts.lk visual
+ * language: near-black depth, a brushed-chrome phantom sigil + wordmark, two-column
+ * live panels (system · signal) with a traces-per-hour sparkline + disk gauge, and a
+ * pulsing emerald OPSEC bar.
+ *
+ * Rendered like a flagship TUI (see the advanced-tui-design + terminal-subcell-graphics
+ * skills): runs on the ALTERNATE screen buffer (htop-style, restores your scrollback),
+ * hides the cursor, and paints each frame inside SYNCHRONIZED OUTPUT (DEC ?2026) with
+ * per-line clear-to-EOL — so frames are atomic and flicker-free. `q` / Ctrl-C to quit.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+
+import type { Command } from 'commander'
+import { loadConfig, type DragonConfig } from '../config.js'
+import { C } from '../utils.js'
+import { panel, chrome, chromeRule, joinColumns, emerald, brailleChart, gauge } from '../ui.js'
+import { resolveAuth } from '../auth.js'
+import { resolveProvider } from '../brain/index.js'
+import { loadSkillLibrary } from '../agent/skills.js'
+import { existsSync, statfsSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { stdin, stdout } from 'node:process'
+
+const SIGIL = ['   ▄▄▄▄▄   ', '  ▟█████▙  ', '  █ ▘ ▘ █  ', '  ▜█████▛  ', '   ▘▘ ▘▘   ']
+const SIGIL_W = 11
+const VER = '4.2.1'
+const PULSE = ['·', '•', '●', '•'] // heartbeat
+const dot = (on: boolean) => (on ? emerald('●') : C.faint('○'))
+const indent = (s: string) => s.split('\n').map((l) => '  ' + l).join('\n')
+
+// Terminal control. ?1049 = alt screen, ?25 = cursor, ?2026 = synchronized output.
+const ENTER = '\x1b[?1049h\x1b[?25l'
+const LEAVE = '\x1b[?25h\x1b[?1049l'
+/** Atomic, flicker-free frame: sync-begin → home → per-line clear-to-EOL → clear-below → sync-end. */
+function paint(content: string): void {
+  const lines = content.split('\n')
+  stdout.write('\x1b[?2026h\x1b[H' + lines.map((l) => l + '\x1b[K').join('\n') + '\x1b[J\x1b[?2026l')
+}
+
+export function registerTuiCommands(program: Command, _config: DragonConfig) {
+  program
+    .command('tui')
+    .description('Live operator command-center (press q to quit)')
+    .action(async () => {
+      const skills = loadSkillLibrary().count
+      const ollama = ['/usr/local/bin/ollama', '/usr/bin/ollama', join(homedir(), '.local/bin/ollama')].some(existsSync)
+      const wyrmReady = [process.env.WYRM_MCP_BIN, join(homedir(), '.npm-global/bin/wyrm-mcp')].filter(Boolean).some((p) => existsSync(p as string))
+      let frame = 0
+
+      const draw = () => {
+        const cols = Math.max(64, Math.min(stdout.columns || 100, 124))
+        const inner = cols - 4
+        const wide = cols >= 92
+        const leftW = wide ? Math.min(44, Math.floor(inner / 2) - 2) : inner
+        const rightW = wide ? inner - leftW - 3 : inner
+        const actMax = (wide ? rightW : inner) - 8
+        const pulse = emerald(PULSE[frame % PULSE.length])
+
+        const cfg = loadConfig()
+        const a = resolveAuth()
+        const active = resolveProvider()
+        const ready: Record<string, boolean> = {
+          claude: !!(process.env.ANTHROPIC_API_KEY || cfg.brain?.keys?.anthropic),
+          worker: a.mode !== 'none', local: ollama,
+          openai: !!(process.env.OPENAI_API_KEY || cfg.brain?.keys?.openai),
+          custom: !!(process.env.DRAGON_OPENAI_BASE || cfg.brain?.customBaseURL), ghost: false,
+        }
+        let diskFrac = 0
+        let diskFree = '—'
+        try { const st = statfsSync(process.cwd()); const free = st.bavail * st.bsize; const total = st.blocks * st.bsize; diskFrac = total ? 1 - free / total : 0; diskFree = `${(free / 1e9).toFixed(0)}G free` } catch { /* skip */ }
+
+        let traces = 0
+        let recent: string[] = []
+        const hours = new Array(24).fill(0)
+        try {
+          const lines = readFileSync(join(homedir(), '.dragon', 'traces', `${new Date().toISOString().slice(0, 10)}.jsonl`), 'utf-8').trim().split('\n').filter(Boolean)
+          traces = lines.length
+          for (const l of lines) { try { const t = JSON.parse(l); hours[new Date(t.ts).getHours()]++ } catch { /* skip */ } }
+          recent = lines.slice(-3).map((l) => { try { return (JSON.parse(l).prompt || '').replace(/\s+/g, ' ').trim() } catch { return '' } }).filter(Boolean)
+        } catch { /* none today */ }
+
+        // ── hero ──
+        const hero = joinColumns(
+          SIGIL.map((l) => chrome(l)).join('\n'),
+          ['', chrome('G H O S T   P R O T O C O L'), `${C.faint('▌')} ${emerald('OPERATOR CONSOLE')} ${C.faint('//')} ${C.info('DRAGON v' + VER)}`, C.faint('on-host coding + ops agent · sovereign-capable · ghosts.lk'), ''].join('\n'),
+          SIGIL_W,
+        )
+
+        // ── panels ──
+        const sysLines = [
+          `${C.faint('brain ')} ${dot(ready[active] ?? false)} ${C.info(active)}`,
+          `${C.faint('auth  ')} ${dot(a.mode !== 'none')} ${a.mode === 'none' ? C.faint('signed out') : C.info(a.email || a.mode)}`,
+          `${C.faint('memory')} ${dot(wyrmReady)} ${wyrmReady ? C.info('Wyrm') : C.faint('—')}    ${C.faint('ollama')} ${dot(ollama)}`,
+          `${C.faint('skills')} ${C.info(String(skills))}`,
+          `${C.faint('disk  ')} ${gauge(diskFrac, 12)} ${C.faint(diskFree)}`,
+        ]
+        const chartW = Math.max(16, Math.min(actMax, 40))
+        const peak = Math.max(...hours, 1)
+        const actLines = [
+          ...(recent.length ? recent.map((r) => `${C.faint('›')} ${C.info(r.slice(0, actMax))}`) : [C.faint('no agent activity today')]),
+          '',
+          `${C.faint('24h traces')} ${C.faint('· peak')} ${emerald(String(peak))}`,
+          ...brailleChart(hours, { width: chartW, height: 3, area: true }),
+          `${pulse} ${C.faint(`listening · ${traces} traces today`)}`,
+        ]
+
+        const body = wide
+          ? joinColumns(panel(sysLines, { title: chrome('SYSTEM'), width: leftW }), panel(actLines, { title: chrome('SIGNAL'), width: rightW }), leftW)
+          : panel(sysLines, { title: chrome('SYSTEM'), width: inner }) + '\n' + panel(actLines, { title: chrome('SIGNAL'), width: inner })
+
+        const bar = `  ${pulse} ${C.faint('SYS')} ${emerald('OK')}  ${C.faint('· brain')} ${C.info(active)}  ${C.faint('· skills')} ${C.info(String(skills))}  ${C.faint('·')} ${C.info(new Date().toLocaleTimeString())}  ${C.faint('· q quit')}`
+
+        paint('\n' + indent(hero) + '\n  ' + chromeRule(inner) + '\n\n' + indent(body) + '\n\n' + bar)
+      }
+
+      stdout.write(ENTER)
+      draw()
+      const iv = setInterval(() => { frame++; draw() }, 1000)
+      const quit = () => { clearInterval(iv); if (stdin.isTTY) { try { stdin.setRawMode(false) } catch { /* ignore */ } } stdout.write(LEAVE); process.exit(0) }
+      process.on('SIGINT', quit)
+      if (stdin.isTTY) { stdin.setRawMode(true); stdin.resume(); stdin.on('data', (d) => { const s = d.toString(); if (s === 'q' || s === 'Q' || d[0] === 3) quit() }) }
+    })
+}