@insforge/cli 0.1.51 → 0.1.53-dev.0

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";
@@ -2000,6 +2000,7 @@ ${prompts.map((p) => `\u2022 "${p}"`).join("\n")}`,
         throw err;
       }
     } catch (err) {
+      await shutdownAnalytics();
       handleError(err, json);
     } finally {
       await shutdownAnalytics();
@@ -2167,6 +2168,7 @@ function registerProjectLinkCommand(program2) {
           return;
         } catch (err) {
           await reportCliUsage("cli.link_direct", false);
+          await shutdownAnalytics();
           handleError(err, json);
         }
       }
@@ -2346,6 +2348,7 @@ ${prompts.map((p) => `\u2022 "${p}"`).join("\n")}`,
       }
     } catch (err) {
       await reportCliUsage("cli.link", false);
+      await shutdownAnalytics();
       handleError(err, json);
     } finally {
       await shutdownAnalytics();
@@ -2668,6 +2671,291 @@ 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_FILENAME_REGEX = /^([1-9][0-9]*)_([a-z0-9-]+)\.sql$/;
+function parseMigrationFilename(filename) {
+  const match = MIGRATION_FILENAME_REGEX.exec(filename);
+  if (!match) {
+    return null;
+  }
+  return {
+    filename,
+    sequenceNumber: Number(match[1]),
+    name: match[2]
+  };
+}
+function getMigrationsDir(cwd = process.cwd()) {
+  return join7(cwd, ".insforge", "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 <sequence_number>_<migration-name>.sql.`
+      );
+    }
+    return parsedMigration;
+  });
+  assertNoDuplicateMigrationSequences(migrations);
+  return migrations.sort((left, right) => left.sequenceNumber - right.sequenceNumber);
+}
+function assertNoDuplicateMigrationSequences(migrations) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const migration of migrations) {
+    if (seen.has(migration.sequenceNumber)) {
+      throw new CLIError(`Duplicate local migration sequence found: ${migration.sequenceNumber}`);
+    }
+    seen.add(migration.sequenceNumber);
+  }
+}
+function getNextLocalMigrationSequence(migrations, latestRemoteSequenceNumber) {
+  const orderedMigrations = [...migrations].sort((left, right) => left.sequenceNumber - right.sequenceNumber);
+  assertNoDuplicateMigrationSequences(orderedMigrations);
+  let expectedSequenceNumber = latestRemoteSequenceNumber + 1;
+  for (const migration of orderedMigrations) {
+    if (migration.sequenceNumber <= latestRemoteSequenceNumber) {
+      continue;
+    }
+    if (migration.sequenceNumber !== expectedSequenceNumber) {
+      throw new CLIError(
+        `Local pending migrations must be contiguous after remote sequence ${latestRemoteSequenceNumber}.`
+      );
+    }
+    expectedSequenceNumber += 1;
+  }
+  return expectedSequenceNumber;
+}
+function formatMigrationSql(statements) {
+  return statements.map((statement) => statement.trim().replace(/;\s*$/u, "")).filter(Boolean).join(";\n\n").concat(statements.length > 0 ? ";\n" : "");
+}
+function findLocalMigrationBySequence(sequenceNumber, filenames) {
+  const matches = filenames.map((filename) => parseMigrationFilename(filename)).filter(
+    (migration) => migration !== null && migration.sequenceNumber === sequenceNumber
+  );
+  if (matches.length === 0) {
+    throw new CLIError(`Local migration for sequence ${sequenceNumber} not found.`);
+  }
+  if (matches.length > 1) {
+    throw new CLIError(
+      `Multiple local migration files found for sequence ${sequenceNumber}.`
+    );
+  }
+  return matches[0];
+}
+function resolveMigrationTarget(target, filenames) {
+  if (/^[1-9][0-9]*$/u.test(target)) {
+    return findLocalMigrationBySequence(Number(target), filenames);
+  }
+  const parsedTarget = parseMigrationFilename(target);
+  if (!parsedTarget) {
+    throw new CLIError(
+      "Migration file names must match <sequence_number>_<migration-name>.sql."
+    );
+  }
+  if (!filenames.includes(target)) {
+    throw new CLIError(`Local migration file not found: ${target}`);
+  }
+  return findLocalMigrationBySequence(parsedTarget.sequenceNumber, filenames);
+}
+
+// src/commands/db/migrations.ts
+function getLatestRemoteSequenceNumber(migrations) {
+  return migrations.reduce(
+    (latestSequenceNumber, migration) => Math.max(latestSequenceNumber, migration.sequenceNumber),
+    0
+  );
+}
+function buildMigrationFilename(sequenceNumber, name) {
+  return `${sequenceNumber}_${name}.sql`;
+}
+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();
+  return Array.isArray(raw.migrations) ? raw.migrations : [];
+}
+function assertValidMigrationName(name) {
+  if (!/^[a-z0-9-]+$/u.test(name)) {
+    throw new CLIError("Migration name must use lowercase letters, numbers, and hyphens only.");
+  }
+}
+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(
+          ["Sequence", "Name", "Created At"],
+          migrations.map((migration) => [
+            String(migration.sequenceNumber),
+            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 .insforge/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) => left.sequenceNumber - right.sequenceNumber
+      )) {
+        const filename = buildMigrationFilename(
+          migration.sequenceNumber,
+          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 latestRemoteSequenceNumber = getLatestRemoteSequenceNumber(migrations);
+      const localMigrations = parseStrictLocalMigrations(listLocalMigrationFilenames());
+      const nextSequenceNumber = getNextLocalMigrationSequence(
+        localMigrations,
+        latestRemoteSequenceNumber
+      );
+      const filename = buildMigrationFilename(nextSequenceNumber, migrationName);
+      const migrationsDir = ensureMigrationsDir();
+      const filePath = join8(migrationsDir, filename);
+      if (existsSync4(filePath)) {
+        throw new CLIError(`Migration file already exists: ${filename}`);
+      }
+      writeFileSync3(filePath, "");
+      if (json) {
+        outputJson({ filename, path: filePath, sequenceNumber: nextSequenceNumber });
+      } 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 exactly one local migration file").action(async (target, _opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const migrations = await fetchRemoteMigrations();
+      const latestRemoteSequenceNumber = getLatestRemoteSequenceNumber(migrations);
+      const filenames = listLocalMigrationFilenames();
+      const targetMigration = resolveMigrationTarget(target, filenames);
+      if (targetMigration.sequenceNumber <= latestRemoteSequenceNumber) {
+        throw new CLIError(
+          `Migration ${targetMigration.filename} is already applied remotely.`
+        );
+      }
+      if (targetMigration.sequenceNumber !== latestRemoteSequenceNumber + 1) {
+        throw new CLIError(
+          `Migration ${targetMigration.filename} is not the next remote sequence. Expected ${latestRemoteSequenceNumber + 1}.`
+        );
+      }
+      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}`);
+      }
+      const body = {
+        name: targetMigration.name,
+        sql
+      };
+      const res = await ossFetch("/api/database/migrations", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      const createdMigration = await res.json();
+      if (createdMigration.sequenceNumber !== targetMigration.sequenceNumber) {
+        throw new CLIError(
+          `Applied migration sequence mismatch. Expected ${targetMigration.sequenceNumber}, received ${createdMigration.sequenceNumber}.`
+        );
+      }
+      if (json) {
+        outputJson(createdMigration);
+      } else {
+        outputSuccess(`Applied migration ${targetMigration.filename}`);
+      }
+      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) => {
@@ -2851,21 +3139,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;
@@ -3052,7 +3340,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) => {
@@ -3061,10 +3349,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();
@@ -3095,8 +3383,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);
@@ -3116,8 +3404,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 {
@@ -4223,13 +4511,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]);
@@ -4299,8 +4587,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);
@@ -4345,15 +4633,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) => {
@@ -4647,6 +4935,7 @@ function registerDiagnoseMetricsCommand(diagnoseCmd2) {
       await reportCliUsage("cli.diagnose.metrics", true);
     } catch (err) {
       await reportCliUsage("cli.diagnose.metrics", false);
+      await shutdownAnalytics();
       handleError(err, json);
     } finally {
       await shutdownAnalytics();
@@ -4714,6 +5003,7 @@ function registerDiagnoseAdvisorCommand(diagnoseCmd2) {
       await reportCliUsage("cli.diagnose.advisor", true);
     } catch (err) {
       await reportCliUsage("cli.diagnose.advisor", false);
+      await shutdownAnalytics();
       handleError(err, json);
     } finally {
       await shutdownAnalytics();
@@ -4903,6 +5193,7 @@ function registerDiagnoseDbCommand(diagnoseCmd2) {
       await reportCliUsage("cli.diagnose.db", true);
     } catch (err) {
       await reportCliUsage("cli.diagnose.db", false);
+      await shutdownAnalytics();
       handleError(err, json);
     } finally {
       await shutdownAnalytics();
@@ -4993,6 +5284,7 @@ function registerDiagnoseLogsCommand(diagnoseCmd2) {
       await reportCliUsage("cli.diagnose.logs", true);
     } catch (err) {
       await reportCliUsage("cli.diagnose.logs", false);
+      await shutdownAnalytics();
       handleError(err, json);
     } finally {
       await shutdownAnalytics();
@@ -5074,7 +5366,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.51";
+        const cliVersion = "0.1.53-dev.0";
         s?.stop("Data collected");
         if (!json) {
           console.log(`
@@ -5284,6 +5576,7 @@ function registerDiagnoseCommands(diagnoseCmd2) {
       await reportCliUsage(usageEvent, true);
     } catch (err) {
       await reportCliUsage(usageEvent, false);
+      await shutdownAnalytics();
       handleError(err, json);
     } finally {
       await shutdownAnalytics();
@@ -5302,7 +5595,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
@@ -5336,6 +5629,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);