md4ai 0.12.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.12.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();
   }
 });
 
@@ -2175,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;
@@ -2193,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") {
@@ -2201,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;
@@ -2211,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;
@@ -2226,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
           });
         }
       }
@@ -2369,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");
@@ -2436,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."));
@@ -2480,7 +2527,7 @@ ${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__" },
@@ -2496,7 +2543,7 @@ ${proposedFiles.length} file(s) proposed for deletion:
               message: "Project name:",
               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;
@@ -2509,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);
@@ -2545,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,
@@ -2591,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) {
@@ -2610,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}`));
@@ -2650,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() });
@@ -3805,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);
@@ -3832,21 +3955,40 @@ Linking "${folder.name}" to this device...
   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) \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);
@@ -3857,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).`));
   }

package/package.json

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