md4ai 0.11.0 → 0.13.0

package/dist/index.bundled.js

@@ -73,7 +73,7 @@ var CURRENT_VERSION;
 var init_check_update = __esm({
   "dist/check-update.js"() {
     "use strict";
-    CURRENT_VERSION = true ? "0.11.0" : "0.0.0-dev";
+    CURRENT_VERSION = true ? "0.13.0" : "0.0.0-dev";
   }
 });
 
@@ -1656,21 +1656,40 @@ var init_marketplace_scanner = __esm({
 
 // dist/doppler/auth.js
 async function resolveDopplerToken() {
+  const { join: join17 } = await import("node:path");
+  const { homedir: homedir10 } = await import("node:os");
+  const credPath = join17(homedir10(), ".md4ai", "credentials.json");
   const creds = await loadCredentials();
   if (creds?.dopplerToken) {
-    const { join: join17 } = await import("node:path");
-    const { homedir: homedir10 } = await import("node:os");
-    return {
-      token: creds.dopplerToken,
-      sourcePath: join17(homedir10(), ".md4ai", "credentials.json")
-    };
+    return { token: creds.dopplerToken, sourcePath: credPath };
+  }
+  if (!creds?.accessToken || !creds?.userId)
+    return null;
+  try {
+    let supabase = createSupabaseClient(getAnonKey(), creds.accessToken);
+    let userId = creds.userId;
+    if (Date.now() > creds.expiresAt) {
+      const refreshed = await refreshSession();
+      if (!refreshed)
+        return null;
+      supabase = refreshed.supabase;
+      userId = refreshed.userId;
+    }
+    const { data } = await supabase.from("user_secrets").select("doppler_token").eq("user_id", userId).maybeSingle();
+    if (!data?.doppler_token)
+      return null;
+    await mergeCredentials({ dopplerToken: data.doppler_token });
+    return { token: data.doppler_token, sourcePath: "Supabase (cached locally)" };
+  } catch {
+    return null;
   }
-  return null;
 }
 var init_auth3 = __esm({
   "dist/doppler/auth.js"() {
     "use strict";
     init_config();
+    init_auth();
+    init_dist();
   }
 });
 
@@ -1713,6 +1732,10 @@ async function validateDopplerToken(token) {
     throw err;
   }
 }
+async function fetchDopplerProjects(token) {
+  const data = await dopplerFetch("https://api.doppler.com/v3/projects", token);
+  return data.projects.map((p) => ({ slug: p.slug, name: p.name }));
+}
 var DopplerApiError, MAX_RETRIES;
 var init_api = __esm({
   "dist/doppler/api.js"() {
@@ -1733,9 +1756,10 @@ var init_api = __esm({
 
 // dist/scanner/doppler-scanner.js
 import { readFile as readFile9 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join11, basename } from "node:path";
 import { existsSync as existsSync6 } from "node:fs";
 import chalk10 from "chalk";
+import { select as select3 } from "@inquirer/prompts";
 async function parseDopplerYaml(projectRoot) {
   const yamlPath = join11(projectRoot, "doppler.yaml");
   if (!existsSync6(yamlPath))
@@ -1751,6 +1775,7 @@ async function parseDopplerYaml(projectRoot) {
 async function scanDoppler(projectRoot, folderId) {
   const tokenResult = await resolveDopplerToken();
   if (!tokenResult) {
+    console.log(chalk10.dim('  Doppler: no token configured. Run "md4ai doppler connect" to set up.'));
     return null;
   }
   let projectSlug = await parseDopplerYaml(projectRoot);
@@ -1762,7 +1787,40 @@ async function scanDoppler(projectRoot, folderId) {
       matchedVia = "manual";
   }
   if (!projectSlug) {
-    return null;
+    if (!folderId || !process.stdin.isTTY) {
+      console.log(chalk10.dim('  Doppler: token configured but no project linked. Run "md4ai doppler set-project <slug>" to link one.'));
+      return null;
+    }
+    const projects = await fetchDopplerProjects(tokenResult.token);
+    if (projects.length === 0) {
+      console.log(chalk10.yellow("  Doppler: no projects accessible with this token."));
+      return null;
+    }
+    const projectName = basename(projectRoot);
+    if (projects.length === 1) {
+      projectSlug = projects[0].slug;
+      console.log(chalk10.green(`  Doppler: using "${projectSlug}" (only accessible project).`));
+    } else {
+      const autoMatch = projects.find((p) => p.slug.toLowerCase() === projectName.toLowerCase());
+      if (autoMatch) {
+        projectSlug = autoMatch.slug;
+        console.log(chalk10.green(`  Doppler: auto-matched project "${projectSlug}" from project name.`));
+      } else {
+        projectSlug = await select3({
+          message: `Which Doppler project holds secrets for "${projectName}"?`,
+          choices: projects.map((p) => ({
+            name: `${p.slug}${p.name !== p.slug ? ` (${p.name})` : ""}`,
+            value: p.slug
+          }))
+        });
+      }
+    }
+    const state = await loadState();
+    const dopplerProjects = state.dopplerProjects ?? {};
+    dopplerProjects[folderId] = projectSlug;
+    await saveState({ dopplerProjects });
+    matchedVia = "manual";
+    console.log(chalk10.dim(`  Doppler: saved "${projectSlug}" for this project. To change: md4ai doppler set-project <slug>`));
   }
   console.log(chalk10.dim(`  Doppler: checking project "${projectSlug}" (via ${matchedVia})...`));
   try {
@@ -2136,7 +2194,7 @@ var init_push_toolings = __esm({
 
 // dist/commands/push-health-results.js
 import chalk11 from "chalk";
-async function pushHealthResults(supabase, folderId, manifest) {
+async function pushHealthResults(supabase, folderId, manifest, deviceId) {
   const { data: checks } = await supabase.from("env_health_checks").select("id, check_type, check_config").eq("folder_id", folderId).eq("enabled", true);
   if (!checks?.length)
     return;
@@ -2154,7 +2212,8 @@ async function pushHealthResults(supabase, folderId, manifest) {
           check_id: chk.id,
           status: localStatus === "present" ? "pass" : "fail",
           message: localStatus === "present" ? "Set" : "Missing",
-          ran_at: ranAt
+          ran_at: ranAt,
+          device_id: deviceId ?? null
         });
       }
     } else if (chk.check_type === "file_exists") {
@@ -2162,7 +2221,8 @@ async function pushHealthResults(supabase, folderId, manifest) {
         check_id: chk.id,
         status: "pass",
         message: "Found",
-        ran_at: ranAt
+        ran_at: ranAt,
+        device_id: deviceId ?? null
       });
     } else if (chk.check_type === "gh_secret") {
       const variable = config2.secret;
@@ -2172,7 +2232,8 @@ async function pushHealthResults(supabase, folderId, manifest) {
         check_id: chk.id,
         status: ghStatus === "present" ? "pass" : ghStatus === "missing" ? "fail" : "warn",
         message: ghStatus === "present" ? "Exists" : ghStatus === "missing" ? "Missing" : "Unknown",
-        ran_at: ranAt
+        ran_at: ranAt,
+        device_id: deviceId ?? null
       });
     } else if (chk.check_type === "vercel_env") {
       const variable = config2.variable;
@@ -2187,14 +2248,16 @@ async function pushHealthResults(supabase, folderId, manifest) {
             check_id: chk.id,
             status: hasTarget ? "pass" : "warn",
             message: hasTarget ? `Present (${target})` : `Present but not in ${target}`,
-            ran_at: ranAt
+            ran_at: ranAt,
+            device_id: deviceId ?? null
           });
         } else {
           results.push({
             check_id: chk.id,
             status: "fail",
             message: `Not found in ${projectName}`,
-            ran_at: ranAt
+            ran_at: ranAt,
+            device_id: deviceId ?? null
           });
         }
       }
@@ -2274,11 +2337,11 @@ var map_exports = {};
 __export(map_exports, {
   mapCommand: () => mapCommand
 });
-import { resolve as resolve4, basename } from "node:path";
+import { resolve as resolve4, basename as basename2 } from "node:path";
 import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
 import { existsSync as existsSync8 } from "node:fs";
 import chalk12 from "chalk";
-import { select as select3, input as input5, confirm as confirm2 } from "@inquirer/prompts";
+import { select as select4, input as input5, confirm as confirm2 } from "@inquirer/prompts";
 async function mapCommand(path, options) {
   await checkForUpdate();
   const projectRoot = resolve4(path ?? process.cwd());
@@ -2288,7 +2351,16 @@ async function mapCommand(path, options) {
   }
   console.log(chalk12.blue(`Scanning: ${projectRoot}
 `));
-  const result = await scanProject(projectRoot);
+  let earlyFolderId;
+  if (!options.offline) {
+    try {
+      const { supabase: earlyDb } = await getAuthenticatedClient();
+      const { data: dp } = await earlyDb.from("device_paths").select("folder_id").eq("path", projectRoot).maybeSingle();
+      earlyFolderId = dp?.folder_id ?? void 0;
+    } catch {
+    }
+  }
+  const result = await scanProject(projectRoot, earlyFolderId);
   console.log(`  Files found:   ${result.graph.nodes.length}`);
   console.log(`  References:    ${result.graph.edges.length}`);
   console.log(`  Broken refs:   ${result.brokenRefs.length}`);
@@ -2297,7 +2369,7 @@ async function mapCommand(path, options) {
   console.log(`  Skills:        ${result.skills.length}`);
   console.log(`  Toolings:      ${result.toolings.length}`);
   console.log(`  Env Vars:      ${result.envManifest?.variables.length ?? 0} (${result.envManifest ? "manifest found" : "no manifest"})`);
-  console.log(`  Doppler:       ${result.doppler ? `${result.doppler.configs.length} config(s)` : "not configured"}`);
+  console.log(`  Doppler:       ${result.doppler ? `${result.doppler.configs.length} config(s) \u2014 ${result.doppler.project}` : "see above"}`);
   console.log(`  Plugins:       ${result.marketplacePlugins.length} (${result.marketplacePlugins.reduce((n, p) => n + p.skills.length, 0)} skills)`);
   console.log(`  Data hash:     ${result.dataHash.slice(0, 12)}...`);
   if (result.brokenRefs.length > 0) {
@@ -2321,10 +2393,12 @@ async function mapCommand(path, options) {
 Local preview: ${htmlPath}`));
   if (!options.offline) {
     try {
-      const { supabase } = await getAuthenticatedClient();
+      const { supabase, userId } = await getAuthenticatedClient();
       const { data: devicePaths } = await supabase.from("device_paths").select("folder_id, device_name").eq("path", projectRoot);
       if (devicePaths?.length) {
         const { folder_id, device_name } = devicePaths[0];
+        const { data: deviceRow } = await supabase.from("devices").select("id").eq("user_id", userId).eq("device_name", device_name).single();
+        const deviceId = deviceRow?.id;
         const { data: proposedFiles } = await supabase.from("folder_files").select("id, file_path, proposed_at").eq("folder_id", folder_id).eq("proposed_for_deletion", true);
         if (proposedFiles?.length && process.stdin.isTTY) {
           const { checkbox } = await import("@inquirer/prompts");
@@ -2388,39 +2462,60 @@ ${proposedFiles.length} file(s) proposed for deletion:
         if (result.doppler) {
           updatePayload.doppler_json = result.doppler;
         }
-        const { error } = await supabase.from("claude_folders").update(updatePayload).eq("id", folder_id);
-        if (error) {
-          console.error(chalk12.yellow(`Sync warning: ${error.message}`));
-        } else {
-          await pushToolings(supabase, folder_id, result.toolings);
-          const manifestForHealth = result.envManifest ?? storedManifest;
-          if (manifestForHealth) {
-            await pushHealthResults(supabase, folder_id, manifestForHealth);
+        try {
+          const { error } = await supabase.from("claude_folders").update(updatePayload).eq("id", folder_id);
+          if (error) {
+            console.log(chalk12.dim(`Debug: claude_folders update skipped (${error.message})`));
           }
-          await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", folder_id).eq("device_name", device_name);
-          await saveState({
-            lastFolderId: folder_id,
-            lastDeviceName: device_name,
-            lastSyncAt: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          console.log(chalk12.green("Synced to Supabase."));
-          console.log(chalk12.cyan(`
+        } catch (err) {
+          console.log(chalk12.dim(`Debug: claude_folders update skipped (${err instanceof Error ? err.message : String(err)})`));
+        }
+        if (deviceId) {
+          await supabase.from("device_scans").upsert({
+            folder_id,
+            device_id: deviceId,
+            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,
+            data_hash: result.dataHash,
+            scanned_at: result.scannedAt
+          }, { onConflict: "folder_id,device_id" });
+        }
+        await pushToolings(supabase, folder_id, result.toolings);
+        const manifestForHealth = result.envManifest ?? storedManifest;
+        if (manifestForHealth) {
+          await pushHealthResults(supabase, folder_id, manifestForHealth, deviceId);
+        }
+        await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", folder_id).eq("device_name", device_name);
+        await saveState({
+          lastFolderId: folder_id,
+          lastDeviceName: device_name,
+          lastSyncAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        console.log(chalk12.green("Synced to Supabase."));
+        console.log(chalk12.cyan(`
   https://www.md4ai.com/project/${folder_id}
 `));
-          const graphPaths = result.graph.nodes.map((n) => n.filePath);
-          const configFiles = await readClaudeConfigFiles(projectRoot, graphPaths);
-          if (configFiles.length > 0) {
-            for (const file of configFiles) {
-              await supabase.from("folder_files").upsert({
-                folder_id,
-                file_path: file.filePath,
-                content: file.content,
-                size_bytes: file.sizeBytes,
-                last_modified: file.lastModified
-              }, { onConflict: "folder_id,file_path" });
-            }
-            console.log(chalk12.green(`  Uploaded ${configFiles.length} config file(s).`));
+        const graphPaths = result.graph.nodes.map((n) => n.filePath);
+        const configFiles = await readClaudeConfigFiles(projectRoot, graphPaths);
+        if (configFiles.length > 0) {
+          for (const file of configFiles) {
+            await supabase.from("folder_files").upsert({
+              folder_id,
+              file_path: file.filePath,
+              content: file.content,
+              size_bytes: file.sizeBytes,
+              last_modified: file.lastModified,
+              device_id: deviceId
+            }, { onConflict: "folder_id,file_path,device_id" });
           }
+          console.log(chalk12.green(`  Uploaded ${configFiles.length} config file(s).`));
         }
       } else {
         console.log(chalk12.yellow("\nThis folder is not linked to a project on your dashboard."));
@@ -2432,13 +2527,13 @@ ${proposedFiles.length} file(s) proposed for deletion:
         if (!shouldLink) {
           console.log(chalk12.dim("Skipped \u2014 local preview still generated."));
         } else {
-          const { supabase: sb, userId } = await getAuthenticatedClient();
+          const { supabase: sb, userId: userId2 } = await getAuthenticatedClient();
           const { data: folders } = await sb.from("claude_folders").select("id, name").order("name");
           const choices = [
             { name: "+ Create a new project", value: "__new__" },
             ...(folders ?? []).map((f) => ({ name: f.name, value: f.id }))
           ];
-          const chosen = await select3({
+          const chosen = await select4({
             message: "Link to which project?",
             choices
           });
@@ -2446,9 +2541,9 @@ ${proposedFiles.length} file(s) proposed for deletion:
           if (chosen === "__new__") {
             const projectName = await input5({
               message: "Project name:",
-              default: basename(projectRoot)
+              default: basename2(projectRoot)
             });
-            const { data: newFolder, error: createErr } = await sb.from("claude_folders").insert({ user_id: userId, name: projectName }).select("id").single();
+            const { data: newFolder, error: createErr } = await sb.from("claude_folders").insert({ user_id: userId2, name: projectName }).select("id").single();
             if (createErr || !newFolder) {
               console.error(chalk12.red(`Failed to create project: ${createErr?.message}`));
               return;
@@ -2461,33 +2556,59 @@ ${proposedFiles.length} file(s) proposed for deletion:
           const deviceName = detectDeviceName();
           const osType = detectOs2();
           await sb.from("devices").upsert({
-            user_id: userId,
+            user_id: userId2,
             device_name: deviceName,
             os_type: osType
           }, { onConflict: "user_id,device_name" });
+          const { data: inlineDeviceRow } = await sb.from("devices").select("id").eq("user_id", userId2).eq("device_name", deviceName).single();
+          const inlineDeviceId = inlineDeviceRow?.id;
           await sb.from("device_paths").upsert({
-            user_id: userId,
+            user_id: userId2,
             folder_id: folderId,
             device_name: deviceName,
             os_type: osType,
             path: projectRoot,
             last_synced: (/* @__PURE__ */ new Date()).toISOString()
           }, { onConflict: "folder_id,device_name" });
-          await sb.from("claude_folders").update({
-            graph_json: result.graph,
-            orphans_json: result.orphans,
-            broken_refs_json: result.brokenRefs,
-            skills_table_json: result.skills,
-            stale_files_json: result.staleFiles,
-            env_manifest_json: result.envManifest,
-            doppler_json: result.doppler,
-            marketplace_plugins_json: result.marketplacePlugins,
-            last_scanned: result.scannedAt,
-            data_hash: result.dataHash
-          }).eq("id", folderId);
+          try {
+            const { error: inlineFolderErr } = await sb.from("claude_folders").update({
+              graph_json: result.graph,
+              orphans_json: result.orphans,
+              broken_refs_json: result.brokenRefs,
+              skills_table_json: result.skills,
+              stale_files_json: result.staleFiles,
+              env_manifest_json: result.envManifest,
+              doppler_json: result.doppler,
+              marketplace_plugins_json: result.marketplacePlugins,
+              last_scanned: result.scannedAt,
+              data_hash: result.dataHash
+            }).eq("id", folderId);
+            if (inlineFolderErr) {
+              console.log(chalk12.dim(`Debug: claude_folders update skipped (${inlineFolderErr.message})`));
+            }
+          } catch (err) {
+            console.log(chalk12.dim(`Debug: claude_folders update skipped (${err instanceof Error ? err.message : String(err)})`));
+          }
+          if (inlineDeviceId) {
+            await sb.from("device_scans").upsert({
+              folder_id: folderId,
+              device_id: inlineDeviceId,
+              user_id: userId2,
+              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,
+              data_hash: result.dataHash,
+              scanned_at: result.scannedAt
+            }, { onConflict: "folder_id,device_id" });
+          }
           await pushToolings(sb, folderId, result.toolings);
           if (result.envManifest) {
-            await pushHealthResults(sb, folderId, result.envManifest);
+            await pushHealthResults(sb, folderId, result.envManifest, inlineDeviceId);
           }
           const graphPaths2 = result.graph.nodes.map((n) => n.filePath);
           const configFiles = await readClaudeConfigFiles(projectRoot, graphPaths2);
@@ -2497,8 +2618,9 @@ ${proposedFiles.length} file(s) proposed for deletion:
               file_path: file.filePath,
               content: file.content,
               size_bytes: file.sizeBytes,
-              last_modified: file.lastModified
-            }, { onConflict: "folder_id,file_path" });
+              last_modified: file.lastModified,
+              device_id: inlineDeviceId
+            }, { onConflict: "folder_id,file_path,device_id" });
           }
           await saveState({
             lastFolderId: folderId,
@@ -2543,7 +2665,7 @@ function isValidProjectPath(p) {
   return resolved.startsWith("/") && !resolved.includes("..") && existsSync11(resolved);
 }
 async function syncCommand(options) {
-  const { supabase } = await getAuthenticatedClient();
+  const { supabase, userId } = await getAuthenticatedClient();
   if (options.all) {
     const { data: devices, error } = await supabase.from("device_paths").select("folder_id, device_name, path");
     if (error || !devices?.length) {
@@ -2562,16 +2684,40 @@ async function syncCommand(options) {
       }
       try {
         const result = await scanProject(device.path);
-        await supabase.from("claude_folders").update({
-          graph_json: result.graph,
-          orphans_json: result.orphans,
-          broken_refs_json: result.brokenRefs,
-          skills_table_json: result.skills,
-          stale_files_json: result.staleFiles,
-          env_manifest_json: result.envManifest,
-          last_scanned: result.scannedAt,
-          data_hash: result.dataHash
-        }).eq("id", 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;
+        try {
+          const { error: allFolderErr } = await supabase.from("claude_folders").update({
+            graph_json: result.graph,
+            orphans_json: result.orphans,
+            broken_refs_json: result.brokenRefs,
+            skills_table_json: result.skills,
+            stale_files_json: result.staleFiles,
+            env_manifest_json: result.envManifest,
+            last_scanned: result.scannedAt,
+            data_hash: result.dataHash
+          }).eq("id", device.folder_id);
+          if (allFolderErr) {
+            console.log(chalk15.dim(`  Debug: claude_folders update skipped (${allFolderErr.message})`));
+          }
+        } catch (folderErr) {
+          console.log(chalk15.dim(`  Debug: claude_folders update skipped (${folderErr instanceof Error ? folderErr.message : String(folderErr)})`));
+        }
+        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,
+            data_hash: result.dataHash,
+            scanned_at: result.scannedAt
+          }, { onConflict: "folder_id,device_id" });
+        }
         await pushToolings(supabase, device.folder_id, result.toolings);
         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}`));
@@ -2602,15 +2748,38 @@ async function syncCommand(options) {
       console.log(chalk15.yellow(`  ${proposedSingle.length} file(s) proposed for deletion \u2014 run \`md4ai scan\` to review.`));
     }
     const result = await scanProject(device.path);
-    await supabase.from("claude_folders").update({
-      graph_json: result.graph,
-      orphans_json: result.orphans,
-      broken_refs_json: result.brokenRefs,
-      skills_table_json: result.skills,
-      stale_files_json: result.staleFiles,
-      last_scanned: result.scannedAt,
-      data_hash: result.dataHash
-    }).eq("id", 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;
+    try {
+      const { error: singleFolderErr } = await supabase.from("claude_folders").update({
+        graph_json: result.graph,
+        orphans_json: result.orphans,
+        broken_refs_json: result.brokenRefs,
+        skills_table_json: result.skills,
+        stale_files_json: result.staleFiles,
+        last_scanned: result.scannedAt,
+        data_hash: result.dataHash
+      }).eq("id", device.folder_id);
+      if (singleFolderErr) {
+        console.log(chalk15.dim(`Debug: claude_folders update skipped (${singleFolderErr.message})`));
+      }
+    } catch (err) {
+      console.log(chalk15.dim(`Debug: claude_folders update skipped (${err instanceof Error ? err.message : String(err)})`));
+    }
+    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,
+        data_hash: result.dataHash,
+        scanned_at: result.scannedAt
+      }, { onConflict: "folder_id,device_id" });
+    }
     await pushToolings(supabase, device.folder_id, result.toolings);
     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() });
@@ -3757,6 +3926,8 @@ Linking "${folder.name}" to this device...
     device_name: deviceName,
     os_type: osType
   }, { onConflict: "user_id,device_name" });
+  const { data: deviceRow } = await supabase.from("devices").select("id").eq("user_id", userId).eq("device_name", deviceName).single();
+  const deviceId = deviceRow.id;
   const { data: existing } = await supabase.from("device_paths").select("id").eq("folder_id", folder.id).eq("device_name", deviceName).maybeSingle();
   if (existing) {
     await supabase.from("device_paths").update({ path: cwd, os_type: osType, last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", existing.id);
@@ -3782,23 +3953,42 @@ Linking "${folder.name}" to this device...
   console.log(`  Skills:    ${result.skills.length}`);
   console.log(`  Toolings:  ${result.toolings.length}`);
   console.log(`  Env Vars:  ${result.envManifest?.variables.length ?? 0} (${result.envManifest ? "manifest found" : "no manifest"})`);
-  console.log(`  Doppler:  ${result.doppler ? `${result.doppler.configs.length} config(s)` : "not configured"}`);
+  console.log(`  Doppler:  ${result.doppler ? `${result.doppler.configs.length} config(s) \u2014 ${result.doppler.project}` : "see above"}`);
   console.log(`  Plugins:   ${result.marketplacePlugins.length} (${result.marketplacePlugins.reduce((n, p) => n + p.skills.length, 0)} skills)`);
-  const { error: scanErr } = await supabase.from("claude_folders").update({
+  try {
+    const { error: scanErr } = await supabase.from("claude_folders").update({
+      graph_json: result.graph,
+      orphans_json: result.orphans,
+      broken_refs_json: result.brokenRefs,
+      skills_table_json: result.skills,
+      stale_files_json: result.staleFiles,
+      env_manifest_json: result.envManifest,
+      doppler_json: result.doppler,
+      marketplace_plugins_json: result.marketplacePlugins,
+      last_scanned: result.scannedAt,
+      data_hash: result.dataHash
+    }).eq("id", folder.id);
+    if (scanErr) {
+      console.log(chalk16.dim(`Debug: claude_folders update skipped (${scanErr.message})`));
+    }
+  } catch (err) {
+    console.log(chalk16.dim(`Debug: claude_folders update skipped (${err instanceof Error ? err.message : String(err)})`));
+  }
+  await supabase.from("device_scans").upsert({
+    folder_id: folder.id,
+    device_id: deviceId,
+    user_id: userId,
     graph_json: result.graph,
     orphans_json: result.orphans,
-    broken_refs_json: result.brokenRefs,
     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,
-    last_scanned: result.scannedAt,
-    data_hash: result.dataHash
-  }).eq("id", folder.id);
-  if (scanErr) {
-    console.error(chalk16.yellow(`Scan upload warning: ${scanErr.message}`));
-  }
+    data_hash: result.dataHash,
+    scanned_at: result.scannedAt
+  }, { onConflict: "folder_id,device_id" });
   await pushToolings(supabase, folder.id, result.toolings);
   const graphPaths = result.graph.nodes.map((n) => n.filePath);
   const configFiles = await readClaudeConfigFiles(cwd, graphPaths);
@@ -3809,8 +3999,9 @@ Linking "${folder.name}" to this device...
         file_path: file.filePath,
         content: file.content,
         size_bytes: file.sizeBytes,
-        last_modified: file.lastModified
-      }, { onConflict: "folder_id,file_path" });
+        last_modified: file.lastModified,
+        device_id: deviceId
+      }, { onConflict: "folder_id,file_path,device_id" });
     }
     console.log(chalk16.green(`  Uploaded ${configFiles.length} config file(s).`));
   }
@@ -4581,6 +4772,8 @@ async function configSetCommand(key, value) {
 // dist/commands/doppler.js
 init_config();
 init_api();
+init_auth();
+init_dist();
 import chalk26 from "chalk";
 import { input as input7 } from "@inquirer/prompts";
 async function dopplerConnectCommand() {
@@ -4599,7 +4792,51 @@ async function dopplerConnectCommand() {
   await mergeCredentials({ dopplerToken: token });
   console.log(chalk26.green(`Token validated \u2014 ${projectCount} project${projectCount !== 1 ? "s" : ""} accessible.`));
   console.log(chalk26.green("Saved to ~/.md4ai/credentials.json"));
-  console.log(chalk26.dim("Doppler will be checked automatically on your next scan."));
+  const creds = await loadCredentials();
+  if (!creds?.accessToken || !creds?.userId) {
+    console.log("");
+    console.log(chalk26.yellow("\u26A0 Not logged in to MD4AI \u2014 token saved locally only."));
+    console.log(chalk26.yellow("  The web dashboard cannot show live Doppler status until the token is synced."));
+    console.log(chalk26.yellow('  To fix: run "md4ai login", then "md4ai doppler connect" again.'));
+  } else {
+    let supabase = createSupabaseClient(getAnonKey(), creds.accessToken);
+    let userId = creds.userId;
+    if (Date.now() > creds.expiresAt) {
+      const refreshed = await refreshSession();
+      if (refreshed) {
+        supabase = refreshed.supabase;
+        userId = refreshed.userId;
+      } else {
+        console.log("");
+        console.log(chalk26.yellow("\u26A0 Session expired \u2014 token saved locally only."));
+        console.log(chalk26.yellow('  To sync to the web dashboard: run "md4ai login", then "md4ai doppler connect" again.'));
+      }
+    }
+    if (supabase) {
+      try {
+        const { error } = await supabase.from("user_secrets").upsert({ user_id: userId, doppler_token: token, updated_at: (/* @__PURE__ */ new Date()).toISOString() }, { onConflict: "user_id" });
+        if (error) {
+          console.log(chalk26.yellow(`\u26A0 Could not sync token to web dashboard: ${error.message}`));
+        } else {
+          const { data: verify } = await supabase.from("user_secrets").select("id").eq("user_id", userId).maybeSingle();
+          if (verify) {
+            console.log(chalk26.green("Token synced to web dashboard."));
+          } else {
+            console.log(chalk26.yellow("\u26A0 Token sync could not be verified \u2014 check the web dashboard."));
+          }
+        }
+      } catch (err) {
+        console.log(chalk26.yellow(`\u26A0 Could not sync token to web dashboard: ${err instanceof Error ? err.message : "unknown error"}`));
+      }
+    }
+  }
+  console.log("");
+  console.log(chalk26.cyan("Next step: link a Doppler project to your Claude project."));
+  console.log(chalk26.dim("  The scanner looks for a doppler.yaml in the project root, e.g.:"));
+  console.log(chalk26.dim("    project: my-doppler-project"));
+  console.log(chalk26.dim("  Or use a manual override:"));
+  console.log(chalk26.dim("    md4ai doppler set-project <slug>"));
+  console.log(chalk26.dim('  Then run "md4ai scan" to fetch secret names from Doppler.'));
 }
 async function dopplerDisconnectCommand() {
   const creds = await loadCredentials();
@@ -4614,7 +4851,26 @@ async function dopplerDisconnectCommand() {
   const credPath = join17(homedir10(), ".md4ai", "credentials.json");
   await writeFile6(credPath, JSON.stringify(rest, null, 2), "utf-8");
   await chmod2(credPath, 384);
-  console.log(chalk26.green("Doppler token removed."));
+  try {
+    const currentCreds = await loadCredentials();
+    if (currentCreds?.accessToken && currentCreds?.userId) {
+      let supabase = createSupabaseClient(getAnonKey(), currentCreds.accessToken);
+      let userId = currentCreds.userId;
+      if (Date.now() > currentCreds.expiresAt) {
+        const refreshed = await refreshSession();
+        if (refreshed) {
+          supabase = refreshed.supabase;
+          userId = refreshed.userId;
+        }
+      }
+      await supabase.from("user_secrets").delete().eq("user_id", userId);
+      console.log(chalk26.green("Doppler token removed from local and web dashboard."));
+    } else {
+      console.log(chalk26.green("Doppler token removed locally."));
+    }
+  } catch {
+    console.log(chalk26.green("Doppler token removed locally."));
+  }
 }
 async function dopplerSetProjectCommand(slug) {
   const state = await loadState();

package/package.json

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