thevoidforge 21.0.0

package/dist/scripts/vault-read.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env npx tsx
+/**
+ * Standalone vault reader — read a single key from the encrypted vault.
+ *
+ * Usage:
+ *   npx tsx scripts/vault-read.ts --key "env:WHATSAPP_ACCESS_TOKEN"
+ *   npx tsx scripts/vault-read.ts --list
+ *
+ * For non-interactive use (CI/CD), set VOIDFORGE_VAULT_PASSWORD env var.
+ */
+export {};

package/dist/scripts/vault-read.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env npx tsx
+/**
+ * Standalone vault reader — read a single key from the encrypted vault.
+ *
+ * Usage:
+ *   npx tsx scripts/vault-read.ts --key "env:WHATSAPP_ACCESS_TOKEN"
+ *   npx tsx scripts/vault-read.ts --list
+ *
+ * For non-interactive use (CI/CD), set VOIDFORGE_VAULT_PASSWORD env var.
+ */
+import { createInterface } from 'node:readline';
+import { vaultExists, vaultUnlock, vaultGet, vaultKeys } from '../wizard/lib/vault.js';
+const args = process.argv.slice(2);
+const keyFlag = args.find((_, i) => args[i - 1] === '--key');
+const listMode = args.includes('--list');
+if (!keyFlag && !listMode) {
+    console.log('Usage:');
+    console.log('  npx tsx scripts/vault-read.ts --key "env:WHATSAPP_ACCESS_TOKEN"');
+    console.log('  npx tsx scripts/vault-read.ts --list');
+    console.log('');
+    console.log('Set VOIDFORGE_VAULT_PASSWORD env var for non-interactive use.');
+    process.exit(1);
+}
+if (!vaultExists()) {
+    console.error('No vault found at ~/.voidforge/vault.enc');
+    process.exit(1);
+}
+async function getPassword() {
+    const envPassword = process.env['VOIDFORGE_VAULT_PASSWORD'];
+    if (envPassword)
+        return envPassword;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        process.stdout.write('Vault password: ');
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        if (stdin.isTTY && stdin.setRawMode) {
+            stdin.setRawMode(true);
+        }
+        let password = '';
+        const onData = (ch) => {
+            const c = ch.toString();
+            if (c === '\n' || c === '\r') {
+                stdin.removeListener('data', onData);
+                if (stdin.isTTY && stdin.setRawMode)
+                    stdin.setRawMode(wasRaw ?? false);
+                process.stdout.write('\n');
+                rl.close();
+                resolve(password);
+            }
+            else if (c === '\u007f' || c === '\b') {
+                password = password.slice(0, -1);
+            }
+            else if (c === '\u0003') {
+                process.exit(1);
+            }
+            else {
+                password += c;
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
+async function main() {
+    const password = await getPassword();
+    const valid = await vaultUnlock(password);
+    if (!valid) {
+        console.error('Wrong vault password');
+        process.exit(1);
+    }
+    if (listMode) {
+        const keys = await vaultKeys(password);
+        for (const key of keys) {
+            console.log(key);
+        }
+        return;
+    }
+    const value = await vaultGet(password, keyFlag);
+    if (value === null) {
+        console.error(`Key not found: ${keyFlag}`);
+        process.exit(1);
+    }
+    // Output value only — suitable for piping
+    process.stdout.write(value);
+}
+main().catch((err) => {
+    console.error(err.message);
+    process.exit(1);
+});

package/dist/scripts/voidforge.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env npx tsx
+/**
+ * VoidForge CLI — v21.0 The Extraction
+ *
+ * npx voidforge                       Launch wizard (browser UI at :3141)
+ * npx voidforge init                  Create new project (Gandalf flow)
+ * npx voidforge init --headless       Create project without browser
+ * npx voidforge init --core           Minimal methodology (no Holocron, no patterns)
+ * npx voidforge update                Update project methodology (Bombadil)
+ * npx voidforge update --self         Update the wizard itself
+ * npx voidforge update --extensions   Update all installed extensions
+ * npx voidforge install <ext>         Add extension to current project
+ * npx voidforge uninstall <ext>       Remove extension from current project
+ * npx voidforge deploy                Deploy project (Haku)
+ * npx voidforge doctor                Check versions, compatibility, health
+ * npx voidforge migrate               Migrate old-model project to v21.0
+ * npx voidforge version               Show wizard + methodology versions
+ * npx voidforge templates             List available project templates
+ */
+export {};

package/dist/scripts/voidforge.js

@@ -0,0 +1,404 @@
+#!/usr/bin/env npx tsx
+/**
+ * VoidForge CLI — v21.0 The Extraction
+ *
+ * npx voidforge                       Launch wizard (browser UI at :3141)
+ * npx voidforge init                  Create new project (Gandalf flow)
+ * npx voidforge init --headless       Create project without browser
+ * npx voidforge init --core           Minimal methodology (no Holocron, no patterns)
+ * npx voidforge update                Update project methodology (Bombadil)
+ * npx voidforge update --self         Update the wizard itself
+ * npx voidforge update --extensions   Update all installed extensions
+ * npx voidforge install <ext>         Add extension to current project
+ * npx voidforge uninstall <ext>       Remove extension from current project
+ * npx voidforge deploy                Deploy project (Haku)
+ * npx voidforge doctor                Check versions, compatibility, health
+ * npx voidforge migrate               Migrate old-model project to v21.0
+ * npx voidforge version               Show wizard + methodology versions
+ * npx voidforge templates             List available project templates
+ */
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+const args = process.argv.slice(2);
+const command = args[0];
+// ── Version ──────────────────────────────────────────────
+async function getPackageVersion() {
+    const dir = import.meta.dirname ?? new URL('.', import.meta.url).pathname;
+    // Try ../package.json (dev: scripts/) then ../../package.json (dist: dist/scripts/)
+    for (const rel of ['..', '../..']) {
+        const pkgPath = resolve(dir, rel, 'package.json');
+        try {
+            const raw = await readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(raw);
+            if (pkg.name === 'voidforge' && pkg.version)
+                return pkg.version;
+        }
+        catch {
+            continue;
+        }
+    }
+    return 'unknown';
+}
+// ── Commands ─────────────────────────────────────────────
+async function cmdVersion() {
+    const ver = await getPackageVersion();
+    const nodeVer = process.version;
+    console.log(`VoidForge v${ver}`);
+    console.log(`Methodology v${ver}`);
+    console.log(`Node ${nodeVer}`);
+}
+async function cmdDoctor() {
+    const ver = await getPackageVersion();
+    const nodeVer = process.version;
+    const nodeMajor = parseInt(nodeVer.slice(1), 10);
+    const { findProjectRoot, getGlobalDir, getVaultPath, readMarker } = await import('../wizard/lib/marker.js');
+    const { readRegistry } = await import('../wizard/lib/project-registry.js');
+    console.log('\nVoidForge Doctor\n');
+    // Node.js check
+    const nodeOk = nodeMajor >= 20 && nodeMajor < 25;
+    console.log(`${nodeOk ? '✓' : '✗'} Node.js ${nodeVer} (required: >=20.11.0 <25.0.0)`);
+    // Wizard install
+    console.log(`✓ Wizard v${ver}`);
+    // Global config
+    const globalDir = getGlobalDir();
+    const globalExists = existsSync(globalDir);
+    console.log(`${globalExists ? '✓' : '✗'} Global config at ${globalDir}`);
+    if (globalExists) {
+        const vaultExists = existsSync(getVaultPath());
+        console.log(`  - Vault: ${vaultExists ? '✓ (encrypted)' : '✗ not found'}`);
+        const projects = await readRegistry();
+        console.log(`  - Projects: ${projects.length} registered`);
+    }
+    // Current project
+    const projectRoot = findProjectRoot();
+    if (projectRoot) {
+        const marker = await readMarker(projectRoot);
+        console.log(`✓ Current project: ${projectRoot}`);
+        if (marker) {
+            console.log(`  - Marker: v${marker.version} (${marker.tier})`);
+            if (marker.extensions.length > 0) {
+                console.log(`  - Extensions: ${marker.extensions.join(', ')}`);
+            }
+        }
+    }
+    else {
+        console.log('— No VoidForge project detected in current directory tree');
+    }
+    console.log('');
+}
+async function cmdTemplates() {
+    const { listTemplates } = await import('../wizard/lib/templates.js');
+    console.log('\nVoidForge Project Templates\n');
+    for (const t of listTemplates()) {
+        console.log(`  ${t.id.padEnd(12)} ${t.name}`);
+        console.log(`  ${''.padEnd(12)} ${t.description}\n`);
+    }
+    console.log('Usage: npx voidforge init --template <id>\n');
+}
+async function cmdDeploy() {
+    const isHeadless = args.includes('--headless');
+    const isSelfDeploy = args.includes('--self');
+    const isEnvOnly = args.includes('--env-only');
+    const projectDirFlag = args.find((a, i) => args[i - 1] === '--dir');
+    const hostFlag = args.find((a, i) => args[i - 1] === '--host');
+    if (isEnvOnly) {
+        const { envOnlyDeploy } = await import('../wizard/lib/headless-deploy.js');
+        await envOnlyDeploy(projectDirFlag);
+    }
+    else if (isSelfDeploy) {
+        const { generateCaddyTemplate } = await import('../wizard/lib/provisioners/self-deploy.js');
+        const domain = hostFlag ?? 'forge.yourdomain.com';
+        console.log('\nVoidForge Self-Deploy\n');
+        console.log('Generate the Caddy config and provision script with:');
+        console.log('  npx voidforge deploy --self --host forge.yourdomain.com\n');
+        console.log('Caddy template:\n');
+        console.log(generateCaddyTemplate(domain));
+    }
+    else if (isHeadless) {
+        const { headlessDeploy } = await import('../wizard/lib/headless-deploy.js');
+        await headlessDeploy(projectDirFlag);
+    }
+    else {
+        await launchWizard('deploy');
+    }
+}
+async function launchWizard(mode = 'init') {
+    const port = parseInt(process.env['VOIDFORGE_PORT'] ?? '3141', 10);
+    const isRemote = args.includes('--remote');
+    const isLan = args.includes('--lan');
+    const hostFlag = args.find((a, i) => args[i - 1] === '--host');
+    const wizardNames = {
+        init: { name: 'Gandalf', path: '/' },
+        deploy: { name: 'Haku', path: '/deploy.html' },
+    };
+    const wizard = wizardNames[mode];
+    const { startServer } = await import('../wizard/server.js');
+    const { openBrowser } = await import('../wizard/lib/open-browser.js');
+    const protocol = isRemote ? 'https' : 'http';
+    const host = isRemote ? (hostFlag ?? 'localhost') : 'localhost';
+    const url = `${protocol}://${host}:${port}${wizard.path}`;
+    const modeLabel = isRemote ? ' (Remote Mode)' : isLan ? ' (LAN Mode)' : '';
+    console.log('');
+    console.log(`  VoidForge — ${wizard.name}${modeLabel}`);
+    console.log(`  Server running at ${url}`);
+    if (isLan) {
+        console.log('  LAN Mode: Listening on all interfaces (0.0.0.0)');
+        console.log('  Access from private network: http://<your-ip>:' + port + wizard.path);
+        console.log('  Auth: optional password (no TOTP, no Caddy)');
+    }
+    if (isRemote)
+        console.log('  Authentication: REQUIRED (5-layer security active)');
+    console.log('  Press Ctrl+C to stop');
+    console.log('');
+    const serverOptions = isRemote ? { remote: true, host: hostFlag }
+        : isLan ? { lan: true }
+            : undefined;
+    await startServer(port, serverOptions);
+    if (!isRemote && !isLan)
+        await openBrowser(url);
+}
+async function cmdInitHeadless() {
+    const nameFlag = args.find((a, i) => args[i - 1] === '--name');
+    const dirFlag = args.find((a, i) => args[i - 1] === '--dir');
+    const onelinerFlag = args.find((a, i) => args[i - 1] === '--oneliner');
+    const domainFlag = args.find((a, i) => args[i - 1] === '--domain');
+    const repoFlag = args.find((a, i) => args[i - 1] === '--repo');
+    const isCore = args.includes('--core');
+    if (!nameFlag) {
+        console.error('Error: --name is required for headless init.');
+        console.error('Usage: npx voidforge init --headless --name "My Project" [--dir path] [--oneliner "..."]');
+        process.exit(1);
+    }
+    const defaultDir = join(process.env['HOME'] ?? process.env['USERPROFILE'] ?? '.', 'Projects', nameFlag.replace(/[^a-zA-Z0-9-_ ]/g, '').replace(/\s+/g, '-').toLowerCase());
+    const directory = dirFlag ?? defaultDir;
+    const { createProject } = await import('../wizard/lib/project-init.js');
+    const result = await createProject({
+        name: nameFlag,
+        directory,
+        oneliner: onelinerFlag,
+        domain: domainFlag,
+        repoUrl: repoFlag,
+        core: isCore,
+    });
+    console.log('');
+    console.log(`  VoidForge — Project Created`);
+    console.log(`  Name:      ${nameFlag}`);
+    console.log(`  Directory: ${result.projectDir}`);
+    console.log(`  Files:     ${result.filesCreated} methodology files`);
+    console.log(`  Marker:    ${result.markerId}`);
+    console.log('');
+    console.log('  Next: cd into the project and start building with Claude Code.');
+    console.log('');
+}
+function showHelp() {
+    console.log('VoidForge — From nothing, everything.\n');
+    console.log('Usage: npx voidforge <command> [options]\n');
+    console.log('Commands:');
+    console.log('  (no command)       Launch the wizard (browser UI)');
+    console.log('  init               Create a new project');
+    console.log('  update             Update project methodology');
+    console.log('  update --self      Update the wizard itself');
+    console.log('  install <ext>      Add extension to current project');
+    console.log('  uninstall <ext>    Remove extension from current project');
+    console.log('  deploy             Deploy project');
+    console.log('  migrate            Migrate v20.x project to v21.0');
+    console.log('  doctor             Check versions, compatibility, health');
+    console.log('  version            Show version information');
+    console.log('  templates          List project templates');
+    console.log('\nOptions:');
+    console.log('  --help, -h         Show this help');
+    console.log('  --remote           Launch in remote mode (0.0.0.0 + auth)');
+    console.log('  --lan              Launch in LAN mode');
+    console.log('  --headless         CLI-only (no browser)');
+    console.log('  --self             Deploy VoidForge itself');
+    console.log('  --env-only         Write vault credentials to .env');
+    console.log('');
+}
+// ── Router ───────────────────────────────────────────────
+async function main() {
+    try {
+        switch (command) {
+            case 'version':
+            case '--version':
+            case '-v':
+                await cmdVersion();
+                break;
+            case 'doctor':
+                await cmdDoctor();
+                break;
+            case 'templates':
+                await cmdTemplates();
+                break;
+            case 'deploy':
+                await cmdDeploy();
+                break;
+            case 'install': {
+                const extName = args[1];
+                if (!extName) {
+                    const { listExtensions } = await import('../wizard/lib/extensions.js');
+                    console.log('\nAvailable extensions:\n');
+                    for (const ext of listExtensions()) {
+                        console.log(`  ${ext.name.padEnd(16)} ${ext.description}`);
+                    }
+                    console.log('\nUsage: npx voidforge install <extension>\n');
+                    break;
+                }
+                const { installExtension } = await import('../wizard/lib/extensions.js');
+                const { findProjectRoot } = await import('../wizard/lib/marker.js');
+                const projectRoot = findProjectRoot();
+                if (!projectRoot) {
+                    console.error('Not a VoidForge project — run `npx voidforge init` first.');
+                    process.exit(1);
+                }
+                const result = await installExtension(projectRoot, extName);
+                console.log(`\n  Extension "${extName}" installed (${result.filesCreated} files created).\n`);
+                break;
+            }
+            case 'uninstall': {
+                const extToRemove = args[1];
+                if (!extToRemove) {
+                    console.error('Usage: npx voidforge uninstall <extension>');
+                    process.exit(1);
+                }
+                const { uninstallExtension } = await import('../wizard/lib/extensions.js');
+                const { findProjectRoot: findRoot } = await import('../wizard/lib/marker.js');
+                const root = findRoot();
+                if (!root) {
+                    console.error('Not a VoidForge project — run `npx voidforge init` first.');
+                    process.exit(1);
+                }
+                await uninstallExtension(root, extToRemove);
+                console.log(`\n  Extension "${extToRemove}" uninstalled.\n`);
+                break;
+            }
+            case 'update': {
+                if (args.includes('--self')) {
+                    const { selfUpdate } = await import('../wizard/lib/updater.js');
+                    const result = selfUpdate();
+                    console.log(result.message);
+                    process.exit(result.success ? 0 : 1);
+                }
+                if (args.includes('--extensions')) {
+                    const { readRegistry } = await import('../wizard/lib/project-registry.js');
+                    const { readMarker: readMkr } = await import('../wizard/lib/marker.js');
+                    const { getExtension } = await import('../wizard/lib/extensions.js');
+                    let updated = 0;
+                    try {
+                        const projects = await readRegistry();
+                        for (const p of projects) {
+                            const marker = await readMkr(p.directory);
+                            if (!marker || marker.extensions.length === 0)
+                                continue;
+                            for (const extName of marker.extensions) {
+                                const ext = getExtension(extName);
+                                if (ext) {
+                                    await ext.install(p.directory);
+                                    updated++;
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Registry read failure — non-fatal
+                    }
+                    console.log(`\n  Extensions updated across ${updated} project(s).\n`);
+                    break;
+                }
+                // Methodology update
+                const { findProjectRoot: findProjRoot } = await import('../wizard/lib/marker.js');
+                const projRoot = findProjRoot();
+                if (!projRoot) {
+                    console.error('Not a VoidForge project — run `npx voidforge init` first.');
+                    process.exit(1);
+                }
+                const { diffMethodology, applyUpdate } = await import('../wizard/lib/updater.js');
+                const plan = await diffMethodology(projRoot);
+                if (plan.added.length === 0 && plan.modified.length === 0) {
+                    console.log('\n  Methodology is up to date. No changes needed.\n');
+                    break;
+                }
+                console.log('\n  VoidForge Update Plan (Bombadil)\n');
+                if (plan.added.length > 0) {
+                    console.log(`  New files (${plan.added.length}):`);
+                    for (const f of plan.added)
+                        console.log(`    + ${f}`);
+                }
+                if (plan.modified.length > 0) {
+                    console.log(`  Modified (${plan.modified.length}):`);
+                    for (const f of plan.modified)
+                        console.log(`    ~ ${f}`);
+                }
+                if (plan.removed.length > 0) {
+                    console.log(`  Removed upstream (${plan.removed.length}):`);
+                    for (const f of plan.removed)
+                        console.log(`    - ${f} (kept locally)`);
+                }
+                console.log(`  Unchanged: ${plan.unchanged} files\n`);
+                const result = await applyUpdate(projRoot);
+                console.log(`  Updated to v${result.newVersion}. ${plan.added.length + plan.modified.length} files changed.\n`);
+                break;
+            }
+            case 'migrate': {
+                const isDryRun = args.includes('--dry-run');
+                const migrateDir = args.find((a, i) => args[i - 1] === '--dir') ?? process.cwd();
+                const { detectV20Project, migrateProject } = await import('../wizard/lib/migrator.js');
+                const migPlan = await detectV20Project(migrateDir);
+                if (!migPlan.hasWizardDir) {
+                    console.log('\n  No wizard/ directory found — this is not a v20.x project.\n');
+                    break;
+                }
+                console.log('\n  VoidForge v21.0 — Migration\n');
+                console.log('  Your project contains an embedded wizard (v20.x model).');
+                console.log('  VoidForge now runs as a standalone application.\n');
+                console.log('  Plan:');
+                console.log(`    1. Backup wizard/ (${migPlan.wizardFileCount} files) to ~/.voidforge/migration-backup/`);
+                if (migPlan.voidforgeDeps.length > 0) {
+                    console.log(`    2. Remove ${migPlan.voidforgeDeps.length} VoidForge deps from package.json`);
+                }
+                console.log('    3. Remove wizard/ directory');
+                console.log('    4. Add .voidforge marker file');
+                console.log('    5. Keep all methodology files in place\n');
+                if (isDryRun) {
+                    console.log('  (dry-run — no changes made)\n');
+                    break;
+                }
+                const migResult = await migrateProject(migrateDir);
+                console.log(`  Migration complete.`);
+                console.log(`  Backup: ${migResult.backupDir}`);
+                console.log(`  Files removed: ${migResult.wizardFilesRemoved}`);
+                if (migResult.depsRemoved.length > 0) {
+                    console.log(`  Deps removed: ${migResult.depsRemoved.join(', ')}`);
+                }
+                console.log(`  Marker created: ${migResult.markerCreated}\n`);
+                console.log('  To rollback: restore from the backup directory.\n');
+                break;
+            }
+            case 'init':
+                if (args.includes('--headless')) {
+                    await cmdInitHeadless();
+                }
+                else {
+                    await launchWizard('init');
+                }
+                break;
+            case '--help':
+            case '-h':
+                showHelp();
+                break;
+            case undefined:
+                // No command — launch wizard
+                await launchWizard('init');
+                break;
+            default:
+                console.error(`Unknown command: ${command}`);
+                showHelp();
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error('Error:', err.message);
+        process.exit(1);
+    }
+}
+main();