@westbayberry/dg 1.0.52 → 1.0.56

package/dist/packages/cli/src/ui/hooks/useInit.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._initialState = _initialState;
+exports._initialStateFirstRun = _initialStateFirstRun;
+exports._reducer = _reducer;
+exports.canGoBack = canGoBack;
+exports.useInit = useInit;
+const react_1 = require("react");
+const discover_1 = require("../../discover");
+const hook_1 = require("../../hook");
+const scan_core_1 = require("../../scan-core");
+const config_1 = require("../../config");
+function _initialState(dryRun) {
+    return initialState(dryRun, false);
+}
+function _initialStateFirstRun(dryRun) {
+    return initialState(dryRun, true);
+}
+function _reducer(state, action) {
+    return reducer(state, action);
+}
+function initialState(dryRun, firstRun) {
+    return {
+        phase: firstRun ? "greet" : "detect",
+        startedAt: Date.now(),
+        dryRun,
+        engaged: false,
+        firstRun,
+        projects: [],
+        hookInfo: null,
+        hookInstalled: false,
+        hookVerifyMs: null,
+        hookError: null,
+        scanRan: false,
+        scanResult: null,
+        scanProgress: null,
+        skipped: new Set(),
+    };
+}
+function reducer(state, action) {
+    if (process.env.DG_DEBUG_WIZARD && action.type !== "scan_progress") {
+        process.stderr.write(`[wizard] action=${action.type} phase=${state.phase}\n`);
+    }
+    switch (action.type) {
+        // ── First-run guided tour transitions ──────────────────────────────────
+        case "welcome_yes":
+            return { ...state, phase: "value_prop", engaged: true };
+        case "welcome_no": {
+            // Engaged=true so sentinel gets marked — user won't be re-prompted.
+            const skipped = new Set([
+                "value_prop", "demo_scanning", "demo_result",
+                "scenario", "detect", "confirm_hook", "install_hook", "verify_hook",
+                "run_scan", "result_first_scan", "what_happens_next",
+                "pitch_app",
+            ]);
+            return { ...state, phase: "done", engaged: true, skipped };
+        }
+        case "value_prop_continue":
+            return { ...state, phase: "demo_scanning" };
+        case "demo_complete":
+            return { ...state, phase: "demo_result" };
+        case "demo_acked":
+            return { ...state, phase: "detect" };
+        case "scenario_acked":
+            return { ...state, phase: "confirm_hook" };
+        case "first_scan_acked":
+            // Skip what_happens_next if the user declined the hook — it talks about
+            // commit behavior that doesn't apply without a pre-commit hook.
+            if (state.firstRun && state.skipped.has("install_hook")) {
+                return { ...state, phase: "pitch_app" };
+            }
+            return { ...state, phase: state.firstRun ? "what_happens_next" : "pitch_app" };
+        case "what_happens_next_acked":
+            return { ...state, phase: "pitch_app" };
+        case "pitch_acked":
+            return { ...state, phase: "done" };
+        // ── Existing Phase 1b transitions (unchanged) ──────────────────────────
+        case "detected":
+            return {
+                ...state,
+                phase: state.firstRun ? "scenario" : "confirm_hook",
+                projects: action.projects,
+                hookInfo: action.hookInfo,
+            };
+        case "confirm_hook_yes":
+            if (state.hookInfo?.alreadyInstalled) {
+                if (state.firstRun) {
+                    return { ...state, phase: "confirm_scan", hookInstalled: true };
+                }
+                return { ...state, phase: "verify_hook", hookInstalled: true };
+            }
+            return { ...state, phase: "install_hook" };
+        case "confirm_hook_no": {
+            const skipped = new Set(state.skipped);
+            skipped.add("install_hook");
+            if (state.firstRun) {
+                return { ...state, phase: "confirm_scan", skipped };
+            }
+            return { ...state, phase: "confirm_wrap", skipped };
+        }
+        case "hook_installed":
+            return { ...state, phase: "verify_hook", hookInstalled: true };
+        case "hook_install_failed":
+            return { ...state, phase: "done", hookError: action.error };
+        case "hook_verified":
+            return {
+                ...state,
+                phase: state.firstRun ? "confirm_scan" : "confirm_wrap",
+                hookVerifyMs: action.durationMs,
+            };
+        case "hook_verify_failed":
+            return {
+                ...state,
+                phase: state.firstRun ? "confirm_scan" : "confirm_wrap",
+                hookError: action.error,
+            };
+        case "wrap_confirmed":
+            return { ...state, phase: "confirm_scan" };
+        case "wrap_skipped": {
+            const skipped = new Set(state.skipped);
+            skipped.add("confirm_wrap");
+            return { ...state, phase: "confirm_scan", skipped };
+        }
+        case "scan_confirmed":
+            return { ...state, phase: "run_scan" };
+        case "scan_skipped": {
+            const skipped = new Set(state.skipped);
+            skipped.add("run_scan");
+            return {
+                ...state,
+                phase: state.firstRun ? "what_happens_next" : "show_app_link",
+                skipped,
+            };
+        }
+        case "scan_progress":
+            return { ...state, scanProgress: action.progress };
+        case "scan_done":
+            return {
+                ...state,
+                phase: state.firstRun ? "result_first_scan" : "show_app_link",
+                scanRan: true,
+                scanResult: action.outcome,
+                scanProgress: null,
+            };
+        case "app_link_acked":
+            return { ...state, phase: "done" };
+        case "go_back":
+            return goBack(state);
+        case "skip_to_end":
+            return { ...state, phase: "done" };
+    }
+}
+function goBack(state) {
+    const reversibleBack = {
+        value_prop: "greet",
+        demo_result: "value_prop",
+        confirm_wrap: "verify_hook", // legacy only
+        show_app_link: "confirm_scan", // legacy only
+    };
+    // Phases that route differently in firstRun vs legacy.
+    if (state.phase === "confirm_hook") {
+        return { ...state, phase: state.firstRun ? "scenario" : "detect" };
+    }
+    if (state.phase === "confirm_scan") {
+        return { ...state, phase: state.firstRun ? "confirm_hook" : "confirm_wrap" };
+    }
+    const prev = reversibleBack[state.phase];
+    if (prev === undefined)
+        return state;
+    return { ...state, phase: prev };
+}
+function canGoBack(state) {
+    const reversibleBack = {
+        value_prop: true,
+        demo_result: true,
+        confirm_hook: true,
+        confirm_wrap: true,
+        confirm_scan: true,
+        show_app_link: true,
+    };
+    return reversibleBack[state.phase] === true;
+}
+function useInit(opts = {}) {
+    const dryRun = opts.dryRun ?? false;
+    const firstRun = opts.firstRun ?? false;
+    const [state, dispatch] = (0, react_1.useReducer)(reducer, initialState(dryRun, firstRun));
+    const scanFn = opts.scanCoreOverride ?? scan_core_1.scanProjectAtPath;
+    const runDetect = (0, react_1.useCallback)(() => {
+        const cwd = opts.cwd ?? process.cwd();
+        const projects = (0, discover_1.discoverProjects)(cwd);
+        const hookInfo = (0, hook_1.detectHookFramework)(cwd);
+        dispatch({ type: "detected", projects, hookInfo });
+    }, [opts.cwd]);
+    const runInstallHook = (0, react_1.useCallback)(() => {
+        if (!state.hookInfo)
+            return;
+        if (state.dryRun) {
+            // Dry run — pretend it worked.
+            dispatch({ type: "hook_installed" });
+            return;
+        }
+        try {
+            (0, hook_1.installHookForFramework)(state.hookInfo);
+            dispatch({ type: "hook_installed" });
+        }
+        catch (e) {
+            dispatch({
+                type: "hook_install_failed",
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }, [state.hookInfo, state.dryRun]);
+    const runVerifyHook = (0, react_1.useCallback)(async () => {
+        if (state.dryRun) {
+            dispatch({ type: "hook_verified", durationMs: 0 });
+            return;
+        }
+        try {
+            const cwd = opts.cwd ?? process.cwd();
+            const config = (0, config_1.parseConfig)([process.argv[0] ?? "node", "init"], false);
+            const outcome = await scanFn(cwd, config);
+            if (outcome.status === "error" && outcome.error) {
+                dispatch({
+                    type: "hook_verify_failed",
+                    error: outcome.message ?? outcome.error.message,
+                });
+                return;
+            }
+            const ms = outcome.result?.durationMs ?? 0;
+            dispatch({ type: "hook_verified", durationMs: ms });
+        }
+        catch (e) {
+            dispatch({
+                type: "hook_verify_failed",
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }, [state.dryRun, opts.cwd, scanFn]);
+    const runScan = (0, react_1.useCallback)(async () => {
+        if (state.dryRun) {
+            dispatch({
+                type: "scan_done",
+                outcome: {
+                    status: "no_packages",
+                    result: {
+                        result: { score: 0, action: "pass", packages: [], safeVersions: {}, durationMs: 0 },
+                        durationMs: 0,
+                        scannedCount: 0,
+                        skippedCount: 0,
+                    },
+                    message: "dry run — scan skipped",
+                },
+            });
+            return;
+        }
+        try {
+            const config = (0, config_1.parseConfig)([process.argv[0] ?? "node", "init", "--scan-all"], false);
+            const projects = state.projects.length > 0
+                ? state.projects
+                : [{ path: opts.cwd ?? process.cwd() }];
+            const allOutcomes = [];
+            for (const proj of projects) {
+                if (process.env.DG_DEBUG_WIZARD)
+                    process.stderr.write(`[wizard] scanning ${proj.path}\n`);
+                const outcome = await scanFn(proj.path, config, (p) => {
+                    dispatch({ type: "scan_progress", progress: p });
+                });
+                if (process.env.DG_DEBUG_WIZARD)
+                    process.stderr.write(`[wizard] scan done ${proj.path} status=${outcome.status}\n`);
+                allOutcomes.push(outcome);
+            }
+            const allPackages = [];
+            const seen = new Set();
+            for (const outcome of allOutcomes) {
+                for (const pkg of outcome.result?.result.packages ?? []) {
+                    const key = `${pkg.name}@${pkg.version}`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    allPackages.push(pkg);
+                }
+            }
+            const totalScanned = seen.size;
+            const totalDuration = allOutcomes.reduce((sum, o) => sum + (o.result?.durationMs ?? 0), 0);
+            const maxScore = allPackages.length > 0
+                ? Math.max(0, ...allPackages.map((p) => p.score))
+                : 0;
+            const action = maxScore >= 70 ? "block" : maxScore >= 60 ? "warn" : "pass";
+            if (totalScanned === 0) {
+                dispatch({
+                    type: "scan_done",
+                    outcome: {
+                        status: "no_packages",
+                        result: {
+                            result: { score: 0, action: "pass", packages: [], safeVersions: {}, durationMs: totalDuration },
+                            durationMs: totalDuration,
+                            scannedCount: 0,
+                            skippedCount: 0,
+                        },
+                    },
+                });
+            }
+            else {
+                dispatch({
+                    type: "scan_done",
+                    outcome: {
+                        status: "ok",
+                        result: {
+                            result: {
+                                score: maxScore,
+                                action,
+                                packages: allPackages,
+                                safeVersions: {},
+                                durationMs: totalDuration,
+                            },
+                            durationMs: totalDuration,
+                            scannedCount: totalScanned,
+                            skippedCount: 0,
+                        },
+                    },
+                });
+            }
+        }
+        catch (e) {
+            const err = e instanceof Error ? e : new Error(String(e));
+            dispatch({
+                type: "scan_done",
+                outcome: { status: "error", result: null, error: err, message: err.message },
+            });
+        }
+    }, [state.dryRun, state.projects, opts.cwd, scanFn]);
+    return {
+        state,
+        canGoBack: canGoBack(state),
+        runDetect,
+        runInstallHook,
+        runVerifyHook,
+        runScan,
+        dispatch,
+    };
+}

package/dist/packages/cli/src/ui/hooks/useLogin.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLogin = useLogin;
+const react_1 = require("react");
+const auth_1 = require("../../auth");
+function reducer(state, action) {
+    switch (action.type) {
+        case "ALREADY_LOGGED_IN":
+            return { phase: "already_logged_in", apiKey: action.apiKey };
+        case "SESSION_READY":
+            return { phase: "ready", verifyUrl: action.verifyUrl };
+        case "BROWSER_OPENED":
+            if (state.phase !== "ready")
+                return state;
+            return { phase: "waiting", verifyUrl: state.verifyUrl };
+        case "AUTH_COMPLETE":
+            return { phase: "success", email: action.email };
+        case "AUTH_EXPIRED":
+            return { phase: "expired" };
+        case "ERROR":
+            return { phase: "error", message: action.message };
+    }
+}
+const POLL_INTERVAL_MS = 2000;
+const MAX_POLL_ATTEMPTS = 150; // 5 minutes
+function useLogin() {
+    const [state, dispatch] = (0, react_1.useReducer)(reducer, { phase: "creating" });
+    const started = (0, react_1.useRef)(false);
+    const sessionRef = (0, react_1.useRef)(null);
+    const cancelledRef = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        if (started.current)
+            return;
+        started.current = true;
+        (async () => {
+            try {
+                const existing = (0, auth_1.getStoredApiKey)();
+                if (existing) {
+                    // Verify the key is still valid on the server
+                    const apiUrl = process.env.DG_API_URL || "https://api.westbayberry.com";
+                    try {
+                        const resp = await fetch(`${apiUrl}/v1/auth/status`, {
+                            headers: { Authorization: `Bearer ${existing}` },
+                            signal: AbortSignal.timeout(5000),
+                        });
+                        if (resp.ok) {
+                            dispatch({ type: "ALREADY_LOGGED_IN", apiKey: existing });
+                            return;
+                        }
+                    }
+                    catch { }
+                    // Key is invalid — clear it and proceed with fresh login
+                    (0, auth_1.saveCredentials)("");
+                }
+                let session;
+                try {
+                    session = await (0, auth_1.createAuthSession)();
+                }
+                catch (err) {
+                    dispatch({
+                        type: "ERROR",
+                        message: err instanceof Error ? err.message : "Failed to create login session",
+                    });
+                    return;
+                }
+                sessionRef.current = session;
+                dispatch({ type: "SESSION_READY", verifyUrl: session.verifyUrl });
+            }
+            catch (err) {
+                dispatch({
+                    type: "ERROR",
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+        })();
+        return () => {
+            cancelledRef.current = true;
+        };
+    }, []);
+    const openAndPoll = (0, react_1.useCallback)(() => {
+        const session = sessionRef.current;
+        if (!session)
+            return;
+        dispatch({ type: "BROWSER_OPENED" });
+        (0, auth_1.openBrowser)(session.verifyUrl);
+        (async () => {
+            try {
+                for (let i = 0; i < MAX_POLL_ATTEMPTS; i++) {
+                    if (cancelledRef.current)
+                        return;
+                    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+                    if (cancelledRef.current)
+                        return;
+                    try {
+                        const result = await (0, auth_1.pollAuthSession)(session.sessionId);
+                        if (result.status === "complete" && result.apiKey) {
+                            (0, auth_1.saveCredentials)(result.apiKey);
+                            dispatch({ type: "AUTH_COMPLETE", email: result.email ?? "unknown" });
+                            return;
+                        }
+                        if (result.status === "expired") {
+                            dispatch({ type: "AUTH_EXPIRED" });
+                            return;
+                        }
+                    }
+                    catch {
+                        // Transient network error — continue polling
+                    }
+                }
+                dispatch({ type: "AUTH_EXPIRED" });
+            }
+            catch (err) {
+                dispatch({
+                    type: "ERROR",
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+        })();
+    }, []);
+    return { state, openAndPoll };
+}

package/dist/packages/cli/src/ui/hooks/useNpmWrapper.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNpmWrapper = useNpmWrapper;
+const react_1 = require("react");
+const npm_wrapper_1 = require("../../npm-wrapper");
+const api_1 = require("../../api");
+const static_output_1 = require("../../static-output");
+function reducer(_state, action) {
+    switch (action.type) {
+        case "PASSTHROUGH":
+            return { phase: "passthrough" };
+        case "RESOLVING":
+            return { phase: "resolving", count: action.count };
+        case "SCANNING":
+            return { phase: "scanning", count: action.count };
+        case "PASS":
+            return { phase: "pass", count: action.count };
+        case "WARN":
+            return { phase: "warn", result: action.result };
+        case "BLOCKED":
+            return { phase: "blocked", result: action.result, dgForce: action.dgForce };
+        case "INSTALLING":
+            return { phase: "installing" };
+        case "DONE":
+            return { phase: "done", exitCode: action.exitCode };
+        case "ERROR":
+            return { phase: "error", message: action.message, proceed: action.proceed };
+        case "TRIAL_EXHAUSTED":
+            return { phase: "trial_exhausted" };
+    }
+}
+function useNpmWrapper(npmArgs, config, exit) {
+    const [state, dispatch] = (0, react_1.useReducer)(reducer, { phase: "resolving", count: 0 });
+    const started = (0, react_1.useRef)(false);
+    const parsedRef = (0, react_1.useRef)((0, npm_wrapper_1.parseNpmArgs)(npmArgs));
+    const pendingInstall = (0, react_1.useRef)(null);
+    const rejectRef = (0, react_1.useRef)(null);
+    const confirmInstall = () => {
+        if (pendingInstall.current) {
+            pendingInstall.current();
+            pendingInstall.current = null;
+            rejectRef.current = null;
+        }
+    };
+    const rejectInstall = () => {
+        if (rejectRef.current) {
+            rejectRef.current();
+            pendingInstall.current = null;
+            rejectRef.current = null;
+        }
+    };
+    (0, react_1.useEffect)(() => {
+        if (started.current)
+            return;
+        started.current = true;
+        const parsed = parsedRef.current;
+        (async () => {
+            try {
+                // Non-install commands: passthrough
+                if (!parsed.shouldScan) {
+                    dispatch({ type: "PASSTHROUGH" });
+                    const code = await (0, npm_wrapper_1.runNpm)(parsed.rawArgs);
+                    dispatch({ type: "DONE", exitCode: code });
+                    return;
+                }
+                // Determine packages to resolve
+                let specs;
+                if (parsed.packages.length === 0) {
+                    // Bare `npm install` -- read from package.json
+                    specs = (0, npm_wrapper_1.readBareInstallPackages)(process.cwd());
+                    if (specs.length === 0) {
+                        // Nothing to scan, just run npm
+                        dispatch({ type: "PASSTHROUGH" });
+                        const code = await (0, npm_wrapper_1.runNpm)(parsed.rawArgs);
+                        dispatch({ type: "DONE", exitCode: code });
+                        return;
+                    }
+                }
+                else {
+                    specs = parsed.packages;
+                }
+                dispatch({ type: "RESOLVING", count: specs.length });
+                // Resolve versions
+                const { resolved } = await (0, npm_wrapper_1.resolvePackages)(specs);
+                if (resolved.length === 0) {
+                    // Could not resolve any packages -- pass through
+                    dispatch({ type: "PASSTHROUGH" });
+                    const code = await (0, npm_wrapper_1.runNpm)(parsed.rawArgs);
+                    dispatch({ type: "DONE", exitCode: code });
+                    return;
+                }
+                dispatch({ type: "SCANNING", count: resolved.length });
+                // Call API
+                const result = await (0, api_1.callAnalyzeAPI)(resolved, config);
+                // Route based on action
+                if (result.action === "pass") {
+                    if (exit)
+                        exit(); // unmount Ink so output persists
+                    const chalk = (await Promise.resolve().then(() => __importStar(require("chalk")))).default;
+                    process.stderr.write(chalk.green(`  \u2713 ${resolved.length} package${resolved.length !== 1 ? "s" : ""} scanned \u2014 all clear\n`));
+                    process.stderr.write("\n");
+                    const code = await (0, npm_wrapper_1.runNpm)(parsed.rawArgs);
+                    process.exit(code);
+                    return;
+                }
+                if (result.action === "warn") {
+                    if (exit)
+                        exit(); // unmount Ink so output persists
+                    process.stdout.write((0, static_output_1.renderResultStatic)(result, config) + "\n");
+                    const chalk = (await Promise.resolve().then(() => __importStar(require("chalk")))).default;
+                    process.stderr.write(chalk.yellow("  Warnings detected. Proceeding with install.\n\n"));
+                    const code = await (0, npm_wrapper_1.runNpm)(parsed.rawArgs);
+                    process.exit(code);
+                    return;
+                }
+                if (result.action === "block") {
+                    // Render findings
+                    process.stdout.write((0, static_output_1.renderResultStatic)(result, config) + "\n");
+                    if (parsed.dgForce) {
+                        // --dg-force: bypass block
+                        dispatch({ type: "BLOCKED", result, dgForce: true });
+                        dispatch({ type: "INSTALLING" });
+                        const code = await (0, npm_wrapper_1.runNpm)(parsed.rawArgs);
+                        dispatch({ type: "DONE", exitCode: code });
+                        return;
+                    }
+                    // Prompt user
+                    dispatch({ type: "BLOCKED", result, dgForce: false });
+                    // Wait for user confirmation
+                    const shouldProceed = await new Promise((resolve) => {
+                        pendingInstall.current = () => resolve(true);
+                        rejectRef.current = () => resolve(false);
+                    });
+                    if (shouldProceed) {
+                        dispatch({ type: "INSTALLING" });
+                        const code = await (0, npm_wrapper_1.runNpm)(parsed.rawArgs);
+                        dispatch({ type: "DONE", exitCode: code });
+                    }
+                    else {
+                        dispatch({ type: "DONE", exitCode: 2 });
+                    }
+                    return;
+                }
+            }
+            catch (error) {
+                if (error instanceof api_1.TrialExhaustedError) {
+                    dispatch({ type: "TRIAL_EXHAUSTED" });
+                    return;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                dispatch({ type: "ERROR", message, proceed: true });
+                dispatch({ type: "INSTALLING" });
+                const code = await (0, npm_wrapper_1.runNpm)(parsedRef.current.rawArgs);
+                dispatch({ type: "DONE", exitCode: code });
+            }
+        })();
+    }, [npmArgs, config]);
+    return { state, confirmInstall, rejectInstall };
+}