ghost-dragon 4.2.1

package/dist/commands/doctor.js

@@ -0,0 +1,73 @@
+/**
+ * dragon doctor — one-glance health check of everything the agent depends on:
+ * node, the active brain + readiness, auth, Wyrm memory, Ollama, the skill library,
+ * disk, and config-file permissions. Read-only; green/amber/red per check.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { loadConfig } from '../config.js';
+import { C } from '../utils.js';
+import { panel, chrome } from '../ui.js';
+import { resolveAuth, whoami } from '../auth.js';
+import { resolveProvider } from '../brain/index.js';
+import { Wyrm } from '../wyrm/mcp.js';
+import { loadSkillLibrary } from '../agent/skills.js';
+import { existsSync, statSync, statfsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const mark = (s) => (s === 'ok' ? C.accent('●') : s === 'warn' ? C.high('◐') : C.critical('○'));
+const paint = (s, v) => (s === 'fail' ? C.critical(v) : s === 'warn' ? C.high(v) : C.info(v));
+export function registerDoctorCommands(program, _config) {
+    program
+        .command('doctor')
+        .description('Health check — brain, auth, memory, models, disk, perms')
+        .action(async () => {
+        const rows = [];
+        const cfg = loadConfig();
+        const a = resolveAuth();
+        const ollama = ['/usr/local/bin/ollama', '/usr/bin/ollama', join(homedir(), '.local/bin/ollama')].some(existsSync);
+        const major = Number(process.version.slice(1).split('.')[0]);
+        rows.push([major >= 20 ? 'ok' : 'warn', 'node', `${process.version}${major >= 20 ? '' : ' (20+ recommended)'}`]);
+        const active = resolveProvider();
+        const ready = {
+            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,
+        };
+        const brainOk = ready[active] ?? false;
+        rows.push([brainOk ? 'ok' : 'warn', 'brain', `${active}${brainOk ? ' · ready' : ' · not set up (will fall back)'}`]);
+        if (a.mode === 'none')
+            rows.push(['warn', 'auth', 'not signed in — run `dragon login`']);
+        else {
+            const me = await whoami();
+            rows.push([me.ok ? 'ok' : 'fail', 'auth', me.ok ? `${a.mode} · ${me.email ?? 'verified'}` : `${a.mode} · invalid (re-login)`]);
+        }
+        const w = new Wyrm();
+        const wok = await w.connect();
+        rows.push([wok ? 'ok' : 'warn', 'memory', wok ? `Wyrm · ${w.toolSpecs().length} tools` : 'Wyrm unavailable (agent works without it)']);
+        await w.close();
+        rows.push([ollama ? 'ok' : 'warn', 'ollama', ollama ? 'installed' : 'not found (local brain needs it)']);
+        const sk = loadSkillLibrary();
+        rows.push([sk.count > 0 ? 'ok' : 'warn', 'skills', `${sk.count} loaded`]);
+        try {
+            const st = statfsSync(process.cwd());
+            const g = (st.bavail * st.bsize) / 1e9;
+            rows.push([g > 2 ? 'ok' : g > 0.5 ? 'warn' : 'fail', 'disk', `${g.toFixed(1)} GB free`]);
+        }
+        catch { /* skip */ }
+        try {
+            const m = statSync(join(homedir(), '.dragon', 'config.json')).mode & 0o777;
+            rows.push([m === 0o600 ? 'ok' : 'warn', 'config', `~/.dragon/config.json ${m.toString(8)}${m === 0o600 ? '' : ' (expected 600)'}`]);
+        }
+        catch { /* no config yet */ }
+        console.log();
+        console.log(panel(rows.map(([s, k, v]) => `${mark(s)} ${C.faint(k.padEnd(7))} ${paint(s, v)}`), { title: chrome('DOCTOR') }));
+        const fails = rows.filter((r) => r[0] === 'fail').length;
+        const warns = rows.filter((r) => r[0] === 'warn').length;
+        console.log(`  ${fails ? C.critical(`${fails} failing`) : warns ? C.high(`${warns} warning${warns > 1 ? 's' : ''}`) : C.accent('all systems green')}`);
+    });
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/global.d.ts

@@ -0,0 +1,11 @@
+/**
+ * dragon init / dragon status / dragon doctor — Global commands
+ *
+ * - init:    Auto-detect product paths and write ~/.dragon/config.json
+ * - status:  Health check across all products + APIs
+ * - doctor:  Contract-test the cross-tool flows (lightweight)
+ */
+import type { Command } from 'commander';
+import type { DragonConfig } from '../config.js';
+export declare function registerGlobalCommands(program: Command, config: DragonConfig): void;
+//# sourceMappingURL=global.d.ts.map

package/dist/commands/global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../../src/commands/global.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAsChD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,QAgN5E"}

package/dist/commands/global.js

@@ -0,0 +1,253 @@
+/**
+ * dragon init / dragon status / dragon doctor — Global commands
+ *
+ * - init:    Auto-detect product paths and write ~/.dragon/config.json
+ * - status:  Health check across all products + APIs
+ * - doctor:  Contract-test the cross-tool flows (lightweight)
+ */
+import { saveConfig } from '../config.js';
+import { label, success, warn } from '../utils.js';
+import chalk from 'chalk';
+import { existsSync, statSync } from 'fs';
+import { join, resolve } from 'path';
+import { homedir } from 'os';
+const KNOWN_MARKERS = {
+    scale: { files: ['includes/payment.php', 'admin/orders.php', 'api/health.php'], name: 'DragonScale' },
+    wyrm: { files: ['packages/mcp-server/src/index.ts', 'install.sh'], name: 'Wyrm' },
+    pentest: { files: ['phantomdragon.py', 'phantom_dragon_ai/control_api.py'], name: 'PhantomDragon' },
+    keep: { files: ['src/engine/sentinel.rs', 'src/engine/shield.rs'], name: 'DragonKeep' },
+    net: { files: ['packages/api/src/server.ts', 'pnpm-workspace.yaml'], name: 'DragonNet' },
+};
+function detectProduct(dir, product) {
+    const markers = KNOWN_MARKERS[product];
+    if (!markers)
+        return false;
+    return markers.files.some(f => existsSync(join(dir, f)));
+}
+async function ping(url, timeoutMs = 1500) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(url, { signal: controller.signal });
+            const text = await res.text();
+            let parsed = null;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = text;
+            }
+            return { ok: res.ok, status: res.status, data: parsed };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    catch (e) {
+        return { ok: false, error: String(e) };
+    }
+}
+export function registerGlobalCommands(program, config) {
+    // --- init ---
+    program
+        .command('init')
+        .description('Auto-detect products and configure dragon CLI')
+        .option('-d, --dir <dir>', 'Directory to scan', resolve('.'))
+        .action(async (opts) => {
+        console.log(label('Dragon'), 'Initializing...\n');
+        const scanDirs = [
+            opts.dir,
+            join(homedir(), 'Git Projects'),
+            join(homedir(), 'Projects'),
+            join(homedir(), 'src'),
+        ];
+        const found = {};
+        for (const baseDir of scanDirs) {
+            if (!existsSync(baseDir))
+                continue;
+            const { readdirSync } = await import('fs');
+            const entries = readdirSync(baseDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const fullPath = join(baseDir, entry.name);
+                for (const [product, _] of Object.entries(KNOWN_MARKERS)) {
+                    if (!found[product] && detectProduct(fullPath, product)) {
+                        found[product] = fullPath;
+                    }
+                }
+            }
+        }
+        // Update config
+        for (const [product, path] of Object.entries(found)) {
+            config.products[product].path = path;
+            success(`${KNOWN_MARKERS[product].name} → ${chalk.dim(path)}`);
+        }
+        for (const [product, markers] of Object.entries(KNOWN_MARKERS)) {
+            if (!found[product]) {
+                warn(`${markers.name} not found`);
+            }
+        }
+        saveConfig(config);
+        console.log();
+        success(`Config saved to ${chalk.dim('~/.dragon/config.json')}`);
+    });
+    // --- status ---
+    program
+        .command('status')
+        .description('Health check across all products + APIs')
+        .action(async () => {
+        console.log(label('Dragon'), 'System status:\n');
+        // DragonScale
+        const scaleUrl = config.products.scale.url;
+        const scalePath = config.products.scale.path;
+        if (scalePath && existsSync(join(scalePath, 'index.php'))) {
+            console.log(`  ${chalk.green('●')} DragonScale          ${chalk.dim(scaleUrl || scalePath)}  ${chalk.green('Installed')}`);
+        }
+        else {
+            console.log(`  ${chalk.dim('○')} DragonScale          ${chalk.dim('Not configured')}`);
+        }
+        // Wyrm
+        const wyrmPath = config.products.wyrm.path;
+        const wyrmPort = config.products.wyrm.port || 3333;
+        if (wyrmPath) {
+            const r = await ping(`http://localhost:${wyrmPort}/health`);
+            if (r.ok) {
+                console.log(`  ${chalk.green('●')} Wyrm                 ${chalk.dim(`localhost:${wyrmPort}`)}  ${chalk.green('Online')}`);
+            }
+            else {
+                console.log(`  ${chalk.yellow('●')} Wyrm                 ${chalk.dim(`localhost:${wyrmPort}`)}  ${chalk.yellow('Installed · Offline')}`);
+            }
+        }
+        else {
+            console.log(`  ${chalk.dim('○')} Wyrm                 ${chalk.dim('Not configured')}`);
+        }
+        // PhantomDragon engine + control_api
+        const pentestPath = config.products.pentest.path;
+        if (pentestPath && (existsSync(join(pentestPath, 'phantom_dragon_ai/control_api.py'))
+            || existsSync(join(pentestPath, 'phantomdragon.py')))) {
+            console.log(`  ${chalk.green('●')} PhantomDragon engine ${chalk.dim(pentestPath)}  ${chalk.green('Installed')}`);
+            const apiPort = config.products.pentest.controlPort ?? 4091;
+            const uiPort = config.products.pentest.controlUiPort ?? 4090;
+            const apiR = await ping(`http://localhost:${apiPort}/health`);
+            if (apiR.ok && apiR.data) {
+                const d = apiR.data;
+                console.log(`    ${chalk.green('●')} Control API        ${chalk.dim(`localhost:${apiPort}`)}  ${chalk.green('Online')}  ${chalk.dim(`(${d.scan_count} scans, ${d.active_runs} runs)`)}`);
+            }
+            else {
+                console.log(`    ${chalk.yellow('●')} Control API        ${chalk.dim(`localhost:${apiPort}`)}  ${chalk.yellow('Offline')}`);
+            }
+            const uiR = await ping(`http://localhost:${uiPort}/`);
+            if (uiR.ok) {
+                console.log(`    ${chalk.green('●')} Control Dashboard  ${chalk.dim(`localhost:${uiPort}`)}  ${chalk.green('Online')}`);
+            }
+            else {
+                console.log(`    ${chalk.yellow('●')} Control Dashboard  ${chalk.dim(`localhost:${uiPort}`)}  ${chalk.yellow('Offline')}`);
+            }
+        }
+        else {
+            console.log(`  ${chalk.dim('○')} PhantomDragon engine ${chalk.dim('Not configured')}`);
+        }
+        // DragonNet
+        const netPath = config.products.net.path;
+        if (netPath && existsSync(join(netPath, 'pnpm-workspace.yaml'))) {
+            console.log(`  ${chalk.green('●')} DragonNet            ${chalk.dim(netPath)}  ${chalk.green('Installed')}`);
+            const apiPort = config.products.net.apiPort ?? 4080;
+            const uiPort = config.products.net.uiPort ?? 4081;
+            const apiR = await ping(`http://localhost:${apiPort}/health`);
+            if (apiR.ok) {
+                console.log(`    ${chalk.green('●')} OSINT API          ${chalk.dim(`localhost:${apiPort}`)}  ${chalk.green('Online')}`);
+            }
+            else {
+                console.log(`    ${chalk.yellow('●')} OSINT API          ${chalk.dim(`localhost:${apiPort}`)}  ${chalk.yellow('Offline')}`);
+            }
+            const uiR = await ping(`http://localhost:${uiPort}/`);
+            if (uiR.ok) {
+                console.log(`    ${chalk.green('●')} OSINT Dashboard    ${chalk.dim(`localhost:${uiPort}`)}  ${chalk.green('Online')}`);
+            }
+            else {
+                console.log(`    ${chalk.yellow('●')} OSINT Dashboard    ${chalk.dim(`localhost:${uiPort}`)}  ${chalk.yellow('Offline')}`);
+            }
+        }
+        else {
+            console.log(`  ${chalk.dim('○')} DragonNet            ${chalk.dim('Not configured')}`);
+        }
+        // Phantom Memory
+        const memPath = join(homedir(), '.copilot', 'phantom-memory.db');
+        if (existsSync(memPath)) {
+            const bytes = statSync(memPath).size;
+            const apiPort = config.products.pentest.controlPort ?? 4091;
+            const memR = await ping(`http://localhost:${apiPort}/v1/memory`);
+            let targetCount = '—';
+            if (memR.ok && memR.data?.targets)
+                targetCount = String(memR.data.targets.length);
+            const sizeStr = bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+            console.log(`  ${chalk.green('●')} Phantom Memory       ${chalk.dim(memPath)}  ${chalk.green(`${targetCount} targets · ${sizeStr}`)}`);
+        }
+        else {
+            console.log(`  ${chalk.dim('○')} Phantom Memory       ${chalk.dim('No DB yet — runs auto-create on first scan')}`);
+        }
+        // DragonKeep (Rust defensive backbone)
+        const keepPath = config.products.keep.path;
+        if (keepPath && existsSync(join(keepPath, 'Cargo.toml'))) {
+            const dbgBin = join(keepPath, 'target/debug/dragonkeep');
+            const relBin = join(keepPath, 'target/release/dragonkeep');
+            const built = existsSync(relBin) || existsSync(dbgBin);
+            const label_ = built ? chalk.green('Installed · built') : chalk.yellow('Installed · not yet built');
+            console.log(`  ${chalk.green('●')} DragonKeep           ${chalk.dim(keepPath)}  ${label_}`);
+            if (!built) {
+                console.log(`    ${chalk.dim('→ cargo build --release in ' + keepPath)}`);
+            }
+        }
+        else {
+            console.log(`  ${chalk.dim('○')} DragonKeep           ${chalk.dim('Not configured')}`);
+        }
+        console.log();
+    });
+    // --- contract (cross-tool flow checks; `dragon doctor` is the health panel) ---
+    program
+        .command('contract')
+        .description('Contract-test cross-tool flows (Phantom Memory / Control API / DragonNet / Wyrm)')
+        .action(async () => {
+        console.log(label('Dragon'), 'Contract checks:\n');
+        const checks = [];
+        // Phantom Memory exists?
+        const memPath = join(homedir(), '.copilot', 'phantom-memory.db');
+        checks.push({ name: 'Phantom Memory DB present', ok: existsSync(memPath), note: memPath });
+        // Control API speaks memory?
+        const apiPort = config.products.pentest.controlPort ?? 4091;
+        const memR = await ping(`http://localhost:${apiPort}/v1/memory`);
+        checks.push({
+            name: 'Control API /v1/memory reachable',
+            ok: memR.ok,
+            note: memR.ok ? `${memR.data?.targets?.length ?? 0} targets` : memR.error,
+        });
+        // DragonNet API reachable?
+        const dnPort = config.products.net.apiPort ?? 4080;
+        const dnR = await ping(`http://localhost:${dnPort}/health`);
+        checks.push({
+            name: 'DragonNet /health reachable',
+            ok: dnR.ok,
+            note: dnR.ok ? 'OK' : 'offline (run: dragon osint serve)',
+        });
+        // Wyrm reachable?
+        const wyrmR = await ping(`http://localhost:${config.products.wyrm.port ?? 3333}/health`);
+        checks.push({
+            name: 'Wyrm /health reachable',
+            ok: wyrmR.ok,
+            note: wyrmR.ok ? 'OK' : 'offline (Wyrm integration becomes best-effort)',
+        });
+        checks.forEach((c) => {
+            const sym = c.ok ? chalk.green('✓') : chalk.yellow('⚠');
+            console.log(`  ${sym} ${c.name.padEnd(40)}  ${chalk.dim(c.note ?? '')}`);
+        });
+        console.log();
+        const failing = checks.filter((c) => !c.ok).length;
+        if (failing === 0)
+            success('All contract checks passing');
+        else
+            warn(`${failing} check(s) need attention — see ~/Git Projects/dragon-cli/docs/SYSTEM-PREMORTEM.md`);
+    });
+}
+//# sourceMappingURL=global.js.map

package/dist/commands/keep.d.ts

@@ -0,0 +1,12 @@
+/**
+ * dragon keep — DragonKeep defensive engine bridge.
+ *
+ * DragonKeep ships independently as a Rust binary (`dragonkeep`); this
+ * subcommand is a thin shim that surfaces its status + control loop
+ * from the unified `dragon` CLI so operators don't need to memorise
+ * a second toolchain.
+ */
+import type { Command } from 'commander';
+import type { DragonConfig } from '../config.js';
+export declare function registerKeepCommands(program: Command, _config: DragonConfig): void;
+//# sourceMappingURL=keep.d.ts.map

package/dist/commands/keep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keep.d.ts","sourceRoot":"","sources":["../../src/commands/keep.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAsBhD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,QAkC3E"}

package/dist/commands/keep.js

@@ -0,0 +1,58 @@
+/**
+ * dragon keep — DragonKeep defensive engine bridge.
+ *
+ * DragonKeep ships independently as a Rust binary (`dragonkeep`); this
+ * subcommand is a thin shim that surfaces its status + control loop
+ * from the unified `dragon` CLI so operators don't need to memorise
+ * a second toolchain.
+ */
+import { spawnSync } from 'node:child_process';
+import { error, info, label } from '../utils.js';
+import chalk from 'chalk';
+function which(bin) {
+    const r = spawnSync('command', ['-v', bin], { shell: true, encoding: 'utf-8' });
+    const out = (r.stdout || '').trim();
+    return out || null;
+}
+function passthrough(args) {
+    const bin = which('dragonkeep');
+    if (!bin) {
+        error('dragonkeep binary not on PATH');
+        info('install it via `dragon install dragonkeep` or build from source in ~/Git Projects/DragonKeep');
+        return 127;
+    }
+    const r = spawnSync(bin, args, { stdio: 'inherit' });
+    return r.status ?? 1;
+}
+export function registerKeepCommands(program, _config) {
+    const keep = program
+        .command('keep')
+        .description('DragonKeep — defensive engine (NGAV · MDR · compliance · SOAR)');
+    keep
+        .command('status')
+        .description('Show DragonKeep daemon status + active engines')
+        .action(() => { process.exit(passthrough(['status'])); });
+    keep
+        .command('scan [path]')
+        .description('Run an on-demand AV scan')
+        .action((path) => { process.exit(passthrough(['scan', ...(path ? [path] : [])])); });
+    keep
+        .command('engines')
+        .description('List the active defensive engines')
+        .action(() => { process.exit(passthrough(['engines'])); });
+    // Default action: print a short summary instead of dumping help.
+    keep.action(() => {
+        console.log();
+        console.log(`  ${label('DragonKeep')}  ${chalk.dim('defensive engine · 28 modules · NGAV + MDR')}`);
+        console.log();
+        console.log(`  ${chalk.dim('dragon keep status')}   ${chalk.dim('— daemon + engine health')}`);
+        console.log(`  ${chalk.dim('dragon keep scan')}     ${chalk.dim('— on-demand scan')}`);
+        console.log(`  ${chalk.dim('dragon keep engines')}  ${chalk.dim('— list active engines')}`);
+        console.log();
+        if (!which('dragonkeep')) {
+            info(`run ${chalk.green('dragon install dragonkeep')} to install the daemon`);
+            console.log();
+        }
+    });
+}
+//# sourceMappingURL=keep.js.map

package/dist/commands/lifecycle.d.ts

@@ -0,0 +1,17 @@
+/**
+ * dragon lifecycle commands — bootstrap + update + install + stop
+ *
+ *   dragon up                — clone every missing repo, install everything
+ *   dragon update            — git pull every product in the manifest
+ *   dragon install <key>     — install one product
+ *   dragon uninstall <key>   — remove a product directory (asks first)
+ *   dragon list              — print the manifest
+ *   dragon stop --all        — kill every running service (uses ~/.dragon/pids/)
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ * Author: Ryan Sebastian <ryan@ghosts.lk>
+ */
+import type { Command } from 'commander';
+import type { DragonConfig } from '../config.js';
+export declare function registerLifecycleCommands(program: Command, _config: DragonConfig): void;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/commands/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/commands/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAoFhD,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,QA6KhF"}