voidforge-build 23.9.1

package/dist/wizard/api/projects.js

@@ -0,0 +1,273 @@
+/**
+ * Projects API — project CRUD routes (get, import, delete).
+ * Listing, access, links in projects-list.ts. Data/analytics in projects-data.ts.
+ * All queries filtered by per-project access control (v7.0).
+ */
+import { access as fsAccess, readFile, realpath } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { addRoute } from '../router.js';
+import { parseJsonBody } from '../lib/body-parser.js';
+import { parseFrontmatter } from '../lib/frontmatter.js';
+import { addProject, getProject, removeProject, findByDirectory, checkProjectAccess, } from '../lib/project-registry.js';
+import { audit } from '../lib/audit-log.js';
+import { validateSession, parseSessionCookie, getClientIp, isRemoteMode } from '../lib/tower-auth.js';
+import { sendJson } from '../lib/http-helpers.js';
+// ── Barrel imports — load split route files ─────────
+import './projects-list.js';
+import './projects-data.js';
+/** Extract session from request. Returns null if not authenticated (local mode returns synthetic admin). */
+function getSession(req) {
+    if (!isRemoteMode()) {
+        return { username: 'local', role: 'admin' };
+    }
+    const token = parseSessionCookie(req.headers.cookie);
+    const ip = getClientIp(req);
+    if (!token)
+        return null;
+    return validateSession(token, ip);
+}
+/** Scan a project directory for metadata. Reuses patterns from wizard/api/deploy.ts. */
+async function scanProjectMetadata(dir) {
+    let name = 'Unknown';
+    try {
+        const claudeMd = await readFile(join(dir, 'CLAUDE.md'), 'utf-8');
+        const nameMatch = claudeMd.match(/\*\*Name:\*\*\s*(.+)/);
+        if (nameMatch) {
+            const extracted = nameMatch[1].trim();
+            if (!extracted.startsWith('['))
+                name = extracted;
+        }
+    }
+    catch { /* use default */ }
+    let deployTarget = '';
+    let deployUrl = '';
+    let hostname = '';
+    let sshHost = '';
+    try {
+        const envContent = await readFile(join(dir, '.env'), 'utf-8');
+        const deployMatch = envContent.match(/DEPLOY_TARGET=(.+)/);
+        if (deployMatch) {
+            deployTarget = deployMatch[1].trim().replace(/^["']|["']$/g, '').split('#')[0].trim();
+        }
+        const hostnameMatch = envContent.match(/HOSTNAME=(.+)/);
+        if (hostnameMatch) {
+            hostname = hostnameMatch[1].trim().replace(/^["']|["']$/g, '').split('#')[0].trim();
+            if (hostname)
+                deployUrl = `https://${hostname}`;
+        }
+        if (deployTarget === 'vps') {
+            const sshMatch = envContent.match(/SSH_HOST=(.+)/);
+            if (sshMatch) {
+                sshHost = sshMatch[1].trim().replace(/^["']|["']$/g, '').split('#')[0].trim();
+            }
+        }
+    }
+    catch { /* no .env */ }
+    let framework = '';
+    let database = 'none';
+    try {
+        const prd = await readFile(join(dir, 'docs', 'PRD.md'), 'utf-8');
+        const { frontmatter } = parseFrontmatter(prd);
+        if (frontmatter.framework)
+            framework = frontmatter.framework;
+        if (frontmatter.database)
+            database = frontmatter.database;
+        if (frontmatter.deploy && !deployTarget)
+            deployTarget = frontmatter.deploy;
+        if (frontmatter.hostname && !hostname) {
+            hostname = frontmatter.hostname;
+            if (!deployUrl && hostname)
+                deployUrl = `https://${hostname}`;
+        }
+    }
+    catch { /* no PRD or no frontmatter */ }
+    if (!framework) {
+        try {
+            const pkg = await readFile(join(dir, 'package.json'), 'utf-8');
+            const pkgData = JSON.parse(pkg);
+            const deps = pkgData.dependencies ?? {};
+            if (deps['next'])
+                framework = 'next.js';
+            else if (deps['express'])
+                framework = 'express';
+        }
+        catch { /* not a Node project */ }
+        if (!framework) {
+            try {
+                const reqs = await readFile(join(dir, 'requirements.txt'), 'utf-8');
+                if (reqs.toLowerCase().includes('django'))
+                    framework = 'django';
+                else
+                    framework = 'python';
+            }
+            catch { /* not Python */ }
+        }
+        if (!framework) {
+            try {
+                await fsAccess(join(dir, 'Gemfile'));
+                framework = 'rails';
+            }
+            catch { /* not Ruby */ }
+        }
+    }
+    let lastBuildPhase = 0;
+    try {
+        const buildState = await readFile(join(dir, 'logs', 'build-state.md'), 'utf-8');
+        const phaseMatch = buildState.match(/\*\*Current Phase:\*\*\s*(\d+)/);
+        if (phaseMatch) {
+            lastBuildPhase = parseInt(phaseMatch[1], 10);
+        }
+    }
+    catch { /* no build state */ }
+    let healthCheckUrl = '';
+    if (deployUrl) {
+        healthCheckUrl = `${deployUrl}/api/health`;
+    }
+    return {
+        name,
+        directory: dir,
+        deployTarget: deployTarget || 'unknown',
+        deployUrl,
+        sshHost,
+        framework: framework || 'unknown',
+        database,
+        createdAt: new Date().toISOString(),
+        lastBuildPhase,
+        lastDeployAt: '',
+        healthCheckUrl,
+        monthlyCost: 0,
+        owner: '',
+        access: [],
+        linkedProjects: [],
+    };
+}
+// GET /api/projects/get — get single project by id (filtered by access)
+addRoute('GET', '/api/projects/get', async (req, res) => {
+    const session = getSession(req);
+    if (!session) {
+        sendJson(res, 401, { success: false, error: 'Authentication required' });
+        return;
+    }
+    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+    const id = url.searchParams.get('id');
+    if (!id) {
+        sendJson(res, 400, { success: false, error: 'id query parameter is required' });
+        return;
+    }
+    // Access check — returns null if project doesn't exist OR user has no access
+    const effectiveRole = await checkProjectAccess(id, session.username, session.role);
+    if (!effectiveRole) {
+        sendJson(res, 404, { success: false, error: 'Project not found' });
+        return;
+    }
+    const project = await getProject(id);
+    if (!project) {
+        sendJson(res, 404, { success: false, error: 'Project not found' });
+        return;
+    }
+    sendJson(res, 200, { success: true, data: { ...project, userRole: effectiveRole } });
+});
+// POST /api/projects/import — import an existing project (sets owner to current user)
+addRoute('POST', '/api/projects/import', async (req, res) => {
+    const session = getSession(req);
+    if (!session) {
+        sendJson(res, 401, { success: false, error: 'Authentication required' });
+        return;
+    }
+    const body = await parseJsonBody(req);
+    if (typeof body !== 'object' || body === null) {
+        sendJson(res, 400, { success: false, error: 'Request body must be a JSON object' });
+        return;
+    }
+    const { directory } = body;
+    if (typeof directory !== 'string' || directory.trim().length === 0) {
+        sendJson(res, 400, { success: false, error: 'directory must be a non-empty string' });
+        return;
+    }
+    if (directory.includes('..')) {
+        sendJson(res, 400, { success: false, error: 'directory must not contain ".." segments' });
+        return;
+    }
+    let dir = resolve(directory);
+    if (!dir.startsWith('/')) {
+        sendJson(res, 400, { success: false, error: 'directory must be an absolute path' });
+        return;
+    }
+    try {
+        await fsAccess(dir);
+    }
+    catch {
+        sendJson(res, 400, { success: false, error: 'Directory does not exist' });
+        return;
+    }
+    // CROSS-R4-005 + IG-R4: Resolve symlinks and use the real path for all subsequent operations.
+    // This handles macOS /tmp → /private/tmp while ensuring we operate on the true filesystem location.
+    try {
+        dir = await realpath(dir);
+    }
+    catch {
+        sendJson(res, 400, { success: false, error: 'Could not resolve directory path' });
+        return;
+    }
+    try {
+        await fsAccess(join(dir, 'CLAUDE.md'));
+    }
+    catch {
+        sendJson(res, 400, { success: false, error: 'Not a VoidForge project — no CLAUDE.md found' });
+        return;
+    }
+    const existing = await findByDirectory(dir);
+    if (existing) {
+        sendJson(res, 409, { success: false, error: 'Project already registered', data: existing });
+        return;
+    }
+    try {
+        const input = await scanProjectMetadata(dir);
+        input.owner = session.username; // Set owner to importing user
+        const project = await addProject(input);
+        const ip = getClientIp(req);
+        await audit('project_create', ip, session.username, { action: 'import', directory: dir, name: project.name });
+        sendJson(res, 201, { success: true, data: { ...project, userRole: 'owner' } });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Import failed';
+        if (message.includes('already registered')) {
+            sendJson(res, 409, { success: false, error: 'Project already registered' });
+        }
+        else {
+            sendJson(res, 500, { success: false, error: 'Failed to import project' });
+        }
+    }
+});
+// POST /api/projects/delete — remove a project (owner or admin only)
+addRoute('POST', '/api/projects/delete', async (req, res) => {
+    const session = getSession(req);
+    if (!session) {
+        sendJson(res, 401, { success: false, error: 'Authentication required' });
+        return;
+    }
+    const body = await parseJsonBody(req);
+    if (typeof body !== 'object' || body === null) {
+        sendJson(res, 400, { success: false, error: 'Request body must be a JSON object' });
+        return;
+    }
+    const { id } = body;
+    if (typeof id !== 'string' || id.trim().length === 0) {
+        sendJson(res, 400, { success: false, error: 'id must be a non-empty string' });
+        return;
+    }
+    // Check access — only owner or admin can delete
+    const effectiveRole = await checkProjectAccess(id, session.username, session.role);
+    if (effectiveRole !== 'admin') {
+        sendJson(res, 404, { success: false, error: 'Project not found' });
+        return;
+    }
+    const removed = await removeProject(id);
+    if (!removed) {
+        sendJson(res, 404, { success: false, error: 'Project not found' });
+        return;
+    }
+    const ip = getClientIp(req);
+    await audit('project_delete', ip, session.username, { projectId: id });
+    sendJson(res, 200, { success: true });
+});

package/dist/wizard/api/provision-status.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Provisioning API — deploy history, incomplete run detection.
+ * Split from provision.ts for file size (v23.3).
+ */
+export {};

package/dist/wizard/api/provision-status.js

@@ -0,0 +1,47 @@
+/**
+ * Provisioning API — deploy history, incomplete run detection.
+ * Split from provision.ts for file size (v23.3).
+ */
+import { addRoute } from '../router.js';
+import { getSessionPassword } from './credentials.js';
+import { listDeploys } from '../lib/deploy-log.js';
+import { listIncompleteRuns } from '../lib/provision-manifest.js';
+import { sendJson } from '../lib/http-helpers.js';
+// GET /api/deploys — list recent deploy history (ADR-021)
+addRoute('GET', '/api/deploys', async (_req, res) => {
+    const password = getSessionPassword();
+    if (!password) {
+        sendJson(res, 401, { error: 'Vault is locked.' });
+        return;
+    }
+    const deploys = await listDeploys();
+    sendJson(res, 200, {
+        deploys: deploys.map(d => ({
+            timestamp: d.timestamp,
+            target: d.target,
+            projectName: d.projectName,
+            deployUrl: d.deployUrl,
+            hostname: d.hostname,
+            resourceCount: d.resources.length,
+        })),
+    });
+});
+// GET /api/provision/incomplete — check for orphaned runs from crashes
+addRoute('GET', '/api/provision/incomplete', async (_req, res) => {
+    const password = getSessionPassword();
+    if (!password) {
+        sendJson(res, 401, { error: 'Vault is locked.' });
+        return;
+    }
+    const incomplete = await listIncompleteRuns();
+    sendJson(res, 200, {
+        runs: incomplete.map((m) => ({
+            runId: m.runId,
+            startedAt: m.startedAt,
+            target: m.target,
+            projectName: m.projectName,
+            resourceCount: m.resources.filter((r) => r.status === 'created').length,
+            resources: m.resources.filter((r) => r.status === 'created').map((r) => `${r.type}: ${r.id}`),
+        })),
+    });
+});

package/dist/wizard/api/provision-steps.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Provisioning API — post-provision finalization steps.
+ * Sentry, env-validator, health monitoring, deploy logging.
+ * Split from provision.ts for file size (v23.3).
+ */
+import type { ProvisionEvent, CreatedResource } from '../lib/provisioners/types.js';
+export interface PostProvisionOpts {
+    projectDir: string;
+    framework: string;
+    deployTarget: string;
+    projectName: string;
+    hostname: string;
+    region: string;
+    runId: string;
+    outputs: Record<string, string>;
+    resources: CreatedResource[];
+    sentryDsn: string | undefined;
+    emit: (event: ProvisionEvent) => void;
+}
+/** Run post-provision finalization: sentry, env-validator, health monitoring, deploy logging. */
+export declare function runPostProvisionSteps(opts: PostProvisionOpts): Promise<void>;

package/dist/wizard/api/provision-steps.js

@@ -0,0 +1,44 @@
+/**
+ * Provisioning API — post-provision finalization steps.
+ * Sentry, env-validator, health monitoring, deploy logging.
+ * Split from provision.ts for file size (v23.3).
+ */
+import { generateEnvValidator } from '../lib/env-validator.js';
+import { logDeploy } from '../lib/deploy-log.js';
+import { setupHealthMonitoring } from '../lib/health-monitor.js';
+import { generateSentryInit } from '../lib/sentry-generator.js';
+import { stripSecrets } from './provision-validate.js';
+/** Run post-provision finalization: sentry, env-validator, health monitoring, deploy logging. */
+export async function runPostProvisionSteps(opts) {
+    const { projectDir, framework, deployTarget, projectName, hostname, region, runId, outputs, resources, sentryDsn, emit } = opts;
+    // ── Sentry integration (ADR-024) ──────────────────────────────
+    await generateSentryInit(projectDir, framework, sentryDsn, emit);
+    // ── Environment validation script (ADR-018) ──────────────────
+    const envResult = await generateEnvValidator(projectDir, framework);
+    if (envResult.file) {
+        const hint = envResult.file.endsWith('.py')
+            ? 'Add "python validate_env.py &&" before your start command'
+            : 'Add "node validate-env.js &&" before your start command in package.json';
+        emit({ step: 'env-validator', status: 'done', message: `Generated ${envResult.file} — ${hint}` });
+    }
+    else {
+        emit({ step: 'env-validator', status: 'skipped', message: 'No .env file found — env validation script skipped' });
+    }
+    // ── Health monitoring (ADR-023) ──────────────────────────────
+    const deployUrl = outputs['DEPLOY_URL'] || '';
+    await setupHealthMonitoring(deployTarget, projectDir, projectName, deployUrl, outputs, emit);
+    // ── Deploy logging (ADR-021) ─────────────────────────────────
+    try {
+        const logOutputs = stripSecrets(outputs);
+        const logPath = await logDeploy({
+            runId, timestamp: new Date().toISOString(), target: deployTarget,
+            projectName, framework, deployUrl: outputs['DEPLOY_URL'] || '', hostname, region,
+            resources: resources.map(r => ({ type: r.type, id: r.id })),
+            outputs: logOutputs,
+        });
+        emit({ step: 'deploy-log', status: 'done', message: `Deploy logged to ${logPath}` });
+    }
+    catch {
+        // Non-fatal — deploy succeeded even if logging fails
+    }
+}

package/dist/wizard/api/provision-validate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Provisioning API — shared state, credential helpers, cleanup route.
+ * Split from provision.ts for file size (v23.3).
+ */
+import type { CreatedResource } from '../lib/provisioners/types.js';
+/** Tracks resources per provisioning run by ID, keyed by runId. */
+export interface ProvisionRun {
+    resources: CreatedResource[];
+    credentials: Record<string, string>;
+    target: string;
+}
+export declare const provisionRuns: Map<string, ProvisionRun>;
+/** Concurrency lock — only one provisioning run at a time (F-02). */
+export declare let activeProvisionRun: string | null;
+export declare function setActiveProvisionRun(runId: string | null): void;
+/** Scope credentials to only the keys a provisioner needs. Internal _-prefixed keys pass through. */
+export declare function scopeCredentials(allCreds: Record<string, string>, target: string): Record<string, string>;
+/** Strip secret values from an outputs map, preserving allowlisted keys. */
+export declare function stripSecrets(outputs: Record<string, string>): Record<string, string>;
+/** Build minimal credential set needed for cleanup of a given deploy target. */
+export declare function buildCleanupCredentials(target: string, allCreds: Record<string, string>, hasDnsRecords: boolean): Record<string, string>;
+export declare function loadCredentials(password: string): Promise<Record<string, string>>;

package/dist/wizard/api/provision-validate.js

@@ -0,0 +1,164 @@
+/**
+ * Provisioning API — shared state, credential helpers, cleanup route.
+ * Split from provision.ts for file size (v23.3).
+ */
+import { addRoute } from '../router.js';
+import { getSessionPassword } from './credentials.js';
+import { vaultGet, vaultKeys } from '../lib/vault.js';
+import { parseJsonBody } from '../lib/body-parser.js';
+import { provisioners, provisionKeys } from '../lib/provisioner-registry.js';
+import { updateManifestStatus, readManifest, deleteManifest, manifestToCreatedResources, } from '../lib/provision-manifest.js';
+import { cleanupDnsRecords } from '../lib/dns/cloudflare-dns.js';
+import { sendJson } from '../lib/http-helpers.js';
+export const provisionRuns = new Map();
+/** Concurrency lock — only one provisioning run at a time (F-02). */
+export let activeProvisionRun = null;
+export function setActiveProvisionRun(runId) {
+    activeProvisionRun = runId;
+}
+/** Scope credentials to only the keys a provisioner needs. Internal _-prefixed keys pass through. */
+export function scopeCredentials(allCreds, target) {
+    const allowed = provisionKeys[target] || [];
+    const scoped = {};
+    for (const key of allowed) {
+        if (allCreds[key])
+            scoped[key] = allCreds[key];
+    }
+    // Internal keys (injected by pre-steps) always pass through
+    for (const [key, val] of Object.entries(allCreds)) {
+        if (key.startsWith('_'))
+            scoped[key] = val;
+    }
+    return scoped;
+}
+/** Secret keywords to strip from SSE outputs and deploy logs. */
+const SECRET_KEYWORDS = [
+    'password', 'secret', 'token', 'credential', '_key', '_pass',
+    '_pwd', 'passphrase', 'bearer', 'oauth', 'jwt', 'signing',
+    'private', 'connection_uri', 'database_url', 'redis_url', 'mongo_uri',
+    'cert', 'hmac', 'auth_code',
+];
+/** Keys that are safe to include in outputs despite matching secret keywords. */
+const SAFE_OUTPUT_KEYS = new Set(['DEPLOY_URL', 'S3_WEBSITE_URL', 'CF_PROJECT_URL', 'GITHUB_REPO_URL', 'SSH_KEY_PATH']);
+/** Strip secret values from an outputs map, preserving allowlisted keys. */
+export function stripSecrets(outputs) {
+    const safe = { ...outputs };
+    delete safe['DB_PASSWORD'];
+    delete safe['GITHUB_TOKEN'];
+    for (const key of Object.keys(safe)) {
+        if (SAFE_OUTPUT_KEYS.has(key))
+            continue;
+        const lk = key.toLowerCase();
+        if (SECRET_KEYWORDS.some((kw) => lk.includes(kw))) {
+            delete safe[key];
+        }
+    }
+    return safe;
+}
+/** Build minimal credential set needed for cleanup of a given deploy target. */
+export function buildCleanupCredentials(target, allCreds, hasDnsRecords) {
+    const cleanupCreds = {};
+    const cleanupKeys = {
+        vps: ['aws-access-key-id', 'aws-secret-access-key', 'aws-region'],
+        static: ['aws-access-key-id', 'aws-secret-access-key', 'aws-region'],
+        vercel: ['vercel-token'],
+        railway: ['railway-token'],
+        cloudflare: ['cloudflare-api-token'],
+        docker: [],
+    };
+    for (const key of (cleanupKeys[target] || [])) {
+        if (allCreds[key])
+            cleanupCreds[key] = allCreds[key];
+    }
+    if (hasDnsRecords && allCreds['cloudflare-api-token']) {
+        cleanupCreds['cloudflare-api-token'] = allCreds['cloudflare-api-token'];
+    }
+    return cleanupCreds;
+}
+export async function loadCredentials(password) {
+    const keys = await vaultKeys(password);
+    const creds = {};
+    for (const key of keys) {
+        const val = await vaultGet(password, key);
+        if (val)
+            creds[key] = val;
+    }
+    return creds;
+}
+// POST /api/provision/cleanup — clean up resources from a provisioning run
+addRoute('POST', '/api/provision/cleanup', async (req, res) => {
+    const password = getSessionPassword();
+    if (!password) {
+        sendJson(res, 401, { error: 'Vault is locked.' });
+        return;
+    }
+    const body = await parseJsonBody(req);
+    // If no runId provided, clean up the most recent run
+    let runId = body.runId;
+    if (!runId) {
+        const keys = [...provisionRuns.keys()];
+        runId = keys[keys.length - 1];
+    }
+    // Try in-memory runs first, then fall back to disk manifests (crash recovery)
+    let target;
+    let resources;
+    let credentials;
+    if (runId && provisionRuns.has(runId)) {
+        const run = provisionRuns.get(runId);
+        target = run.target;
+        resources = run.resources;
+        credentials = run.credentials;
+    }
+    else if (runId) {
+        // Crash recovery: load from disk manifest + vault credentials
+        const manifest = await readManifest(runId);
+        if (!manifest || manifest.status === 'cleaned') {
+            sendJson(res, 200, { cleaned: true, message: 'No resources to clean up' });
+            return;
+        }
+        target = manifest.target;
+        resources = manifestToCreatedResources(manifest);
+        credentials = await loadCredentials(password);
+    }
+    else {
+        sendJson(res, 200, { cleaned: true, message: 'No resources to clean up' });
+        return;
+    }
+    if (resources.length === 0) {
+        await deleteManifest(runId);
+        sendJson(res, 200, { cleaned: true, message: 'No resources to clean up' });
+        return;
+    }
+    const provisioner = provisioners[target];
+    if (!provisioner) {
+        sendJson(res, 400, { error: `Unknown target: ${target}` });
+        return;
+    }
+    try {
+        // Clean up DNS records separately (they're not managed by the provisioner)
+        // Skip github-repo — repos are tracked for idempotency, not cleanup (ADR-012)
+        const dnsResources = resources.filter((r) => r.type === 'dns-record');
+        const infraResources = resources.filter((r) => r.type !== 'dns-record' && r.type !== 'github-repo');
+        if (dnsResources.length > 0 && credentials['cloudflare-api-token']) {
+            await cleanupDnsRecords(credentials['cloudflare-api-token'], dnsResources.map((r) => r.id));
+        }
+        // Clean up infrastructure resources via the provisioner
+        if (infraResources.length > 0) {
+            await provisioner.cleanup(infraResources, credentials);
+        }
+        const count = resources.length;
+        provisionRuns.delete(runId);
+        await updateManifestStatus(runId, 'cleaned');
+        await deleteManifest(runId);
+        const notes = [];
+        // Domain registration and GitHub repos are irreversible — always warn
+        notes.push('Note: If a domain was registered during this run, that purchase cannot be reversed. Manage it at dash.cloudflare.com.');
+        if (resources.some((r) => r.type === 'github-repo')) {
+            notes.push('Note: GitHub repository was not deleted (repos are preserved). Delete manually at github.com if needed.');
+        }
+        sendJson(res, 200, { cleaned: true, message: `Cleaned up ${count} resources`, notes });
+    }
+    catch (err) {
+        sendJson(res, 500, { error: `Cleanup failed: ${err.message}` });
+    }
+});

package/dist/wizard/api/provision.d.ts

@@ -0,0 +1,2 @@
+import './provision-validate.js';
+import './provision-status.js';