qhttpx 2.1.0 → 2.3.1

package/dist/chunk-QW72SEAS.mjs

@@ -0,0 +1,98 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// core/index.js
+var require_core = __commonJS({
+  "core/index.js"(exports, module) {
+    "use strict";
+    var { join } = __require("path");
+    var { platform, arch } = process;
+    var nativeBinding = null;
+    if (platform === "win32" && arch === "x64") {
+      nativeBinding = __require("./qhttpx-core-new.win32-x64-msvc.node");
+    } else if (platform === "linux" && arch === "x64") {
+      nativeBinding = __require("./qhttpx-core-new.linux-x64-gnu.node");
+    } else if (platform === "darwin") {
+      if (arch === "x64") {
+        nativeBinding = __require("./qhttpx-core-new.darwin-x64.node");
+      } else if (arch === "arm64") {
+        nativeBinding = __require("./qhttpx-core-new.darwin-arm64.node");
+      }
+    } else {
+      throw new Error(`Unsupported platform: ${platform} ${arch}`);
+    }
+    module.exports = nativeBinding;
+  }
+});
+
+// src/env.ts
+import fs from "fs";
+import path from "path";
+function parseEnv(content) {
+  const env2 = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const [key, ...values] = trimmed.split("=");
+    if (!key) continue;
+    const value = values.join("=").trim();
+    const finalValue = value.replace(/^['"](.*)['"]$/, "$1");
+    env2[key.trim()] = finalValue;
+  }
+  return env2;
+}
+function loadEnv(filePath) {
+  const envPath = filePath || path.resolve(process.cwd(), ".env");
+  if (fs.existsSync(envPath)) {
+    const content = fs.readFileSync(envPath, "utf-8");
+    const parsed = parseEnv(content);
+    for (const [key, value] of Object.entries(parsed)) {
+      if (!process.env[key]) {
+        process.env[key] = value;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function env(key, defaultValue) {
+  return process.env[key] || defaultValue || "";
+}
+
+export {
+  __require,
+  __toESM,
+  require_core,
+  loadEnv,
+  env
+};

package/dist/{src/cli/index.d.ts → cli.d.mts}

@@ -1,2 +1 @@
 #!/usr/bin/env node
-export {};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// core/index.js
+var require_core = __commonJS({
+  "core/index.js"(exports2, module2) {
+    "use strict";
+    var { join } = require("path");
+    var { platform, arch } = process;
+    var nativeBinding = null;
+    if (platform === "win32" && arch === "x64") {
+      nativeBinding = require("./qhttpx-core-new.win32-x64-msvc.node");
+    } else if (platform === "linux" && arch === "x64") {
+      nativeBinding = require("./qhttpx-core-new.linux-x64-gnu.node");
+    } else if (platform === "darwin") {
+      if (arch === "x64") {
+        nativeBinding = require("./qhttpx-core-new.darwin-x64.node");
+      } else if (arch === "arm64") {
+        nativeBinding = require("./qhttpx-core-new.darwin-arm64.node");
+      }
+    } else {
+      throw new Error(`Unsupported platform: ${platform} ${arch}`);
+    }
+    module2.exports = nativeBinding;
+  }
+});
+
+// src/cli.ts
+var import_commander = require("commander");
+var import_child_process = require("child_process");
+var import_path2 = __toESM(require("path"));
+var import_picocolors = __toESM(require("picocolors"));
+var import_fs2 = __toESM(require("fs"));
+var import_core = __toESM(require_core());
+
+// src/env.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+function parseEnv(content) {
+  const env = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const [key, ...values] = trimmed.split("=");
+    if (!key) continue;
+    const value = values.join("=").trim();
+    const finalValue = value.replace(/^['"](.*)['"]$/, "$1");
+    env[key.trim()] = finalValue;
+  }
+  return env;
+}
+function loadEnv(filePath) {
+  const envPath = filePath || import_path.default.resolve(process.cwd(), ".env");
+  if (import_fs.default.existsSync(envPath)) {
+    const content = import_fs.default.readFileSync(envPath, "utf-8");
+    const parsed = parseEnv(content);
+    for (const [key, value] of Object.entries(parsed)) {
+      if (!process.env[key]) {
+        process.env[key] = value;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/cli.ts
+loadEnv();
+var resolveDbTarget = (options) => {
+  const postgresUrl = options.postgres ?? process.env.POSTGRES_URL;
+  const sqliteUrl = options.sqlite ?? process.env.SQLITE_URL;
+  if (postgresUrl && sqliteUrl) {
+    throw new Error("Provide only one of --postgres or --sqlite.");
+  }
+  if (sqliteUrl) {
+    return { type: "sqlite", url: sqliteUrl };
+  }
+  if (postgresUrl) {
+    return { type: "postgres", url: postgresUrl };
+  }
+  const envUrl = process.env.DATABASE_URL;
+  if (envUrl) {
+    const type = envUrl.startsWith("sqlite") ? "sqlite" : "postgres";
+    return { type, url: envUrl };
+  }
+  return null;
+};
+var splitSqlStatements = (sql) => {
+  const statements = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < sql.length; i += 1) {
+    const ch = sql[i];
+    const prev = i > 0 ? sql[i - 1] : "";
+    if (ch === "'" && !inDouble && prev !== "\\") {
+      inSingle = !inSingle;
+    } else if (ch === '"' && !inSingle && prev !== "\\") {
+      inDouble = !inDouble;
+    }
+    if (ch === ";" && !inSingle && !inDouble) {
+      const trimmed2 = current.trim();
+      if (trimmed2) statements.push(trimmed2);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  const trimmed = current.trim();
+  if (trimmed) statements.push(trimmed);
+  return statements;
+};
+var readSqlStatements = async (filePath) => {
+  const raw = await import_fs2.default.promises.readFile(filePath, "utf8");
+  const cleaned = raw.replace(/^\s*--.*$/gm, "").trim();
+  if (!cleaned) return [];
+  return splitSqlStatements(cleaned);
+};
+var ensureMigrationsTable = async (engine, dbType) => {
+  const sql = dbType === "sqlite" ? "CREATE TABLE IF NOT EXISTS _qhttpx_migrations (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE NOT NULL, applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP)" : "CREATE TABLE IF NOT EXISTS _qhttpx_migrations (id SERIAL PRIMARY KEY, name TEXT UNIQUE NOT NULL, applied_at TIMESTAMP NOT NULL DEFAULT NOW())";
+  await engine.queryDb(sql);
+};
+var getAppliedMigrations = async (engine) => {
+  const res = await engine.queryDb("SELECT name FROM _qhttpx_migrations ORDER BY id");
+  const rows = JSON.parse(res);
+  return rows.map((row) => row.name).filter((name) => Boolean(name));
+};
+var getMigrationFiles = async (dir) => {
+  const entries = await import_fs2.default.promises.readdir(dir, { withFileTypes: true });
+  const migrations = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".up.sql")).map((entry) => {
+    const name = entry.name.replace(/\.up\.sql$/, "");
+    const upPath = import_path2.default.join(dir, entry.name);
+    const downPath = import_path2.default.join(dir, `${name}.down.sql`);
+    return { name, upPath, downPath };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  return migrations;
+};
+var applyStatements = async (engine, statements) => {
+  for (const statement of statements) {
+    await engine.queryDb(statement);
+  }
+};
+var insertMigration = async (engine, dbType, name) => {
+  const placeholder = dbType === "sqlite" ? "?" : "$1";
+  await engine.queryDbWithParams(
+    `INSERT INTO _qhttpx_migrations (name) VALUES (${placeholder})`,
+    [name]
+  );
+};
+var removeMigration = async (engine, dbType, name) => {
+  const placeholder = dbType === "sqlite" ? "?" : "$1";
+  await engine.queryDbWithParams(
+    `DELETE FROM _qhttpx_migrations WHERE name = ${placeholder}`,
+    [name]
+  );
+};
+var runMigrations = async (direction, options) => {
+  const dbTarget = resolveDbTarget(options);
+  if (!dbTarget) {
+    throw new Error("No database configured. Use --postgres, --sqlite, or set DATABASE_URL.");
+  }
+  const migrationsDir = import_path2.default.resolve(process.cwd(), options.dir || "migrations");
+  if (!import_fs2.default.existsSync(migrationsDir)) {
+    throw new Error(`Migrations directory not found: ${migrationsDir}`);
+  }
+  const engine = new import_core.NativeEngine(0);
+  if (dbTarget.type === "sqlite") {
+    await engine.connectSqlite(dbTarget.url);
+  } else {
+    await engine.connectPostgres(dbTarget.url);
+  }
+  await ensureMigrationsTable(engine, dbTarget.type);
+  const migrations = await getMigrationFiles(migrationsDir);
+  if (migrations.length === 0) {
+    console.log(import_picocolors.default.yellow("No migrations found."));
+    return;
+  }
+  if (direction === "up") {
+    const applied2 = new Set(await getAppliedMigrations(engine));
+    const pending = migrations.filter((m) => !applied2.has(m.name));
+    if (pending.length === 0) {
+      console.log(import_picocolors.default.green("All migrations already applied."));
+      return;
+    }
+    for (const migration of pending) {
+      const statements = await readSqlStatements(migration.upPath);
+      if (statements.length === 0) continue;
+      await applyStatements(engine, statements);
+      await insertMigration(engine, dbTarget.type, migration.name);
+      console.log(import_picocolors.default.green(`Applied ${migration.name}`));
+    }
+    return;
+  }
+  const applied = await getAppliedMigrations(engine);
+  const steps = Math.max(1, Number.parseInt(options.steps || "1", 10) || 1);
+  const toRollback = applied.slice(-steps).reverse();
+  if (toRollback.length === 0) {
+    console.log(import_picocolors.default.yellow("No migrations to roll back."));
+    return;
+  }
+  for (const name of toRollback) {
+    const migration = migrations.find((m) => m.name === name);
+    if (!migration) {
+      throw new Error(`Migration file missing for ${name}`);
+    }
+    if (!import_fs2.default.existsSync(migration.downPath)) {
+      throw new Error(`Down migration not found for ${name}`);
+    }
+    const statements = await readSqlStatements(migration.downPath);
+    if (statements.length === 0) continue;
+    await applyStatements(engine, statements);
+    await removeMigration(engine, dbTarget.type, name);
+    console.log(import_picocolors.default.yellow(`Reverted ${name}`));
+  }
+};
+var program = new import_commander.Command();
+program.name("qhttpx").description("The AI-Native High-Performance Web Engine CLI").version("0.1.1");
+program.command("dev [entry]").description('Start the development server with "Magic" Dev Mode').action((entry = "src/index.ts") => {
+  console.clear();
+  console.log(import_picocolors.default.bold(import_picocolors.default.cyan(`
+\u2728 QHTTPX Magic Dev Mode
+`)));
+  const args = ["watch", entry];
+  const fs3 = require("fs");
+  if (!fs3.existsSync(entry)) {
+    console.error(import_picocolors.default.red(`\u274C Entry file not found: ${entry}`));
+    console.log(import_picocolors.default.gray(`Please provide a valid entry file (default: src/index.ts)`));
+    process.exit(1);
+  }
+  console.log(import_picocolors.default.gray(`Watching ${entry} and dependencies...`));
+  const child = (0, import_child_process.spawn)("npx", ["tsx", ...args], {
+    stdio: "inherit",
+    shell: true,
+    env: { ...process.env, NODE_ENV: "development", FORCE_COLOR: "1" }
+  });
+  child.on("error", (err) => {
+    console.error(import_picocolors.default.red(`Failed to start server: ${err.message}`));
+  });
+  process.on("SIGINT", () => {
+    child.kill("SIGINT");
+    process.exit(0);
+  });
+});
+var migrate = program.command("migrate").description("Run SQL migrations");
+migrate.command("up").option("--dir <path>", "Migrations directory", "migrations").option("--postgres <url>", "Postgres connection string").option("--sqlite <url>", "SQLite connection string").action(async (options) => {
+  try {
+    await runMigrations("up", options);
+  } catch (err) {
+    console.error(import_picocolors.default.red(err?.message || "Migration failed."));
+    process.exitCode = 1;
+  }
+});
+migrate.command("down").option("--dir <path>", "Migrations directory", "migrations").option("--postgres <url>", "Postgres connection string").option("--sqlite <url>", "SQLite connection string").option("--steps <count>", "Number of migrations to roll back", "1").action(async (options) => {
+  try {
+    await runMigrations("down", options);
+  } catch (err) {
+    console.error(import_picocolors.default.red(err?.message || "Migration failed."));
+    process.exitCode = 1;
+  }
+});
+program.parse();

package/dist/cli.mjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import {
+  __require,
+  __toESM,
+  loadEnv,
+  require_core
+} from "./chunk-QW72SEAS.mjs";
+
+// src/cli.ts
+var import_core = __toESM(require_core());
+import { Command } from "commander";
+import { spawn } from "child_process";
+import path from "path";
+import pc from "picocolors";
+import fs from "fs";
+loadEnv();
+var resolveDbTarget = (options) => {
+  const postgresUrl = options.postgres ?? process.env.POSTGRES_URL;
+  const sqliteUrl = options.sqlite ?? process.env.SQLITE_URL;
+  if (postgresUrl && sqliteUrl) {
+    throw new Error("Provide only one of --postgres or --sqlite.");
+  }
+  if (sqliteUrl) {
+    return { type: "sqlite", url: sqliteUrl };
+  }
+  if (postgresUrl) {
+    return { type: "postgres", url: postgresUrl };
+  }
+  const envUrl = process.env.DATABASE_URL;
+  if (envUrl) {
+    const type = envUrl.startsWith("sqlite") ? "sqlite" : "postgres";
+    return { type, url: envUrl };
+  }
+  return null;
+};
+var splitSqlStatements = (sql) => {
+  const statements = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < sql.length; i += 1) {
+    const ch = sql[i];
+    const prev = i > 0 ? sql[i - 1] : "";
+    if (ch === "'" && !inDouble && prev !== "\\") {
+      inSingle = !inSingle;
+    } else if (ch === '"' && !inSingle && prev !== "\\") {
+      inDouble = !inDouble;
+    }
+    if (ch === ";" && !inSingle && !inDouble) {
+      const trimmed2 = current.trim();
+      if (trimmed2) statements.push(trimmed2);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  const trimmed = current.trim();
+  if (trimmed) statements.push(trimmed);
+  return statements;
+};
+var readSqlStatements = async (filePath) => {
+  const raw = await fs.promises.readFile(filePath, "utf8");
+  const cleaned = raw.replace(/^\s*--.*$/gm, "").trim();
+  if (!cleaned) return [];
+  return splitSqlStatements(cleaned);
+};
+var ensureMigrationsTable = async (engine, dbType) => {
+  const sql = dbType === "sqlite" ? "CREATE TABLE IF NOT EXISTS _qhttpx_migrations (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE NOT NULL, applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP)" : "CREATE TABLE IF NOT EXISTS _qhttpx_migrations (id SERIAL PRIMARY KEY, name TEXT UNIQUE NOT NULL, applied_at TIMESTAMP NOT NULL DEFAULT NOW())";
+  await engine.queryDb(sql);
+};
+var getAppliedMigrations = async (engine) => {
+  const res = await engine.queryDb("SELECT name FROM _qhttpx_migrations ORDER BY id");
+  const rows = JSON.parse(res);
+  return rows.map((row) => row.name).filter((name) => Boolean(name));
+};
+var getMigrationFiles = async (dir) => {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  const migrations = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".up.sql")).map((entry) => {
+    const name = entry.name.replace(/\.up\.sql$/, "");
+    const upPath = path.join(dir, entry.name);
+    const downPath = path.join(dir, `${name}.down.sql`);
+    return { name, upPath, downPath };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  return migrations;
+};
+var applyStatements = async (engine, statements) => {
+  for (const statement of statements) {
+    await engine.queryDb(statement);
+  }
+};
+var insertMigration = async (engine, dbType, name) => {
+  const placeholder = dbType === "sqlite" ? "?" : "$1";
+  await engine.queryDbWithParams(
+    `INSERT INTO _qhttpx_migrations (name) VALUES (${placeholder})`,
+    [name]
+  );
+};
+var removeMigration = async (engine, dbType, name) => {
+  const placeholder = dbType === "sqlite" ? "?" : "$1";
+  await engine.queryDbWithParams(
+    `DELETE FROM _qhttpx_migrations WHERE name = ${placeholder}`,
+    [name]
+  );
+};
+var runMigrations = async (direction, options) => {
+  const dbTarget = resolveDbTarget(options);
+  if (!dbTarget) {
+    throw new Error("No database configured. Use --postgres, --sqlite, or set DATABASE_URL.");
+  }
+  const migrationsDir = path.resolve(process.cwd(), options.dir || "migrations");
+  if (!fs.existsSync(migrationsDir)) {
+    throw new Error(`Migrations directory not found: ${migrationsDir}`);
+  }
+  const engine = new import_core.NativeEngine(0);
+  if (dbTarget.type === "sqlite") {
+    await engine.connectSqlite(dbTarget.url);
+  } else {
+    await engine.connectPostgres(dbTarget.url);
+  }
+  await ensureMigrationsTable(engine, dbTarget.type);
+  const migrations = await getMigrationFiles(migrationsDir);
+  if (migrations.length === 0) {
+    console.log(pc.yellow("No migrations found."));
+    return;
+  }
+  if (direction === "up") {
+    const applied2 = new Set(await getAppliedMigrations(engine));
+    const pending = migrations.filter((m) => !applied2.has(m.name));
+    if (pending.length === 0) {
+      console.log(pc.green("All migrations already applied."));
+      return;
+    }
+    for (const migration of pending) {
+      const statements = await readSqlStatements(migration.upPath);
+      if (statements.length === 0) continue;
+      await applyStatements(engine, statements);
+      await insertMigration(engine, dbTarget.type, migration.name);
+      console.log(pc.green(`Applied ${migration.name}`));
+    }
+    return;
+  }
+  const applied = await getAppliedMigrations(engine);
+  const steps = Math.max(1, Number.parseInt(options.steps || "1", 10) || 1);
+  const toRollback = applied.slice(-steps).reverse();
+  if (toRollback.length === 0) {
+    console.log(pc.yellow("No migrations to roll back."));
+    return;
+  }
+  for (const name of toRollback) {
+    const migration = migrations.find((m) => m.name === name);
+    if (!migration) {
+      throw new Error(`Migration file missing for ${name}`);
+    }
+    if (!fs.existsSync(migration.downPath)) {
+      throw new Error(`Down migration not found for ${name}`);
+    }
+    const statements = await readSqlStatements(migration.downPath);
+    if (statements.length === 0) continue;
+    await applyStatements(engine, statements);
+    await removeMigration(engine, dbTarget.type, name);
+    console.log(pc.yellow(`Reverted ${name}`));
+  }
+};
+var program = new Command();
+program.name("qhttpx").description("The AI-Native High-Performance Web Engine CLI").version("0.1.1");
+program.command("dev [entry]").description('Start the development server with "Magic" Dev Mode').action((entry = "src/index.ts") => {
+  console.clear();
+  console.log(pc.bold(pc.cyan(`
+\u2728 QHTTPX Magic Dev Mode
+`)));
+  const args = ["watch", entry];
+  const fs2 = __require("fs");
+  if (!fs2.existsSync(entry)) {
+    console.error(pc.red(`\u274C Entry file not found: ${entry}`));
+    console.log(pc.gray(`Please provide a valid entry file (default: src/index.ts)`));
+    process.exit(1);
+  }
+  console.log(pc.gray(`Watching ${entry} and dependencies...`));
+  const child = spawn("npx", ["tsx", ...args], {
+    stdio: "inherit",
+    shell: true,
+    env: { ...process.env, NODE_ENV: "development", FORCE_COLOR: "1" }
+  });
+  child.on("error", (err) => {
+    console.error(pc.red(`Failed to start server: ${err.message}`));
+  });
+  process.on("SIGINT", () => {
+    child.kill("SIGINT");
+    process.exit(0);
+  });
+});
+var migrate = program.command("migrate").description("Run SQL migrations");
+migrate.command("up").option("--dir <path>", "Migrations directory", "migrations").option("--postgres <url>", "Postgres connection string").option("--sqlite <url>", "SQLite connection string").action(async (options) => {
+  try {
+    await runMigrations("up", options);
+  } catch (err) {
+    console.error(pc.red(err?.message || "Migration failed."));
+    process.exitCode = 1;
+  }
+});
+migrate.command("down").option("--dir <path>", "Migrations directory", "migrations").option("--postgres <url>", "Postgres connection string").option("--sqlite <url>", "SQLite connection string").option("--steps <count>", "Number of migrations to roll back", "1").action(async (options) => {
+  try {
+    await runMigrations("down", options);
+  } catch (err) {
+    console.error(pc.red(err?.message || "Migration failed."));
+    process.exitCode = 1;
+  }
+});
+program.parse();