md4ai 0.17.2 → 0.18.0

package/dist/index.bundled.js

@@ -49,16 +49,6 @@ function printUpdateBanner(latest) {
   console.log(chalk.yellow("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
   console.log("");
 }
-async function checkForUpdate() {
-  const latest = await fetchLatest();
-  if (!latest)
-    return;
-  if (latest !== CURRENT_VERSION && isNewer(latest, CURRENT_VERSION)) {
-    printUpdateBanner(latest);
-  } else {
-    console.log(chalk.green(`md4ai v${CURRENT_VERSION} \u2014 you're on the latest version.`));
-  }
-}
 async function autoCheckForUpdate() {
   try {
     const latest = await fetchLatest();
@@ -122,7 +112,7 @@ var CURRENT_VERSION;
 var init_check_update = __esm({
   "dist/check-update.js"() {
     "use strict";
-    CURRENT_VERSION = true ? "0.17.2" : "0.0.0-dev";
+    CURRENT_VERSION = true ? "0.18.0" : "0.0.0-dev";
   }
 });
 
@@ -365,14 +355,26 @@ import chalk5 from "chalk";
 import { confirm, input as input2, password as password2 } from "@inquirer/prompts";
 async function getAuthenticatedClient() {
   const creds = await loadCredentials();
-  const needsLogin = !creds?.accessToken || Date.now() > creds.expiresAt;
-  if (needsLogin) {
-    const reason = !creds?.accessToken ? "Not logged in." : "Session expired.";
-    console.log(chalk5.yellow(`${reason}`));
+  if (!creds?.accessToken) {
+    console.log(chalk5.yellow("Not logged in."));
     const shouldLogin = await confirm({ message: "Would you like to log in now?" });
-    if (!shouldLogin) {
+    if (!shouldLogin)
       process.exit(0);
+    return promptLogin();
+  }
+  if (creds.refreshToken) {
+    const refreshed = await refreshSession();
+    if (refreshed) {
+      updateDeviceCliVersion(refreshed.supabase, refreshed.userId).catch(() => {
+      });
+      return refreshed;
     }
+  }
+  if (Date.now() > creds.expiresAt) {
+    console.log(chalk5.yellow("Session expired."));
+    const shouldLogin = await confirm({ message: "Would you like to log in now?" });
+    if (!shouldLogin)
+      process.exit(0);
     return promptLogin();
   }
   const anonKey = getAnonKey();
@@ -2069,6 +2071,11 @@ var init_doppler_scanner = __esm({
 });
 
 // dist/scanner/index.js
+var scanner_exports = {};
+__export(scanner_exports, {
+  readClaudeConfigFiles: () => readClaudeConfigFiles,
+  scanProject: () => scanProject
+});
 import { readdir as readdir5 } from "node:fs/promises";
 import { join as join12, relative as relative3 } from "node:path";
 import { existsSync as existsSync7 } from "node:fs";
@@ -2619,7 +2626,7 @@ ${proposedFiles.length} file(s) proposed for deletion:
           }
         }
         if (deviceId) {
-          await supabase.from("device_scans").upsert({
+          const scanPayload = {
             folder_id,
             device_id: deviceId,
             user_id: userId,
@@ -2635,7 +2642,14 @@ ${proposedFiles.length} file(s) proposed for deletion:
             data_hash: result.dataHash,
             scanned_at: result.scannedAt,
             cli_version: CURRENT_VERSION
-          }, { onConflict: "folder_id,device_id" });
+          };
+          const { data: updated, error: updateErr } = await supabase.from("device_scans").update(scanPayload).eq("folder_id", folder_id).eq("device_id", deviceId).select("id");
+          if (updateErr || !updated?.length) {
+            const { error: insertErr } = await supabase.from("device_scans").insert(scanPayload);
+            if (insertErr) {
+              console.error(chalk12.red(`  Failed to save scan data: ${insertErr.message}`));
+            }
+          }
         }
         await pushToolings(supabase, folder_id, result.toolings, deviceId);
         const manifestForHealth = result.envManifest ?? storedManifest;
@@ -2785,139 +2799,15 @@ var init_map = __esm({
   }
 });
 
-// dist/commands/sync.js
-var sync_exports = {};
-__export(sync_exports, {
-  syncCommand: () => syncCommand
-});
-import { resolve as resolve5 } from "node:path";
-import { existsSync as existsSync11 } from "node:fs";
-import chalk15 from "chalk";
-function isValidProjectPath(p) {
-  const resolved = resolve5(p);
-  return resolved.startsWith("/") && !resolved.includes("..") && existsSync11(resolved);
-}
-async function syncCommand(options) {
-  const { supabase, userId } = await getAuthenticatedClient();
-  if (options.all) {
-    const currentDeviceName = detectDeviceName();
-    const { data: devices, error } = await supabase.from("device_paths").select("folder_id, device_name, path").eq("device_name", currentDeviceName);
-    if (error || !devices?.length) {
-      console.log(chalk15.yellow(`
-  No projects linked on ${currentDeviceName} yet.
-`));
-      console.log(chalk15.dim("  To link a project, cd into its folder and run:"));
-      console.log(chalk15.cyan("    md4ai scan"));
-      console.log(chalk15.dim("  Or link an existing project from the dashboard:"));
-      console.log(chalk15.cyan("    md4ai link <project-id>\n"));
-      return;
-    }
-    for (const device of devices) {
-      if (!isValidProjectPath(device.path)) {
-        console.error(chalk15.red(`  Skipping invalid path: ${device.path}`));
-        continue;
-      }
-      console.log(chalk15.blue(`Syncing: ${device.path}`));
-      const { data: proposedAll } = await supabase.from("folder_files").select("file_path").eq("folder_id", device.folder_id).eq("proposed_for_deletion", true);
-      if (proposedAll?.length) {
-        console.log(chalk15.yellow(`  ${proposedAll.length} file(s) proposed for deletion \u2014 run \`md4ai scan\` to review.`));
-      }
-      try {
-        const result = await scanProject(device.path, device.folder_id);
-        const { data: allDeviceRow } = await supabase.from("devices").select("id").eq("user_id", userId).eq("device_name", device.device_name).single();
-        const allDeviceId = allDeviceRow?.id;
-        if (allDeviceId) {
-          await supabase.from("device_scans").upsert({
-            folder_id: device.folder_id,
-            device_id: allDeviceId,
-            user_id: userId,
-            graph_json: result.graph,
-            orphans_json: result.orphans,
-            skills_table_json: result.skills,
-            stale_files_json: result.staleFiles,
-            broken_refs_json: result.brokenRefs,
-            env_manifest_json: result.envManifest,
-            plugin_versions_json: result.pluginVersions,
-            data_hash: result.dataHash,
-            scanned_at: result.scannedAt,
-            cli_version: CURRENT_VERSION
-          }, { onConflict: "folder_id,device_id" });
-        }
-        await pushToolings(supabase, device.folder_id, result.toolings, allDeviceId);
-        await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
-        console.log(chalk15.green(`  Done: ${device.device_name}`));
-      } catch (err) {
-        console.error(chalk15.red(`  Failed: ${device.path}: ${err}`));
-      }
-    }
-    await saveState({ lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
-    console.log(chalk15.green("\nAll devices synced."));
-  } else {
-    const state = await loadState();
-    if (!state.lastFolderId) {
-      console.error(chalk15.yellow("No recent sync. Use: md4ai sync --all, or md4ai scan <path> first."));
-      process.exit(1);
-    }
-    const { data: device } = await supabase.from("device_paths").select("folder_id, device_name, path").eq("folder_id", state.lastFolderId).eq("device_name", state.lastDeviceName).single();
-    if (!device) {
-      console.error(chalk15.red("Could not find last synced device/folder."));
-      process.exit(1);
-    }
-    if (!isValidProjectPath(device.path)) {
-      console.error(chalk15.red(`Invalid project path: ${device.path}`));
-      process.exit(1);
-    }
-    console.log(chalk15.blue(`Syncing: ${device.path}`));
-    const { data: proposedSingle } = await supabase.from("folder_files").select("file_path").eq("folder_id", device.folder_id).eq("proposed_for_deletion", true);
-    if (proposedSingle?.length) {
-      console.log(chalk15.yellow(`  ${proposedSingle.length} file(s) proposed for deletion \u2014 run \`md4ai scan\` to review.`));
-    }
-    const result = await scanProject(device.path, device.folder_id);
-    const { data: singleDeviceRow } = await supabase.from("devices").select("id").eq("user_id", userId).eq("device_name", device.device_name).single();
-    const singleDeviceId = singleDeviceRow?.id;
-    if (singleDeviceId) {
-      await supabase.from("device_scans").upsert({
-        folder_id: device.folder_id,
-        device_id: singleDeviceId,
-        user_id: userId,
-        graph_json: result.graph,
-        orphans_json: result.orphans,
-        skills_table_json: result.skills,
-        stale_files_json: result.staleFiles,
-        broken_refs_json: result.brokenRefs,
-        plugin_versions_json: result.pluginVersions,
-        data_hash: result.dataHash,
-        scanned_at: result.scannedAt,
-        cli_version: CURRENT_VERSION
-      }, { onConflict: "folder_id,device_id" });
-    }
-    await pushToolings(supabase, device.folder_id, result.toolings, singleDeviceId);
-    await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
-    await saveState({ lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
-    console.log(chalk15.green("Synced."));
-  }
-}
-var init_sync = __esm({
-  "dist/commands/sync.js"() {
-    "use strict";
-    init_auth();
-    init_config();
-    init_scanner();
-    init_push_toolings();
-    init_check_update();
-    init_device_utils();
-  }
-});
-
 // dist/mcp/read-configs.js
 import { readFile as readFile12 } from "node:fs/promises";
 import { join as join15 } from "node:path";
 import { homedir as homedir9 } from "node:os";
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { readdir as readdir6 } from "node:fs/promises";
 async function readJsonSafe(path) {
   try {
-    if (!existsSync13(path))
+    if (!existsSync12(path))
       return null;
     const raw = await readFile12(path, "utf-8");
     return JSON.parse(raw);
@@ -2988,14 +2878,14 @@ async function readAllMcpConfigs() {
   const cwdMcp = await readJsonSafe(join15(process.cwd(), ".mcp.json"));
   entries.push(...parseServers(cwdMcp, "project"));
   const pluginsBase = join15(home, ".claude", "plugins", "marketplaces");
-  if (existsSync13(pluginsBase)) {
+  if (existsSync12(pluginsBase)) {
     try {
       const marketplaces = await readdir6(pluginsBase, { withFileTypes: true });
       for (const mp of marketplaces) {
         if (!mp.isDirectory())
           continue;
         const extDir = join15(pluginsBase, mp.name, "external_plugins");
-        if (!existsSync13(extDir))
+        if (!existsSync12(extDir))
           continue;
         const plugins = await readdir6(extDir, { withFileTypes: true });
         for (const plugin of plugins) {
@@ -3009,7 +2899,7 @@ async function readAllMcpConfigs() {
     }
   }
   const cacheBase = join15(home, ".claude", "plugins", "cache");
-  if (existsSync13(cacheBase)) {
+  if (existsSync12(cacheBase)) {
     try {
       const registries = await readdir6(cacheBase, { withFileTypes: true });
       for (const reg of registries) {
@@ -3174,7 +3064,7 @@ var mcp_watch_exports = {};
 __export(mcp_watch_exports, {
   mcpWatchCommand: () => mcpWatchCommand
 });
-import chalk21 from "chalk";
+import chalk20 from "chalk";
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 function detectTty() {
@@ -3328,20 +3218,20 @@ function buildRows(configs, httpResults, cdpStatus) {
 }
 function printTable(rows, deviceName, watcherPid, cdpResult) {
   process.stdout.write("\x1B[3J\x1B[2J\x1B[H");
-  console.log(chalk21.bold.cyan(`
-  MCP Monitor v${CURRENT_VERSION} \u2014 ${deviceName}`) + chalk21.dim(`  (PID ${watcherPid})`));
-  console.log(chalk21.dim(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \xB7 refreshes every 30s \xB7 Ctrl+C to stop
+  console.log(chalk20.bold.cyan(`
+  MCP Monitor v${CURRENT_VERSION} \u2014 ${deviceName}`) + chalk20.dim(`  (PID ${watcherPid})`));
+  console.log(chalk20.dim(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \xB7 refreshes every 30s \xB7 Ctrl+C to stop
 `));
   if (cdpResult) {
     if (cdpResult.status === "reachable") {
       const browserInfo = cdpResult.browser ? ` (${cdpResult.browser})` : "";
-      console.log(chalk21.green("  \u2714 Chrome browser connected") + chalk21.dim(browserInfo));
-      console.log(chalk21.dim("    Claude Code can control Chrome via DevTools Protocol on localhost:9222"));
+      console.log(chalk20.green("  \u2714 Chrome browser connected") + chalk20.dim(browserInfo));
+      console.log(chalk20.dim("    Claude Code can control Chrome via DevTools Protocol on localhost:9222"));
     } else {
-      console.log(chalk21.red("  \u2717 Chrome browser not connected"));
-      console.log(chalk21.dim("    Claude Code cannot reach Chrome. To fix:"));
-      console.log(chalk21.dim("    1. Open Chrome with: google-chrome --remote-debugging-port=9222"));
-      console.log(chalk21.dim("    2. Or add --remote-debugging-port=9222 to your Chrome shortcut"));
+      console.log(chalk20.red("  \u2717 Chrome browser not connected"));
+      console.log(chalk20.dim("    Claude Code cannot reach Chrome. To fix:"));
+      console.log(chalk20.dim("    1. Open Chrome with: google-chrome --remote-debugging-port=9222"));
+      console.log(chalk20.dim("    2. Or add --remote-debugging-port=9222 to your Chrome shortcut"));
     }
     console.log("");
   }
@@ -3362,41 +3252,41 @@ function printTable(rows, deviceName, watcherPid, cdpResult) {
       sessionNum++;
       const totalMem = servers.reduce((sum, s) => sum + (s.memory_mb ?? 0), 0);
       const label = byTty.size === 1 ? "Claude Code session" : `Claude Code session ${sessionNum}`;
-      console.log(chalk21.green(`  ${label}`) + chalk21.dim(` \u2014 ${servers.length} server${servers.length !== 1 ? "s" : ""} \xB7 ${totalMem} MB \xB7 terminal ${tty}`));
+      console.log(chalk20.green(`  ${label}`) + chalk20.dim(` \u2014 ${servers.length} server${servers.length !== 1 ? "s" : ""} \xB7 ${totalMem} MB \xB7 terminal ${tty}`));
       for (const s of servers) {
         const uptime = formatUptime(s.uptime_seconds ?? 0);
-        const source = chalk21.dim(`[${s.config_source}]`);
-        console.log(`    ${chalk21.green("\u25CF")} ${s.server_name.padEnd(20)} ${source} ${chalk21.dim((s.package_name ?? "").padEnd(25))} ${String(s.memory_mb ?? 0).padStart(4)} MB  ${uptime}`);
+        const source = chalk20.dim(`[${s.config_source}]`);
+        console.log(`    ${chalk20.green("\u25CF")} ${s.server_name.padEnd(20)} ${source} ${chalk20.dim((s.package_name ?? "").padEnd(25))} ${String(s.memory_mb ?? 0).padStart(4)} MB  ${uptime}`);
       }
       console.log("");
     }
     if (byTty.size > 1) {
-      console.log(chalk21.dim("  Each open Claude Code window runs its own set of MCP servers.\n"));
+      console.log(chalk20.dim("  Each open Claude Code window runs its own set of MCP servers.\n"));
     }
   }
   if (runningHttp.length > 0) {
-    console.log(chalk21.blue(`  Remote Services (${runningHttp.length})`) + chalk21.dim(" \u2014 HTTP endpoints reachable"));
+    console.log(chalk20.blue(`  Remote Services (${runningHttp.length})`) + chalk20.dim(" \u2014 HTTP endpoints reachable"));
     for (const s of runningHttp) {
-      console.log(`    ${chalk21.blue("\u25CF")} ${s.server_name.padEnd(20)} ${chalk21.dim((s.http_url ?? "").padEnd(30))}`);
+      console.log(`    ${chalk20.blue("\u25CF")} ${s.server_name.padEnd(20)} ${chalk20.dim((s.http_url ?? "").padEnd(30))}`);
     }
     console.log("");
   }
   if (stopped.length > 0 || errored.length > 0) {
     const notRunning = [...stopped, ...errored];
-    console.log(chalk21.yellow(`  Not Running (${notRunning.length})`) + chalk21.dim(" \u2014 configured but no process detected"));
+    console.log(chalk20.yellow(`  Not Running (${notRunning.length})`) + chalk20.dim(" \u2014 configured but no process detected"));
     for (const s of notRunning) {
-      const icon = s.status === "error" ? chalk21.red("\u2717") : chalk21.yellow("\u25CB");
-      const source = chalk21.dim(`[${s.config_source}]`);
-      const detail = s.error_detail ? chalk21.dim(` \u2014 ${s.error_detail}`) : "";
+      const icon = s.status === "error" ? chalk20.red("\u2717") : chalk20.yellow("\u25CB");
+      const source = chalk20.dim(`[${s.config_source}]`);
+      const detail = s.error_detail ? chalk20.dim(` \u2014 ${s.error_detail}`) : "";
       console.log(`    ${icon} ${s.server_name.padEnd(20)} ${source}${detail}`);
     }
     console.log("");
   }
   if (rows.length === 0) {
-    console.log(chalk21.yellow("  No MCP servers configured."));
-    console.log(chalk21.dim("  Configure servers in ~/.claude/mcp.json or .mcp.json\n"));
+    console.log(chalk20.yellow("  No MCP servers configured."));
+    console.log(chalk20.dim("  Configure servers in ~/.claude/mcp.json or .mcp.json\n"));
   }
-  console.log(chalk21.bgYellow.black.bold("  \u26A0  DO NOT CLOSE THIS WINDOW \u2014 it feeds live data to the dashboard  \u26A0  "));
+  console.log(chalk20.bgYellow.black.bold("  \u26A0  DO NOT CLOSE THIS WINDOW \u2014 it feeds live data to the dashboard  \u26A0  "));
   console.log("");
 }
 function formatUptime(seconds) {
@@ -3426,7 +3316,7 @@ async function mcpWatchCommand() {
   const { data: existingWatchers } = await supabase.from("mcp_watchers").select("pid, tty, cli_version, started_at").eq("device_id", deviceId);
   if (existingWatchers && existingWatchers.length > 0) {
     console.log("");
-    console.log(chalk21.yellow(`  Replacing ${existingWatchers.length} existing watcher${existingWatchers.length !== 1 ? "s" : ""} on this device...`));
+    console.log(chalk20.yellow(`  Replacing ${existingWatchers.length} existing watcher${existingWatchers.length !== 1 ? "s" : ""} on this device...`));
     for (const w of existingWatchers) {
       try {
         if (typeof w.pid === "number" && w.pid > 1 && w.pid !== process.pid) {
@@ -3437,15 +3327,15 @@ async function mcpWatchCommand() {
     }
     await supabase.from("mcp_watchers").delete().eq("device_id", deviceId);
     await new Promise((r) => setTimeout(r, 1e3));
-    console.log(chalk21.dim("  Previous watcher stopped.\n"));
+    console.log(chalk20.dim("  Previous watcher stopped.\n"));
   }
   process.stdout.write(`\x1B]0;MCP mon\x07`);
-  console.log(chalk21.blue(`Starting MCP monitor for ${deviceName}...`));
+  console.log(chalk20.blue(`Starting MCP monitor for ${deviceName}...`));
   console.log("");
-  console.log(chalk21.dim("  View this in the online dashboard at:"));
-  console.log(chalk21.cyan(`  https://www.md4ai.com/device/${deviceId}`));
+  console.log(chalk20.dim("  View this in the online dashboard at:"));
+  console.log(chalk20.cyan(`  https://www.md4ai.com/device/${deviceId}`));
   console.log("");
-  console.log(chalk21.yellow("  Please note, closing this window will stop ALL watch reports."));
+  console.log(chalk20.yellow("  Please note, closing this window will stop ALL watch reports."));
   console.log("");
   await supabase.from("mcp_watchers").upsert({
     device_id: deviceId,
@@ -3475,7 +3365,7 @@ async function mcpWatchCommand() {
       return;
     }
     if (deleteError) {
-      console.error(chalk21.red(`  [debug] Failed to delete old status: ${deleteError.message}`));
+      console.error(chalk20.red(`  [debug] Failed to delete old status: ${deleteError.message}`));
     }
     if (rows.length > 0) {
       const { error: insertError } = await supabase.from("mcp_server_status").insert(rows.map((row) => ({
@@ -3488,7 +3378,7 @@ async function mcpWatchCommand() {
         return;
       }
       if (insertError) {
-        console.error(chalk21.red(`  [debug] Failed to write MCP status: ${insertError.message}`));
+        console.error(chalk20.red(`  [debug] Failed to write MCP status: ${insertError.message}`));
       }
     }
     const { error: heartbeatError } = await supabase.from("mcp_watchers").update({ last_heartbeat: now }).eq("device_id", deviceId).eq("pid", myPid);
@@ -3506,11 +3396,11 @@ async function mcpWatchCommand() {
       return;
     }
     jwtRefreshAttempted = true;
-    console.log(chalk21.yellow("\n  Session token expired \u2014 attempting to refresh..."));
+    console.log(chalk20.yellow("\n  Session token expired \u2014 attempting to refresh..."));
     const refreshed = await refreshSession();
     if (refreshed) {
       supabase = refreshed.supabase;
-      console.log(chalk21.green("  Session refreshed successfully. Resuming monitoring.\n"));
+      console.log(chalk20.green("  Session refreshed successfully. Resuming monitoring.\n"));
       jwtRefreshAttempted = false;
       await supabase.from("mcp_watchers").upsert({
         device_id: deviceId,
@@ -3528,14 +3418,14 @@ async function mcpWatchCommand() {
   function printSessionExpired() {
     process.stdout.write("\x1B[3J\x1B[2J\x1B[H");
     console.log("");
-    console.log(chalk21.bgRed.white.bold("  \u2717  SESSION EXPIRED \u2014 this watcher is no longer sending data to the dashboard  \u2717  "));
+    console.log(chalk20.bgRed.white.bold("  \u2717  SESSION EXPIRED \u2014 this watcher is no longer sending data to the dashboard  \u2717  "));
     console.log("");
-    console.log(chalk21.yellow("  Your authentication token has expired and could not be refreshed."));
-    console.log(chalk21.yellow('  The dashboard will show "No watchers" because this process can no longer update it.'));
+    console.log(chalk20.yellow("  Your authentication token has expired and could not be refreshed."));
+    console.log(chalk20.yellow('  The dashboard will show "No watchers" because this process can no longer update it.'));
     console.log("");
-    console.log(chalk21.white("  To fix this:"));
-    console.log(chalk21.cyan("    1. Run: md4ai login"));
-    console.log(chalk21.cyan("    2. Then restart the watcher: md4ai mcp-watch"));
+    console.log(chalk20.white("  To fix this:"));
+    console.log(chalk20.cyan("    1. Run: md4ai login"));
+    console.log(chalk20.cyan("    2. Then restart the watcher: md4ai mcp-watch"));
     console.log("");
   }
   let interval;
@@ -3578,7 +3468,7 @@ async function mcpWatchCommand() {
     clearInterval(interval);
     clearInterval(envInterval);
     await supabase.from("mcp_watchers").delete().eq("device_id", deviceId).eq("pid", myPid);
-    console.log(chalk21.dim("\nMCP monitor stopped."));
+    console.log(chalk20.dim("\nMCP monitor stopped."));
     process.exit(0);
   };
   process.on("SIGINT", () => {
@@ -3593,12 +3483,13 @@ async function checkPendingRescans(supabase, deviceId, deviceName) {
   if (!paths?.length)
     return;
   const folderIds = paths.map((p) => p.folder_id);
-  const { data: folders } = await supabase.from("claude_folders").select("id, last_scanned, rescan_requested_at").in("id", folderIds).not("rescan_requested_at", "is", null);
+  const { data: folders } = await supabase.from("claude_folders").select("id, rescan_requested_at").in("id", folderIds).not("rescan_requested_at", "is", null);
   if (!folders?.length)
     return;
   for (const folder of folders) {
     const requested = new Date(folder.rescan_requested_at).getTime();
-    const scanned = folder.last_scanned ? new Date(folder.last_scanned).getTime() : 0;
+    const { data: scanRow } = await supabase.from("device_scans").select("scanned_at").eq("folder_id", folder.id).eq("device_id", deviceId).maybeSingle();
+    const scanned = scanRow?.scanned_at ? new Date(scanRow.scanned_at).getTime() : 0;
     if (requested <= scanned)
       continue;
     const dp = paths.find((p) => p.folder_id === folder.id);
@@ -3606,24 +3497,46 @@ async function checkPendingRescans(supabase, deviceId, deviceName) {
       continue;
     try {
       const result = await scanProject(dp.path);
-      await supabase.from("device_scans").upsert({
+      const userId = (await supabase.auth.getUser()).data.user.id;
+      const scanPayload = {
         folder_id: folder.id,
         device_id: deviceId,
-        user_id: (await supabase.auth.getUser()).data.user.id,
+        user_id: userId,
         graph_json: result.graph,
         orphans_json: result.orphans,
         skills_table_json: result.skills,
         stale_files_json: result.staleFiles,
         broken_refs_json: result.brokenRefs,
         env_manifest_json: result.envManifest,
+        doppler_json: result.doppler,
+        marketplace_plugins_json: result.marketplacePlugins,
+        plugin_versions_json: result.pluginVersions,
         data_hash: result.dataHash,
         scanned_at: result.scannedAt,
         cli_version: CURRENT_VERSION
-      }, { onConflict: "folder_id,device_id" });
+      };
+      const { data: updated } = await supabase.from("device_scans").update(scanPayload).eq("folder_id", folder.id).eq("device_id", deviceId).select("id");
+      if (!updated?.length) {
+        await supabase.from("device_scans").insert(scanPayload);
+      }
       await supabase.from("claude_folders").update({
         rescan_requested_at: null
       }).eq("id", folder.id);
       await pushToolings(supabase, folder.id, result.toolings, deviceId);
+      const graphPaths = result.graph.nodes.map((n) => n.filePath);
+      const { readClaudeConfigFiles: readClaudeConfigFiles2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
+      const configFiles = await readClaudeConfigFiles2(dp.path, graphPaths);
+      for (const cf of configFiles) {
+        await supabase.from("folder_files").upsert({
+          folder_id: folder.id,
+          file_path: cf.filePath,
+          content: cf.content,
+          size_bytes: cf.sizeBytes,
+          last_modified: cf.lastModified,
+          synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+          device_id: deviceId
+        }, { onConflict: "folder_id,file_path,device_id" });
+      }
       await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", folder.id).eq("device_name", deviceName);
     } catch {
       await supabase.from("claude_folders").update({ rescan_requested_at: null }).eq("id", folder.id);
@@ -3648,6 +3561,130 @@ var init_mcp_watch = __esm({
   }
 });
 
+// dist/commands/sync.js
+var sync_exports = {};
+__export(sync_exports, {
+  syncCommand: () => syncCommand
+});
+import { resolve as resolve8 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import chalk22 from "chalk";
+function isValidProjectPath(p) {
+  const resolved = resolve8(p);
+  return resolved.startsWith("/") && !resolved.includes("..") && existsSync14(resolved);
+}
+async function syncCommand(options) {
+  const { supabase, userId } = await getAuthenticatedClient();
+  if (options.all) {
+    const currentDeviceName = detectDeviceName();
+    const { data: devices, error } = await supabase.from("device_paths").select("folder_id, device_name, path").eq("device_name", currentDeviceName);
+    if (error || !devices?.length) {
+      console.log(chalk22.yellow(`
+  No projects linked on ${currentDeviceName} yet.
+`));
+      console.log(chalk22.dim("  To link a project, cd into its folder and run:"));
+      console.log(chalk22.cyan("    md4ai scan"));
+      console.log(chalk22.dim("  Or link an existing project from the dashboard:"));
+      console.log(chalk22.cyan("    md4ai link <project-id>\n"));
+      return;
+    }
+    for (const device of devices) {
+      if (!isValidProjectPath(device.path)) {
+        console.error(chalk22.red(`  Skipping invalid path: ${device.path}`));
+        continue;
+      }
+      console.log(chalk22.blue(`Syncing: ${device.path}`));
+      const { data: proposedAll } = await supabase.from("folder_files").select("file_path").eq("folder_id", device.folder_id).eq("proposed_for_deletion", true);
+      if (proposedAll?.length) {
+        console.log(chalk22.yellow(`  ${proposedAll.length} file(s) proposed for deletion \u2014 run \`md4ai scan\` to review.`));
+      }
+      try {
+        const result = await scanProject(device.path, device.folder_id);
+        const { data: allDeviceRow } = await supabase.from("devices").select("id").eq("user_id", userId).eq("device_name", device.device_name).single();
+        const allDeviceId = allDeviceRow?.id;
+        if (allDeviceId) {
+          await supabase.from("device_scans").upsert({
+            folder_id: device.folder_id,
+            device_id: allDeviceId,
+            user_id: userId,
+            graph_json: result.graph,
+            orphans_json: result.orphans,
+            skills_table_json: result.skills,
+            stale_files_json: result.staleFiles,
+            broken_refs_json: result.brokenRefs,
+            env_manifest_json: result.envManifest,
+            plugin_versions_json: result.pluginVersions,
+            data_hash: result.dataHash,
+            scanned_at: result.scannedAt,
+            cli_version: CURRENT_VERSION
+          }, { onConflict: "folder_id,device_id" });
+        }
+        await pushToolings(supabase, device.folder_id, result.toolings, allDeviceId);
+        await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
+        console.log(chalk22.green(`  Done: ${device.device_name}`));
+      } catch (err) {
+        console.error(chalk22.red(`  Failed: ${device.path}: ${err}`));
+      }
+    }
+    await saveState({ lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
+    console.log(chalk22.green("\nAll devices synced."));
+  } else {
+    const state = await loadState();
+    if (!state.lastFolderId) {
+      console.error(chalk22.yellow("No recent sync. Use: md4ai sync --all, or md4ai scan <path> first."));
+      process.exit(1);
+    }
+    const { data: device } = await supabase.from("device_paths").select("folder_id, device_name, path").eq("folder_id", state.lastFolderId).eq("device_name", state.lastDeviceName).single();
+    if (!device) {
+      console.error(chalk22.red("Could not find last synced device/folder."));
+      process.exit(1);
+    }
+    if (!isValidProjectPath(device.path)) {
+      console.error(chalk22.red(`Invalid project path: ${device.path}`));
+      process.exit(1);
+    }
+    console.log(chalk22.blue(`Syncing: ${device.path}`));
+    const { data: proposedSingle } = await supabase.from("folder_files").select("file_path").eq("folder_id", device.folder_id).eq("proposed_for_deletion", true);
+    if (proposedSingle?.length) {
+      console.log(chalk22.yellow(`  ${proposedSingle.length} file(s) proposed for deletion \u2014 run \`md4ai scan\` to review.`));
+    }
+    const result = await scanProject(device.path, device.folder_id);
+    const { data: singleDeviceRow } = await supabase.from("devices").select("id").eq("user_id", userId).eq("device_name", device.device_name).single();
+    const singleDeviceId = singleDeviceRow?.id;
+    if (singleDeviceId) {
+      await supabase.from("device_scans").upsert({
+        folder_id: device.folder_id,
+        device_id: singleDeviceId,
+        user_id: userId,
+        graph_json: result.graph,
+        orphans_json: result.orphans,
+        skills_table_json: result.skills,
+        stale_files_json: result.staleFiles,
+        broken_refs_json: result.brokenRefs,
+        plugin_versions_json: result.pluginVersions,
+        data_hash: result.dataHash,
+        scanned_at: result.scannedAt,
+        cli_version: CURRENT_VERSION
+      }, { onConflict: "folder_id,device_id" });
+    }
+    await pushToolings(supabase, device.folder_id, result.toolings, singleDeviceId);
+    await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
+    await saveState({ lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
+    console.log(chalk22.green("Synced."));
+  }
+}
+var init_sync = __esm({
+  "dist/commands/sync.js"() {
+    "use strict";
+    init_auth();
+    init_config();
+    init_scanner();
+    init_push_toolings();
+    init_check_update();
+    init_device_utils();
+  }
+});
+
 // dist/index.js
 import { Command } from "commander";
 
@@ -4012,9 +4049,6 @@ function generatePrintHtml(result, title) {
 </html>`;
 }
 
-// dist/index.js
-init_sync();
-
 // dist/commands/link.js
 init_auth();
 init_config();
@@ -4022,23 +4056,23 @@ init_scanner();
 init_push_toolings();
 init_device_utils();
 init_check_update();
-import { resolve as resolve6 } from "node:path";
-import chalk16 from "chalk";
+import { resolve as resolve5 } from "node:path";
+import chalk15 from "chalk";
 async function linkCommand(projectId) {
   const shouldContinue = await promptUpdateIfAvailable(["link", projectId]);
   if (!shouldContinue)
     return;
   const { supabase, userId } = await getAuthenticatedClient();
-  const cwd = resolve6(process.cwd());
+  const cwd = resolve5(process.cwd());
   const deviceName = detectDeviceName();
   const osType = detectOs();
   const { data: folder, error: folderErr } = await supabase.from("claude_folders").select("id, name").eq("id", projectId).single();
   if (folderErr || !folder) {
-    console.error(chalk16.red("Project not found, or you do not have access."));
-    console.error(chalk16.yellow("Check the project ID in the MD4AI web dashboard."));
+    console.error(chalk15.red("Project not found, or you do not have access."));
+    console.error(chalk15.yellow("Check the project ID in the MD4AI web dashboard."));
     process.exit(1);
   }
-  console.log(chalk16.blue(`
+  console.log(chalk15.blue(`
 Linking "${folder.name}" to this device...
 `));
   console.log(`  Project:  ${folder.name}`);
@@ -4064,12 +4098,12 @@ Linking "${folder.name}" to this device...
       path: cwd
     });
     if (pathErr) {
-      console.error(chalk16.red(`Failed to link: ${pathErr.message}`));
+      console.error(chalk15.red(`Failed to link: ${pathErr.message}`));
       process.exit(1);
     }
   }
-  console.log(chalk16.green("\nLinked successfully."));
-  console.log(chalk16.blue("\nRunning initial scan...\n"));
+  console.log(chalk15.green("\nLinked successfully."));
+  console.log(chalk15.blue("\nRunning initial scan...\n"));
   const result = await scanProject(cwd, folder.id);
   console.log(`  Files:     ${result.graph.nodes.length}`);
   console.log(`  References:${result.graph.edges.length}`);
@@ -4110,7 +4144,7 @@ Linking "${folder.name}" to this device...
         device_id: deviceId
       }, { onConflict: "folder_id,file_path,device_id" });
     }
-    console.log(chalk16.green(`  Uploaded ${configFiles.length} config file(s).`));
+    console.log(chalk15.green(`  Uploaded ${configFiles.length} config file(s).`));
   }
   await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", folder.id).eq("device_name", deviceName);
   await saveState({
@@ -4119,28 +4153,28 @@ Linking "${folder.name}" to this device...
     lastSyncAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const projectUrl = `https://www.md4ai.com/project/${folder.id}`;
-  console.log(chalk16.green("\nDone! Project linked and scanned."));
-  console.log(chalk16.cyan(`
+  console.log(chalk15.green("\nDone! Project linked and scanned."));
+  console.log(chalk15.cyan(`
   ${projectUrl}
 `));
-  console.log(chalk16.grey('Run "md4ai scan" to rescan at any time.'));
+  console.log(chalk15.grey('Run "md4ai scan" to rescan at any time.'));
 }
 
 // dist/commands/import-bundle.js
 import { readFile as readFile11, writeFile as writeFile4, mkdir as mkdir3, stat as fsStat } from "node:fs/promises";
-import { dirname as dirname3, resolve as resolve7 } from "node:path";
-import { existsSync as existsSync12 } from "node:fs";
-import chalk17 from "chalk";
+import { dirname as dirname3, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
+import chalk16 from "chalk";
 import { confirm as confirm3, input as input6 } from "@inquirer/prompts";
 var MAX_BUNDLE_SIZE_BYTES = 50 * 1024 * 1024;
 async function importBundleCommand(zipPath) {
-  if (!existsSync12(zipPath)) {
-    console.error(chalk17.red(`File not found: ${zipPath}`));
+  if (!existsSync11(zipPath)) {
+    console.error(chalk16.red(`File not found: ${zipPath}`));
     process.exit(1);
   }
   const fileStat = await fsStat(zipPath);
   if (fileStat.size > MAX_BUNDLE_SIZE_BYTES) {
-    console.error(chalk17.red(`Bundle too large (${Math.round(fileStat.size / 1024 / 1024)} MB). Maximum is 50 MB.`));
+    console.error(chalk16.red(`Bundle too large (${Math.round(fileStat.size / 1024 / 1024)} MB). Maximum is 50 MB.`));
     process.exit(1);
   }
   const JSZip = (await import("jszip")).default;
@@ -4148,11 +4182,11 @@ async function importBundleCommand(zipPath) {
   const zip = await JSZip.loadAsync(zipData);
   const manifestFile = zip.file("manifest.json");
   if (!manifestFile) {
-    console.error(chalk17.red("Invalid bundle: missing manifest.json"));
+    console.error(chalk16.red("Invalid bundle: missing manifest.json"));
     process.exit(1);
   }
   const manifest = JSON.parse(await manifestFile.async("string"));
-  console.log(chalk17.blue(`
+  console.log(chalk16.blue(`
 Bundle: ${manifest.folderName}`));
   console.log(`  Exported by: ${manifest.ownerEmail}`);
   console.log(`  Exported at: ${manifest.exportedAt}`);
@@ -4166,10 +4200,10 @@ Bundle: ${manifest.folderName}`));
     }
   }
   if (files.length === 0) {
-    console.log(chalk17.yellow("No Claude config files found in bundle."));
+    console.log(chalk16.yellow("No Claude config files found in bundle."));
     return;
   }
-  console.log(chalk17.blue(`
+  console.log(chalk16.blue(`
 Files to extract:`));
   for (const f of files) {
     console.log(`  ${f.filePath}`);
@@ -4182,39 +4216,39 @@ Files to extract:`));
     message: `Extract ${files.length} file(s) to ${targetDir}?`
   });
   if (!proceed) {
-    console.log(chalk17.yellow("Cancelled."));
+    console.log(chalk16.yellow("Cancelled."));
     return;
   }
-  const resolvedTarget = resolve7(targetDir);
+  const resolvedTarget = resolve6(targetDir);
   for (const file of files) {
-    const fullPath = resolve7(targetDir, file.filePath);
+    const fullPath = resolve6(targetDir, file.filePath);
     if (!fullPath.startsWith(resolvedTarget + "/") && fullPath !== resolvedTarget) {
-      console.error(chalk17.red(`  Blocked path traversal: ${file.filePath}`));
+      console.error(chalk16.red(`  Blocked path traversal: ${file.filePath}`));
       continue;
     }
     const dir = dirname3(fullPath);
-    if (!existsSync12(dir)) {
+    if (!existsSync11(dir)) {
       await mkdir3(dir, { recursive: true });
     }
     await writeFile4(fullPath, file.content, "utf-8");
-    console.log(chalk17.green(`  \u2713 ${file.filePath}`));
+    console.log(chalk16.green(`  \u2713 ${file.filePath}`));
   }
-  console.log(chalk17.green(`
+  console.log(chalk16.green(`
 Done! ${files.length} file(s) extracted to ${targetDir}`));
 }
 
 // dist/commands/admin-update-tool.js
 init_auth();
-import chalk18 from "chalk";
+import chalk17 from "chalk";
 var VALID_CATEGORIES = ["framework", "runtime", "cli", "mcp", "package", "database", "other"];
 async function adminUpdateToolCommand(options) {
   const { supabase } = await getAuthenticatedClient();
   if (!options.name) {
-    console.error(chalk18.red("--name is required."));
+    console.error(chalk17.red("--name is required."));
     process.exit(1);
   }
   if (options.category && !VALID_CATEGORIES.includes(options.category)) {
-    console.error(chalk18.red(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`));
+    console.error(chalk17.red(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`));
     process.exit(1);
   }
   const { data: existing } = await supabase.from("tools_registry").select("id, name, display_name, category").eq("name", options.name).maybeSingle();
@@ -4236,13 +4270,13 @@ async function adminUpdateToolCommand(options) {
       updates.notes = options.notes;
     const { error } = await supabase.from("tools_registry").update(updates).eq("id", existing.id);
     if (error) {
-      console.error(chalk18.red(`Failed to update: ${error.message}`));
+      console.error(chalk17.red(`Failed to update: ${error.message}`));
       process.exit(1);
     }
-    console.log(chalk18.green(`Updated "${existing.display_name}" in the registry.`));
+    console.log(chalk17.green(`Updated "${existing.display_name}" in the registry.`));
   } else {
     if (!options.display || !options.category) {
-      console.error(chalk18.red("New tools require --display and --category."));
+      console.error(chalk17.red("New tools require --display and --category."));
       process.exit(1);
     }
     const { error } = await supabase.from("tools_registry").insert({
@@ -4256,25 +4290,25 @@ async function adminUpdateToolCommand(options) {
       notes: options.notes ?? null
     });
     if (error) {
-      console.error(chalk18.red(`Failed to create: ${error.message}`));
+      console.error(chalk17.red(`Failed to create: ${error.message}`));
       process.exit(1);
     }
-    console.log(chalk18.green(`Added "${options.display}" to the registry.`));
+    console.log(chalk17.green(`Added "${options.display}" to the registry.`));
   }
 }
 
 // dist/commands/admin-list-tools.js
 init_auth();
-import chalk19 from "chalk";
+import chalk18 from "chalk";
 async function adminListToolsCommand() {
   const { supabase } = await getAuthenticatedClient();
   const { data: tools, error } = await supabase.from("tools_registry").select("*").order("category").order("display_name");
   if (error) {
-    console.error(chalk19.red(`Failed to fetch tools: ${error.message}`));
+    console.error(chalk18.red(`Failed to fetch tools: ${error.message}`));
     process.exit(1);
   }
   if (!tools?.length) {
-    console.log(chalk19.yellow("No tools in the registry."));
+    console.log(chalk18.yellow("No tools in the registry."));
     return;
   }
   const nameW = Math.max(16, ...tools.map((t) => t.display_name.length));
@@ -4288,7 +4322,7 @@ async function adminListToolsCommand() {
     "Beta".padEnd(betaW),
     "Last Checked"
   ].join("  ");
-  console.log(chalk19.bold(header));
+  console.log(chalk18.bold(header));
   console.log("\u2500".repeat(header.length));
   for (const tool of tools) {
     const lastChecked = tool.updated_at ? formatRelative(new Date(tool.updated_at)) : "\u2014";
@@ -4301,7 +4335,7 @@ async function adminListToolsCommand() {
     ].join("  ");
     console.log(row);
   }
-  console.log(chalk19.grey(`
+  console.log(chalk18.grey(`
 ${tools.length} tool(s) in registry.`));
 }
 function formatRelative(date) {
@@ -4319,7 +4353,7 @@ function formatRelative(date) {
 
 // dist/commands/admin-fetch-versions.js
 init_auth();
-import chalk20 from "chalk";
+import chalk19 from "chalk";
 
 // dist/commands/version-sources.js
 var VERSION_SOURCES = {
@@ -4340,7 +4374,15 @@ var VERSION_SOURCES = {
   "turborepo": { type: "npm", package: "turbo" },
   "npm": { type: "npm", package: "npm" },
   "node": { type: "github", repo: "nodejs/node" },
-  "supabase-cli": { type: "npm", package: "supabase" }
+  "supabase-cli": { type: "npm", package: "supabase" },
+  "vercel-cli": { type: "npm", package: "vercel" },
+  "@sentry/node": { type: "npm", package: "@sentry/node" },
+  "react-markdown": { type: "npm", package: "react-markdown" },
+  "rehype-sanitize": { type: "npm", package: "rehype-sanitize" },
+  "@react-email/render": { type: "npm", package: "@react-email/render" },
+  "@anthropic-ai/sdk": { type: "npm", package: "@anthropic-ai/sdk" },
+  "@xyflow/react": { type: "npm", package: "@xyflow/react" },
+  "fflate": { type: "npm", package: "fflate" }
 };
 
 // dist/commands/admin-fetch-versions.js
@@ -4348,11 +4390,11 @@ async function adminFetchVersionsCommand() {
   const { supabase } = await getAuthenticatedClient();
   const { data: tools, error } = await supabase.from("tools_registry").select("*").order("display_name");
   if (error) {
-    console.error(chalk20.red(`Failed to fetch tools: ${error.message}`));
+    console.error(chalk19.red(`Failed to fetch tools: ${error.message}`));
     process.exit(1);
   }
   if (!tools?.length) {
-    console.log(chalk20.yellow("No tools in the registry."));
+    console.log(chalk19.yellow("No tools in the registry."));
   }
   const { data: allProjectToolings } = await supabase.from("project_toolings").select("tool_name, detection_source").is("tool_id", null);
   const registeredNames = new Set((tools ?? []).map((t) => t.name));
@@ -4363,7 +4405,7 @@ async function adminFetchVersionsCommand() {
     }
   }
   if (unregisteredNames.size > 0) {
-    console.log(chalk20.blue(`Auto-registering ${unregisteredNames.size} unverified package(s)...
+    console.log(chalk19.blue(`Auto-registering ${unregisteredNames.size} unverified package(s)...
 `));
     for (const name of unregisteredNames) {
       const displayName = name;
@@ -4381,10 +4423,10 @@ async function adminFetchVersionsCommand() {
     }
   }
   if (!tools?.length) {
-    console.log(chalk20.yellow("No tools to fetch."));
+    console.log(chalk19.yellow("No tools to fetch."));
     return;
   }
-  console.log(chalk20.bold(`Fetching versions for ${tools.length} tool(s)...
+  console.log(chalk19.bold(`Fetching versions for ${tools.length} tool(s)...
 `));
   const results = await Promise.all(tools.map(async (tool) => {
     const source = VERSION_SOURCES[tool.name] ?? { type: "npm", package: tool.name };
@@ -4423,10 +4465,10 @@ async function adminFetchVersionsCommand() {
     "Beta".padEnd(betaW),
     "Status".padEnd(statusW)
   ].join("  ");
-  console.log(chalk20.bold(header));
+  console.log(chalk19.bold(header));
   console.log("\u2500".repeat(header.length));
   for (const result of results) {
-    const statusColour = result.status === "updated" ? chalk20.green : result.status === "unchanged" ? chalk20.grey : result.status === "failed" ? chalk20.red : chalk20.yellow;
+    const statusColour = result.status === "updated" ? chalk19.green : result.status === "unchanged" ? chalk19.grey : result.status === "failed" ? chalk19.red : chalk19.yellow;
     const row = [
       result.displayName.padEnd(nameW),
       (result.stable ?? "\u2014").padEnd(stableW),
@@ -4439,8 +4481,8 @@ async function adminFetchVersionsCommand() {
   const unchanged = results.filter((r) => r.status === "unchanged").length;
   const failed = results.filter((r) => r.status === "failed").length;
   const noSource = results.filter((r) => r.status === "no source").length;
-  console.log(chalk20.grey(`
-${results.length} tool(s): `) + chalk20.green(`${updated} updated`) + ", " + chalk20.grey(`${unchanged} unchanged`) + ", " + chalk20.red(`${failed} failed`) + ", " + chalk20.yellow(`${noSource} no source`));
+  console.log(chalk19.grey(`
+${results.length} tool(s): `) + chalk19.green(`${updated} updated`) + ", " + chalk19.grey(`${unchanged} unchanged`) + ", " + chalk19.red(`${failed} failed`) + ", " + chalk19.yellow(`${noSource} no source`));
 }
 async function fetchVersions(source) {
   const controller = new AbortController();
@@ -4498,10 +4540,10 @@ async function fetchGitHubVersions(repo, signal) {
 init_mcp_watch();
 
 // dist/commands/init-manifest.js
-import { resolve as resolve8, join as join16, relative as relative4, dirname as dirname4 } from "node:path";
+import { resolve as resolve7, join as join16, relative as relative4, dirname as dirname4 } from "node:path";
 import { readFile as readFile13, writeFile as writeFile5, mkdir as mkdir4 } from "node:fs/promises";
-import { existsSync as existsSync14 } from "node:fs";
-import chalk22 from "chalk";
+import { existsSync as existsSync13 } from "node:fs";
+import chalk21 from "chalk";
 var SECRET_PATTERNS = [
   /_KEY$/i,
   /_SECRET$/i,
@@ -4518,7 +4560,7 @@ async function discoverEnvFiles(projectRoot) {
   const apps = [];
   for (const envName of [".env", ".env.local", ".env.example"]) {
     const envPath = join16(projectRoot, envName);
-    if (existsSync14(envPath)) {
+    if (existsSync13(envPath)) {
       const vars = await extractVarNames(envPath);
       if (vars.length > 0) {
         apps.push({ name: "root", envFilePath: envName, vars });
@@ -4529,11 +4571,11 @@ async function discoverEnvFiles(projectRoot) {
   const subdirs = ["web", "cli", "api", "app", "server", "packages"];
   for (const sub of subdirs) {
     const subDir = join16(projectRoot, sub);
-    if (!existsSync14(subDir))
+    if (!existsSync13(subDir))
       continue;
     for (const envName of [".env.local", ".env", ".env.example"]) {
       const envPath = join16(subDir, envName);
-      if (existsSync14(envPath)) {
+      if (existsSync13(envPath)) {
         const vars = await extractVarNames(envPath);
         if (vars.length > 0) {
           apps.push({
@@ -4593,33 +4635,33 @@ function generateManifest(apps) {
   return lines.join("\n");
 }
 async function initManifestCommand() {
-  const projectRoot = resolve8(process.cwd());
+  const projectRoot = resolve7(process.cwd());
   const manifestPath = join16(projectRoot, "docs", "reference", "env-manifest.md");
-  if (existsSync14(manifestPath)) {
-    console.log(chalk22.yellow(`Manifest already exists: ${relative4(projectRoot, manifestPath)}`));
-    console.log(chalk22.dim("Edit it directly to make changes."));
+  if (existsSync13(manifestPath)) {
+    console.log(chalk21.yellow(`Manifest already exists: ${relative4(projectRoot, manifestPath)}`));
+    console.log(chalk21.dim("Edit it directly to make changes."));
     return;
   }
-  console.log(chalk22.blue("Scanning for .env files...\n"));
+  console.log(chalk21.blue("Scanning for .env files...\n"));
   const apps = await discoverEnvFiles(projectRoot);
   if (apps.length === 0) {
-    console.log(chalk22.yellow("No .env files found. Create a manifest manually at:"));
-    console.log(chalk22.cyan(`  docs/reference/env-manifest.md`));
+    console.log(chalk21.yellow("No .env files found. Create a manifest manually at:"));
+    console.log(chalk21.cyan(`  docs/reference/env-manifest.md`));
     return;
   }
   for (const app of apps) {
-    console.log(`  ${chalk22.green(app.name)}: ${app.envFilePath} (${app.vars.length} vars)`);
+    console.log(`  ${chalk21.green(app.name)}: ${app.envFilePath} (${app.vars.length} vars)`);
   }
   const content = generateManifest(apps);
   const dir = dirname4(manifestPath);
-  if (!existsSync14(dir)) {
+  if (!existsSync13(dir)) {
     await mkdir4(dir, { recursive: true });
   }
   await writeFile5(manifestPath, content, "utf-8");
-  console.log(chalk22.green(`
+  console.log(chalk21.green(`
 Manifest created: ${relative4(projectRoot, manifestPath)}`));
-  console.log(chalk22.dim("Review and edit the file \u2014 it is your source of truth."));
-  console.log(chalk22.dim("Then run `md4ai scan` to verify against your environments."));
+  console.log(chalk21.dim("Review and edit the file \u2014 it is your source of truth."));
+  console.log(chalk21.dim("Then run `md4ai scan` to verify against your environments."));
 }
 
 // dist/commands/update.js
@@ -5028,32 +5070,39 @@ init_check_update();
 var program = new Command();
 program.name("md4ai").description("MD4AI \u2014 Claude tooling visualiser").version(CURRENT_VERSION).addHelpText("after", `
 Quick start:
-  md4ai start    Check for updates, scan project, and start MCP monitoring
-  md4ai          Same as md4ai start (when run in a linked project folder)`);
+  md4ai login               Log in with email and password
+  md4ai link <project-id>   Link this folder to a dashboard project
+  md4ai scan                Scan project and push to dashboard
+
+Daily use:
+  md4ai                     Scan + start MCP monitoring (all-in-one)
+
+More:
+  md4ai config ...          Configuration (tokens, settings)
+  md4ai doppler ...         Doppler secrets integration
+  md4ai admin ...           Advanced tools (simulate, print, import, etc.)`);
 program.command("start").description("Check for updates, scan project, and start MCP monitoring \u2014 the all-in-one command").action(startCommand);
 program.command("login").description("Log in to MD4AI with email and password").action(loginCommand);
 program.command("logout").description("Log out and clear stored credentials").action(logoutCommand);
 program.command("status").description("Show login status, device count, folder count, last sync").action(statusCommand);
-program.command("add-folder").description("Create a new Claude folder").action(addFolderCommand);
-program.command("add-device").description("Add a device path to a Claude folder").action(addDeviceCommand);
-program.command("list-devices").description("List all devices and their linked folders").action(listDevicesCommand);
 program.command("link <project-id>").description("Link the current directory to a project created in the web dashboard").action(linkCommand);
 program.command("scan [path]").description("Scan Claude project files and push results to your dashboard").option("--offline", "Skip pushing to Supabase").action(mapCommand);
-program.command("simulate <prompt>").description("Show which files Claude would load for a given prompt").action(simulateCommand);
-program.command("print <title>").description("Generate a printable wall-chart HTML from the last scan").action(printCommand);
-program.command("sync").description("Re-push latest scan data to Supabase").option("--all", "Sync all folders on all devices").action(syncCommand);
-program.command("import <zipfile>").description("Import a Claude setup bundle exported from the web dashboard").action(importBundleCommand);
-program.command("update").description("Check for updates, install, and optionally rescan and start watching").option("--post-update", "Internal: run post-update flow (called by the update command)").action(updateCommand);
-program.command("check-update").description("Check if a newer version of md4ai is available").action(checkForUpdate);
 program.command("mcp-watch").description("Monitor MCP server status on this device (runs until Ctrl+C)").action(mcpWatchCommand);
-program.command("init-manifest").description("Scaffold a starter env-manifest.md from detected .env files").action(initManifestCommand);
+program.command("update").description("Check for updates, install, and optionally rescan and start watching").option("--post-update", "Internal: run post-update flow (called by the update command)").action(updateCommand);
 var config = program.command("config").description("Manage CLI configuration");
 config.command("set <key> <value>").description("Set a configuration value (e.g. vercel-token)").action(configSetCommand);
 var doppler = program.command("doppler").description("Manage Doppler integration");
 doppler.command("connect").description("Configure Doppler token for secrets scanning").action(dopplerConnectCommand);
 doppler.command("disconnect").description("Remove stored Doppler token").action(dopplerDisconnectCommand);
 doppler.command("set-project <slug>").description("Override Doppler project slug for the current linked project").action(dopplerSetProjectCommand);
-var admin = program.command("admin").description("Admin commands for managing the tools registry");
+var admin = program.command("admin").description("Advanced tools \u2014 simulate, print, import, device management, registry");
+admin.command("simulate <prompt>").description("Show which files Claude would load for a given prompt").action(simulateCommand);
+admin.command("print <title>").description("Generate a printable wall-chart HTML from the last scan").action(printCommand);
+admin.command("import <zipfile>").description("Import a Claude setup bundle exported from the web dashboard").action(importBundleCommand);
+admin.command("init-manifest").description("Scaffold a starter env-manifest.md from detected .env files").action(initManifestCommand);
+admin.command("list-devices").description("List all devices and their linked folders").action(listDevicesCommand);
+admin.command("add-folder").description("Create a new Claude folder").action(addFolderCommand);
+admin.command("add-device").description("Add a device path to a Claude folder").action(addDeviceCommand);
 admin.command("update-tool").description("Add or update a tool in the master registry").requiredOption("--name <name>", "Canonical tool name (e.g. next, playwright)").option("--display <display>", 'Human-friendly display name (e.g. "Next.js")').option("--category <category>", "Tool category (framework|runtime|cli|mcp|package|database|other)").option("--stable <version>", "Latest stable version").option("--beta <version>", "Latest beta/RC version").option("--source <url>", "Source of truth URL for checking versions").option("--install <url>", "Download/install link").option("--notes <text>", "Compatibility notes or warnings").action(adminUpdateToolCommand);
 admin.command("list-tools").description("List all tools in the master registry").action(adminListToolsCommand);
 admin.command("fetch-versions").description("Fetch latest stable and beta versions from npm and GitHub").action(adminFetchVersionsCommand);
@@ -5063,7 +5112,7 @@ if (process.argv.length <= 2) {
 } else {
   program.parseAsync().then(() => {
     const ran = program.args[0];
-    const skipAutoCheck = ["update", "check-update", "mcp-watch", "start"];
+    const skipAutoCheck = ["update", "mcp-watch", "start"];
     if (!skipAutoCheck.includes(ran)) {
       autoCheckForUpdate();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "md4ai",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "description": "CLI for MD4AI — scan Claude projects and sync to your dashboard",
   "type": "module",
   "bin": {