react-doctor-cli-dev 1.0.1 → 1.0.3

package/backend/src/routes/reports.ts

@@ -1,110 +1,328 @@
+// ─────────────────────────────────────────────────────────────
+// backend/src/routes/reports.ts
+//
+// All report endpoints.
+//
+// ENDPOINTS:
+//
+//   GET  /api/reports
+//     Returns a summary list (no blobs) — fast for the dashboard
+//     history page. Each row has id, project, score, grade, dates.
+//
+//   GET  /api/reports/:id
+//     Returns the full report for one run — static + runtime +
+//     suggestions all parsed back to objects.
+//
+//   GET  /api/reports/project/:name
+//     All runs for a named project, summary only.
+//
+//   POST /api/reports/upload   (requires x-api-key header)
+//     Accepts a FinalReport from the CLI.
+//     Strips screenshot dataUrls → saves as .png files.
+//     Stores static_json, runtime_json, suggestions in DB.
+//
+// SCREENSHOT HANDLING ON UPLOAD:
+//   The CLI sends the full FinalReport including base64 screenshots
+//   (up to 200KB each). We extract those before storing so the DB
+//   stays lean. Each screenshot is saved as:
+//     data/screenshots/<reportId>-<routeKey>-<label>.png
+//   And the dataUrl in runtime_json is replaced with:
+//     /screenshots/<filename>
+//   so the dashboard can load them as normal <img> tags.
+// ─────────────────────────────────────────────────────────────
 
 import { Router, Request, Response, RequestHandler } from "express";
-import db from "../db";
-import { requireApiKey } from "../middleware/auth";
- 
+import path from "path";
+import fs   from "fs";
+import db, { screenshotsDir } from "../db";
+import { requireApiKey }      from "../middleware/auth";
+
 const router = Router();
- 
 
-router.get("/", (req: Request, res: Response) => {
+// ── GET /api/reports ─────────────────────────────────────────
+// Summary list — no blobs, just the columns the history page needs.
+
+router.get("/", (_req: Request, res: Response) => {
   try {
     const rows = db.prepare(`
       SELECT id, project, score, grade, analyzed_at, created_at
-      FROM reports
-      ORDER BY created_at DESC
-      LIMIT 50
+      FROM   reports
+      ORDER  BY created_at DESC
+      LIMIT  100
     `).all() as any[];
- 
+
     res.json({ count: rows.length, reports: rows });
   } catch (err: any) {
+    console.error("GET / error:", err.message);
     res.status(500).json({ error: "Internal server error" });
   }
 });
- 
+
+// ── GET /api/reports/project/:name ───────────────────────────
+// All runs for one project, summary only.
 
 router.get("/project/:name", (req: Request, res: Response) => {
   try {
     const rows = db.prepare(`
       SELECT id, project, score, grade, analyzed_at, created_at
-      FROM reports
-      WHERE project = ?
-      ORDER BY created_at DESC
+      FROM   reports
+      WHERE  project = ?
+      ORDER  BY created_at DESC
     `).all(req.params.name) as any[];
- 
-    res.json({
-      project: req.params.name,
-      count: rows.length,
-      reports: rows,
-    });
+
+    res.json({ project: req.params.name, count: rows.length, reports: rows });
   } catch (err: any) {
+    console.error("GET /project/:name error:", err.message);
     res.status(500).json({ error: "Internal server error" });
   }
 });
- 
-// ==========================================
-// Endpoint 1: POST /api/report/upload
-// يستقبل التقرير من الـ CLI ويتحقق منه ثم يحفظه
-// ==========================================
-router.post("/upload", requireApiKey as RequestHandler, (req: Request, res: Response) => {
-  try {
-    const report = req.body;
- 
-    // التحقق من وجود الحقول الإلزامية الثلاثة
-    if (!report || !report.projectName || !report.analyzedAt || report.performanceScore === undefined) {
-      res.status(400).json({ error: "Invalid report — missing required fields" });
-      return;
+
+// ── POST /api/reports/upload ──────────────────────────────────
+// Receives a FinalReport from the CLI, strips screenshots to disk,
+// and stores the three JSON blobs in separate columns.
+
+router.post(
+  "/upload",
+  requireApiKey as RequestHandler,
+  (req: Request, res: Response) => {
+    try {
+      const body = req.body;
+
+      // ── Validate required top-level fields ──────────────────
+      if (
+        !body ||
+        !body.projectName ||
+        !body.analyzedAt  ||
+        body.performanceScore === undefined ||
+        !body.static          ||
+        !body.runtime         ||
+        !body.suggestions
+      ) {
+        res.status(400).json({
+          error:   "Invalid report",
+          missing: getMissingFields(body),
+        });
+        return;
+      }
+
+      // ── Extract grade from static report ────────────────────
+      const grade: string = body.static?.grade ?? "N/A";
+
+      // ── Strip screenshots from runtime, save as .png files ──
+      // We do this BEFORE inserting so the DB never holds base64.
+      // The row ID isn't known yet — we'll rename after insert.
+      // For now we use a temp prefix and rename below.
+      const { cleanedRuntime, pendingScreenshots } = extractScreenshots(body.runtime);
+
+      // ── Insert the row ───────────────────────────────────────
+      const stmt = db.prepare(`
+        INSERT INTO reports
+          (project, score, grade, analyzed_at, static_json, runtime_json, suggestions)
+        VALUES
+          (?, ?, ?, ?, ?, ?, ?)
+      `);
+
+      const result = stmt.run(
+        body.projectName,
+        body.performanceScore,
+        grade,
+        body.analyzedAt,
+        JSON.stringify(body.static),
+        JSON.stringify(cleanedRuntime),
+        JSON.stringify(body.suggestions),
+      ) as any;
+
+      const reportId: number = result.lastInsertRowid;
+
+      // ── Save screenshots with final filenames ────────────────
+      const savedScreenshots = saveScreenshots(reportId, pendingScreenshots);
+
+      // ── Patch runtime_json with final screenshot paths ───────
+      // Now that we have the reportId we can write the correct paths.
+      if (savedScreenshots.length > 0) {
+        const patchedRuntime = patchScreenshotPaths(
+          cleanedRuntime,
+          savedScreenshots,
+        );
+        db.prepare(
+          "UPDATE reports SET runtime_json = ? WHERE id = ?"
+        ).run(JSON.stringify(patchedRuntime), reportId);
+      }
+
+      res.status(201).json({
+        message:     "Report saved successfully",
+        id:          reportId,
+        screenshots: savedScreenshots.length,
+      });
+    } catch (err: any) {
+      console.error("POST /upload error:", err.message);
+      res.status(500).json({ error: "Internal server error" });
     }
- 
-    const grade = report.static?.grade ?? "N/A";
- 
-    // تجهيز استعلام الإدخال لـ SQLite
-    const stmt = db.prepare(`
-      INSERT INTO reports (project, score, grade, analyzed_at, payload)
-      VALUES (?, ?, ?, ?, ?)
-    `);
- 
-    // تنفيذ الاستعلام وحفظ جسم التقرير كـ string
-    const result = stmt.run(
-      report.projectName,
-      report.performanceScore,
-      grade,
-      report.analyzedAt,
-      JSON.stringify(report)
-    );
- 
-    res.status(201).json({
-      message: "Report saved successfully",
-      id: result.lastInsertRowid,
-    });
-  } catch (err: any) {
-    console.error("Upload error:", err.message);
-    res.status(500).json({ error: "Internal server error" });
-  }
-});
- 
+  },
+);
+
+// ── GET /api/reports/:id ─────────────────────────────────────
+// Full report for one run — parses all three JSON columns back
+// to objects and returns a unified response.
+
 router.get("/:id", (req: Request, res: Response) => {
   try {
     const row = db.prepare(
       "SELECT * FROM reports WHERE id = ?"
     ).get(req.params.id) as any;
- 
+
     if (!row) {
       res.status(404).json({ error: "Report not found" });
       return;
     }
- 
+
     res.json({
-      id: row.id,
-      project: row.project,
-      score: row.score,
-      grade: row.grade,
-      analyzedAt: row.analyzed_at,
-      createdAt: row.created_at,
-      report: JSON.parse(row.payload),
+      id:          row.id,
+      project:     row.project,
+      score:       row.score,
+      grade:       row.grade,
+      analyzedAt:  row.analyzed_at,
+      createdAt:   row.created_at,
+      // Parse the three JSON blobs back into objects
+      static:      JSON.parse(row.static_json),
+      runtime:     JSON.parse(row.runtime_json),
+      suggestions: JSON.parse(row.suggestions),
     });
   } catch (err: any) {
+    console.error("GET /:id error:", err.message);
     res.status(500).json({ error: "Internal server error" });
   }
 });
- 
-export default router;
+
+export default router;
+
+// ─────────────────────────────────────────────────────────────
+// HELPERS
+// ─────────────────────────────────────────────────────────────
+
+function getMissingFields(body: any): string[] {
+  const required = ["projectName", "analyzedAt", "performanceScore", "static", "runtime", "suggestions"];
+  return required.filter(f => body?.[f] === undefined || body?.[f] === null);
+}
+
+interface PendingScreenshot {
+  routeKey: string;
+  label:    string;
+  buffer:   Buffer;
+  // placeholder path written into cleanedRuntime — replaced after insert
+  tempPath: string;
+}
+
+/**
+ * Walk the runtime map, strip every screenshot.dataUrl,
+ * and collect them as Buffers ready to write to disk.
+ *
+ * Returns:
+ *   cleanedRuntime  — runtime map with dataUrls replaced by tempPath markers
+ *   pendingScreenshots — list of screenshots to save once we have a reportId
+ */
+function extractScreenshots(
+  runtime: Record<string, any>,
+): { cleanedRuntime: Record<string, any>; pendingScreenshots: PendingScreenshot[] } {
+  const pending: PendingScreenshot[] = [];
+  const cleaned: Record<string, any> = {};
+
+  for (const [routeKey, routeData] of Object.entries(runtime)) {
+    const routeClone = { ...routeData };
+
+    if (Array.isArray(routeClone.screenshots)) {
+      routeClone.screenshots = routeClone.screenshots.map((shot: any) => {
+        if (!shot.dataUrl || !shot.dataUrl.startsWith("data:image/png;base64,")) {
+          return shot;
+        }
+
+        const base64 = shot.dataUrl.replace("data:image/png;base64,", "");
+        const buffer = Buffer.from(base64, "base64");
+
+        // Sanitise routeKey for use in a filename — replace "/" and ":" with "-"
+        const safeRoute = routeKey.replace(/[/:]/g, "-").replace(/^-+/, "");
+        const safeLabel = shot.label.replace(/[^a-z0-9]/gi, "-");
+        const tempPath  = `__PENDING__${safeRoute}__${safeLabel}`;
+
+        pending.push({ routeKey, label: shot.label, buffer, tempPath });
+
+        return { ...shot, dataUrl: tempPath };
+      });
+    }
+
+    cleaned[routeKey] = routeClone;
+  }
+
+  return { cleanedRuntime: cleaned, pendingScreenshots: pending };
+}
+
+interface SavedScreenshot {
+  routeKey: string;
+  label:    string;
+  tempPath: string;
+  filePath: string; // relative URL path served by express static
+}
+
+/**
+ * Write each screenshot buffer to data/screenshots/<reportId>-<route>-<label>.png
+ * Returns the list of saved files with their final URL paths.
+ */
+function saveScreenshots(
+  reportId: number,
+  pending:  PendingScreenshot[],
+): SavedScreenshot[] {
+  const saved: SavedScreenshot[] = [];
+
+  for (const shot of pending) {
+    const safeRoute = shot.routeKey.replace(/[/:]/g, "-").replace(/^-+/, "");
+    const safeLabel = shot.label.replace(/[^a-z0-9]/gi, "-");
+    const filename  = `${reportId}-${safeRoute}-${safeLabel}.png`;
+    const fullPath  = path.join(screenshotsDir, filename);
+
+    try {
+      fs.writeFileSync(fullPath, shot.buffer);
+      saved.push({
+        routeKey: shot.routeKey,
+        label:    shot.label,
+        tempPath: shot.tempPath,
+        filePath: `/screenshots/${filename}`,
+      });
+    } catch (err: any) {
+      console.warn(`Could not save screenshot ${filename}: ${err.message}`);
+    }
+  }
+
+  return saved;
+}
+
+/**
+ * Replace the __PENDING__ markers in runtime_json with
+ * the final /screenshots/<file> URL paths.
+ */
+function patchScreenshotPaths(
+  runtime: Record<string, any>,
+  saved:   SavedScreenshot[],
+): Record<string, any> {
+  // Build a lookup from tempPath → filePath
+  const lookup: Record<string, string> = {};
+  for (const s of saved) lookup[s.tempPath] = s.filePath;
+
+  const patched: Record<string, any> = {};
+
+  for (const [routeKey, routeData] of Object.entries(runtime)) {
+    const routeClone = { ...routeData };
+
+    if (Array.isArray(routeClone.screenshots)) {
+      routeClone.screenshots = routeClone.screenshots.map((shot: any) => {
+        if (shot.dataUrl && lookup[shot.dataUrl]) {
+          return { ...shot, dataUrl: lookup[shot.dataUrl] };
+        }
+        return shot;
+      });
+    }
+
+    patched[routeKey] = routeClone;
+  }
+
+  return patched;
+}

package/cli/dist/commands/dashboard.js

@@ -0,0 +1,152 @@
+"use strict";
+// ─────────────────────────────────────────────────────────────
+// cli/src/commands/dashboard.ts
+//
+// react-doctor dashboard
+//
+// Opens the React Doctor dashboard in the browser.
+//
+// WHAT IT DOES:
+//   1. Checks if the backend is already running on the port
+//   2. If not — starts it automatically (same logic as --upload)
+//   3. Opens http://localhost:PORT in the default browser
+//
+// This command is the natural companion to --upload.
+// Workflow:
+//   react-doctor full ./my-app --upload   ← runs analysis + saves report
+//   react-doctor dashboard                ← opens the dashboard to view it
+//
+// Or in one shot:
+//   react-doctor full ./my-app --upload && react-doctor dashboard
+// ─────────────────────────────────────────────────────────────
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDashboardCommand = registerDashboardCommand;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const axios_1 = __importDefault(require("axios"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const ui_1 = require("../ui");
+function registerDashboardCommand(program) {
+    program
+        .command("dashboard")
+        .description("Open the React Doctor dashboard (auto-starts backend if needed)")
+        .option("--port <port>", "Port the backend runs on", "3000")
+        .option("--api-key <key>", "API key for the backend", process.env.REACT_DOCTOR_API_KEY || "react-doctor-secret-key-change-this")
+        .option("--no-banner", "Skip the banner")
+        .action(async (options) => {
+        if (!options.noBanner)
+            (0, ui_1.printBanner)();
+        const port = options.port;
+        const apiUrl = `http://localhost:${port}`;
+        (0, ui_1.printSection)("Dashboard");
+        (0, ui_1.printInfo)("Backend URL", apiUrl);
+        console.log();
+        const spin = (0, ui_1.spinner)("Checking backend status...");
+        try {
+            // ── 1. Check if backend is already up ─────────────────
+            let backendRunning = false;
+            try {
+                await axios_1.default.get(`${apiUrl}/health`, { timeout: 2000 });
+                backendRunning = true;
+            }
+            catch {
+                backendRunning = false;
+            }
+            // ── 2. Start backend if not running ───────────────────
+            if (!backendRunning) {
+                spin.text = "  Backend not running — starting automatically...";
+                // Locate backend folder (sibling of cli/)
+                const projectRoot = path_1.default.resolve(__dirname, "..", "..", "..");
+                const backendRoot = path_1.default.resolve(projectRoot, "backend");
+                const backendDist = path_1.default.join(backendRoot, "dist", "index.js");
+                const backendSrc = path_1.default.join(backendRoot, "src", "index.ts");
+                let command;
+                let args;
+                if (fs_1.default.existsSync(backendDist)) {
+                    command = "node";
+                    args = [backendDist];
+                }
+                else if (fs_1.default.existsSync(backendSrc)) {
+                    command = "npx";
+                    args = ["ts-node", backendSrc];
+                }
+                else {
+                    spin.fail(chalk_1.default.red("Backend not found"));
+                    (0, ui_1.printFail)(`Could not find backend at: ${backendRoot}\n\n` +
+                        `  Make sure the 'backend/' folder exists next to 'cli/'.`);
+                    process.exit(1);
+                }
+                // Create data dir inside npm global cache for the backend DB
+                const dataDir = path_1.default.join(backendRoot, "data");
+                fs_1.default.mkdirSync(dataDir, { recursive: true });
+                (0, child_process_1.spawn)(command, args, {
+                    stdio: "ignore",
+                    detached: true,
+                    env: {
+                        ...process.env,
+                        API_KEY: options.apiKey,
+                        PORT: port,
+                        DB_PATH: path_1.default.join(dataDir, "reports.db"),
+                    },
+                    cwd: backendRoot,
+                }).unref(); // let CLI exit without killing the server
+                // Wait for backend to be ready (up to 15 seconds)
+                let ready = false;
+                let retries = 0;
+                while (!ready && retries < 15) {
+                    try {
+                        await axios_1.default.get(`${apiUrl}/health`, { timeout: 1000 });
+                        ready = true;
+                    }
+                    catch {
+                        await new Promise(r => setTimeout(r, 1000));
+                        retries++;
+                    }
+                }
+                if (!ready) {
+                    spin.fail(chalk_1.default.red("Backend failed to start"));
+                    (0, ui_1.printFail)("Backend did not respond after 15 seconds.");
+                    process.exit(1);
+                }
+                spin.succeed(chalk_1.default.green("Backend started successfully"));
+            }
+            else {
+                spin.succeed(chalk_1.default.green("Backend already running"));
+            }
+            // ── 3. Open dashboard in default browser ──────────────
+            const dashboardUrl = apiUrl;
+            console.log();
+            (0, ui_1.printInfo)("Opening", dashboardUrl);
+            console.log();
+            // Cross-platform browser open
+            const openCmd = process.platform === "win32" ? ["cmd", ["/c", "start", dashboardUrl]] :
+                process.platform === "darwin" ? ["open", [dashboardUrl]] :
+                    ["xdg-open", [dashboardUrl]];
+            (0, child_process_1.spawn)(openCmd[0], openCmd[1], {
+                stdio: "ignore",
+                detached: true,
+            }).unref();
+            (0, ui_1.printDone)(`Dashboard opened at ${chalk_1.default.cyan(dashboardUrl)}`);
+            // ── 4. Show quick API reference ───────────────────────
+            console.log(chalk_1.default.gray("  Available endpoints:"));
+            console.log(chalk_1.default.cyan(`    GET  ${apiUrl}/health`));
+            console.log(chalk_1.default.cyan(`    GET  ${apiUrl}/api/reports`));
+            console.log(chalk_1.default.cyan(`    GET  ${apiUrl}/api/reports/:id`));
+            console.log(chalk_1.default.cyan(`    GET  ${apiUrl}/api/reports/project/:name`));
+            console.log(chalk_1.default.cyan(`    POST ${apiUrl}/api/reports/upload`));
+            console.log();
+            console.log(chalk_1.default.gray("  Tip: run ") +
+                chalk_1.default.cyan("react-doctor full ./ --upload") +
+                chalk_1.default.gray(" to add a new report.\n"));
+        }
+        catch (err) {
+            spin.fail(chalk_1.default.red("Dashboard failed to open"));
+            console.log(chalk_1.default.red(`\n  ${err.message}\n`));
+            process.exit(1);
+        }
+    });
+}

package/cli/dist/index.js

@@ -1,77 +1,51 @@
 #!/usr/bin/env node
 "use strict";
 // ─────────────────────────────────────────────────────────────
-// cli/src/index.ts
-//
-// The CLI entry point. This is the file that runs when the
-// user types "react-doctor" in their terminal.
-//
-// HOW IT WORKS:
-// 1. Commander.js parses the command and flags from argv
-// 2. The matching command handler is called
-// 3. The handler imports core modules and runs the pipeline
-//
-// HOW THE BINARY REGISTRATION WORKS:
-// package.json has a "bin" field:
-//   "bin": { "react-doctor": "./dist/index.js" }
-//
-// After "npm link" (dev) or "npm install" (production),
-// npm creates a symlink from the system's bin directory
-// to this file. That's what makes "react-doctor" a real
-// terminal command available anywhere.
-//
-// THE SHEBANG (#!/usr/bin/env node) on line 1:
-// This tells the OS to run this file with Node.js when
-// called directly as a script. Without it, the OS doesn't
-// know which interpreter to use.
+// cli/src/index.ts  —  CLI entry point
 // ─────────────────────────────────────────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const analyze_1 = require("./commands/analyze");
 const profile_1 = require("./commands/profile");
 const full_1 = require("./commands/full");
-const install_1 = require("./commands/install");
+const dashboard_1 = require("./commands/dashboard");
 const program = new commander_1.Command();
 // ── Program metadata ──────────────────────────────────────────
 program
     .name("react-doctor")
     .description("React performance analyzer — static analysis + runtime profiling + smart suggestions")
-    .version("1.0.0");
-// ── Register all commands ─────────────────────────────────────
-// Each function adds one command to the program.
-// The order here is the order they appear in --help output.
+    .version("1.0.2");
+// ── Register commands ─────────────────────────────────────────
 (0, full_1.registerFullCommand)(program); // react-doctor full
 (0, analyze_1.registerAnalyzeCommand)(program); // react-doctor analyze
 (0, profile_1.registerProfileCommand)(program); // react-doctor profile
-(0, install_1.registerInstallCommand)(program); // react-doctor install
-// ── Usage examples shown at bottom of --help ─────────────────
+(0, dashboard_1.registerDashboardCommand)(program); // react-doctor dashboard
+// ── Usage examples ────────────────────────────────────────────
 program.addHelpText("after", `
 Examples:
-  $ react-doctor full ./my-app                       Desktop only (default)
-  $ react-doctor full ./my-app --mobile              Mobile only
-  $ react-doctor full ./my-app --desktop --mobile    Both desktop and mobile
-  $ react-doctor full ./my-app --cpu 4               Simulate slow Android device
-  $ react-doctor full ./my-app --throttle slow4g     Simulate slow 4G network
-  $ react-doctor full ./my-app --throttle 3g         Simulate 3G network
-  $ react-doctor full ./my-app --cpu 4 --throttle 3g Slow device + slow network
-  $ react-doctor full ./my-app --upload              Upload results to dashboard
+  $ react-doctor full ./my-app                          Run full diagnostic (desktop)
+  $ react-doctor full ./my-app --mobile                 Include mobile viewport
+  $ react-doctor full ./my-app --desktop --mobile       Both desktop and mobile
+  $ react-doctor full ./my-app --cpu 4                  Simulate slow Android device
+  $ react-doctor full ./my-app --throttle slow4g        Simulate slow 4G network
+  $ react-doctor full ./my-app --throttle 3g            Simulate 3G network
+  $ react-doctor full ./my-app --cpu 4 --throttle 3g   Slow device + slow network
+  $ react-doctor full ./my-app --upload                 Run + save report to dashboard
 
-  $ react-doctor analyze ./my-app                    Static code analysis only
-  $ react-doctor analyze ./my-app --full             Static + runtime + rules
+  $ react-doctor analyze ./my-app                       Static code analysis only
+  $ react-doctor analyze ./my-app --full                Static + runtime + rules
 
-  $ react-doctor profile ./my-app                    Desktop only (default)
-  $ react-doctor profile ./my-app --mobile           Mobile only
-  $ react-doctor profile ./my-app --desktop --mobile Both devices
-  $ react-doctor profile ./my-app --cpu 4            4x CPU slowdown simulation
-  $ react-doctor profile ./my-app --throttle slow4g  Simulate slow 4G network
-  $ react-doctor profile ./my-app --throttle 3g      Simulate 3G network
+  $ react-doctor profile ./my-app                       Runtime profiling only (desktop)
+  $ react-doctor profile ./my-app --mobile              Mobile viewport
+  $ react-doctor profile ./my-app --desktop --mobile    Both devices
+  $ react-doctor profile ./my-app --cpu 4               4x CPU slowdown simulation
+  $ react-doctor profile ./my-app --throttle slow4g     Simulate slow 4G network
+  $ react-doctor profile ./my-app --throttle 3g         Simulate 3G network
 
-  $ react-doctor install                       Install from GitHub into a project
-  $ react-doctor install --path ./my-app       Install into a specific folder
+  $ react-doctor dashboard                              Open dashboard (auto-starts backend)
+  $ react-doctor dashboard --port 4000                  Use custom port
 `);
 // ── Show help if called with no arguments ─────────────────────
-// Without this, calling "react-doctor" with no command just
-// exits silently, which is confusing. This prints help instead.
 if (process.argv.length < 3) {
     program.help();
 }