@insforge/cli 0.1.54 → 0.1.55

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join10, dirname } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join12, dirname } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
 import * as clack11 from "@clack/prompts";
@@ -1123,7 +1123,7 @@ async function reportCliUsage(toolName, success, maxRetries = 1, explicitConfig)
 
 // src/lib/analytics.ts
 import { PostHog } from "posthog-node";
-var POSTHOG_API_KEY = "phc_ueV1ii62wdBTkH7E70ugyeqHIHu8dFDdjs0qq3TZhJz";
+var POSTHOG_API_KEY = "";
 var POSTHOG_HOST = process.env.POSTHOG_HOST || "https://us.i.posthog.com";
 var client = null;
 function getClient() {
@@ -1211,6 +1211,9 @@ ${err.nextActions}`;
     if (res.status === 404 && path5.startsWith("/api/compute")) {
       message = "Compute services are not available on this backend.\nSelf-hosted: upgrade your InsForge instance. Cloud: contact your InsForge admin to enable compute.";
     }
+    if (res.status === 404 && path5 === "/api/database/migrations") {
+      message = "Database migrations are not available on this backend.\nSelf-hosted: upgrade your InsForge instance. Cloud: contact your InsForge admin about database migration support.";
+    }
     throw new CLIError(message);
   }
   return res;
@@ -2671,6 +2674,451 @@ function registerDbImportCommand(dbCmd2) {
   });
 }
 
+// src/commands/db/migrations.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8 } from "path";
+
+// src/lib/migrations.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { join as join7 } from "path";
+var MIGRATION_VERSION_REGEX = /^\d{14}$/u;
+var MIGRATION_FILENAME_REGEX = /^(\d{14})_([a-z0-9-]+)\.sql$/u;
+function assertValidMigrationVersion(version) {
+  if (!MIGRATION_VERSION_REGEX.test(version)) {
+    throw new CLIError(`Invalid migration version: ${version}. Expected YYYYMMDDHHmmss.`);
+  }
+}
+function parseMigrationFilename(filename) {
+  const match = MIGRATION_FILENAME_REGEX.exec(filename);
+  if (!match) {
+    return null;
+  }
+  return {
+    filename,
+    version: match[1],
+    name: match[2]
+  };
+}
+function compareMigrationVersions(left, right) {
+  return left.localeCompare(right);
+}
+function getRemoteMigrationVersionStatus(version, appliedVersions, latestRemoteVersion) {
+  if (appliedVersions.has(version)) {
+    return "already-applied";
+  }
+  if (latestRemoteVersion && compareMigrationVersions(version, latestRemoteVersion) < 0) {
+    return "older-than-head";
+  }
+  return "pending";
+}
+function formatMigrationVersion(date) {
+  const year = String(date.getUTCFullYear());
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hour = String(date.getUTCHours()).padStart(2, "0");
+  const minute = String(date.getUTCMinutes()).padStart(2, "0");
+  const second = String(date.getUTCSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hour}${minute}${second}`;
+}
+function incrementMigrationVersion(version) {
+  const year = Number(version.slice(0, 4));
+  const month = Number(version.slice(4, 6)) - 1;
+  const day = Number(version.slice(6, 8));
+  const hour = Number(version.slice(8, 10));
+  const minute = Number(version.slice(10, 12));
+  const second = Number(version.slice(12, 14));
+  const nextTimestamp = Date.UTC(year, month, day, hour, minute, second + 1);
+  return formatMigrationVersion(new Date(nextTimestamp));
+}
+function getMigrationsDir(cwd = process.cwd()) {
+  return join7(cwd, "migrations");
+}
+function ensureMigrationsDir(cwd = process.cwd()) {
+  const migrationsDir = getMigrationsDir(cwd);
+  if (!existsSync3(migrationsDir)) {
+    mkdirSync2(migrationsDir, { recursive: true });
+  }
+  return migrationsDir;
+}
+function listLocalMigrationFilenames(cwd = process.cwd()) {
+  const migrationsDir = getMigrationsDir(cwd);
+  if (!existsSync3(migrationsDir)) {
+    return [];
+  }
+  return readdirSync(migrationsDir).sort((left, right) => left.localeCompare(right));
+}
+function parseStrictLocalMigrations(filenames) {
+  const migrations = filenames.map((filename) => {
+    const parsedMigration = parseMigrationFilename(filename);
+    if (!parsedMigration) {
+      throw new CLIError(
+        `Invalid migration filename: ${filename}. Expected <migration_version>_<migration-name>.sql.`
+      );
+    }
+    return parsedMigration;
+  });
+  assertNoDuplicateMigrationVersions(migrations);
+  return migrations.sort((left, right) => compareMigrationVersions(left.version, right.version));
+}
+function assertNoDuplicateMigrationVersions(migrations) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const migration of migrations) {
+    if (seen.has(migration.version)) {
+      throw new CLIError(`Duplicate local migration version found: ${migration.version}`);
+    }
+    seen.add(migration.version);
+  }
+}
+function getNextLocalMigrationVersion(migrations, latestRemoteVersion, now = /* @__PURE__ */ new Date()) {
+  const orderedMigrations = [...migrations].sort(
+    (left, right) => compareMigrationVersions(left.version, right.version)
+  );
+  assertNoDuplicateMigrationVersions(orderedMigrations);
+  const latestKnownVersion = orderedMigrations.reduce(
+    (latestVersion, migration) => {
+      if (!latestVersion || compareMigrationVersions(migration.version, latestVersion) > 0) {
+        return migration.version;
+      }
+      return latestVersion;
+    },
+    latestRemoteVersion
+  );
+  const currentVersion = formatMigrationVersion(now);
+  if (!latestKnownVersion || compareMigrationVersions(currentVersion, latestKnownVersion) > 0) {
+    return currentVersion;
+  }
+  return incrementMigrationVersion(latestKnownVersion);
+}
+function formatMigrationSql(statements) {
+  const normalizedStatements = statements.map((statement) => statement.trim().replace(/;\s*$/u, "")).filter(Boolean);
+  return normalizedStatements.join(";\n\n").concat(normalizedStatements.length > 0 ? ";\n" : "");
+}
+function findOlderThanHeadLocalMigrations(migrations, appliedVersions, latestRemoteVersion) {
+  return migrations.filter(
+    (migration) => getRemoteMigrationVersionStatus(
+      migration.version,
+      appliedVersions,
+      latestRemoteVersion
+    ) === "older-than-head"
+  );
+}
+function findLocalMigrationByVersion(version, filenames) {
+  const matches = filenames.map((filename) => parseMigrationFilename(filename)).filter(
+    (migration) => migration !== null && migration.version === version
+  );
+  if (matches.length === 0) {
+    throw new CLIError(`Local migration for version ${version} not found.`);
+  }
+  if (matches.length > 1) {
+    throw new CLIError(
+      `Multiple local migration files found for version ${version}.`
+    );
+  }
+  return matches[0];
+}
+function resolveMigrationTarget(target, filenames) {
+  if (/^\d{14}$/u.test(target)) {
+    return findLocalMigrationByVersion(target, filenames);
+  }
+  const parsedTarget = parseMigrationFilename(target);
+  if (!parsedTarget) {
+    throw new CLIError(
+      "Migration file names must match <migration_version>_<migration-name>.sql."
+    );
+  }
+  if (!filenames.includes(target)) {
+    throw new CLIError(`Local migration file not found: ${target}`);
+  }
+  return parsedTarget;
+}
+
+// src/commands/db/migrations.ts
+function getLatestRemoteVersion(migrations) {
+  return migrations.reduce(
+    (latestVersion, migration) => !latestVersion || compareMigrationVersions(migration.version, latestVersion) > 0 ? migration.version : latestVersion,
+    null
+  );
+}
+function buildMigrationFilename(version, name) {
+  return `${version}_${name}.sql`;
+}
+function buildOlderThanHeadError(migrationLabel, latestRemoteVersion) {
+  return new CLIError(
+    `Migration ${migrationLabel} is older than the current remote head (${latestRemoteVersion}) and is not applied remotely. Rename it with a newer timestamp, or delete it locally if it is stale.`
+  );
+}
+function formatCreatedAt(createdAt) {
+  const date = new Date(createdAt);
+  return Number.isNaN(date.getTime()) ? createdAt : date.toLocaleString();
+}
+async function fetchRemoteMigrations() {
+  const res = await ossFetch("/api/database/migrations");
+  const raw = await res.json();
+  const migrations = Array.isArray(raw.migrations) ? raw.migrations : [];
+  for (const migration of migrations) {
+    assertValidMigrationVersion(migration.version);
+  }
+  return migrations;
+}
+function assertValidMigrationName(name) {
+  if (!/^[a-z0-9-]+$/u.test(name)) {
+    throw new CLIError("Migration name must use lowercase letters, numbers, and hyphens only.");
+  }
+}
+async function applyMigration(targetMigration, sql) {
+  const body = {
+    version: targetMigration.version,
+    name: targetMigration.name,
+    sql
+  };
+  const res = await ossFetch("/api/database/migrations", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  const createdMigration = await res.json();
+  if (createdMigration.version !== targetMigration.version) {
+    throw new CLIError(
+      `Applied migration version mismatch. Expected ${targetMigration.version}, received ${createdMigration.version}.`
+    );
+  }
+  return createdMigration;
+}
+function registerDbMigrationsCommand(dbCmd2) {
+  const migrationsCmd = dbCmd2.command("migrations").description("Manage database migration files");
+  migrationsCmd.command("list").description("List applied remote database migrations").action(async (_opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const migrations = await fetchRemoteMigrations();
+      if (json) {
+        outputJson({ migrations });
+      } else if (migrations.length === 0) {
+        console.log("No database migrations found.");
+      } else {
+        outputTable(
+          ["Version", "Name", "Created At"],
+          migrations.map((migration) => [
+            migration.version,
+            migration.name,
+            formatCreatedAt(migration.createdAt)
+          ])
+        );
+      }
+      await reportCliUsage("cli.db.migrations.list", true);
+    } catch (err) {
+      await reportCliUsage("cli.db.migrations.list", false);
+      handleError(err, json);
+    }
+  });
+  migrationsCmd.command("fetch").description("Fetch applied remote migrations into migrations/").action(async (_opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const migrations = await fetchRemoteMigrations();
+      const migrationsDir = ensureMigrationsDir();
+      const createdFiles = [];
+      const skippedFiles = [];
+      for (const migration of [...migrations].sort(
+        (left, right) => compareMigrationVersions(left.version, right.version)
+      )) {
+        assertValidMigrationName(migration.name);
+        const filename = buildMigrationFilename(
+          migration.version,
+          migration.name
+        );
+        const filePath = join8(migrationsDir, filename);
+        if (existsSync4(filePath)) {
+          skippedFiles.push(filename);
+          continue;
+        }
+        writeFileSync3(filePath, formatMigrationSql(migration.statements));
+        createdFiles.push(filename);
+      }
+      if (json) {
+        outputJson({
+          directory: migrationsDir,
+          totalRemoteMigrations: migrations.length,
+          createdFiles,
+          skippedFiles
+        });
+      } else {
+        outputSuccess(
+          `Fetched ${migrations.length} remote migration(s) into ${migrationsDir}.`
+        );
+        console.log(`Created: ${createdFiles.length}`);
+        console.log(`Skipped: ${skippedFiles.length}`);
+      }
+      await reportCliUsage("cli.db.migrations.fetch", true);
+    } catch (err) {
+      await reportCliUsage("cli.db.migrations.fetch", false);
+      handleError(err, json);
+    }
+  });
+  migrationsCmd.command("new <migration-name>").description("Create a new local migration file").action(async (migrationName, _opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      assertValidMigrationName(migrationName);
+      const migrations = await fetchRemoteMigrations();
+      const latestRemoteVersion = getLatestRemoteVersion(migrations);
+      const localMigrations = parseStrictLocalMigrations(listLocalMigrationFilenames());
+      const nextVersion = getNextLocalMigrationVersion(
+        localMigrations,
+        latestRemoteVersion
+      );
+      const filename = buildMigrationFilename(nextVersion, migrationName);
+      const migrationsDir = ensureMigrationsDir();
+      const filePath = join8(migrationsDir, filename);
+      try {
+        writeFileSync3(filePath, "", { flag: "wx" });
+      } catch (error) {
+        if (error.code === "EEXIST") {
+          throw new CLIError(`Migration file already exists: ${filename}`);
+        }
+        throw error;
+      }
+      if (json) {
+        outputJson({ filename, path: filePath, version: nextVersion });
+      } else {
+        outputSuccess(`Created migration file ${filename}`);
+      }
+      await reportCliUsage("cli.db.migrations.new", true);
+    } catch (err) {
+      await reportCliUsage("cli.db.migrations.new", false);
+      handleError(err, json);
+    }
+  });
+  migrationsCmd.command("up [target]").description("Apply one or more local migration files").option("--all", "Apply all pending local migration files").option("--to <version-or-filename>", "Apply pending local migrations up to a version or file").action(async (target, options, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const migrations = await fetchRemoteMigrations();
+      const latestRemoteVersion = getLatestRemoteVersion(migrations);
+      const appliedRemoteVersions = new Set(
+        migrations.map((migration) => migration.version)
+      );
+      const filenames = listLocalMigrationFilenames();
+      const requestedModes = [Boolean(target), Boolean(options.all), Boolean(options.to)].filter(Boolean);
+      if (requestedModes.length !== 1) {
+        throw new CLIError(
+          "Use exactly one apply mode: `up <target>`, `up --to <version-or-filename>`, or `up --all`."
+        );
+      }
+      const applySingleTarget = async (targetMigrationFilenameOrVersion) => {
+        const targetMigration = resolveMigrationTarget(targetMigrationFilenameOrVersion, filenames);
+        const validLocalMigrations = filenames.map((filename) => parseMigrationFilename(filename)).filter((migration) => migration !== null).sort((left, right) => compareMigrationVersions(left.version, right.version));
+        const targetRemoteStatus = getRemoteMigrationVersionStatus(
+          targetMigration.version,
+          appliedRemoteVersions,
+          latestRemoteVersion
+        );
+        if (targetRemoteStatus === "already-applied") {
+          throw new CLIError(`Migration ${targetMigration.filename} is already applied remotely.`);
+        }
+        if (targetRemoteStatus === "older-than-head" && latestRemoteVersion) {
+          throw buildOlderThanHeadError(targetMigration.filename, latestRemoteVersion);
+        }
+        const earlierPendingMigration = validLocalMigrations.find(
+          (migration) => migration.version !== targetMigration.version && (!latestRemoteVersion || compareMigrationVersions(migration.version, latestRemoteVersion) > 0) && compareMigrationVersions(migration.version, targetMigration.version) < 0
+        );
+        if (earlierPendingMigration) {
+          throw new CLIError(
+            `Migration ${targetMigration.filename} is not the next pending local migration. Apply ${earlierPendingMigration.filename} first, or fix/delete it locally if it is invalid or no longer needed.`
+          );
+        }
+        const filePath = join8(getMigrationsDir(), targetMigration.filename);
+        if (!existsSync4(filePath)) {
+          throw new CLIError(`Local migration file not found: ${targetMigration.filename}`);
+        }
+        const sql = readFileSync4(filePath, "utf-8");
+        if (!sql.trim()) {
+          throw new CLIError(`Migration file is empty: ${targetMigration.filename}`);
+        }
+        return applyMigration(targetMigration, sql);
+      };
+      let appliedMigrations = [];
+      if (target) {
+        appliedMigrations = [await applySingleTarget(target)];
+      } else {
+        const localMigrations = parseStrictLocalMigrations(filenames);
+        const olderThanHeadMigrations = findOlderThanHeadLocalMigrations(
+          localMigrations,
+          appliedRemoteVersions,
+          latestRemoteVersion
+        );
+        const pendingMigrations = localMigrations.filter(
+          (migration) => getRemoteMigrationVersionStatus(
+            migration.version,
+            appliedRemoteVersions,
+            latestRemoteVersion
+          ) === "pending"
+        );
+        if (olderThanHeadMigrations.length > 0 && latestRemoteVersion) {
+          throw buildOlderThanHeadError(
+            olderThanHeadMigrations[0].filename,
+            latestRemoteVersion
+          );
+        }
+        if (pendingMigrations.length === 0) {
+          if (json) {
+            outputJson({ appliedMigrations: [] });
+          } else {
+            outputSuccess("No pending local migrations to apply.");
+          }
+          await reportCliUsage("cli.db.migrations.up", true);
+          return;
+        }
+        let migrationsToApply = pendingMigrations;
+        if (options.to) {
+          const targetVersion = /^\d{14}$/u.test(options.to) ? options.to : resolveMigrationTarget(options.to, filenames).version;
+          const targetRemoteStatus = getRemoteMigrationVersionStatus(
+            targetVersion,
+            appliedRemoteVersions,
+            latestRemoteVersion
+          );
+          if (targetRemoteStatus === "already-applied") {
+            throw new CLIError(`Migration ${options.to} is already applied remotely.`);
+          }
+          if (targetRemoteStatus === "older-than-head" && latestRemoteVersion) {
+            throw buildOlderThanHeadError(options.to, latestRemoteVersion);
+          }
+          migrationsToApply = pendingMigrations.filter(
+            (migration) => compareMigrationVersions(migration.version, targetVersion) <= 0
+          );
+          if (migrationsToApply.length === 0 || migrationsToApply[migrationsToApply.length - 1]?.version !== targetVersion) {
+            throw new CLIError(
+              `Pending local migration not found for target ${options.to}.`
+            );
+          }
+        }
+        for (const migration of migrationsToApply) {
+          const filePath = join8(getMigrationsDir(), migration.filename);
+          if (!existsSync4(filePath)) {
+            throw new CLIError(`Local migration file not found: ${migration.filename}`);
+          }
+          const sql = readFileSync4(filePath, "utf-8");
+          if (!sql.trim()) {
+            throw new CLIError(`Migration file is empty: ${migration.filename}`);
+          }
+          appliedMigrations.push(await applyMigration(migration, sql));
+        }
+      }
+      if (json) {
+        outputJson({ appliedMigrations });
+      } else {
+        outputSuccess(`Applied ${appliedMigrations.length} migration file(s).`);
+        for (const migration of appliedMigrations) {
+          console.log(`- ${buildMigrationFilename(migration.version, migration.name)}`);
+        }
+      }
+      await reportCliUsage("cli.db.migrations.up", true);
+    } catch (err) {
+      await reportCliUsage("cli.db.migrations.up", false);
+      handleError(err, json);
+    }
+  });
+}
+
 // src/commands/records/list.ts
 function registerRecordsCommands(recordsCmd2) {
   recordsCmd2.command("list <table>").description("List records from a table").option("--select <columns>", "Columns to select (comma-separated)").option("--filter <filter>", 'Filter expression (e.g. "name=eq.John")').option("--order <order>", 'Order by (e.g. "created_at.desc")').option("--limit <n>", "Limit number of records", parseInt).option("--offset <n>", "Offset for pagination", parseInt).action(async (table, opts, cmd) => {
@@ -2854,21 +3302,21 @@ function registerFunctionsCommands(functionsCmd2) {
 }
 
 // src/commands/functions/deploy.ts
-import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
+import { join as join9 } from "path";
 function registerFunctionsDeployCommand(functionsCmd2) {
   functionsCmd2.command("deploy <slug>").description("Deploy an edge function (create or update)").option("--file <path>", "Path to the function source file").option("--name <name>", "Function display name").option("--description <desc>", "Function description").action(async (slug, opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
       await requireAuth();
-      const filePath = opts.file ?? join7(process.cwd(), "insforge", "functions", slug, "index.ts");
-      if (!existsSync3(filePath)) {
+      const filePath = opts.file ?? join9(process.cwd(), "insforge", "functions", slug, "index.ts");
+      if (!existsSync5(filePath)) {
         throw new CLIError(
           `Source file not found: ${filePath}
-Specify --file <path> or create ${join7("insforge", "functions", slug, "index.ts")}`
+Specify --file <path> or create ${join9("insforge", "functions", slug, "index.ts")}`
         );
       }
-      const code = readFileSync4(filePath, "utf-8");
+      const code = readFileSync5(filePath, "utf-8");
       const name = opts.name ?? slug;
       const description = opts.description ?? "";
       let exists = false;
@@ -3055,7 +3503,7 @@ function registerStorageBucketsCommand(storageCmd2) {
 }
 
 // src/commands/storage/upload.ts
-import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
 import { basename as basename5 } from "path";
 function registerStorageUploadCommand(storageCmd2) {
   storageCmd2.command("upload <file>").description("Upload a file to a storage bucket").requiredOption("--bucket <name>", "Target bucket name").option("--key <objectKey>", "Object key (defaults to filename)").action(async (file, opts, cmd) => {
@@ -3064,10 +3512,10 @@ function registerStorageUploadCommand(storageCmd2) {
       await requireAuth();
       const config = getProjectConfig();
       if (!config) throw new ProjectNotLinkedError();
-      if (!existsSync4(file)) {
+      if (!existsSync6(file)) {
         throw new CLIError(`File not found: ${file}`);
       }
-      const fileContent = readFileSync5(file);
+      const fileContent = readFileSync6(file);
       const objectKey = opts.key ?? basename5(file);
       const bucketName = opts.bucket;
       const formData = new FormData();
@@ -3098,8 +3546,8 @@ function registerStorageUploadCommand(storageCmd2) {
 }
 
 // src/commands/storage/download.ts
-import { writeFileSync as writeFileSync3 } from "fs";
-import { join as join8, basename as basename6 } from "path";
+import { writeFileSync as writeFileSync4 } from "fs";
+import { join as join10, basename as basename6 } from "path";
 function registerStorageDownloadCommand(storageCmd2) {
   storageCmd2.command("download <objectKey>").description("Download a file from a storage bucket").requiredOption("--bucket <name>", "Source bucket name").option("--output <path>", "Output file path (defaults to current directory)").action(async (objectKey, opts, cmd) => {
     const { json } = getRootOpts(cmd);
@@ -3119,8 +3567,8 @@ function registerStorageDownloadCommand(storageCmd2) {
         throw new CLIError(err.error ?? `Download failed: ${res.status}`);
       }
       const buffer = Buffer.from(await res.arrayBuffer());
-      const outputPath = opts.output ?? join8(process.cwd(), basename6(objectKey));
-      writeFileSync3(outputPath, buffer);
+      const outputPath = opts.output ?? join10(process.cwd(), basename6(objectKey));
+      writeFileSync4(outputPath, buffer);
       if (json) {
         outputJson({ success: true, path: outputPath, size: buffer.length });
       } else {
@@ -4226,13 +4674,13 @@ function registerComputeLogsCommand(computeCmd2) {
 }
 
 // src/commands/compute/deploy.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, renameSync } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, renameSync } from "fs";
+import { join as join11 } from "path";
 import { execSync, spawn } from "child_process";
 function parseFlyToml(dir) {
-  const tomlPath = join9(dir, "fly.toml");
-  if (!existsSync5(tomlPath)) return {};
-  const content = readFileSync6(tomlPath, "utf-8");
+  const tomlPath = join11(dir, "fly.toml");
+  if (!existsSync7(tomlPath)) return {};
+  const content = readFileSync7(tomlPath, "utf-8");
   const config = {};
   const portMatch = content.match(/internal_port\s*=\s*(\d+)/);
   if (portMatch) config.internalPort = Number(portMatch[1]);
@@ -4302,8 +4750,8 @@ function registerComputeDeployCommand(computeCmd2) {
       checkFlyctl();
       const flyToken = getFlyToken();
       const dir = directory ?? process.cwd();
-      const dockerfilePath = join9(dir, "Dockerfile");
-      if (!existsSync5(dockerfilePath)) {
+      const dockerfilePath = join11(dir, "Dockerfile");
+      if (!existsSync7(dockerfilePath)) {
         throw new CLIError(`No Dockerfile found in ${dir}`);
       }
       const flyTomlDefaults = parseFlyToml(dir);
@@ -4348,15 +4796,15 @@ function registerComputeDeployCommand(computeCmd2) {
         serviceId = service.id;
         flyAppId = service.flyAppId;
       }
-      const existingTomlPath = join9(dir, "fly.toml");
-      const backupTomlPath = join9(dir, "fly.toml.insforge-backup");
+      const existingTomlPath = join11(dir, "fly.toml");
+      const backupTomlPath = join11(dir, "fly.toml.insforge-backup");
       let hadExistingToml = false;
-      if (existsSync5(existingTomlPath)) {
+      if (existsSync7(existingTomlPath)) {
         hadExistingToml = true;
         renameSync(existingTomlPath, backupTomlPath);
       }
       const tomlContent = generateFlyToml(flyAppId, { port, memory, cpu, region });
-      writeFileSync4(existingTomlPath, tomlContent);
+      writeFileSync5(existingTomlPath, tomlContent);
       try {
         if (!json) outputInfo("Building and deploying (this may take a few minutes)...");
         await new Promise((resolve4, reject) => {
@@ -5081,7 +5529,7 @@ function registerDiagnoseCommands(diagnoseCmd2) {
         const s = !json ? clack10.spinner() : null;
         s?.start("Collecting diagnostic data...");
         const data2 = await collectDiagnosticData(projectId, ossMode, apiUrl);
-        const cliVersion = "0.1.54";
+        const cliVersion = "0.1.55";
         s?.stop("Data collected");
         if (!json) {
           console.log(`
@@ -5310,7 +5758,7 @@ function formatBytesCompact(bytes) {
 
 // src/index.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(readFileSync7(join10(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync8(join12(__dirname, "../package.json"), "utf-8"));
 var INSFORGE_LOGO = `
 \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
@@ -5344,6 +5792,7 @@ registerDbTriggersCommand(dbCmd);
 registerDbRpcCommand(dbCmd);
 registerDbExportCommand(dbCmd);
 registerDbImportCommand(dbCmd);
+registerDbMigrationsCommand(dbCmd);
 var recordsCmd = program.command("records", { hidden: true }).description("CRUD operations on table records");
 registerRecordsCommands(recordsCmd);
 registerRecordsCreateCommand(recordsCmd);