@vibecodemax/cli 0.1.11 → 0.1.13

package/dist/cli.js

@@ -473,6 +473,132 @@ function runSupabaseCommand(args, dependencyManager) {
         fail("SUPABASE_CLI_ERROR", [result.stderr, result.stdout].find(isNonEmptyString) || `Supabase CLI ${args.join(" ")} failed.`, 1, { exitCode: result.status ?? 1 });
     }
 }
+function runSupabaseCommandResult(args, dependencyManager) {
+    const runner = getSupabaseRunnerCommand(dependencyManager);
+    return spawnSync(runner.command, [...runner.args, ...args], {
+        cwd: process.cwd(),
+        encoding: "utf8",
+    });
+}
+function runSupabaseCommandCapture(args, dependencyManager) {
+    const result = runSupabaseCommandResult(args, dependencyManager);
+    if (result.status !== 0) {
+        fail("SUPABASE_CLI_ERROR", [result.stderr, result.stdout].find(isNonEmptyString) || `Supabase CLI ${args.join(" ")} failed.`, 1, { exitCode: result.status ?? 1 });
+    }
+    return result.stdout || "";
+}
+function extractMigrationVersion(value) {
+    if (!isNonEmptyString(value))
+        return "";
+    const match = value.trim().match(/^(\d{14})/);
+    return match ? match[1] : "";
+}
+function listLocalMigrationVersions(cwd = process.cwd()) {
+    const migrationsDir = path.join(cwd, "supabase", "migrations");
+    let entries = [];
+    try {
+        entries = fs.readdirSync(migrationsDir);
+    }
+    catch {
+        return [];
+    }
+    return [...new Set(entries.map((entry) => extractMigrationVersion(entry)).filter(Boolean))].sort();
+}
+function collectVersionsFromRows(rows, keyCandidates) {
+    const values = new Set();
+    for (const row of rows) {
+        if (!row || typeof row !== "object")
+            continue;
+        const record = row;
+        for (const key of keyCandidates) {
+            const version = extractMigrationVersion(record[key]);
+            if (version) {
+                values.add(version);
+            }
+        }
+    }
+    return Array.from(values).sort();
+}
+function parseMigrationListTableOutput(raw) {
+    const localVersions = new Set();
+    const remoteVersions = new Set();
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line.includes("|"))
+            continue;
+        const columns = line.split("|").map((value) => value.trim());
+        if (columns.length < 2)
+            continue;
+        const [localCell, remoteCell] = columns;
+        const normalizedLocal = localCell.toLowerCase();
+        const normalizedRemote = remoteCell.toLowerCase();
+        if ((normalizedLocal === "local" && normalizedRemote === "remote")
+            || (/^-+$/.test(localCell.replace(/\s/g, "")) && /^-+$/.test(remoteCell.replace(/\s/g, "")))) {
+            continue;
+        }
+        const localVersion = extractMigrationVersion(localCell);
+        const remoteVersion = extractMigrationVersion(remoteCell);
+        if (localVersion)
+            localVersions.add(localVersion);
+        if (remoteVersion)
+            remoteVersions.add(remoteVersion);
+    }
+    if (localVersions.size === 0 && remoteVersions.size === 0)
+        return null;
+    return {
+        localVersions: Array.from(localVersions).sort(),
+        remoteVersions: Array.from(remoteVersions).sort(),
+    };
+}
+function parseMigrationListOutput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return { localVersions: [], remoteVersions: [] };
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        const rows = Array.isArray(parsed)
+            ? parsed
+            : Array.isArray(parsed?.migrations)
+                ? (parsed.migrations)
+                : Array.isArray(parsed?.data)
+                    ? (parsed.data)
+                    : null;
+        if (!rows) {
+            fail("INVALID_MIGRATION_LIST_OUTPUT", "Supabase migration list JSON output did not contain a rows array.");
+        }
+        const localVersions = collectVersionsFromRows(rows, [
+            "local",
+            "local_version",
+            "localVersion",
+            "localMigration",
+            "local_migration",
+        ]);
+        const remoteVersions = collectVersionsFromRows(rows, [
+            "remote",
+            "remote_version",
+            "remoteVersion",
+            "remoteMigration",
+            "remote_migration",
+        ]);
+        if (localVersions.length === 0 && remoteVersions.length === 0) {
+            fail("INVALID_MIGRATION_LIST_OUTPUT", "Supabase migration list JSON output did not include recognizable local or remote migration version fields.");
+        }
+        return { localVersions, remoteVersions };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            const fallback = parseMigrationListTableOutput(trimmed);
+            if (fallback)
+                return fallback;
+            fail("INVALID_MIGRATION_LIST_OUTPUT", "Supabase migration list output was neither valid JSON nor a recognizable table. Upgrade the local Supabase CLI if its migration list format is unsupported.");
+        }
+        throw error;
+    }
+}
+function supportsJsonMigrationListFailure(result) {
+    const combined = [result.stderr, result.stdout].filter(isNonEmptyString).join("\n").toLowerCase();
+    return combined.includes("--output") || combined.includes("unknown flag") || combined.includes("unknown option");
+}
 async function supabaseManagementApiRequest(params) {
     const response = await fetch(`${MANAGEMENT_API_BASE}${params.endpoint}`, {
         method: params.method,
@@ -752,6 +878,36 @@ async function linkBaseSupabaseProject(flags) {
         bootstrapKeysWritten: writes.bootstrapKeysWritten,
     });
 }
+function preflightBaseMigrationState(flags) {
+    const dependencyManager = normalizeDependencyManagerFlag(flags);
+    const localVersions = listLocalMigrationVersions();
+    let result = runSupabaseCommandResult(["migration", "list", "--linked", "--output", "json"], dependencyManager);
+    if (result.status !== 0 && supportsJsonMigrationListFailure(result)) {
+        result = runSupabaseCommandResult(["migration", "list", "--linked"], dependencyManager);
+    }
+    if (result.status !== 0) {
+        fail("SUPABASE_CLI_ERROR", [result.stderr, result.stdout].find(isNonEmptyString) || "Supabase CLI migration list failed.", 1, { exitCode: result.status ?? 1 });
+    }
+    const raw = result.stdout || "";
+    const parsed = parseMigrationListOutput(raw);
+    const localSet = new Set(localVersions);
+    const remoteSet = new Set(parsed.remoteVersions);
+    const localOnlyVersions = localVersions.filter((version) => !remoteSet.has(version));
+    const remoteOnlyVersions = parsed.remoteVersions.filter((version) => !localSet.has(version));
+    const blocked = remoteOnlyVersions.length > 0;
+    printJson({
+        ok: true,
+        command: "base preflight-migration-state",
+        localVersions,
+        remoteVersions: parsed.remoteVersions,
+        localOnlyVersions,
+        remoteOnlyVersions,
+        blocked,
+        requiresUserDecision: blocked,
+        decisionOptions: blocked ? ["reset", "repair", "relink"] : ["continue"],
+        status: blocked ? "diverged" : "aligned_or_recoverable",
+    });
+}
 async function supabaseAdminRequest(params) {
     const response = await fetch(`${params.supabaseUrl}${params.endpoint}`, {
         method: params.method,
@@ -1952,6 +2108,7 @@ async function main() {
                 "base check-supabase-access-token",
                 "base create-supabase-project",
                 "base link-supabase-project",
+                "base preflight-migration-state",
                 "admin ensure-admin",
                 "storage check-supabase-context",
                 "storage setup-supabase",
@@ -1987,6 +2144,8 @@ async function main() {
         return createBaseSupabaseProject(flags);
     if (command === "base" && subcommand === "link-supabase-project")
         return linkBaseSupabaseProject(flags);
+    if (command === "base" && subcommand === "preflight-migration-state")
+        return preflightBaseMigrationState(flags);
     if (command === "admin" && subcommand === "ensure-admin")
         return ensureAdmin(flags);
     if (command === "storage" && subcommand === "check-supabase-context")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibecodemax/cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "VibeCodeMax CLI — local provider setup for bootstrap and project configuration",
   "type": "module",
   "bin": {